Mybatis的一级缓存和二级缓存

一：一级缓存：

一级缓存在mybatis中默认是开启的并且是session级别，它的作用域为一次sqlSession会话。

import com.smartdata.pms.PmsApplication;
import com.smartdata.pms.entity.PmsProduct;
import com.smartdata.pms.mapper.PmsProductMapper;
import com.smartdata.pms.service.PmsProductService;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.transaction.annotation.Transactional;

import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

/**
 * @ProjectName: smartdata
 * @Package: PACKAGE_NAME
 * @ClassName: CacheTest
 * @Author: heluwei
 * @Description: 缓存测试
 * @Date: 2020/3/21 18:34
 * @Version: 1.0
 */
@RunWith(SpringJUnit4ClassRunner.class)
@SpringBootTest(classes = PmsApplication.class)
public class CacheTest{
    @Autowired
    PmsProductMapper pmsProductMapper;
    @Test
    @Transactional(rollbackFor = Throwable.class)
    public void testFistCache(){
        // 第一次查询，缓存到一级缓存
        System.out.println(pmsProductMapper.selectById(1));
        // 第二次查询，直接读取一级缓存
        System.out.println(pmsProductMapper.selectById(1));

    }
}

为什么开启事务
由于使用了数据库连接池，默认每次查询完之后自动commite，这就导致两次查询使用的不是同一个sqlSessioin，根据一级缓存的原理，它将永远不会生效。
当我们开启了事务，两次查询都在同一个sqlSession中，从而让第二次查询命中了一级缓存。读者可以自行关闭事务验证此结论。

 

 

 二：二级缓存

默认情况下，mybatis打开了二级缓存，但它并未生效，因为二级缓存的作用域是namespace，所以还需要在Mapper.xml文件中配置一下才能使二级缓存生效

 

使用Redis实现Mybatis的二级缓存。因为Mybatis的二级缓存存放在本地内存中。

一：在yml文件中

#配置mapper
mybatis:
  #开启Mybatis的二级缓存
  configuration:
    cache-enabled: true

二：自定义MybatisRedisCache 

package com.smartdata.pms.cache;

import lombok.extern.slf4j.Slf4j;
import org.apache.ibatis.cache.Cache;
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.core.ValueOperations;
import org.springframework.util.CollectionUtils;

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

/**
 * @ProjectName: smartdata
 * @Package: com.smartdata.pms.cache
 * @ClassName: MyDefineRedisCache
 * @Author: heluwei
 * @Description: 使用Redis缓存Mybatis的二级缓存
 * @Date: 2020/3/22 22:56
 * @Version: 1.0
 */
@Slf4j
public class MybatisRedisCache implements Cache {
    // 读写锁
    private final ReadWriteLock readWriteLock = new ReentrantReadWriteLock(true);

    private static RedisTemplate redisTemplate;

//    private RedisTemplate<String, Object> redisTemplate = SpringContextHolder.getBean("redisTemplate");

    private String id;

    public MybatisRedisCache(final String id) {
        if (id == null) {
            throw new IllegalArgumentException("Cache instances require an ID");
        }
        log.info("Redis Cache id " + id);
        this.id = id;
    }

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

    @Override
    public void putObject(Object key, Object value) {
        if (value != null) {
            // 向Redis中添加数据，有效时间是2天
            redisTemplate.opsForValue().set(key.toString(), value, 2, TimeUnit.DAYS);
        }
    }

    @Override
    public Object getObject(Object key) {
        try {
            if (key != null) {
                Object obj = redisTemplate.opsForValue().get(key.toString());
                return obj;
            }
        } catch (Exception e) {
            log.error(e.getMessage());
        }
        return null;
    }

    @Override
    public Object removeObject(Object key) {
        try {
            if (key != null) {
                redisTemplate.delete(key.toString());
            }
        } catch (Exception e) {
            log.error(e.getMessage());
        }
        return null;
    }

    @Override
    public void clear() {
        log.info("清空缓存");
        try {
            Set<String> keys = redisTemplate.keys("*:" + this.id + "*");
            if (!CollectionUtils.isEmpty(keys)) {
                redisTemplate.delete(keys);
            }
        } catch (Exception e) {
            log.error(e.getMessage());
        }
    }

    @Override
    public int getSize() {
        Long size = (Long) redisTemplate.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;
    }

    public static void setRedisConnectionFactory(RedisTemplate redisTemplate) {
        MybatisRedisCache.redisTemplate = redisTemplate;
    }
}

在spring启动的时候，将redisTemplate注入到MybatisRedisCache类中

package com.smartdata.pms.cache;

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

/**
 * @ProjectName: smartdata
 * @Package: com.smartdata.pms.cache
 * @ClassName: RedisCacheTransfer
 * @Author: heluwei
 * @Description:
 * @Date: 2020/3/22 23:19
 * @Version: 1.0
 */
@Component
public class RedisCacheTransfer {

    @Autowired
    public void setJedisConnectionFactory(RedisTemplate redisTemplate) {
        MybatisRedisCache.setRedisConnectionFactory(redisTemplate);
    }
}

在xml文件中加入<cache></cache>标签

<?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.smartdata.pms.mapper.PmsProductMapper">
    <cache type="com.smartdata.pms.cache.MybatisRedisCache">
        <property name="eviction" value="LRU" />
        <property name="flushInterval" value="6000000" />
        <property name="size" value="1024" />
        <property name="readOnly" value="false" />
    </cache>
    <select id="getPmsProductPage"  resultType="com.smartdata.pms.entity.PmsProduct">
        select * from pms_product pp
        where 1=1
        and pp.del_flag = '0'
        <if test="pmsProduct.proNo != null and pmsProduct.proNo != ''">
            and pp.pro_no = #{pmsProduct.proNo}
        </if>
    </select>

    <select id="getOneById" parameterType="Long" resultType="String">
        select pro_no proNo from pms_product where 1=1 and pro_id = #{pId}
    </select>
</mapper>

缓存的只有在xml中的。利用Mybatis-plus，查询的接口没有效果。

测试：

import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.smartdata.pms.PmsApplication;
import com.smartdata.pms.mapper.PmsProductMapper;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.transaction.annotation.Transactional;


/**
 * @ProjectName: smartdata
 * @Package: PACKAGE_NAME
 * @ClassName: CacheTest
 * @Author: heluwei
 * @Description: 缓存测试
 * @Date: 2020/3/21 18:34
 * @Version: 1.0
 */
@RunWith(SpringJUnit4ClassRunner.class)
@SpringBootTest(classes = PmsApplication.class)
public class CacheTest{
    @Autowired
    PmsProductMapper pmsProductMapper;
    /**
      * @Description: 一级缓存，因为使用了连接池，每次查询自动commit。
     */
    @Test
    @Transactional(rollbackFor = Throwable.class)
    public void testFistCache(){
        // 第一次查询，缓存到一级缓存
        System.out.println(pmsProductMapper.selectById(1));
        // 第二次查询，直接读取一级缓存
        System.out.println(pmsProductMapper.selectById(1));
    }

    /**
     * 测试二级缓存效果
     * 需要*Mapper.xml开启二级缓存
     **/
    @Test
    public void testSecondCache(){
        System.out.println(pmsProductMapper.getOneById(1L));
        System.out.println(pmsProductMapper.getOneById(1L));
        System.out.println(pmsProductMapper.getOneById(1L));
        System.out.println(pmsProductMapper.getOneById(1L));
        System.out.println(pmsProductMapper.selectById(1L));
        System.out.println(pmsProductMapper.selectById(1L));
        System.out.println(pmsProductMapper.selectById(1L));
        System.out.println(pmsProductMapper.selectById(1L));
    }
}