Spring Cache 与 Redis

为什么需要缓存

数据库是大多数 Web 应用的性能瓶颈。即便是高性能的 PostgreSQL，单实例 QPS 也通常在数千到数万之间，而 Redis 单机 QPS 可达 10 万+。合理使用缓存可以带来：

• 降低数据库压力：热点数据（商品信息、用户资料）缓存后，大量请求无需访问数据库
• 降低响应延迟：内存读取耗时微秒级，数据库查询通常毫秒级，差距可达百倍
• 抵御突发流量：活动开始瞬间的流量洪峰由缓存承接，数据库得到保护

核心概念名词解释

缓存命中与未命中流程

配置 Redis 缓存

@Configuration
@EnableCaching  // 开启 Spring Cache 注解支持
public class CacheConfig {

    @Bean
    public RedisCacheConfiguration defaultCacheConfig() {
        return RedisCacheConfiguration.defaultCacheConfig()
            .entryTtl(Duration.ofMinutes(30))   // 默认 30 分钟 TTL
            .serializeValuesWith(RedisSerializationContext.SerializationPair
                .fromSerializer(new GenericJackson2JsonRedisSerializer()))
            .disableCachingNullValues();  // null 不缓存（防止缓存穿透）
    }

    @Bean
    public RedisCacheManager cacheManager(RedisConnectionFactory factory) {
        // 为不同缓存设置不同 TTL
        Map<String, RedisCacheConfiguration> configs = new HashMap<>();
        configs.put("users", defaultCacheConfig().entryTtl(Duration.ofMinutes(10)));
        configs.put("products", defaultCacheConfig().entryTtl(Duration.ofHours(2)));

        return RedisCacheManager.builder(factory)
            .cacheDefaults(defaultCacheConfig())
            .withInitialCacheConfigurations(configs)
            .build();
    }
}

注解式缓存使用

@Service
@RequiredArgsConstructor
public class UserServiceImpl implements UserService {

    private final UserRepository userRepository;

    // 查询时缓存（key = "users::123"）
    @Cacheable(value = "users", key = "#id")
    @Transactional(readOnly = true)
    public UserResponseDTO findById(Long id) {
        // 只有缓存未命中时才执行此方法
        return userRepository.findById(id)
            .map(this::toDTO)
            .orElseThrow(() -> new EntityNotFoundException("用户不存在"));
    }

    // 更新后刷新缓存（执行方法并更新缓存）
    @CachePut(value = "users", key = "#result.id")
    @Transactional
    public UserResponseDTO update(Long id, UserUpdateDTO dto) {
        User user = userRepository.findById(id)
            .orElseThrow(() -> new EntityNotFoundException("用户不存在"));
        user.setUsername(dto.getUsername());
        return toDTO(userRepository.save(user));
    }

    // 删除时清除缓存
    @CacheEvict(value = "users", key = "#id")
    @Transactional
    public void delete(Long id) {
        userRepository.deleteById(id);
    }
}

RedisTemplate 直接操作

当需要更精细的 Redis 控制时（计数器、排行榜、分布式锁），直接使用 RedisTemplate：

@Service
@RequiredArgsConstructor
public class RedisService {

    private final StringRedisTemplate redisTemplate;

    // String 操作：计数器
    public void incrementLoginCount(Long userId) {
        String key = "login:count:" + userId;
        redisTemplate.opsForValue().increment(key);
        redisTemplate.expire(key, Duration.ofDays(7));
    }

    // Hash 操作：存储用户会话信息
    public void saveUserSession(String sessionId, Map<String, String> userInfo) {
        String key = "session:" + sessionId;
        redisTemplate.opsForHash().putAll(key, userInfo);
        redisTemplate.expire(key, Duration.ofHours(2));
    }

    // ZSet 操作：商品热度排行榜
    public void recordProductView(Long productId) {
        redisTemplate.opsForZSet().incrementScore(
            "product:hot", productId.toString(), 1.0);
    }

    // 获取 Top 10 热门商品
    public Set<String> getTop10Products() {
        return redisTemplate.opsForZSet().reverseRange("product:hot", 0, 9);
    }

    // 分布式锁（简单实现）
    public boolean tryLock(String lockKey, String lockValue, long seconds) {
        Boolean result = redisTemplate.opsForValue()
            .setIfAbsent(lockKey, lockValue, Duration.ofSeconds(seconds));
        return Boolean.TRUE.equals(result);
    }
}

分布式 Session

<!-- Spring Session + Redis -->
<dependency>
    <groupId>org.springframework.session</groupId>
    <artifactId>spring-session-data-redis</artifactId>
</dependency>

spring:
  session:
    store-type: redis      # Session 存储到 Redis
    timeout: 2h            # Session 过期时间
  data:
    redis:
      host: localhost
      port: 6379
      password: ${REDIS_PASSWORD}

三大缓存问题的代码防护

// 防缓存穿透：空值缓存 + 短 TTL
@Cacheable(value = "users", key = "#id", unless = "false")
public UserResponseDTO findById(Long id) {
    return userRepository.findById(id)
        .map(this::toDTO)
        .orElse(null);   // 返回 null 也会被缓存（unless = "false" 表示始终缓存）
}

// TTL 加随机抖动（防雪崩）
public RedisCacheConfiguration withJitter(Duration baseTtl) {
    long jitterSeconds = new Random().nextLong(60);   // ±60 秒随机
    return RedisCacheConfiguration.defaultCacheConfig()
        .entryTtl(baseTtl.plusSeconds(jitterSeconds));
}

// 互斥锁防击穿（只允许一个请求重建缓存）
public UserResponseDTO findByIdWithMutex(Long id) throws InterruptedException {
    String cacheKey = "users::" + id;
    String lockKey  = "lock:users:" + id;

    // 1. 先查缓存
    Object cached = redisTemplate.opsForValue().get(cacheKey);
    if (cached != null) return (UserResponseDTO) cached;

    // 2. 缓存未命中，尝试获取互斥锁（setIfAbsent = SETNX）
    Boolean locked = redisTemplate.opsForValue()
        .setIfAbsent(lockKey, "1", Duration.ofSeconds(10));

    if (Boolean.TRUE.equals(locked)) {
        try {
            // 3. 获锁成功：查 DB，写缓存
            UserResponseDTO dto = userRepository.findById(id)
                .map(this::toDTO).orElse(null);
            redisTemplate.opsForValue().set(cacheKey, dto, Duration.ofMinutes(10));
            return dto;
        } finally {
            redisTemplate.delete(lockKey);  // 释放锁
        }
    } else {
        // 4. 未获锁：短暂等待后重试
        Thread.sleep(50);
        return findByIdWithMutex(id);
    }
}