SpringMVC Cache注解+Redis

依赖jar包：
Xml代码  收藏代码

<!-- redis -->  
            <dependency>  
                <groupId>org.springframework.data</groupId>  
                <artifactId>spring-data-redis</artifactId>  
                <version>1.3.4.RELEASE</version>  
            </dependency>  
      
            <dependency>  
                <groupId>redis.clients</groupId>  
                <artifactId>jedis</artifactId>  
                <version>2.5.2</version>  
            </dependency>

applicationContext-cache-redis.xml

Xml代码  收藏代码

<context:property-placeholder  
            location="classpath:/config/properties/redis.properties" />  
      
        <!-- 启用缓存注解功能，这个是必须的，否则注解不会生效，另外，该注解一定要声明在spring主配置文件中才会生效 -->  
        <cache:annotation-driven cache-manager="cacheManager" />  
      
        <!-- spring自己的换管理器，这里定义了两个缓存位置名称 ，既注解中的value -->  
        <bean id="cacheManager" class="org.springframework.cache.support.SimpleCacheManager">  
            <property name="caches">  
                <set>  
                    <bean class="org.cpframework.cache.redis.RedisCache">  
                        <property name="redisTemplate" ref="redisTemplate" />  
                        <property name="name" value="default"/>  
                    </bean>  
                    <bean class="org.cpframework.cache.redis.RedisCache">  
                        <property name="redisTemplate" ref="redisTemplate02" />  
                        <property name="name" value="commonCache"/>  
                    </bean>  
                </set>  
            </property>  
        </bean>  
      
        <!-- redis 相关配置 -->  
        <bean id="poolConfig" class="redis.clients.jedis.JedisPoolConfig">  
            <property name="maxIdle" value="${redis.maxIdle}" />        
            <property name="maxWaitMillis" value="${redis.maxWait}" />  
            <property name="testOnBorrow" value="${redis.testOnBorrow}" />  
        </bean>  
      
        <bean id="connectionFactory"  
            class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory"  
            p:host-name="${redis.host}" p:port="${redis.port}" p:pool-config-ref="poolConfig"  
            p:database="${redis.database}" />  
      
        <bean id="redisTemplate" class="org.springframework.data.redis.core.RedisTemplate">  
            <property name="connectionFactory" ref="connectionFactory" />  
        </bean>  
          
        <bean id="connectionFactory02"  
            class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory"  
            p:host-name="${redis.host}" p:port="${redis.port}" p:pool-config-ref="poolConfig"  
            p:database="${redis.database}" />  
      
        <bean id="redisTemplate02" class="org.springframework.data.redis.core.RedisTemplate">  
            <property name="connectionFactory" ref="connectionFactory02" />  
        </bean>

redis.properties

Java代码  收藏代码

# Redis settings    
    # server IP  
    redis.host=192.168.xx.xx  
    # server port  
    redis.port=6379     
    # use dbIndex  
    redis.database=0  
    # 控制一个pool最多有多少个状态为idle(空闲的)的jedis实例  
    redis.maxIdle=300    
    # 表示当borrow(引入)一个jedis实例时，最大的等待时间，如果超过等待时间(毫秒)，则直接抛出JedisConnectionException；  
    redis.maxWait=3000    
    # 在borrow一个jedis实例时，是否提前进行validate操作；如果为true，则得到的jedis实例均是可用的  
    redis.testOnBorrow=true

RedisCache.java

Java代码  收藏代码

package org.cpframework.cache.redis;  
      
    import java.io.ByteArrayInputStream;  
    import java.io.ByteArrayOutputStream;  
    import java.io.IOException;  
    import java.io.ObjectInputStream;  
    import java.io.ObjectOutputStream;  
      
    import org.springframework.cache.Cache;  
    import org.springframework.cache.support.SimpleValueWrapper;  
    import org.springframework.dao.DataAccessException;  
    import org.springframework.data.redis.connection.RedisConnection;  
    import org.springframework.data.redis.core.RedisCallback;  
    import org.springframework.data.redis.core.RedisTemplate;  
      
      
    public class RedisCache implements Cache {  
      
        private RedisTemplate<String, Object> redisTemplate;  
        private String name;  
      
        public RedisTemplate<String, Object> getRedisTemplate() {  
            return redisTemplate;  
        }  
      
        public void setRedisTemplate(RedisTemplate<String, Object> redisTemplate) {  
            this.redisTemplate = redisTemplate;  
        }  
      
        public void setName(String name) {  
            this.name = name;  
        }  
      
        @Override  
        public String getName() {  
            // TODO Auto-generated method stub  
            return this.name;  
        }  
      
        @Override  
        public Object getNativeCache() {  
            // TODO Auto-generated method stub  
            return this.redisTemplate;  
        }  
      
        @Override  
        public ValueWrapper get(Object key) {  
            // TODO Auto-generated method stub  
            final String keyf = (String) key;  
            Object object = null;  
            object = redisTemplate.execute(new RedisCallback<Object>() {  
                public Object doInRedis(RedisConnection connection)  
                        throws DataAccessException {  
      
                    byte[] key = keyf.getBytes();  
                    byte[] value = connection.get(key);  
                    if (value == null) {  
                        return null;  
                    }  
                    return toObject(value);  
      
                }  
            });  
            return (object != null ? new SimpleValueWrapper(object) : null);  
        }  
      
        @Override  
        public void put(Object key, Object value) {  
            // TODO Auto-generated method stub  
            final String keyf = (String) key;  
            final Object valuef = value;  
            final long liveTime = 86400;  
      
            redisTemplate.execute(new RedisCallback<Long>() {  
                public Long doInRedis(RedisConnection connection)  
                        throws DataAccessException {  
                    byte[] keyb = keyf.getBytes();  
                    byte[] valueb = toByteArray(valuef);  
                    connection.set(keyb, valueb);  
                    if (liveTime > 0) {  
                        connection.expire(keyb, liveTime);  
                    }  
                    return 1L;  
                }  
            });  
        }  
      
        /**
         * 描述 : <Object转byte[]>. <br>
         * <p>
         * <使用方法说明>
         * </p>
         *  
         * @param obj
         * @return
         */  
        private byte[] toByteArray(Object obj) {  
            byte[] bytes = null;  
            ByteArrayOutputStream bos = new ByteArrayOutputStream();  
            try {  
                ObjectOutputStream oos = new ObjectOutputStream(bos);  
                oos.writeObject(obj);  
                oos.flush();  
                bytes = bos.toByteArray();  
                oos.close();  
                bos.close();  
            } catch (IOException ex) {  
                ex.printStackTrace();  
            }  
            return bytes;  
        }  
      
        /**
         * 描述 : <byte[]转Object>. <br>
         * <p>
         * <使用方法说明>
         * </p>
         *  
         * @param bytes
         * @return
         */  
        private Object toObject(byte[] bytes) {  
            Object obj = null;  
            try {  
                ByteArrayInputStream bis = new ByteArrayInputStream(bytes);  
                ObjectInputStream ois = new ObjectInputStream(bis);  
                obj = ois.readObject();  
                ois.close();  
                bis.close();  
            } catch (IOException ex) {  
                ex.printStackTrace();  
            } catch (ClassNotFoundException ex) {  
                ex.printStackTrace();  
            }  
            return obj;  
        }  
      
        @Override  
        public void evict(Object key) {  
            // TODO Auto-generated method stub  
            final String keyf = (String) key;  
            redisTemplate.execute(new RedisCallback<Long>() {  
                public Long doInRedis(RedisConnection connection)  
                        throws DataAccessException {  
                    return connection.del(keyf.getBytes());  
                }  
            });  
        }  
      
        @Override  
        public void clear() {  
            // TODO Auto-generated method stub  
            redisTemplate.execute(new RedisCallback<String>() {  
                public String doInRedis(RedisConnection connection)  
                        throws DataAccessException {  
                    connection.flushDb();  
                    return "ok";  
                }  
            });  
        }  
      
    }