mybatis+redis实现二级缓存

在网上看了很多资料，发现例子都是千篇一律的相互复制。而且，使用的都是jedis的客户端。。我这里使用的是redistemplate类实现。

缓存的原理。。实现cache类接口，当哪个类需要缓存的时候，就直接将cache标签引入，并且制定我们的缓存类就可以了。

上代码：

1、引入spring-data-redis

 <!-- redis服务 start-->
         <dependency>
           <groupId>org.springframework.data</groupId>
           <artifactId>spring-data-redis</artifactId>
           <version>1.6.2.RELEASE</version>
         </dependency>

2、java缓存类，至于里面如何获取bean，ApplicationUtil.getBean("redisTemplate")，请查看我上篇文章：普通java类获取springbean的方法

 package com.iafclub.demo.cache;

 import java.io.Serializable;
 import java.util.Set;
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.locks.ReadWriteLock;
 import java.util.concurrent.locks.ReentrantReadWriteLock;

 import org.apache.commons.codec.digest.DigestUtils;
 import org.apache.ibatis.cache.Cache;
 import org.apache.log4j.Logger;
 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;
 import org.springframework.data.redis.serializer.JdkSerializationRedisSerializer;

 import com.iafclub.demo.util.ApplicationUtil;

 /**
  * 使用第三方缓存服务器，处理二级缓存
  * 缓存时间在putObject中设置
  *
  * @author chenweixian
  *
  */
 public class RedisCache implements Cache {
     private static final Logger logger = Logger.getLogger(RedisCache.class);

     private final ReadWriteLock readWriteLock = new ReentrantReadWriteLock(true);

     private final String COMMON_CACHE_KEY = "demo:MYBATIS:";

     private String id;

     private JdkSerializationRedisSerializer jdkSerializer = new JdkSerializationRedisSerializer();
     /**所有key*/
     private String getKeys() {
         return COMMON_CACHE_KEY + this.id + ":*";
     }
     /**
      * 按照一定规则标识key
      */
     private String getKey(Object key) {
         return COMMON_CACHE_KEY + this.id + ":"+DigestUtils.md5Hex(String.valueOf(key));
     }

     public RedisTemplate<String, Serializable> getRedisTemplate(){
         return (RedisTemplate<String, Serializable>) ApplicationUtil.getBean("redisTemplate");
     }

     public RedisCache(final String id) {
         if (id == null) {
             throw new IllegalArgumentException("必须传入ID");
         }
         logger.debug("MybatisRedisCache:id=" + id);
         this.id = id;
     }

     @Override
     public String getId() {
         return this.id;
     }

     @Override
     public void putObject(Object key, Object value) {
         if (getRedisTemplate()==null){
             return ;
         }
         if (value != null) {
             getRedisTemplate().opsForValue().set(getKey(key),
                     jdkSerializer.serialize(value), 20, TimeUnit.SECONDS);
         }
     }

     @Override
     public Object getObject(Object key) {
         if (getRedisTemplate()==null){
             return null;
         }
         try {
             if (key != null) {
                 Object obj = getRedisTemplate().opsForValue().get(getKey(key));
                 return jdkSerializer.deserialize((byte[]) obj);
             }
         } catch (Exception e) {
             logger.error("redis ");
         }
         return null;
     }

     @Override
     public Object removeObject(Object key) {
         if (getRedisTemplate()==null){
             return null;
         }
         try {
             if (key != null) {
                 getRedisTemplate().delete(getKey(key));
                 logger.debug("从缓存中移除-----"+this.id);
             }
         } catch (Exception e) {
         }
         return null;
     }

     @Override
     public void clear() {
         if (getRedisTemplate()==null){
             return ;
         }
         try {
             Set<String> keys = getRedisTemplate().keys(getKeys());
             getRedisTemplate().delete(keys);
             logger.debug("出现新增、修改、删除操作，清空对应Mapper缓存======>"+keys.size());
         } catch (Exception e) {
             logger.error(e.getMessage(), e);
         }
     }

     @Override
     public int getSize() {
         if (getRedisTemplate()==null){
             return 0;
         }
         Long size = getRedisTemplate().execute(
                 new RedisCallback<Long>() {
                     @Override
                     public Long doInRedis(RedisConnection connection)
                             throws DataAccessException {
                         return connection.dbSize();
                     }
                 });
         return size.intValue();
     }

     @Override
     public ReadWriteLock getReadWriteLock() {
         return this.readWriteLock;
     }
 }

3、mybatis配置：注意加粗标红，斜线部分:

21 <!-- redis缓存 -->
22 <cache type="com.iafclub.demo.cache.RedisCache" eviction="LRU" />

 <?xml version="1.0" encoding="UTF-8" ?>
 <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd" >
 <mapper namespace="com.iafclub.demo.dao.DictionaryMapper" >
     <resultMap id="BaseResultMap" type="com.iafclub.demo.domain.Dictionary" >
     <id column="auto_id" property="autoId" jdbcType="VARCHAR" />
     <result column="type_id" property="typeId" jdbcType="VARCHAR" />
     <result column="type_name" property="typeName" jdbcType="VARCHAR" />
     <result column="field_key" property="fieldKey" jdbcType="VARCHAR" />
     <result column="field_value" property="fieldValue" jdbcType="VARCHAR" />
     <result column="field_back" property="fieldBack" jdbcType="VARCHAR" />
     <result column="field_back2" property="fieldBack2" jdbcType="VARCHAR" />
     <result column="field_back3" property="fieldBack3" jdbcType="VARCHAR" />
     <result column="remark" property="remark" jdbcType="VARCHAR" />
     <result column="editor" property="editor" jdbcType="VARCHAR" />
     <result column="edittime" property="edittime" jdbcType="TIMESTAMP" />
   </resultMap>
   <sql id="Base_Column_List" >
     auto_id, type_id, type_name, field_key, field_value, field_back, field_back2, field_back3,
     remark, editor, edittime
   </sql>
21 <!-- redis缓存 -->
22 <cache type="com.iafclub.demo.cache.RedisCache" eviction="LRU" />
   <select id="selectByPrimaryKey" resultMap="BaseResultMap" parameterType="java.lang.String" >
     select
     <include refid="Base_Column_List" />
     from t_dictionary
     where auto_id = #{autoId}
   </select>
   <select id="selectAll" resultMap="BaseResultMap" parameterType="java.lang.String" >
     select
     <include refid="Base_Column_List" />
     from t_dictionary limit 200
   </select>
 </mapper>

4、mybatis配置：

 <?xml version="1.0" encoding="UTF-8" ?>
 <!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN" "http://mybatis.org/dtd/mybatis-3-config.dtd">
 <configuration>
     <settings>
         <!-- 开启缓存 -->
         <setting name="cacheEnabled" value="true"/>
         <!-- Java属性与数据库字段采用驼峰式对应 -->
         <setting name="mapUnderscoreToCamelCase" value="true" />
     </settings>
     <!--
     <settings>
         <setting name="useColumnLabel" value="true"/>
         <setting name="useGeneratedKeys" value="false"/>
         <setting name="cacheEnabled" value="true" /> 这个配置使全局的映射器启用或禁用缓存
         <setting name="multipleResultSetsEnabled" value="true"/>对于未知的SQL查询，允许返回不同的结果集以达到通用的效果
         <setting name="defaultExecutorType" value="REUSE" />配置默认的执行器。SIMPLE 执行器没有什么特别之处。REUSE 执行器重用预处理语句。BATCH 执行器重用语句和批量更新
         <setting name="lazyLoadingEnabled" value="false" />全局启用或禁用延迟加载。当禁用时，所有关联对象都会即时加载
         <setting name="aggressiveLazyLoading" value="true" />
         <setting name="enhancementEnabled" value="true"/>
         <setting name="defaultStatementTimeout" value="25000" /> 设置超时时间，它决定驱动等待一个数据库响应的时间。
     </settings>
      -->
 </configuration>

5、其他页面实现，次要。。。

n、测试运行结果：只有第一次查询，发送了sql，第二次后，就不会发送sql，直接在redis中查询。如果进行增删改，都会清空，然后，再发sql