Spring集成Ehcache和Redis,使用@Cache注解方式实现缓存

 1.配置Redis

//使用jackson序列化value 
public Jackson2JsonRedisSerializer jackson2JsonRedisSerializer() {
        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
        ObjectMapper objectMapper = new ObjectMapper();
        //这里可以将jdk8的LocalDateTime成功序列化不报错配置
        //  .registerModule(new ParameterNamesModule())
        //  .registerModule(new Jdk8Module())
        //  .registerModule(new JavaTimeModule());
        objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        objectMapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jackson2JsonRedisSerializer.setObjectMapper(objectMapper);
        return jackson2JsonRedisSerializer;
    }

 
    //配置连接池,也可以使用lettuce,底层netty实现,支持并发使用
    @Bean
    public JedisConnectionFactory jedisConnectionFactory(JedisPoolConfig jedisPoolConfig) {
        RedisStandaloneConfiguration standaloneConfiguration = new RedisStandaloneConfiguration(hostname, port);
        standaloneConfiguration.setPassword(password);
        standaloneConfiguration.setDatabase(15);
        JedisClientConfiguration clientConfiguration = JedisClientConfiguration.builder()
                .readTimeout(Duration.ofSeconds(6))
                .connectTimeout(Duration.ofSeconds(3))
                .usePooling()
                .poolConfig(jedisPoolConfig).build();
        JedisConnectionFactory factory = new JedisConnectionFactory(standaloneConfiguration, clientConfiguration);
        return factory;
    }

    
    //配置模板
    @Bean
    public RedisTemplate<String, String> redisTemplate(RedisConnectionFactory factory) {
        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
        ObjectMapper objectMapper = new ObjectMapper();
        objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        objectMapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jackson2JsonRedisSerializer.setObjectMapper(objectMapper);
        StringRedisTemplate template = new StringRedisTemplate(factory);
        template.setValueSerializer(jackson2JsonRedisSerializer);//如果key是String 需要配置一下StringSerializer,不然key会乱码 /XX/XX
        template.afterPropertiesSet();
        return template;
    }

    //配置自定义生成键,否则注解不写key会报错
    @Bean
    public KeyGenerator keyGenerator() {
        return (target, method, params) -> {
            StringBuilder sb = new StringBuilder();
            sb.append(target.getClass().getName());
            sb.append(method.getName());
            for (Object obj : params) {
                sb.append(obj.toString());
            }
            return sb.toString();
        };
    }
  
    //自定义缓存管理,这里可以实现根据注解自定义过期时间
    public static class MyRedisCacheManager extends RedisCacheManager {
        public MyRedisCacheManager(RedisCacheWriter cacheWriter, RedisCacheConfiguration defaultCacheConfiguration) {
            super(cacheWriter, defaultCacheConfiguration);
        }

        @Override
        protected RedisCache createRedisCache(String name, RedisCacheConfiguration cacheConfig) {
            String[] array = StringUtils.delimitedListToStringArray(name, "#");
            name = array[0];
            if (array.length > 1) { // 解析TTL
                long ttl = Long.parseLong(array[1]);
                cacheConfig = cacheConfig.entryTtl(Duration.ofSeconds(ttl));
            }
            return super.createRedisCache(name, cacheConfig);
        }
    }
   
    
    //指定bean名称,可以根据注解名字进行切换
    @Bean(WfCacheConstant.CACHE_REDIS)
    public RedisCacheManager redisCacheManager(JedisConnectionFactory jedisConnectionFactory) {
        RedisCacheConfiguration cacheConfig = RedisCacheConfiguration.defaultCacheConfig()
                .entryTtl(Duration.ofHours(1))
                .serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(jackson2JsonRedisSerializer()))
                .disableCachingNullValues();
        MyRedisCacheManager redisCacheManager = new MyRedisCacheManager(RedisCacheWriter.nonLockingRedisCacheWriter(jedisConnectionFactory),
                cacheConfig);
        return redisCacheManager;
    }

 使用注解,此处可以根据cacheName来判断需要指定的缓存时间,这里是60秒

 @Cacheable(value = "indexType3#60", cacheManager = WfCacheConstant.CACHE_REDIS, unless = "#result==null")

 

2.配置Ehcache

    @Bean
    public EhCacheManagerFactoryBean ehCacheManagerFactoryBean() {
        EhCacheManagerFactoryBean cacheManagerFactoryBean = new EhCacheManagerFactoryBean();
        cacheManagerFactoryBean.setConfigLocation(new ClassPathResource("ehcache.xml"));
        cacheManagerFactoryBean.setShared(true);
        return cacheManagerFactoryBean;
    }
    
    //使用默认bean,否则报错
    @Primary
    @Bean(WfCacheConstant.CACHE_LOCAL)
    public EhCacheCacheManager eCacheCacheManager(EhCacheManagerFactoryBean bean) {
        return new EhCacheCacheManager(bean.getObject());
    }

ehcache.xml 

<?xml version="1.0" encoding="UTF-8"?>
<ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:noNamespaceSchemaLocation="http://ehcache.org/ehcache.xsd"
         updateCheck="false">
    <defaultCache maxElementsInMemory="1000"
                  overflowToDisk="false" diskPersistent="false" timeToIdleSeconds="3600"
                  timeToLiveSeconds="3600" memoryStoreEvictionPolicy="LRU"/>
    <!--
       name:缓存名称。
       maxElementsInMemory：缓存最大个数。
       eternal:对象是否永久有效，一但设置了，timeout将不起作用。
       timeToIdleSeconds：设置对象在失效前的允许闲置时间（单位：秒）。仅当eternal=false对象不是永久有效时使用，可选属性，默认值是0，也就是可闲置时间无穷大。
       timeToLiveSeconds：设置对象在失效前允许存活时间（单位：秒）。最大时间介于创建时间和失效时间之间。仅当eternal=false对象不是永久有效时使用，默认是0.，也就是对象存活时间无穷大。
       overflowToDisk：当内存中对象数量达到maxElementsInMemory时，Ehcache将会对象写到磁盘中。
       diskSpoolBufferSizeMB：这个参数设置DiskStore（磁盘缓存）的缓存区大小。默认是30MB。每个Cache都应该有自己的一个缓冲区。
       maxElementsOnDisk：硬盘最大缓存个数。
       diskPersistent：是否缓存虚拟机重启期数据 Whether the disk store persists between restarts of the Virtual Machine. The default value is false.
       diskExpiryThreadIntervalSeconds：磁盘失效线程运行时间间隔，默认是120秒。
       memoryStoreEvictionPolicy：当达到maxElementsInMemory限制时，Ehcache将会根据指定的策略去清理内存。默认策略是LRU（最近最少使用）。你可以设置为FIFO（先进先出）或是LFU（较少使用）。
       clearOnFlush：内存数量最大时是否清除。
       -->
    <cache name="30s" maxElementsInMemory="1000" eternal="false"
           overflowToDisk="false" diskPersistent="false" timeToIdleSeconds="0" timeToLiveSeconds="30"
           memoryStoreEvictionPolicy="LRU"/>
    <cache name="60s" maxElementsInMemory="1000" eternal="false"
           overflowToDisk="false" diskPersistent="false" timeToIdleSeconds="0" timeToLiveSeconds="60"
           memoryStoreEvictionPolicy="LRU"/>
</ehcache>

使用注解,value是xml中配置的缓存名称,key可以不写,unless是指定不缓存返回值为null的值 

@Cacheable(value = "60s", cacheManager = WfCacheConstant.CACHE_LOCAL, unless = "#result==null")

 

3.注意事项:

1.此处我是Springmvc项目集成,要注意spring-data-redis和jedis的版本关系,这个上网查;

2.在旧版本中(spring-data-redis 1.8.11之前),redis的方式在并发时可能会出现返回null的情况;

是由于检查缓存逻辑是先判断key是否存在,然后取值返回,但是可能会在取值时缓存瞬间失效的情况,所以新版改为先取值在判断;

我使用的版本是:

        <dependency>
            <groupId>org.springframework.data</groupId>
            <artifactId>spring-data-redis</artifactId>
            <version>2.3.9.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
            <version>3.3.0</version>
        </dependency>