java的cacheable使用

   @Cacheable(key = "'test:'+#query.id",cacheNames = "tets3#100")
    public List<Test> getData(TestQuery query){
        return testMapper.queryPage(query);
    }

//cachename和value同名，只能存在一个
//key的过期时间是在value和cacheNames中使用#后面跟着时间的方式来设置key的过期时间
//当id有值得时候key为tets3::test:3，当id没有值得时候key为tets3::test:null
//key中需要存储变量的id
//在同一个类中一个方法调用另外一个注解缓存的方法是不能进行缓存的，因为spring boot使用的是aop方式

使用redis的配置
//需要注意一下key的问题，key如果需要多个组装的时候需要注意他们都需要是字符串，如果是一个Interger一个字符串拼接起来是有问题的
key = “#shopId.toString() + ‘-’ + #tplCode.toString()”

@EnableCaching
@Configuration
public class RedisConfig extends CachingConfigurerSupport {
    private final Logger logger = LogManager.getLogger();

    /**
     * 缓存基本配置
     *
     * @param redisTemplate redisTemplate
     * @return RedisCacheManager
     */

    @Bean
    @SuppressWarnings(value = {"rawtypes"})
    public RedisCacheManager redisCacheManager(RedisTemplate redisTemplate) {
        RedisSerializer<String> redisSerializer = new StringRedisSerializer();
        Jackson2JsonRedisSerializer<Object> serializer = new Jackson2JsonRedisSerializer<>(Object.class);

        ObjectMapper mapper = new ObjectMapper();
        mapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        PolymorphicTypeValidator ptv = new LaissezFaireSubTypeValidator();
        mapper.activateDefaultTyping(ptv, ObjectMapper.DefaultTyping.NON_FINAL);
        mapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);
        serializer.setObjectMapper(mapper);

        RedisCacheWriter redisCacheWriter = RedisCacheWriter.nonLockingRedisCacheWriter(Objects.requireNonNull(redisTemplate.getConnectionFactory()));
        RedisCacheConfiguration redisCacheConfiguration = RedisCacheConfiguration.defaultCacheConfig()
                .entryTtl(Duration.ofMinutes(30))
                .serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(redisSerializer))
                .serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(serializer));


        return new MallRedisCacheManager(redisCacheWriter, redisCacheConfiguration);
    }

    /**
     * redis数据操作异常处理 这里的处理：在日志中打印出错误信息，但是放行
     * 保证redis服务器出现连接等问题的时候不影响程序的正常运行，使得能够出问题时不用缓存
     *
     * @return
     */
    @Bean
    @Override
    public CacheErrorHandler errorHandler() {
        return new CacheErrorHandler() {
            @Override
            public void handleCachePutError(RuntimeException exception, Cache cache, Object key, Object value) {
                redisErrorException(exception, key);
            }

            @Override
            public void handleCacheGetError(RuntimeException exception, Cache cache, Object key) {
                redisErrorException(exception, key);
            }

            @Override
            public void handleCacheEvictError(RuntimeException exception, Cache cache, Object key) {
                redisErrorException(exception, key);
            }

            @Override
            public void handleCacheClearError(RuntimeException exception, Cache cache) {
                redisErrorException(exception, null);
            }
        };
    }

    private void redisErrorException(Exception exception, Object key) {
        logger.error("Redis exception: key={}", key, exception);
    }

    @Bean
    public StringRedisTemplate stringTemplate(RedisConnectionFactory factory) {
        return new StringRedisTemplate(factory);
    }

    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(factory);

        Jackson2JsonRedisSerializer<?> jacksonSeial = new Jackson2JsonRedisSerializer<>(Object.class);
        ObjectMapper om = new ObjectMapper();
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        om.activateDefaultTyping(BasicPolymorphicTypeValidator.builder().build());
        jacksonSeial.setObjectMapper(om);

        template.setValueSerializer(jacksonSeial);
        template.setKeySerializer(new StringRedisSerializer());

        template.setHashKeySerializer(new StringRedisSerializer());
        template.setHashValueSerializer(jacksonSeial);
        template.afterPropertiesSet();
        return template;
    }

}

public class MallRedisCacheManager extends RedisCacheManager {


    public MallRedisCacheManager(RedisCacheWriter cacheWriter, RedisCacheConfiguration defaultCacheConfiguration) {
        super(cacheWriter, defaultCacheConfiguration);
    }

    /**
     * 针对@Cacheable设置缓存过期时间
     *
     * @param name        缓存名称
     * @param cacheConfig 缓存配置
     * @return RedisCache
     */
    @NotNull
    @Override
    protected RedisCache createRedisCache(@NotNull String name, RedisCacheConfiguration cacheConfig) {
        String[] array = StringUtils.delimitedListToStringArray(name, "#");
        name = array[0];
        if (array.length > 1) {
            long ttl = Long.parseLong(array[1]);
            cacheConfig = cacheConfig.entryTtl(Duration.ofSeconds(ttl));
        }
        return super.createRedisCache(name, cacheConfig);
    }

}