redis在springboot中做缓存操作的两种方法应用实例

@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 中获取缓存数据
    User user = ops.get(cacheKey);
    // 缓存未命中（包含空值标记的情况）
    if (user == null) {
        // 穿透到数据库查询真实数据
        user = userRepository.findById(id).orElse(null);
        if (user != null) {
            // 数据库存在数据：写入缓存并设置 30 分钟过期时间
            ops.set(cacheKey, user, Duration.ofMinutes(30)); 
        } else {
            // 数据库不存在数据：写入特殊空值标记，设置 5 分钟较短过期时间
            // 使用 new NullValue() 而非 null 是为了区分：
            // 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));
}