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}