Mybatis整合Redis实现二级缓存

本期内容：

1、集成ehcache

2、集成redis

一、mybatis使用ehcache作为二级缓存 1、导入相关依赖


    org.springframework
    spring-context-support
    ${spring.version}




    org.mybatis.caches
    mybatis-ehcache
    1.1.0




    net.sf.ehcache
    ehcache
    2.10.0

2、修改日志配置，因为ehcache使用了Slf4j作为日志输出

日志我们使用slf4j，并用log4j来实现。SLF4J不同于其他日志类库，与其它有很大的不同。

SLF4J(Simple logging Facade for Java)不是一个真正的日志实现，而是一个抽象层，

它允许你在后台使用任意一个日志类库。

将pom.xml文件中相关配置修改：将图片内的内容分别修改为以下代码


    2.9.1
    3.2.0
    1.7.13



    
    
    
      org.slf4j
      slf4j-api
      ${slf4j.version}
    
    
      org.slf4j
      jcl-over-slf4j
      ${slf4j.version}
      runtime
    

    
    
      org.apache.logging.log4j
      log4j-api
      ${log4j2.version}
    
    
      org.apache.logging.log4j
      log4j-core
      ${log4j2.version}
    
    
    
      org.apache.logging.log4j
      log4j-slf4j-impl
      ${log4j2.version}
    
    
    
      org.apache.logging.log4j
      log4j-web
      ${log4j2.version}
      runtime
    

    
    
      com.lmax
      disruptor
      ${log4j2.disruptor.version}

3、在Resource中添加一个ehcache.xml的配置文件

在resources中新建ehcache.xml文件：放入缓存策略

4、在applicationContext.xml中加入chache配置

在resources中新建applicationContext.xml文件：

在resources中新建applicationContext-ehcache.xml文件：将ehcache缓存内容放入,配置ehcache中的一些相关配置

5、mybaits的二级缓存是mapper范围级别，除了在SqlMapConfig.xml设置二级缓存的总开关，还要在具体的mapper.xml中开启二级缓存

进入applicationtext-mybatis.xml文件开启二级缓存，在此文件添加内容：

6、在XxxMapper.xml中配置cache，添加二级缓存的核心类

7、可以通过select标签的useCache属性打开或关闭二级缓存

总结框架的缓存策略：

1、二级缓存开启，既可以缓存单条，也可以缓存多条

2、可以通过mapper.xml的useCache属性控制是否使用缓存

8、测试：

    @Test
    public void cacheOne() {
    System.out.println(this.bookService.selectBooksIn(Arrays.asList(new Integer[]{24,28,29})));
    System.out.println(this.bookService.selectBooksIn(Arrays.asList(new Integer[]{24,28,29})));
    }

输出结果：第二次执行时利用了缓存

二、mybatis使用redis作为二级缓存 1、添加redis相关依赖

 
 
    2.9.0
    1.7.1.RELEASE
    
 
    
      redis.clients
      jedis
      ${redis.version}
    
    
      org.springframework.data
      spring-data-redis
      ${redis.spring.version}

2、导入Jackson相关依赖

    2.9.3 



    
      com.fasterxml.jackson.core
      jackson-databind
      ${jackson.version}
    
    
      com.fasterxml.jackson.core
      jackson-core
      ${jackson.version}
    
    
      com.fasterxml.jackson.core
      jackson-annotations
      ${jackson.version}

3、spring + redis 集成实现缓存功能(与mybatis无关)

添加两个redis的配置文件，并将redis.properties和applicationContext-redis.xml配置到applicationContext.xml文件中

注1：将redis.properties导入到applicationContext.xml文件中

在resource文件中新建文件 redis.properties：包含连接信息

#虚拟机的IP
redis.hostName=47.100.191.44
redis.port=6379
redis.password=xiaoli_redis
redis.timeout=10000
redis.maxIdle=300
redis.maxTotal=1000
redis.maxWaitMillis=1000
redis.minEvictableIdleTimeMillis=300000
redis.numTestsPerEvictionRun=1024
redis.timeBetweenEvictionRunsMillis=30000
redis.testonBorrow=true
redis.testWhileIdle=true

在resource文件中新建文件 applicationContext-redis.xml：含有数据源

4、将redis缓存引入到mybatis中

创建mybatis的自定义缓存类“RedisCache”，必须实现org.apache.ibatis.cache.Cache接口

在util包内添加RedisCache.java文件：

package com.lv.util;


import org.apache.ibatis.cache.Cache;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
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 java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;


public class RedisCache implements Cache //实现类
{
    private static final Logger logger = LoggerFactory.getLogger(RedisCache.class);

    private static RedisTemplate redisTemplate;

    private final String id;

    
    private final ReadWriteLock readWriteLock = new ReentrantReadWriteLock();

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

    public static void setRedisTemplate(RedisTemplate redisTemplate) {
        RedisCache.redisTemplate = redisTemplate;
    }

    public RedisCache(final String id) {
        if (id == null) {
            throw new IllegalArgumentException("Cache instances require an ID");
        }
        logger.debug("MybatisRedisCache:id=" + id);
        this.id = id;
    }

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

    @Override
    public void putObject(Object key, Object value) {
        try{
            logger.info(">>>>>>>>>>>>>>>>>>>>>>>>putObject: key="+key+",value="+value);
            if(null!=value) {
                redisTemplate.opsForValue().set(key.toString(),value,60, TimeUnit.SECONDS);
            }
        }catch (Exception e){
            e.printStackTrace();
            logger.error("redis保存数据异常！");
        }
    }

    @Override
    public Object getObject(Object key) {
        try{
            logger.info(">>>>>>>>>>>>>>>>>>>>>>>>getObject: key="+key);
            if(null!=key) {
                return redisTemplate.opsForValue().get(key.toString());
            }
        }catch (Exception e){
            e.printStackTrace();
            logger.error("redis获取数据异常！");
        }
        return null;
    }

    @Override
    public Object removeObject(Object key) {
        try{
            if(null!=key) {
                return redisTemplate.expire(key.toString(),1,TimeUnit.DAYS);
            }
        }catch (Exception e){
            e.printStackTrace();
            logger.error("redis获取数据异常！");
        }
        return null;
    }

    @Override
    public void clear() {
        Long size=redisTemplate.execute(new RedisCallback() {
            @Override
            public Long doInRedis(RedisConnection redisConnection) throws DataAccessException {
                Long size = redisConnection.dbSize();
                //连接清除数据
                redisConnection.flushDb();
                redisConnection.flushAll();
                return size;
            }
        });
        logger.info(">>>>>>>>>>>>>>>>>>>>>>>>clear: 清除了" + size + "个对象");
    }

    @Override
    public int getSize() {
        Long size = redisTemplate.execute(new RedisCallback() {
            @Override
            public Long doInRedis(RedisConnection connection)
                    throws DataAccessException {
                return connection.dbSize();
            }
        });
        return size.intValue();
    }
}

将RedisCache.java文件配置到BookMapper.xml文件中：

4、静态注入中间类“RedisCacheTransfer”，解决RedisCache中RedisTemplate的静态注入，从而使MyBatis实现第三方缓存

在util包内新建RedisCacheTransfer.java类：

package com.lv.util;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;

public class RedisCacheTransfer {
    @Autowired
    public void setRedisTemplate(RedisTemplate redisTemplate) {
        RedisCache.setRedisTemplate(redisTemplate);
    }
}

在applicationContext-redis.xml文件中做配置：

在applicationContext.xml文件中配置：

本期内容结束~

Mybatis整合Redis实现二级缓存

Java相关栏目本月热门文章