Spring 缓存抽象

// 直接使用 Redis 客户端
@Service
public class UserService {
    
    @Autowired
    private RedisTemplate<String, Object> redisTemplate;
    
    public User getUserById(Long id) {
        String key = "user:" + id;
        // 手动查询缓存
        User user = (User) redisTemplate.opsForValue().get(key);
        if (user != null) {
            return user;
        }
        // 缓存未命中，查询数据库
        user = userMapper.selectById(id);
        // 手动写入缓存
        redisTemplate.opsForValue().set(key, user, 1, TimeUnit.HOURS);
        return user;
    }
}

// 使用 Spring 缓存注解
@Service
public class UserService {
    
    @Cacheable(value = "user", key = "#id")
    public User getUserById(Long id) {
        return userMapper.selectById(id);
    }
}

@Service
public class UserService {

    // 基本用法：使用参数作为 Key
    @Cacheable(value = "user", key = "#id")
    public User getUserById(Long id) {
        return userMapper.selectById(id);
    }

    // 组合 Key：使用多个参数
    @Cacheable(value = "user", key = "#deptId + ':' + #name")
    public User getByDeptAndName(Long deptId, String name) {
        return userMapper.selectByDeptAndName(deptId, name);
    }

    // 条件缓存：只缓存特定条件的数据
    @Cacheable(value = "user", key = "#id", condition = "#id > 100")
    public User getUserWithCondition(Long id) {
        return userMapper.selectById(id);
    }

    // 排除空值：不缓存 null 结果
    @Cacheable(value = "user", key = "#id", unless = "#result == null")
    public User getUserExcludeNull(Long id) {
        return userMapper.selectById(id);
    }
}

@Service
public class UserService {

    // 更新用户并刷新缓存
    @CachePut(value = "user", key = "#user.id")
    public User updateUser(User user) {
        userMapper.updateById(user);
        return user;
    }

    // 创建用户并写入缓存
    @CachePut(value = "user", key = "#result.id")
    public User createUser(User user) {
        userMapper.insert(user);
        return user;  // 返回插入后的对象（包含生成的 ID）
    }
}

@Service
public class UserService {

    // 删除用户并清除对应缓存
    @CacheEvict(value = "user", key = "#id")
    public void deleteUser(Long id) {
        userMapper.deleteById(id);
    }

    // 清除整个 user 缓存区域
    @CacheEvict(value = "user", allEntries = true)
    public void clearAllUserCache() {
        // 方法体可以为空，仅触发缓存清除
    }

    // 方法执行前清除缓存（默认是执行后）
    @CacheEvict(value = "user", key = "#id", beforeInvocation = true)
    public void deleteUserBeforeInvocation(Long id) {
        userMapper.deleteById(id);
    }
}

@Service
public class UserService {

    // 组合：查询时缓存多个 Key
    @Caching(cacheable = {
        @Cacheable(value = "user", key = "#id"),
        @Cacheable(value = "user:detail", key = "#id")
    })
    public User getUserById(Long id) {
        return userMapper.selectById(id);
    }

    // 组合：更新时清除多个缓存
    @Caching(evict = {
        @CacheEvict(value = "user", key = "#user.id"),
        @CacheEvict(value = "user:list", allEntries = true),
        @CacheEvict(value = "user:detail", key = "#user.id")
    })
    public User updateUser(User user) {
        userMapper.updateById(user);
        return user;
    }

    // 混合操作：更新缓存 + 清除其他缓存
    @Caching(
        put = @CachePut(value = "user", key = "#user.id"),
        evict = @CacheEvict(value = "user:list", allEntries = true)
    )
    public User updateUserAndClearList(User user) {
        userMapper.updateById(user);
        return user;
    }
}

@Service
@CacheConfig(
    cacheNames = "user",           // 默认缓存名称
    keyGenerator = "myKeyGenerator", // 默认 Key 生成器
    cacheManager = "redisCacheManager" // 默认缓存管理器
)
public class UserService {

    // 继承类级别配置，只需指定 Key
    @Cacheable(key = "#id")
    public User getUserById(Long id) {
        return userMapper.selectById(id);
    }

    // 可以覆盖类级别配置
    @Cacheable(value = "user:detail", key = "#id")
    public User getUserDetail(Long id) {
        return userMapper.selectDetailById(id);
    }
}

@Configuration
@EnableCaching
public class CacheConfig {

    @Bean
    public CacheManager cacheManager() {
        SimpleCacheManager cacheManager = new SimpleCacheManager();
        cacheManager.setCaches(Arrays.asList(
            new ConcurrentMapCache("user"),
            new ConcurrentMapCache("product")
        ));
        return cacheManager;
    }
}

@Bean
public CacheManager cacheManager() {
    return new ConcurrentMapCacheManager("user", "product", "order");
}

# application.yml
spring:
  cache:
    type: redis
    redis:
      time-to-live: 3600000  # 默认过期时间：1小时（毫秒）
      cache-null-values: false  # 不缓存 null 值
      key-prefix: "myapp:"  # Key 前缀
      use-key-prefix: true  # 是否使用 Key 前缀

@Configuration
@EnableCaching
public class RedisCacheConfig {

    @Bean
    public RedisCacheManager cacheManager(RedisConnectionFactory factory) {
        // 配置序列化
        RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig()
            .entryTtl(Duration.ofHours(1))  // 默认过期时间
            .serializeKeysWith(RedisSerializationContext.SerializationPair
                .fromSerializer(new StringRedisSerializer()))
            .serializeValuesWith(RedisSerializationContext.SerializationPair
                .fromSerializer(new GenericJackson2JsonRedisSerializer()))
            .disableCachingNullValues()  // 不缓存 null
            .prefixCacheNameWith("myapp:");  // Key 前缀

        // 针对不同缓存区域配置不同过期时间
        Map<String, RedisCacheConfiguration> cacheConfigurations = new HashMap<>();
        cacheConfigurations.put("user", config.entryTtl(Duration.ofMinutes(30)));
        cacheConfigurations.put("product", config.entryTtl(Duration.ofHours(2)));
        cacheConfigurations.put("hot", config.entryTtl(Duration.ofMinutes(5)));

        return RedisCacheManager.builder(factory)
            .cacheDefaults(config)
            .withInitialCacheConfigurations(cacheConfigurations)
            .transactionAware()  // 支持事务
            .build();
    }
}

<dependency>
    <groupId>com.github.ben-manes.caffeine</groupId>
    <artifactId>caffeine</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-cache</artifactId>
</dependency>

@Configuration
@EnableCaching
public class CaffeineCacheConfig {

    @Bean
    public CacheManager cacheManager() {
        CaffeineCacheManager cacheManager = new CaffeineCacheManager();
        cacheManager.setCaffeine(Caffeine.newBuilder()
            .expireAfterWrite(Duration.ofMinutes(30))  // 写入后 30 分钟过期
            .initialCapacity(100)  // 初始容量
            .maximumSize(1000)  // 最大容量
            .recordStats());  // 开启统计
        return cacheManager;
    }

    // 针对不同缓存区域配置不同策略
    @Bean
    @Primary
    public CacheManager caffeineCacheManager() {
        CaffeineCacheManager cacheManager = new CaffeineCacheManager("user", "product");
        cacheManager.setCaffeine(Caffeine.newBuilder()
            .expireAfterWrite(Duration.ofMinutes(30))
            .maximumSize(500));
        return cacheManager;
    }
}

// 默认生成的 Key 示例
@Cacheable("user")  // Key = SimpleKey.EMPTY
public List<User> getAllUsers() { ... }

@Cacheable("user")  // Key = 123L（参数值）
public User getUserById(Long id) { ... }

@Cacheable("user")  // Key = SimpleKey [1L, "admin"]
public User getByDeptAndName(Long deptId, String name) { ... }

@Service
public class UserService {

    // 使用参数属性
    @Cacheable(value = "user", key = "#user.id")
    public User saveUser(User user) {
        return userMapper.insert(user);
    }

    // 使用方法名 + 参数
    @Cacheable(value = "user", key = "#root.methodName + ':' + #id")
    public User getUserById(Long id) {
        return userMapper.selectById(id);
    }

    // 使用返回值（@CachePut）
    @CachePut(value = "user", key = "'user:' + #result.id")
    public User updateUser(User user) {
        userMapper.updateById(user);
        return user;
    }

    // 复杂表达式
    @Cacheable(value = "user", 
               key = "T(String).format('user:%d:%s', #deptId, #name)")
    public User getByDeptAndName(Long deptId, String name) {
        return userMapper.selectByDeptAndName(deptId, name);
    }
}

@Component("customKeyGenerator")
public class CustomKeyGenerator implements KeyGenerator {

    @Override
    public Object generate(Object target, Method method, Object... params) {
        StringBuilder sb = new StringBuilder();
        sb.append(target.getClass().getSimpleName()).append(":");
        sb.append(method.getName()).append(":");
        
        if (params.length == 0) {
            sb.append("no_params");
        } else {
            for (Object param : params) {
                sb.append(param == null ? "null" : param.toString()).append(",");
            }
            sb.setLength(sb.length() - 1);  // 移除最后的逗号
        }
        
        return sb.toString();
    }
}

// 使用自定义 KeyGenerator
@Cacheable(value = "user", keyGenerator = "customKeyGenerator")
public User getUserById(Long id) {
    return userMapper.selectById(id);
}
// 生成的 Key: UserService:getUserById:123

@Service
@CacheConfig(cacheNames = "user")
public class UserService {

    @Autowired
    private UserMapper userMapper;

    /**
     * 查询用户：优先从缓存获取
     * Key: user:{id}
     */
    @Cacheable(key = "'user:' + #id", unless = "#result == null")
    public User getUserById(Long id) {
        return userMapper.selectById(id);
    }

    /**
     * 更新用户：更新数据库后刷新缓存
     * Key: user:{user.id}
     */
    @CachePut(key = "'user:' + #user.id")
    public User updateUser(User user) {
        userMapper.updateById(user);
        return user;
    }

    /**
     * 删除用户：删除数据库后清除缓存
     * 同时清除用户详情缓存和用户列表缓存
     */
    @Caching(evict = {
        @CacheEvict(key = "'user:' + #id"),
        @CacheEvict(key = "'user:detail:' + #id"),
        @CacheEvict(key = "'user:list'", cacheNames = "user")
    })
    public void deleteUser(Long id) {
        userMapper.deleteById(id);
    }

    /**
     * 查询用户列表：使用分页参数作为 Key
     * 注意：列表缓存需要在数据变更时清除
     */
    @Cacheable(key = "'user:list:' + #pageNum + ':' + #pageSize")
    public List<User> getUserList(int pageNum, int pageSize) {
        return userMapper.selectList(pageNum, pageSize);
    }
}

@Configuration
@EnableCaching
public class MultiLevelCacheConfig {

    // 一级缓存：Caffeine（本地）
    @Bean("localCacheManager")
    public CacheManager localCacheManager() {
        CaffeineCacheManager cacheManager = new CaffeineCacheManager("user", "product");
        cacheManager.setCaffeine(Caffeine.newBuilder()
            .expireAfterWrite(Duration.ofMinutes(5))  // 本地缓存时间短
            .maximumSize(100));
        return cacheManager;
    }

    // 二级缓存：Redis（分布式）
    @Bean("redisCacheManager")
    @Primary
    public CacheManager redisCacheManager(RedisConnectionFactory factory) {
        RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig()
            .entryTtl(Duration.ofHours(1));  // Redis 缓存时间长
        return RedisCacheManager.builder(factory)
            .cacheDefaults(config)
            .build();
    }
}

// 使用时指定缓存管理器
@Service
public class UserService {

    // 本地缓存（高频访问、容忍短暂不一致）
    @Cacheable(cacheNames = "user", key = "#id", cacheManager = "localCacheManager")
    public User getUserFromLocal(Long id) {
        return getUserFromRedis(id);
    }

    // Redis 缓存（需要一致性保证）
    @Cacheable(cacheNames = "user", key = "#id", cacheManager = "redisCacheManager")
    public User getUserFromRedis(Long id) {
        return userMapper.selectById(id);
    }
}

// 方案 1：缓存空值（设置较短过期时间）
@Cacheable(value = "user", key = "#id", unless = "#result == null")
public User getUserById(Long id) {
    User user = userMapper.selectById(id);
    if (user == null) {
        // 返回空对象，会被缓存（需配置 cache-null-values: true）
        return User.EMPTY;  // 定义一个空对象标记
    }
    return user;
}

// 方案 2：布隆过滤器（在 Redis 模块详细介绍）
// 在查询前先通过布隆过滤器判断数据是否可能存在

// 方案 1：互斥锁（只让一个请求去加载数据）
@Cacheable(value = "user", key = "#id")
public User getUserByIdWithLock(Long id) {
    String lockKey = "lock:user:" + id;
    try {
        // 尝试获取分布式锁
        Boolean locked = redisTemplate.opsForValue()
            .setIfAbsent(lockKey, "1", Duration.ofSeconds(10));
        
        if (Boolean.TRUE.equals(locked)) {
            User user = userMapper.selectById(id);
            // 更新缓存
            redisTemplate.opsForValue()
                .set("user::" + id, user, Duration.ofHours(1));
            return user;
        } else {
            // 等待并重试获取缓存
            Thread.sleep(100);
            return getUserById(id);  // 递归调用
        }
    } catch (InterruptedException e) {
        Thread.currentThread().interrupt();
        throw new RuntimeException("获取用户信息失败", e);
    } finally {
        redisTemplate.delete(lockKey);
    }
}

// 方案 2：逻辑过期（不设置 TTL，数据永不过期）
// 在数据中存储过期时间，后台异步刷新

// 方案 1：随机过期时间
@Configuration
public class CacheConfig {
    
    @Bean
    public RedisCacheManager cacheManager(RedisConnectionFactory factory) {
        RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig()
            .entryTtl(Duration.ofSeconds(3600 + new Random().nextInt(600)));  // 1小时 + 随机0-10分钟
        return RedisCacheManager.builder(factory).cacheDefaults(config).build();
    }
}

// 方案 2：缓存预热（应用启动时加载热点数据）
@Component
public class CachePreheat implements ApplicationRunner {
    
    @Autowired
    private UserService userService;
    
    @Override
    public void run(ApplicationArguments args) {
        // 预加载热点用户数据
        List<Long> hotUserIds = Arrays.asList(1L, 2L, 3L, 4L, 5L);
        for (Long id : hotUserIds) {
            userService.getUserById(id);
        }
    }
}

@Configuration
@EnableCaching
public class CacheConfig {

    @Bean
    public RedisCacheManager cacheManager(RedisConnectionFactory factory) {
        RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig()
            // Spring 6 推荐使用 JSON 序列化
            .serializeValuesWith(RedisSerializationContext.SerializationPair
                .fromSerializer(new GenericJackson2JsonRedisSerializer()))
            .entryTtl(Duration.ofMinutes(30))
            .disableCachingNullValues();
        
        return RedisCacheManager.builder(factory)
            .cacheDefaults(config)
            .transactionAware()  // Spring 6 支持事务感知
            .enableStatistics()  // 开启统计（Spring 6 新增）
            .build();
    }
}

// Caffeine 3.x API 变化
@Bean
public CacheManager caffeineCacheManager() {
    CaffeineCacheManager cacheManager = new CaffeineCacheManager();
    cacheManager.setCaffeine(Caffeine.newBuilder()
        // 3.x 使用 Duration API
        .expireAfterWrite(Duration.ofMinutes(30))
        .maximumSize(1000)
        // 3.x 移除了 recordStats()，默认开启
        .evictionListener((key, value, cause) -> {
            // 驱逐监听器
        }));
    return cacheManager;
}