spring的cacheManager与redis的整合

1,系统中整合redis服务。

• properties文件中的redis配置:

        redis.host=127.0.0.1
        redis.port=6379
        redis.default.db=0
        redis.timeout=100000
        redis.maxActive=300
        redis.maxIdle=100
        redis.maxWait=1000
        redis.testOnBorrow=true

• spring整合redis的配置(肯定要导入properties文件的这里就省略了):

        <!-- jedis pool配置 -->  
        <bean id="jedisPoolConfig" class="redis.clients.jedis.JedisPoolConfig">  
            <property name="maxIdle" value="${redis.maxIdle}" />  
            <property name="testOnBorrow" value="${redis.testOnBorrow}" />  
        </bean> 

        <!-- spring data redis -->  
        <bean id="jedisConnectionFactory" class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory">  
            <property name="usePool" value="true"></property>  
            <property name="hostName" value="${redis.host}" />  
            <property name="port" value="${redis.port}" />  
            <property name="timeout" value="${redis.timeout}" />  
            <property name="database" value="${redis.default.db}"></property>  
            <constructor-arg index="0" ref="jedisPoolConfig" />  
        </bean> 

        <bean id="redisTemplate" class="org.springframework.data.redis.core.StringRedisTemplate"  
            p:connectionFactory-ref="jedisConnectionFactory" p:keySerializer-ref="stringRedisSerializer">  
        </bean>

2,自定义RedisCache实现自org.springframework.cache.Cache接口

• 定义成员变量name,定义成员变量redisClint(该成员变量是一个直接操作redis的类的对象)

• 重写getNativeCache,get,put,evict,clear方法(重写这些方法是为了使用redis来存储缓存,同时使用自己的规则来命名key也方便日志查看)

        public Object getNativeCache() {
            return jedisClient;
        }

        public void put(Object key, Object value) {
            //logger.info("存入緩存---put------------key:"+key);
            //修改key的值，与name绑定
            String _key=this.name+"_"+String.valueOf(key);//key必须是String 类型
            //logger.info("存入緩存,对应redis key:"+_key);
            //将数据存入redis
            if(null!=value){
                Serializable val=(Serializable) value;//value必须是Serializable类型
                jedisClient.set(_key.getBytes(), SerializeUtil.serialize(val));
            }
        }

        public ValueWrapper get(Object key) {
            //logger.info("获取缓存---ValueWrapper------------key:"+key);
            //修改key的值，与name绑定
            String _key=this.name+"_"+String.valueOf(key);//key必须是String 类型
            //logger.info("获取缓存,对应redis key:"+_key);
            ValueWrapper result = null;
            //从redis获取数据
            byte[] v=jedisClient.get(_key.getBytes());
            Serializable val=SerializeUtil.unserialize(v);
            Object thevalue = val;
            if (thevalue != null) {
                result = new SimpleValueWrapper(thevalue);
            }
            return result;
        }

        public void evict(Object key) {
            //logger.info("删除緩存---evict------------key:"+key);
            //修改key的值，与name绑定
            String _key=this.name+"_"+String.valueOf(key);//key必须是String 类型
            //logger.info("删除緩存,对应redis key:"+_key);
            //从redis中删除
            jedisClient.keyDel(_key.getBytes());
        }

        public void clear() {
            //清楚缓存，需要根据Cache的name属性，在redis中模糊查询相关key值的集合，并全部删除
            String pattern=this.name+"*";//前缀匹配
            //logger.info("清除缓存---clear------------key pattern:"+pattern);
            Set<byte[]> ks= jedisClient.keys(pattern.getBytes());
             for(byte[] bys:ks){
                 //logger.info("清除缓存-redis删除key:"+new String(bys));
                 this.jedisClient.keyDel(bys);
             }
        }   

3,自定义CacheManager继承org.springframework.cache.support.AbstractCacheManager

• 创建成员变量private Collection

        public void setCaches(Collection<? extends RedisCache> caches) { 
            this.caches = caches; 
        }

• 重写loadCaches加载自定义的缓存对象caches

        protected Collection<? extends RedisCache> loadCaches() {
            return caches;
        }

4,spring配置文件中配置如下：

    <!-- 数据库缓存管理器 -->
    <cache:annotation-driven cache-manager="cacheManager"/>
    <!-- 缓存类及缓存定义 -->
    <bean id="cacheManager" class="自定义CacheManager所在包">
        <property name="caches"> 
            <set> 
                <!-- 测试缓存类 -->
                <!-- 
                    p:name属性大概等同于<property name="name" ref="RedisCache中的name"></property>是给
                    RedisCache类中的name属性注入名字
                -->
                <bean class="自定义RedisCache所在包" p:name="RedisCache中的name" >
                    <property name="jedisClient" ref="jedisClient"></property>
                </bean>
            </set>
        </property> 
    </bean> 

5,在需要缓存的方法上用注解

• @Cacheable(value=”RedisCache中的name”,key=”自定义key规则确保每条数据唯一”,condition(可选属性)=”“) 标示该方法的返回值需要缓存(在key属性中可以用#参数来确保唯一,同时condition属性可以用#参数与条件来判断)

• @CacheEvict(value=”RedisCache中的name”,allEntries=true) 该注解是标示该方法需要清除缓存,allEntries=true表示清除该value所对应的全部缓存