【mybatis】之四：mybatis缓存机制

一、概要

mybatis的缓存分为一级缓存和二级缓存。一级缓存是本地缓存，SqlSession级别的。二级缓存是全局缓存。

二、缓存体验

一级缓存体验

    @Test
    public void testFirstLevelCache(){
        SqlSession sqlSession = null;
        try{
            sqlSession = getSession();
            CacheMapper mapper = sqlSession.getMapper(CacheMapper.class);
            Employee e1 = mapper.testFirstLevelCache(1);
            System.out.println("第一次查询完毕");
            Employee e2 = mapper.testFirstLevelCache(1);
            System.out.println("第二次查询完毕");
            boolean b = (e1 == e2);
            System.out.println("e1与e2是否相等：" + b);
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            sqlSession.close();
        }
    }

此例中，使用同一个sqlSession进行查询，然后判断两个对象是否相等。结果如下：

DEBUG [main] - ==>  Preparing: SELECT * FROM tbl_employee where id=? 
DEBUG [main] - ==> Parameters: 1(Integer)
DEBUG [main] - <==      Total: 1
第一次查询完毕
第二次查询完毕
e1与e2是否相等：true

从控制台打印结果可以看出，同一会话中的两次查询，只发送了一条sql语句，并且两次查询出的对象是相等的。如此可以体验到mybatis提供的一级缓存。

二级缓存体验

二级缓存是mybatis的全局缓存，需要进行一些配置项的设置才可以生效。

在全局配置文件中，有如下配置项，用来设置全局缓存的开启或者关闭。

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

然后，在需要使用二级缓存的mapper.xml中，配置如下选项，标识此mapper使用二级缓存，并设置与二级缓存相关的各种参数。

<mapper namespace="com.hly.dao.CacheMapper">
    <cache></cache>
    <select id="testFirstLevelCache" resultType="com.hly.entity.Employee">
        SELECT * FROM tbl_employee where id=#{id}
    </select>
</mapper>

在完成以上配置之后，体验二级缓存之前，还有一个地方需要注意。二级缓存中的内容，是在sqlSession关闭后，将本sqlSession的缓存结果放入二级缓存。

    @Test
    public void testSecondLevelCache(){
        SqlSession sqlSession = null;
        SqlSession sqlSession2 = null;
        try{
            sqlSession = getSession();
            sqlSession2 = getSession();
            CacheMapper mapper = sqlSession.getMapper(CacheMapper.class);
            Employee e1 = mapper.testFirstLevelCache(1); // 方法名懒得改了
            System.out.println("查询1完成");
            sqlSession.close();
            CacheMapper mapper2 = sqlSession2.getMapper(CacheMapper.class);
            Employee e2 = mapper2.testFirstLevelCache(1);
            System.out.println("查询2完成");
            boolean b = (e1 == e2);
            System.out.println("e1与e2是否相等：" + b);
        } catch(Exception e){
            e.printStackTrace();
        } finally {
          sqlSession2.close();
        }
    }

代码写好后，满怀欣喜的等待执行结果，却未曾料想得到以下惊喜：

DEBUG [main] - Cache Hit Ratio [com.hly.dao.CacheMapper]: 0.0
DEBUG [main] - ==>  Preparing: SELECT * FROM tbl_employee where id=? 
DEBUG [main] - ==> Parameters: 1(Integer)
DEBUG [main] - <==      Total: 1
查询1完成
org.apache.ibatis.cache.CacheException: Error serializing object.  Cause: java.io.NotSerializableException: com.hly.entity.Employee
    at org.apache.ibatis.cache.decorators.SerializedCache.serialize(SerializedCache.java:102)
    at org.apache.ibatis.cache.decorators.SerializedCache.putObject(SerializedCache.java:56)
    at org.apache.ibatis.cache.decorators.LoggingCache.putObject(LoggingCache.java:51)
    at org.apache.ibatis.cache.decorators.SynchronizedCache.putObject(SynchronizedCache.java:45)
    at org.apache.ibatis.cache.decorators.TransactionalCache.flushPendingEntries(TransactionalCache.java:122)
    at org.apache.ibatis.cache.decorators.TransactionalCache.commit(TransactionalCache.java:105)
…省略详细异常栈

在这里，笔者疏漏了一点，那就是一个对象要通过二级缓存缓存的话，需要实现序列化。从异常信息中也可以看出这点。我们给实体加上实现序列化接口，满心欢喜的再执行一下：

DEBUG [main] - Cache Hit Ratio [com.hly.dao.CacheMapper]: 0.0
DEBUG [main] - ==>  Preparing: SELECT * FROM tbl_employee where id=? 
DEBUG [main] - ==> Parameters: 1(Integer)
DEBUG [main] - <==      Total: 1
查询1完成
DEBUG [main] - Cache Hit Ratio [com.hly.dao.CacheMapper]: 0.0
DEBUG [main] - ==>  Preparing: SELECT * FROM tbl_employee where id=? 
DEBUG [main] - ==> Parameters: 1(Integer)
DEBUG [main] - <==      Total: 1
查询2完成
e1与e2是否相等：false

这次是没有报错了，也打印了Cache Hit ...这样的日志，说明二级缓存开启了。但是，依然发送了两条sql语句。这不符合预期呀。一番查证之后发现，问题出现在getSession方法中：

    public SqlSession getSession() throws IOException {
        String resource = "mybatis-config.xml";
        InputStream inputStream = Resources.getResourceAsStream(resource);
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
        return sqlSessionFactory.openSession();
    }

可以看到，每次调用这个getSession方法时，会去读配置文件，生成一个新的SqlSessionFactory导致没有命中缓存。（这里是为什么呢？猜测是框架对不同的factory进行了缓存隔离，后面看源码的时候验证一下）修改getSession方法，一分为二：

    /**
     * 这种写法在多线程下调用是有问题的
     * @return
     * @throws IOException
     */
    public SqlSessionFactory initFactory() throws IOException{
        if(sqlSessionFactory == null){
            String resource = "mybatis-config.xml";
            InputStream inputStream = Resources.getResourceAsStream(resource);
            sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
        }
        return sqlSessionFactory;
    }

    public SqlSession getSession() throws IOException {
        initFactory();
        System.out.println(sqlSessionFactory);
        return this.sqlSessionFactory.openSession();
    }

现在再执行，就可以达到预期效果了:

DEBUG [main] - Cache Hit Ratio [com.hly.dao.CacheMapper]: 0.0
DEBUG [main] - ==>  Preparing: SELECT * FROM tbl_employee where id=? 
DEBUG [main] - ==> Parameters: 1(Integer)
DEBUG [main] - <==      Total: 1
查询1完成
DEBUG [main] - Cache Hit Ratio [com.hly.dao.CacheMapper]: 0.5
查询2完成
e1与e2是否相等：false

但是这个地方两个对象是不相等的，留个疑问，后面看看源码再说。

三、sqlSession失效的四种情况：

不同sqlSession

sqlSession相同，查询条件不同（当前sqlSession中还没有这个缓存）

sqlSession相同，两次查询之间执行了增删改操作

sqlSession相同，手动清空了一级缓存中的内容（执行了sqlSession.clearCache()）

情况1：不同sqlSession

    @Test
    public void testFirstLevelCacheFaild01(){
        SqlSession sqlSession = null;
        SqlSession sqlSession2 = null;
        try{
            sqlSession = getSession();
            sqlSession2 = getSession();
            CacheMapper mapper = sqlSession.getMapper(CacheMapper.class);
            CacheMapper mapper2 = sqlSession2.getMapper(CacheMapper.class);
            Employee e1 = mapper.testFirstLevelCache(1);
            System.out.println("会话1查询完毕");
            Employee e2 = mapper2.testFirstLevelCache(1);
            System.out.println("会话2查询完毕");
            boolean b = (e1 == e2);
            System.out.println("e1与e2是否相等：" + b);
        }catch(Exception e){
            e.printStackTrace();
        }finally{
            sqlSession.close();
            sqlSession2.close();
        }
    }

在测试方法中，打开了两个sqlSession，并且执行同样的方法，同样的参数，效果如下。执行了两遍sql语句，返回的对象并不相等。

DEBUG [main] - ==>  Preparing: SELECT * FROM tbl_employee where id=? 
DEBUG [main] - ==> Parameters: 1(Integer)
DEBUG [main] - <==      Total: 1
会话1查询完毕
DEBUG [main] - ==>  Preparing: SELECT * FROM tbl_employee where id=? 
DEBUG [main] - ==> Parameters: 1(Integer)
DEBUG [main] - <==      Total: 1
会话2查询完毕
e1与e2是否相等：false

情况2：相同session，查询条件不同

    @Test
    public void testFirstLevelCacheFailed02(){
        SqlSession sqlSession = null;
        try{
            sqlSession = getSession();
            CacheMapper mapper = sqlSession.getMapper(CacheMapper.class);
            Employee e1 = mapper.testFirstLevelCache(1);
            System.out.println("会话1查询完毕");
            Employee e2 = mapper.testFirstLevelCache(2);
            System.out.println("会话2查询完毕");
            boolean b = (e1 == e2);
            System.out.println("e1与e2是否相等：" + b);
        }catch(Exception e){
            e.printStackTrace();
        }finally{
            sqlSession.close();
        }
    }

查询条件不同，是要发送两个sql的：

DEBUG [main] - Cache Hit Ratio [com.hly.dao.CacheMapper]: 0.0
DEBUG [main] - ==>  Preparing: SELECT * FROM tbl_employee where id=? 
DEBUG [main] - ==> Parameters: 1(Integer)
DEBUG [main] - <==      Total: 1
会话1查询完毕
DEBUG [main] - Cache Hit Ratio [com.hly.dao.CacheMapper]: 0.0
DEBUG [main] - ==>  Preparing: SELECT * FROM tbl_employee where id=? 
DEBUG [main] - ==> Parameters: 2(Integer)
DEBUG [main] - <==      Total: 0
会话2查询完毕
e1与e2是否相等：false

情况3：相同session但是两次查询之间进行了增删改操作
测试代码如下：

    @Test
    public void testFirstLevelCacheFailed03(){
        SqlSession sqlSession = null;
        try{
            sqlSession = getSession();
            CacheMapper mapper = sqlSession.getMapper(CacheMapper.class);
            Employee e1 = mapper.testFirstLevelCache(1);
            System.out.println("会话1查询完毕");
            e1.setName("修改用户名");
            mapper.updateEmp(e1);
            System.out.println("修改完毕");
            Employee e2 = mapper.testFirstLevelCache(2);
            System.out.println("会话2查询完毕");
            boolean b = (e1 == e2);
            System.out.println("e1与e2是否相等：" + b);
        }catch(Exception e){
            e.printStackTrace();
        }finally{
            sqlSession.close();
        }
    }

两次查询中间，加入了一条更新语句。执行结果如下：

DEBUG [main] - Cache Hit Ratio [com.hly.dao.CacheMapper]: 0.0
DEBUG [main] - ==>  Preparing: SELECT * FROM tbl_employee where id=? 
DEBUG [main] - ==> Parameters: 1(Integer)
DEBUG [main] - <==      Total: 1
会话1查询完毕
DEBUG [main] - ==>  Preparing: UPDATE tbl_employee SET name=? WHERE id=? 
DEBUG [main] - ==> Parameters: 修改用户名(String), 1(Integer)
DEBUG [main] - <==    Updates: 1
修改完毕
DEBUG [main] - Cache Hit Ratio [com.hly.dao.CacheMapper]: 0.0
DEBUG [main] - ==>  Preparing: SELECT * FROM tbl_employee where id=? 
DEBUG [main] - ==> Parameters: 2(Integer)
DEBUG [main] - <==      Total: 0
会话2查询完毕
e1与e2是否相等：false

可以看到，发送了三个sql语句。两次查询，虽说在同一个session内，且查询条件也一样，但由于两次查询之间有增删改语句，所以缓存失效了。

情况4：相同session，但是手动执行了sqlSession.clearCache()方法

    @Test
    public void testFirstLevelCacheFailed04(){
        SqlSession sqlSession = null;
        try{
            sqlSession = getSession();
            CacheMapper mapper = sqlSession.getMapper(CacheMapper.class);
            Employee e1 = mapper.testFirstLevelCache(1);
            System.out.println("会话1查询完毕");
            sqlSession.clearCache();
            System.out.println("缓存clear完毕");
            Employee e2 = mapper.testFirstLevelCache(2);
            System.out.println("会话2查询完毕");
            boolean b = (e1 == e2);
            System.out.println("e1与e2是否相等：" + b);
        }catch(Exception e){
            e.printStackTrace();
        }finally{
            sqlSession.close();
        }
    }

两次查询之间，手动调用clearCache，使一级缓存失效。结果符合预期。

DEBUG [main] - Cache Hit Ratio [com.hly.dao.CacheMapper]: 0.0
DEBUG [main] - ==>  Preparing: SELECT * FROM tbl_employee where id=? 
DEBUG [main] - ==> Parameters: 1(Integer)
DEBUG [main] - <==      Total: 1
会话1查询完毕
缓存clear完毕
DEBUG [main] - Cache Hit Ratio [com.hly.dao.CacheMapper]: 0.0
DEBUG [main] - ==>  Preparing: SELECT * FROM tbl_employee where id=? 
DEBUG [main] - ==> Parameters: 2(Integer)
DEBUG [main] - <==      Total: 0
会话2查询完毕
e1与e2是否相等：false

四、二级缓存简单原理

二级缓存：基于namspace的缓存

工作机制：

一个会话，查询一条数据，这个数据就会被放在当前会话的一级缓存中；
如果会话关闭，一级缓存中的数据会被保存到二级缓存中，新的会话查询信息，就可以参照二级缓存中的内容；
如果sqlSession既有employee mapper查的employee对象，又有department mapper查询的department对象：不同namespace查出的数据会放在自己对应的缓存map中。

使用步骤总结：

开启全局二级缓存配置（cacheEnable）
去每个mapper.xml中配置使用二级缓存
我们的pojo需要实现序列化接口

五、缓存相关的设置和属性：

CacheEnabled(false时，二级缓存关闭)。
每个select标签都有useCache=“true”，false的时候一级缓存依然可以使用，二级缓存不可用。
每个增删改标签的flushCache=“true”，增删改执行完成后就会清除缓存。
sqlSession.clearCache（）是否会影响二级缓存？不会的。。只是清除当前session的一级缓存。
localCacheScope：本地缓存作用域（一级缓存）。可以通过将其值设置为STATEMENT来禁用一级缓存。

人面猴
序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
沈念sama阅读 203,772评论 6赞 477
死咒
序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
沈念sama阅读 85,458评论 2赞 381
救了他两次的神仙让他今天三更去死
文/潘晓璐我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
开封第一讲书人阅读 150,610评论 0赞 337
道士缉凶录：失踪的卖姜人
文/不坏的土叔我叫张陵，是天一观的道长。经常有香客问我，道长，这世上最难降的妖魔是什么？我笑而不...
开封第一讲书人阅读 54,640评论 1赞 276
港岛之恋（遗憾婚礼）
正文为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
茶点故事阅读 63,657评论 5赞 365
恶毒庶女顶嫁案：这布局不是一般人想出来的
文/花漫我一把揭开白布。她就那样静静地躺着，像睡着了一般。火红的嫁衣衬着肌肤如雪。梳的纹丝不乱的头发上，一...
开封第一讲书人阅读 48,590评论 1赞 281
城市分裂传说
那天，我揣着相机与录音，去河边找鬼。笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。我是一名探鬼主播，决...
沈念sama阅读 37,962评论 3赞 395
双鸳鸯连环套：你想象不到人心有多黑
文/苍兰香墨我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
开封第一讲书人阅读 36,631评论 0赞 258
万荣杀人案实录
序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
沈念sama阅读 40,870评论 1赞 297
护林员之死
正文独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋以下内容为张勋视角年9月15日...
茶点故事阅读 35,611评论 2赞 321
白月光启示录
正文我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
茶点故事阅读 37,704评论 1赞 329
活死人
序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
沈念sama阅读 33,386评论 4赞 319
日本核电站爆炸内幕
正文年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
茶点故事阅读 38,969评论 3赞 307
男人毒药：我在死后第九天来索命
文/蒙蒙一、第九天我趴在偏房一处隐蔽的房顶上张望。院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
开封第一讲书人阅读 29,944评论 0赞 19
一桩弑父案，背后竟有这般阴谋
文/苍兰香墨我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。一阵脚步声响...
开封第一讲书人阅读 31,179评论 1赞 260
情欲美人皮
我被黑心中介骗来泰国打工，没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。一个月前我还...
沈念sama阅读 44,742评论 2赞 349
代替公主和亲
正文我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
茶点故事阅读 42,440评论 2赞 342