【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的全局缓存，需要进行一些配置项的设置才可以生效。

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

然后，在需要使用二级缓存的mapper.xml中，配置如下选项，标识此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来禁用一级缓存。