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));
    }
}