使用Redis做Mybatis的二级缓存

前因

处室的一个项目，会有大量的数据需要频繁被使用（查询），很少做新增修改删除的操作，这种数据很适合使用Redis进行缓存，所以新的版本想把Redis引入进来。

细化

使用Redis倒是难度不大，但是怎么样舒服的使用Redis就要多考虑一下了：
1、可以使用Jedis直接对Redis操作，这样的好处是全部自主掌控，可以在自己需要的地方增加对Redis的操作，坏处也显而易见，就是对现有代码改造比较大；另外一种方法是，通过Mybatis的二级缓存实现，优点是，对现有代码改造少，缺点也有，下面说。

2、单位对Redis的支持力度一般，不像有些公司会搭建平台级的Redis，我们都是每个项目自己搭建自己的Redis环境。所以很多同事会对Redis的高可用性报以怀疑（主要因为不熟悉），所以要保证Redis挂了之后，系统可以照常使用（读DB）。进而要求做一个开关，可以选择性的使用Redis。总结，两个问题：
1）设置开关；关闭时，不使用Redis。
2）开关打开后，系统在运行过程中，Redis挂了，系统应该照常运行。

3、领导想把Redis做成整个处室所有系统公用的，所以在Redis中的Key需要做一定的处理。

实现

吐槽一下，单位的网...连不上...github

1、pom.xml

<dependency>
    <groupId>org.mybatis.caches</groupId>
    <artifactId>mybatis-redis</artifactId>
    <version>1.0.0-beta2</version>
</dependency>

2、redis.properties，放到resource目录下

redis.ip=localhost    redis地址
redis.port=6379        redis端口
jedis.pool.maxActive=3000    最大连接数
jedis.pool.maxIdle=1000        空闲时最大连接数
jedis.pool.maxWait=1500        最大等待时间
jedis.pool.testOnBorrow=true
jedis.pool.testOnReturn=true

redis.switch = true    开关
redis.key = SOA        redis的KEY,以这个开头，区分系统

3、实现org.apache.ibatis.cache.Cache接口
见文章最下方

4、mybatis-config.xml开启二级缓存
<setting name="cacheEnabled" value="true" />

5、mybatis的Mapper配置文件中增加配置：
<cache type="com.taikang.tms.cache.RedisCache" />

<select id="selectAllConfig" resultMap="dataSourceConfig" useCache="false">
    select id,managecom,dataSourceName,managename from dataSourceConfig
</select>

其中useCache="false"表示，这个查询SQL不进行缓存。

<select id="selectConfigByManagecom" resultMap="dataSourceConfig" parameterType="String" useCache="true">
    select id,managecom,dataSourceName,managename from dataSourceConfig where managecom=#{managecom} 
</select>

useCache="true"，这个查询SQL的结果进行缓存。（第一个sql是查询全部，一般这种sql我们不做缓存）

其余的insert、update、delete操作，可以进行如下配置：
flushCache="true/false"，当设置成true的时候，执行sql会把redis中的缓存删除（调用Cache实现类的clear()方法），设置成false，则不做操作。

所以到这里也可以清楚的理解何时进行缓存、何时进行删除缓存了：
程序刚启动的时候，Redis中是空的。
每次执行select的时候，首先会去redis读取，读取不到的话，再去db中查询，查询结束后，将结果存入redis中，注意，如果sql查询无结果，也会放入redis中。
执行insert、update、delete语句的时候，清除对应的redis中的值。

上面说到使用这种方式的缺点....就是...框架自动生成的key看的很不爽，比如：
-189751634:3770288340:DataSourceConfigMapper.selectConfigByManagecom:0:2147483647:select id,managecom,dataSourceName,managename from dataSourceConfig where managecom=?:C

这是一个Key，从这个也能看出来，有一部分是select的查询语句。前面的数字看起来就不爽了，没有翻源码，不知道是啥含义。

这里还有一个坑需要注意，就是缓存删除，前面说过执行mybatis配置文件中的insert、update、delete操作的时候会删除缓存，不过有些系统....会直接登录到数据库上做一些操作吧，这种操作，缓存肯定是无法删除的。
我们系统做的更简单，因为我们系统中，这些需要缓存的数据基本上都是通过SQL语句初始化进去的，不需要前台有维护页面，所以...每次维护数据之和，手动去redis中进行flushdb。或者考虑启动服务的时候删除，或者前台做一个按钮什么的，点击一下删除redis中的缓存。

---

单位的网....不能连接github，今天尝试了一下使用其他的代码托管网站，也都失败了，并且我没有找到简书上如何上传附件，这次拼了，直接上代码：

RedisCache.java

package com.taikang.tms.cache;

import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

import org.apache.ibatis.cache.Cache;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.taikang.tms.util.JedisUtils;
import com.taikang.tms.util.ConfigUtils;

public class RedisCache implements Cache {

    private static Logger logger = LoggerFactory.getLogger(RedisCache.class);
     
    private String cacheId;
     
    private final ReadWriteLock readWriteLock = new ReentrantReadWriteLock(true);
     
    public RedisCache(String cacheId) {
        if (cacheId == null) {
            throw new IllegalArgumentException("Cache instances require an ID");
        }
        this.cacheId = ConfigUtils.key + "." + cacheId;
        logger.info("NTSRedisCache cacheId ========== " + cacheId);
        
        if(ConfigUtils.redisSwitch){
            JedisUtils.getInstance();
        }
    }

    @Override
    public String getId() {
        return cacheId;
    }
 
    @Override
    public void putObject(Object key, Object value) {
        //TODO:开关采用一个静态变量，每个需要使用redis的地方，都判断这个变量，比较繁琐
        logger.info("NTSRedisCache putObject = " + cacheId);
        
        if(ConfigUtils.redisSwitch){
            JedisUtils.put(cacheId, key, value);
        }
    }
 
    @Override
    public Object getObject(Object key) {
        logger.info("NTSRedisCache getObject = " + cacheId);
        
        if(ConfigUtils.redisSwitch){
            return JedisUtils.get(cacheId, key);
        }else{
            return null;
        }
    }
 
    @Override
    public Object removeObject(Object key) {
        logger.info("NTSRedisCache removeObject = " + cacheId);
        
        if(ConfigUtils.redisSwitch){
            return JedisUtils.remove(cacheId, key);
        }else{
            return null;
        }
    }
 
    @Override
    public void clear() {
        logger.info("NTSRedisCache clear = " + cacheId);
        
        if(ConfigUtils.redisSwitch){
            JedisUtils.removeAll(cacheId);
        }
    }
 
    @Override
    public int getSize() {
        logger.info("NTSRedisCache getSize = " + cacheId);
        
        if(ConfigUtils.redisSwitch){
            return JedisUtils.getSize(cacheId);
        }else{
            return -1;
        }
    }
 
    @Override
    public ReadWriteLock getReadWriteLock() {
        return readWriteLock;
    }
 
}

所用到的几个工具类：

ConfigUtils.java

package com.taikang.tms.util;

import java.io.IOException;
import java.util.Properties;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import redis.clients.jedis.JedisPool;

public class ConfigUtils {
    private static Logger logger = LoggerFactory.getLogger(ConfigUtils.class);
    
    public static boolean redisSwitch ;
    public static int maxIdle ;
    public static boolean testOnBorrow;
    public static boolean testOnReturn;
    public static String ip;
    public static int port;
    public static String key;
    
    public static int fail_count = 0 ;
    
    static {
        Properties props = new Properties();
        try {
            props.load(JedisUtils.class.getResourceAsStream("/properties/redis.properties"));
            
            redisSwitch = Boolean.valueOf(props.getProperty("redis.switch"));
            maxIdle = Integer.valueOf(props.getProperty("jedis.pool.maxIdle"));
            testOnBorrow = Boolean.valueOf(props.getProperty("jedis.pool.testOnBorrow"));
            testOnReturn = Boolean.valueOf(props.getProperty("jedis.pool.testOnReturn"));
            ip = props.getProperty("redis.ip") ;
            port = Integer.valueOf(props.getProperty("redis.port"));
            key = props.getProperty("redis.key") ;
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        
    }
    
    public static void setSwitch(boolean redisSwitch){
        if(true == ConfigUtils.redisSwitch && false == redisSwitch){
            //switch : open --> close
            logger.info("switch : open --> close");
            JedisUtils.closeJedisPool();
        }else if(false == ConfigUtils.redisSwitch && true == redisSwitch){
            //switch : close --> open
            logger.info("switch : close --> open");
            JedisUtils.getInstance();
        }
        
        ConfigUtils.redisSwitch = redisSwitch ;
    }
    
    //TODO:当redis连接异常超过一定数量之后， 不再走redis,但是没有一个机制，当redis恢复之后会重新使用redis
    public static void setFailCount(){
        if(redisSwitch){
            fail_count += 1;
            
            //TODO:失败数量配置到配置文件中
            if(fail_count > 10){
                logger.info(" setSwitch(false) ");
                setSwitch(false);
            }
        }
    }
    
    public static void setSucc(){
        if(fail_count > 0 ){
            fail_count = 0 ;
        }
        
        if(!redisSwitch){
            setSwitch(true);
        }
    }
}

JedisUtils.java

package com.taikang.tms.util;

import java.io.IOException;
import java.util.Map;
import java.util.Properties;

import org.mybatis.caches.redis.RedisCallback;
import org.mybatis.caches.redis.SerializeUtil;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;
import redis.clients.jedis.exceptions.JedisConnectionException;

public class JedisUtils {
     
    private static Logger logger = LoggerFactory.getLogger(JedisUtils.class);
    
    private static JedisPool JEDISPOOL;
  
    public static void getInstance(){
        if(JEDISPOOL == null){
            logger.info(" JedisUtils getInstance ");
            Properties props = new Properties();
            try {
                //TODO:配置文件固定，换成使用spring加载的方式
                JedisPoolConfig conf = new JedisPoolConfig();
                conf.setMaxIdle(ConfigUtils.maxIdle);   
                conf.setTestOnBorrow(ConfigUtils.testOnBorrow);   
                conf.setTestOnReturn(ConfigUtils.testOnReturn);
                JEDISPOOL = new JedisPool(conf, ConfigUtils.ip, ConfigUtils.port);
            } catch (Exception e) {
                logger.error("加载[jedis.properties]异常[" + e.getMessage() + "]", e);
            }
        }
    }
    
    
    public static Jedis getJedis() {
        try{
              return JEDISPOOL.getResource();
        }catch (Exception e) {
              //throw new JedisConnectionException("Could not get a resource from the pool");
              return null;
        }
    }
     
    public static void recycleJedis(Jedis jedis) {
        if(jedis != null){
            jedis.close();
        }
    }
    
    public static void closeJedisPool(){
        if(JEDISPOOL != null){
            JEDISPOOL.close();
        }
    }
     
    /**
     * Redis存储Object序列化流
     * */
    public static void put(String id , Object key, Object value) {
        Jedis jedis = getJedis();
        try{
            logger.info(" redis put ... key = [" + key + "]");
            //jedis.set(SerializeUtils.serialize(key), SerializeUtils.serialize(value));
            jedis.hset(id.toString().getBytes(), key.toString().getBytes(), SerializeUtils.serialize(value));
            //TODO:考虑用切片处理
            ConfigUtils.setSucc();
        }catch(Exception e){
            //TODO:异常放在utils中捕捉，还是在NTSRedisCache捕捉
            //TODO:统一异常处理方法
            ConfigUtils.setFailCount();
            logger.error("Redis执行异常[" + e.getMessage() + "]" , e);
        }finally {
            recycleJedis(jedis);
        }
    }
     
    public static <T> T get(String id , Object key) {
        Jedis jedis = getJedis();
        try{
            //T value = SerializeUtils.unserialize(jedis.get(SerializeUtils.serialize(key)));
            T value = SerializeUtils.unserialize(jedis.hget(id.toString().getBytes(), key.toString().getBytes()));
            logger.info(" redis get ... key = [" + key + "] , value = [" + value + "]");

            ConfigUtils.setSucc();
            return value;
        }catch(Exception e){
            ConfigUtils.setFailCount();
            logger.error("Redis执行异常[" + e.getMessage() + "]" , e);
        }finally {
            recycleJedis(jedis);
        }
        return null;
    }
     
    public static Long remove(String id , Object key) {
        Jedis jedis = getJedis();
        try{
            Long num = jedis.hdel(id.toString(), key.toString());;
            //Long num = jedis.del(SerializeUtils.serialize(key));
            ConfigUtils.setSucc();
            return num;
        }catch(Exception e){
            ConfigUtils.setFailCount();
            logger.error("Redis执行异常[" + e.getMessage() + "]" , e);
        }finally {
            recycleJedis(jedis);
        }
        return 0L;
    }
     
    public static void removeAll(String id) {
        Jedis jedis = getJedis();
        try{
            jedis.del(id.toString());
            //jedis.flushDB();
            ConfigUtils.setSucc();
        }catch(Exception e){
            ConfigUtils.setFailCount();
            logger.error("Redis执行异常[" + e.getMessage() + "]" , e);
        }finally {
            recycleJedis(jedis);
        }
    }
    
    public static int getSize(String id) {
        return 0;
        /*Jedis jedis = getJedis();
        try{
            Map<byte[], byte[]> result = jedis.hgetAll(id.toString().getBytes());
            return result.size();
        }catch(Exception e){
            ConfigUtils.setFailCount();
            logger.error("Redis执行异常[" + e.getMessage() + "]" , e);
        }finally {
            recycleJedis(jedis);
        }
        return -1 ;*/
    }
}

SerializeUtils.java

package com.taikang.tms.util;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;

public class SerializeUtils {
     
    //private static final Logger logger = Logger.getLogger(SerializeUtils.class);
     
    private static void close(ObjectOutputStream objectOutputStream, ByteArrayOutputStream byteArrayOutputStream) {
        try {
            if (byteArrayOutputStream != null) {
                byteArrayOutputStream.close();
            }
            if (objectOutputStream != null) {
                objectOutputStream.close();
            }
        } catch (Exception e) {
            e.printStackTrace();
            //logger.error("关闭IO资源异常[" + e.getMessage() + "]", e);
        }
    }
     
    private static void close(ObjectInputStream objectInputStream, ByteArrayInputStream byteArrayInputStream) {
        try {
            if (objectInputStream != null) {
                objectInputStream.close();
            }
            if (byteArrayInputStream != null) {
                byteArrayInputStream.close();
            }
        } catch (Exception e) {
            e.printStackTrace();
            //logger.error("关闭IO资源异常[" + e.getMessage() + "]", e);
        }
    }
     
    public static byte[] serialize(Object object) {
        ObjectOutputStream objectOutputStream = null;
        ByteArrayOutputStream byteArrayOutputStream = null;
        try {
            byteArrayOutputStream = new ByteArrayOutputStream();
            objectOutputStream = new ObjectOutputStream(byteArrayOutputStream);
            objectOutputStream.writeObject(object);
            byte[] bytes = byteArrayOutputStream.toByteArray();
            return bytes;
        } catch (Exception e) {
            e.printStackTrace();
            //logger.error("序列化对象异常[" + e.getMessage() + "]", e);
        } finally {
            close(objectOutputStream, byteArrayOutputStream);
        }
        return null;
    }
 
    @SuppressWarnings("unchecked")
    public static <T> T unserialize(byte[] bytes) {
        if (bytes == null)
            return null;
        ByteArrayInputStream byteArrayInputStream = null;
        ObjectInputStream objectInputStream = null;
        try {
            byteArrayInputStream = new ByteArrayInputStream(bytes);
            objectInputStream = new ObjectInputStream(byteArrayInputStream);
            return (T) objectInputStream.readObject();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            close(objectInputStream, byteArrayInputStream);
        }
        return null;
    }
 
}

测试用例...就不贴了，我继续找找单位可以使用的代码托管软件..话说，今天连各种SVN都试过了。