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