使用 Redis 做 MyBatis 二级缓存

1. 首先安装 Redis Server，设置好用户名密码，然后 pom 里添加依赖：

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

2. mybatis-config.xml 文件开启缓存：

<setting name="cacheEnabled" value="true" /> 

3. Spring 容器里定义 redisTemplate Bean:

<bean id="poolConfig" class="redis.clients.jedis.JedisPoolConfig">
	<property name="maxIdle" value="100" />
	<property name="maxTotal" value="500" />
	<property name="testOnBorrow" value="true" />
</bean>

<bean id="connectionFactory"  class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory">
	<property name="hostName" value="127.0.0.1" />
	<property name="port" value="6379" />
	<property name="password" value="" />
	<property name="poolConfig" ref="poolConfig" />
</bean>

<bean id="redisTemplate" class="org.springframework.data.redis.core.RedisTemplate">
	<property name="connectionFactory" ref="connectionFactory" />
</bean>

4. 实现二级缓存处理类：

package com.hebta.vinci.controller;

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

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 org.springframework.web.context.ContextLoader;

public class RedisCache implements Cache {
	private static final Logger logger = Logger.getLogger(RedisCache.class);

	private final ReadWriteLock readWriteLock = new ReentrantReadWriteLock();

	/*
	 * 由于 Mapper.xml 是运行时通过反射生成代理类，所以无法注册为 Spring Bean，
	 * 也就无法通过依赖注入 redisTemplate, 需要在方法调用的时候初始化此变量
	 */	
	private RedisTemplate<Serializable, Serializable> redisTemplate;  

	private String id;

	private JdkSerializationRedisSerializer jdkSerializer = new JdkSerializationRedisSerializer();

	// 通过 ContextLoader 静态方法获取 Bean，初始化 redisTemplate 属性
	private RedisTemplate<Serializable, Serializable> getRedisTemplate(){
		if (redisTemplate == null){
			redisTemplate = (RedisTemplate<Serializable, Serializable>) ContextLoader.getCurrentWebApplicationContext().getBean("redisTemplate"); 
		}
		return redisTemplate;
	}

	@Override
	public void putObject(Object key, Object value) {
		logger.info("enter RedisCache.putObject(), key is ##  " + key);
		if (value != null) {
			getRedisTemplate().opsForValue().set(key.toString(), jdkSerializer.serialize(value), 1, TimeUnit.DAYS);
		}
	}

	@Override
	public Object getObject(Object key) {
		logger.info("enter RedisCache.getObject(), the key is :: " + key);
		try {
			if (key != null) {
				Object obj = getRedisTemplate().opsForValue().get(key.toString());
				return jdkSerializer.deserialize((byte[]) obj);
			}
		} catch (Exception e) {
			logger.error("redis " + e.getMessage());
		}
		return null;
	}

	@Override
	public Object removeObject(Object key) {
		try {
			if (key != null) {
				getRedisTemplate().expire(key.toString(), 1, TimeUnit.SECONDS);
			}
		} catch (Exception e) {
			logger.error("redis " + e.getMessage());
		}
		return null;
	}

	@Override
	public void clear() {
		// jedis not support
	}

	@Override
	public int getSize() {
		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 readWriteLock;
	}

	public RedisCache() {
		super();
	}

	public RedisCache(final String id) {
		this.id = id;
	}

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

5. 将二级缓存实现类注册到 **Mapper.xml 里：

6. POJO 类需要实现序列化接口：

项目中所有需要二级缓存的 Mapper.xml 和对应 POJO 类都要做第 5，6 步。

Mybatis 的 CacheKey 的 key 实在太长了，它的 toString() 方法按照下列规则生成：

1. mapper id : mapper.xml 的全限定名+方法名
2. 查询结果返回条数的 offset 和 limit
3. 查询语句字符串，所有入参
这些条件被用来计算 checksum 和 hashcode, 整个 key.toString() = hashcode + checksum + id + offset + limit + sql + parameters, 
中间以分号分隔，尤其当 sql/parameters 很长的话，key 就非常长，作为 redis 里面的 key 不合适。

一个例子：

这个 key 被 MyBatis 用来作为一级缓存的，也可以用来作为二级缓存的，第 88 行判断是否开启了二级缓存，是则在 101 行将当前查询结果放入二级缓存。所以上面定义的二级缓存实现类，最好要对 key.toString() 返回的字符串进行压缩，这样可以使 key 在 redis 容器里简短。