mybatis 缓存的一些测试

环境和spring 事务的传播级别一致

  @Autowired
    private SqlSessionFactory sqlSessionFactory;

    @Test
    public void testOneLevelCache(){
        SqlSession session = sqlSessionFactory.openSession();
        StudentMapper mapper = session.getMapper(StudentMapper.class);
        System.out.println("第一次查询");
        Student student = mapper.getById(1);
        System.out.println(student);
        System.out.println("第二次查询");
        Student student2 = mapper.getById(1);
        System.out.println(student2);
        session.commit();
        session.close();
    }

 

结果：只是打印一次sql

下面测试commit是否会清空缓存

 @Test
    public void testCommit(){
        SqlSession oldSession = sqlSessionFactory.openSession();
        System.out.println("获取的session"+oldSession);
        StudentMapper mapper = oldSession.getMapper(StudentMapper.class);
        Student student = mapper.getById(1);
        System.out.println("第一次查询结果"+student);
        oldSession.commit();
        Student student2 = mapper.getById(1);
        System.out.println("第二次查询结果"+student2);
    }

结果：打印了两条sql，缓存被清空了

1、修改第二次查询ID为2

结果：打印两次sql

2、修改为关闭sqlSession后，在此查询相同sql，如下所示

 @Test
    public void testOneLevelCache(){
        SqlSession oldSession = sqlSessionFactory.openSession();
        System.out.println("第一次获取的session"+oldSession);
        StudentMapper mapper = oldSession.getMapper(StudentMapper.class);
        System.out.println("第一次查询结果");
        Student student = mapper.getById(1);
        System.out.println(student);
        oldSession.commit();
        oldSession.close();

        SqlSession newSession = sqlSessionFactory.openSession();
        StudentMapper newMapper = newSession.getMapper(StudentMapper.class);
        System.out.println("重新获取的session"+newSession);
        System.out.println("第二次查询结果");
        Student student2 = newMapper.getById(1);
        System.out.println(student2);
        newSession.commit();
        newSession.close();
    }

结果：两个打印session对象必然是不同的，发现打印两条一样的sql

综上所述：

    在sqlSession生命周期内，是存在缓存的。也就是mybatis的一级缓存，是个默认配置。

3、清空sqlSession中的缓存，同样是执行相同sql

 @Test
    public void testOneLevelCache2(){
        SqlSession oldSession = sqlSessionFactory.openSession();
        System.out.println("第一次获取的session"+oldSession);
        StudentMapper mapper = oldSession.getMapper(StudentMapper.class);
        System.out.println("第一次查询结果");
        Student student = mapper.getById(1);
        System.out.println(student);
        oldSession.clearCache();
        System.out.println("第二次查询结果");
        Student student2 = mapper.getById(1);
        System.out.println(student2);
    }

结果：同样是两条sql

4、做个测试，同个sqlSession获取到的mapper是否一致，是否会影响到前面mybatis一级缓存的测试结果

    @Test
    public void testOneLevelCache03(){
        SqlSession oldSession = sqlSessionFactory.openSession();
        System.out.println("第一次获取的session"+oldSession);
        StudentMapper mapper = oldSession.getMapper(StudentMapper.class);
        System.out.println("第一次的mapper "+mapper);
        Student student = mapper.getById(1);
        System.out.println("第一次的查询结果 "+student);
        StudentMapper mapper2 = oldSession.getMapper(StudentMapper.class);
        System.out.println("第二次的mapper "+mapper2);
        Student student2 = mapper2.getById(1);
        System.out.println("第二次的查询结果 "+student2);
    }

结果：

第一次获取的sessionorg.apache.ibatis.session.defaults.DefaultSqlSession@358ab600
第一次的mapper org.apache.ibatis.binding.MapperProxy@e26af6

JDBC Connection [HikariProxyConnection@657628458 wrapping com.mysql.jdbc.JDBC4Connection@1ee47d9e] will not be managed by Spring
==>  Preparing: select * from Student where id = ? 
==> Parameters: 1(Integer)

<==    Columns: id, name, age
<==        Row: 1, stu01, 22
<==      Total: 1
第一次的查询结果 Student{id=1, name='stu01', age=22}
第二次的mapper org.apache.ibatis.binding.MapperProxy@77f905e3
第二次的查询结果 Student{id=1, name='stu01', age=22}

结论：发现sql还是一条，所以一级缓存是sqlSession生命周期内，与mapper实例是否同一个没关系。

5、缓存何时刷新，如果我们没有主动clearCache，修改下面代码，在两次查询中穿插DML语句

    @Test
    public void testOneLevelCache04(){
        SqlSession oldSession = sqlSessionFactory.openSession();
        StudentMapper mapper = oldSession.getMapper(StudentMapper.class);
        Student student = mapper.getById(1);
        System.out.println("第二次的查询结果 "+student);
        int record = mapper.updateNameById(1,"cherish");
        Student student2 = mapper.getById(1);
        System.out.println("第二次的查询结果 "+student2);
        oldSession.close();
    }

结果: 执行了三条语句，第二次查询结果为更新后的结果，所以，缓存在更新操作后已经失效了。后面查询并非从缓存中查询。

 

二级缓存测试

老师模块Mapper来做测试

@CacheNamespace()
public interface TeacherMapper {
    @Insert("insert into teacher(name,age) values(#{name},#{age})")
    int addTeacher(Teacher teacher);


//    用于测试二级缓存
    @Select("select * from teacher where id = #{stuID}")
    Student getById(Integer stuID);

    @Update("update teacher set name = #{ name } where id = #{ id }")
    int updateNameById(@Param(value = "id") Integer id, @Param(value = "name") String name);
}

1、如下测试，两次发起一样的查询

    @Autowired
    private SqlSessionFactory sqlSessionFactory;

    @Test
    public void testTwoLevelCache01(){
        SqlSession oldSession = sqlSessionFactory.openSession();
        TeacherMapper oldMapper = oldSession.getMapper(TeacherMapper.class);
        Teacher teacher1 = oldMapper.getById(1);
        System.out.println("第一次查询结果 "+teacher1);
        SqlSession newSession = sqlSessionFactory.openSession();
        TeacherMapper newMapper = newSession.getMapper(TeacherMapper.class);
        Teacher teacher2 = newMapper.getById(1);
        System.out.println("第二次查询结果 "+teacher2);
    }

结果：发起两次sql查询

结论：二级缓存失效（不同的sqlSession，在前面一级缓存中测试过了，不会使用一级缓存）

2、session commit测试，在第一次查询后添加一次如下提交

oldSession.commit();

结果：

分析：来自缓存异常，提示需要标识序列化

解决：

运行结果：

缓存命中率日志提示，同时sql语句只打印一条。也就说明二级缓存生效了

3、做一个测试，就是第一次commit，后面几次打开相同操作都不commit，打印看看命中率有啥变化

@Test
    public void testTwoLevelCache02(){
        SqlSession oldSession = sqlSessionFactory.openSession();
        TeacherMapper oldMapper = oldSession.getMapper(TeacherMapper.class);
        Teacher teacher1 = oldMapper.getById(1);
        System.out.println("第一次查询结果 "+teacher1);
        oldSession.commit();
        SqlSession newSession = sqlSessionFactory.openSession();
        TeacherMapper newMapper = newSession.getMapper(TeacherMapper.class);
        Teacher teacher2 = newMapper.getById(1);
        System.out.println("第二次查询结果 "+teacher2);

        SqlSession thridSession = sqlSessionFactory.openSession();
        TeacherMapper thirdMapper = thridSession.getMapper(TeacherMapper.class);
        Teacher teacher3 = thirdMapper.getById(1);
        System.out.println("第三次查询结果 "+teacher3);

        SqlSession forthSession = sqlSessionFactory.openSession();
        TeacherMapper forthMapper = forthSession.getMapper(TeacherMapper.class);
        Teacher teacher04 = forthMapper.getById(1);
        System.out.println("第四次查询结果 "+teacher04);
    }

结果

命中率：不断提高

4、在第三次和第四次操作中，穿插一个DML更新

        SqlSession middleSession = sqlSessionFactory.openSession();
        TeacherMapper mapper = middleSession.getMapper(TeacherMapper.class);
        int zls = mapper.updateNameById(1, "詹老师");

结果：前面三次查询是：第一次操作查询一条sql，第二次、第三次都是命中缓存。

中间DML更新打印了一次sql，第四次查询则又是命中缓存，缓存中的数据是未更新前的数据，所以缓存未更新。

5、在修改后加上commit，如下所示：

  SqlSession middleSession = sqlSessionFactory.openSession();
        TeacherMapper mapper = middleSession.getMapper(TeacherMapper.class);
        int zls = mapper.updateNameById(1, "詹老师");
        middleSession.commit();

结果：

前面三次查询及更新操作未变，而第四次查询则是打印一条sql，

结论：缓存更新了。DML语句会刷新二级缓存，并且生成缓存和刷新缓存都需要commit操作

6、这些默认配置在哪？

@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.TYPE})
public @interface CacheNamespace {
    映射语句文件中的所有 select 语句的结果将会被缓存。
    映射语句文件中的所有 insert、update 和 delete 语句会刷新缓存。

    Class<? extends Cache> implementation() default PerpetualCache.class;
    缓存会使用最近最少使用算法（LRU, Least Recently Used）算法来清除不需要的缓存。
    Class<? extends Cache> eviction() default LruCache.class;
    缓存不会定时进行刷新（也就是说，没有刷新间隔）。
    long flushInterval() default 0L;
    缓存会保存列表或对象（无论查询方法返回哪种）的 1024 个引用。
    int size() default 1024;
    缓存会被视为读/写缓存，这意味着获取到的对象并不是共享的，可以安全地被调用者修改，而不干扰其他 
    调用者或线程所做的潜在修改。
    boolean readWrite() default true;

    boolean blocking() default false;

    Property[] properties() default {};
}

下面是部分网络资料

http://www.mybatis.org/mybatis-3/zh/sqlmap-xml.html#cache

提示：   缓存只作用于 cache 标签所在的映射文件中的语句。如果你混合使用 Java API 和 XML 映射文件，在共用接口中的语句将不会被默认缓存。你需要使用 @CacheNamespaceRef 注解指定缓存作用域。

 

在使用二级缓存中，查阅了些资料，其中

https://blog.csdn.net/isea533/article/details/44566257

的说法：避免使用二级缓存，我觉得很有道理

PS：缓存和Mapper的namespace是紧关联的，如果使用这缓存，容易出现多表之间关联问题，在写大量业务代码时还需要花心思去思考缓存那些事，开发效率应该会更低吧，而且团队中并非所有开发者对缓存都能够熟悉，所以将缓存实现在业务层的可控缓存中可能是个更好的解决方案。

1、可以使用Redis等NoSQL来缓存，在更新数据后清空缓存，这些缓存l逻辑都通过代码中维护，也是一个解决方案。

 

以上是博主对mybatis 缓存的一些学习笔记，方便以后查阅。好记性不如“烂笔头“，何况也不烂。