@SpringBootApplication
@EnableCaching
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

@Configuration
public class RedisCacheConfig {
    @Bean
    public RedisCacheManager cacheManager(RedisConnectionFactory connectionFactory) {
        RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig()
                .serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(new StringRedisSerializer()))
                .serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(new GenericJackson2JsonRedisSerializer()))
                .entryTtl(Duration.ofMinutes(30)); // 默認過期時間30分鐘
        return RedisCacheManager.builder(connectionFactory)
                .cacheDefaults(config)
                .withCacheConfiguration("userCache", RedisCacheConfiguration.defaultCacheConfig().entryTtl(Duration.ofMinutes(10))) // 自定義緩存過期
                .transactionAware()
                .build();
    }
}

@Cacheable(value = "userCache", key = "#id", unless = "#result == null")
public User getUserById(Long id) {
    return userRepository.findById(id).orElse(null);
}

@CachePut(value = "userCache", key = "#user.id")
public User updateUser(User user) {
    return userRepository.save(user); // 強制更新緩存
}

@CacheEvict(value = "userCache", key = "#id", beforeInvocation = true)
public void deleteUser(Long id) {
    userRepository.deleteById(id);
}

import org.springframework.context.annotation.Bean;  
import org.springframework.context.annotation.Configuration;  
import org.springframework.data.redis.connection.RedisConnectionFactory;  
import org.springframework.data.redis.core.RedisTemplate;  
import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;  
import org.springframework.data.redis.serializer.StringRedisSerializer;  
@Configuration  
public class RedisConfig {  
    @Bean  
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {  
        RedisTemplate<String, Object> template = new RedisTemplate<>();  
        template.setConnectionFactory(redisConnectionFactory);  
        // 設置 key 序列化器  
        template.setKeySerializer(new StringRedisSerializer());  
        // 設置 value 序列化器  
        template.setValueSerializer(new GenericJackson2JsonRedisSerializer());  
        template.afterPropertiesSet();  
        return template;  
    }  
}

public User getUserById(Long id) {
    // 生成緩存鍵，格式為 "user:{id}"（如 "user:123"）
    String cacheKey = "user:" + id;
    // 獲取 Redis 的 String 類型操作接口
    ValueOperations<String, User> ops = redisTemplate.opsForValue();
    // 嘗試從 Redis 中獲取緩存數(shù)據(jù)
    User user = ops.get(cacheKey);
    // 緩存未命中（包含空值標記的情況）
    if (user == null) {
        // 穿透到數(shù)據(jù)庫查詢真實數(shù)據(jù)
        user = userRepository.findById(id).orElse(null);
        if (user != null) {
            // 數(shù)據(jù)庫存在數(shù)據(jù)：寫入緩存并設置 30 分鐘過期時間
            ops.set(cacheKey, user, Duration.ofMinutes(30)); 
        } else {
            // 數(shù)據(jù)庫不存在數(shù)據(jù)：寫入特殊空值標記，設置 5 分鐘較短過期時間
            // 使用 new NullValue() 而非 null 是為了區(qū)分：
            // 1. 真實緩存空值（防止穿透）
            // 2. Redis 未存儲該鍵（真正的緩存未命中）
            ops.set(cacheKey, new NullValue(), Duration.ofMinutes(5));
        }
    }
    // 返回前進行空值標記判斷
    return user instanceof NullValue ? null : user;
}

public void updateUserProfile(Long userId, Map<String, String> profile) {
    String hashKey = "userProfiles";
    redisTemplate.opsForHash().putAll(hashKey, profile);
    // 設置整個 Hash 的過期時間
    redisTemplate.expire(hashKey, Duration.ofHours(24));
}