@Configuration
@EnableCaching
public class RedisConfig {
    /**
     * 自定义key序列化
     * @param redisConnectionFactory
     * @return
     */
    @Bean
    public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory)  {
        RedisTemplate<Object, Object> template = new RedisTemplate();
        template.setConnectionFactory(redisConnectionFactory);
        //自定义key的序列化工具对象
        //设置redis中key的序列化
        template.setKeySerializer(new StringRedisSerializer());
        //设置hash中field序列化
        template.setHashKeySerializer(new StringRedisSerializer());
        return template;
    }

    /**
     * 配置 cacheManager 代替默认的cacheManager （缓存管理器）
     * @param factory RedisConnectionFactory
     * @return  CacheManager
     */
    @Bean
    public CacheManager cacheManager(RedisConnectionFactory factory) {
        RedisSerializer<String> redisSerializer = new StringRedisSerializer();
        Jackson2JsonRedisSerializer serializer = new Jackson2JsonRedisSerializer(Object.class);
        ObjectMapper objectMapper = new ObjectMapper();
        //设置被序列化的对象的属性都可访问：暴力反射
        objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        //仅仅序列化对象的属性，且属性不可为final修饰
        objectMapper.activateDefaultTyping(LaissezFaireSubTypeValidator.instance,ObjectMapper.DefaultTyping.NON_FINAL, JsonTypeInfo.As.PROPERTY);
        serializer.setObjectMapper(objectMapper);
        // 配置key value序列化
        RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig()
                .serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(redisSerializer))
                .serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(serializer))
                //关闭控制存储--》禁止缓存value为null的数据
                .disableCachingNullValues()
                //修改前缀与key的间隔符号，默认是::  eg:name:findById
                .computePrefixWith(cacheName->cacheName+":");

        //设置特有的Redis配置
        Map<String, RedisCacheConfiguration> cacheConfigurations = new HashMap<>();
        //定制化的Cache 设置过期时间 eg:以role：开头的缓存存活时间为10s
        cacheConfigurations.put("role",customRedisCacheConfiguration(config,Duration.ofSeconds(20)));
        cacheConfigurations.put("stock",customRedisCacheConfiguration(config, Duration.ofSeconds(3000)));
        cacheConfigurations.put("market",customRedisCacheConfiguration(config,Duration.ofSeconds(300)));
        //构建redis缓存管理器
        RedisCacheManager cacheManager = RedisCacheManager.builder(factory)
                //Cache事务支持
                .transactionAware()
                .withInitialCacheConfigurations(cacheConfigurations)
                .cacheDefaults(config)
                .build();
        //设置过期时间
        return cacheManager;
    }

    /**
     * 设置RedisConfiguration配置
     * @param config
     * @param ttl
     * @return
     */
    public RedisCacheConfiguration customRedisCacheConfiguration(RedisCacheConfiguration config, Duration ttl) {
        //设置缓存缺省超时时间
        return config.entryTtl(ttl);
    }

    /**
     * 可通过引用myKeyGenerator使用公共的key生成器
     * @return
     */
    @Bean("myKeyGenerator")
    public KeyGenerator keyGenerator(){
        return (o,method,objects)->method.getName()+ "["+ Arrays.asList(objects).toString()+"]";
    }

}

常用注解
@Cacheable
如果缓存中有数据，直接返回结果
如果没有数据，查询数据库，返回结果

  //    @Cacheable(keyGenerator = "myKeyGenerator",key = "findAllRole")
    @Cacheable(key = "#root.method.getName()")
    @Override
    public CommonResult findAllRole() {
        List<Role> roleList = roleMapper.findAll();
        return CommonResult.success(roleList);
    }
 
}

@CacheEvict注解

@CacheEvict：删除缓存的注解,这对删除旧的数据和无用的数据是非常有用的。这里还多了一个参数(allEntries),设置allEntries=true时，可以对整个条目进行批量删除。

    /**
     * .@CacheEvict 缓存清除
     *  key：指定要清除的数据
     *  allEntries：指定清除这个缓存库的所有数据，默认为false
     *  beforeInvocation：在执行方法之前清除，默认为false，在方法之后执行
     */
    @Override
    @CacheEvict(/*value = "role",*/key = "#id")
    public Integer delete(Integer id) {
        return roleMapper.deleteByPrimaryKey(id);
    }

@CachePut注解

@CachePut：当需要更新缓存而不干扰方法的运行时 ，可以使用该注解。也就是说，始终执行该方法，并将结果放入缓存

  /**
     * .@CachePut既调用方法、又更新数据，达到同步更新缓存
     * <p>
     * 运行时机：
     * 1、先调用目标方法
     * 2、将目标方法的结果缓存起来
     *
     * 条件：存取Id的key要保持一致
     *     key = "#role.id"     传入员工的Id
     *     key = "#result.id"   使用返回员工的Id
     * 注意： @Cacheable不能使用#result
     *      因为 @Cacheable在目标方法执行之前需要得到这个key，所以不能用#result
     */
    @Override
    @CachePut(key = "#result.id")
    public Role update(Role role) {
        roleMapper.updateByPrimaryKey(role);
        return role;
    }

@Caching注释

在使用缓存的时候，有可能会同时进行更新和删除，会出现同时使用多个注解的情况.而@Caching可以实现``

//添加user缓存的同时，移除userPage的缓存
@Caching(put =@CachePut(value = "user",key ="#userVo.id"),
evict = @CacheEvict(value = "userPage",allEntries = true))