spring整合redis缓存并以注解(@Cacheable、@CachePut、@CacheEvict)形式使用

maven项目中在pom.xml中依赖2个jar包，其他的spring的jar包省略：

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

spring-Redis.xml中的内容：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans" 
  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p" 
  xmlns:context="http://www.springframework.org/schema/context" 
  xmlns:mvc="http://www.springframework.org/schema/mvc" 
  xmlns:cache="http://www.springframework.org/schema/cache"
  xsi:schemaLocation="http://www.springframework.org/schema/beans  
            http://www.springframework.org/schema/beans/spring-beans-4.2.xsd  
            http://www.springframework.org/schema/context  
            http://www.springframework.org/schema/context/spring-context-4.2.xsd  
            http://www.springframework.org/schema/mvc  
            http://www.springframework.org/schema/mvc/spring-mvc-4.2.xsd
            http://www.springframework.org/schema/cache 
            http://www.springframework.org/schema/cache/spring-cache-4.2.xsd"> 
    
  <context:property-placeholder location="classpath:redis-config.properties" /> 
  
  <!-- 启用缓存注解功能，这个是必须的，否则注解不会生效，另外，该注解一定要声明在spring主配置文件中才会生效 --> 
  <cache:annotation-driven cache-manager="cacheManager" /> 
    
   <!-- 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="JedisConnectionFactory" class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory" 
    p:host-name="${redis.host}" p:port="${redis.port}" p:password="${redis.pass}" p:pool-config-ref="poolConfig"/> 
   
   <bean id="redisTemplate" class="org.springframework.data.redis.core.RedisTemplate"> 
     <property name="connectionFactory" ref="JedisConnectionFactory" /> 
   </bean> 
    
   <!-- spring自己的缓存管理器，这里定义了缓存位置名称 ，即注解中的value --> 
   <bean id="cacheManager" class="org.springframework.cache.support.SimpleCacheManager"> 
     <property name="caches"> 
      <set> 
        <!-- 这里可以配置多个redis -->
        <!-- <bean class="com.cn.util.RedisCache"> 
           <property name="redisTemplate" ref="redisTemplate" /> 
           <property name="name" value="default"/> 
        </bean> --> 
        <bean class="com.cn.util.RedisCache"> 
           <property name="redisTemplate" ref="redisTemplate" /> 
           <property name="name" value="common"/> 
           <!-- common名称要在类或方法的注解中使用 -->
        </bean>
      </set> 
     </property> 
   </bean> 
    
</beans>

redis-config.properties中的内容：

# Redis settings
# server IP
redis.host=127.0.0.1
# server port
redis.port=6379
# server pass
redis.pass=
# 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

com.cn.util.RedisCache类中的内容：

package com.cn.util;

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
        System.out.println("get key");
        final String keyf = key.toString();
        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
        System.out.println("put key");
        final String keyf = key.toString();
        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;
            }
        });
    }

    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;
    }

    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
        System.out.println("del key");
        final String keyf = key.toString();
        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
        System.out.println("clear key");
        redisTemplate.execute(new RedisCallback<String>() {
            public String doInRedis(RedisConnection connection) throws DataAccessException {
                connection.flushDb();
                return "ok";
            }
        });
    }

    @Override
    public <T> T get(Object key, Class<T> type) {
        // TODO Auto-generated method stub
        return null;
    }

    @Override
    public ValueWrapper putIfAbsent(Object key, Object value) {
        // TODO Auto-generated method stub
        return null;
    }

}

到了这一步，大部分人会想在web.xml的启动配置文件地方(context-param)加入了spring-redis.xml,让项目启动时加载这个配置文件吧，但是这样启动后注解不生效。

正确的做法是：web.xml中配置了servlet控制器：

<servlet>
 <servlet-name>SpringMVC</servlet-name>
 <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class> 
 <init-param>
  <param-name>contextConfigLocation</param-name>
  <param-value>/WEB-INF/spring-mvc.xml</param-value>
 </init-param>
 <load-on-startup>1</load-on-startup>
 <async-supported>true</async-supported>
</servlet>

在DispatcherServlet的初始化过程中，框架会在web应用的 WEB-INF文件夹下寻找名为spring-mvc.xml的配置文件，如果不指定的话，默认是applicationContext.xml

只需要在spring-mvc.xml文件中引入spring-redis配置文件即可，正如spring-redis.xml中的启用注解说的：<cache:annotation-driven cache-manager="cacheManager" />注解一定要声明在spring主配置文件中才会生效。

spring-mvc.xml内容，省略了spring与spring MVC整合的那部分：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans" 
  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p" 
  xmlns:context="http://www.springframework.org/schema/context" 
  xmlns:mvc="http://www.springframework.org/schema/mvc" 
  xsi:schemaLocation="http://www.springframework.org/schema/beans  
            http://www.springframework.org/schema/beans/spring-beans-4.2.xsd  
            http://www.springframework.org/schema/context  
            http://www.springframework.org/schema/context/spring-context-4.2.xsd  
            http://www.springframework.org/schema/mvc  
            http://www.springframework.org/schema/mvc/spring-mvc-4.2.xsd">
  <!-- 自动扫描该包，使SpringMVC认为包下用了@controller注解的类是控制器 --> 
  <context:component-scan base-package="com.cn" /> 
    
  <!-- 引入同文件夹下的redis属性配置文件 -->
  <import resource="spring-redis.xml"/>
    
</beans>

在service的实现类中：

@Service
public class UserServiceImpl implements UserService {

    @Autowired
    private UserBo userBo;

    @Cacheable(value = "common", key = "'id_'+#id")
    public User selectByPrimaryKey(Integer id) {
        return userBo.selectByPrimaryKey(id);
    }

    @CachePut(value = "common", key = "#user.getUserName()")
    public void insertSelective(User user) {
        userBo.insertSelective(user);
    }

    @CacheEvict(value = "common", key = "'id_'+#id")
    public void deleteByPrimaryKey(Integer id) {
        userBo.deleteByPrimaryKey(id);
    }
}

原文链接：http://blog.csdn.net/aqsunkai/article/details/51758900

spring整合redis缓存并以注解(@Cacheable、@CachePut、@CacheEvict)形式使用

免责声明！