MyBatis~基于SqlSession的一级缓存和基于namespace的二级缓存

缓存简介

一般的查询,需要连接数据库, 那多次查询, 就很耗资源

缓存就是我们将一次的查询结果放到缓存中

当我们再次去查找的时候,就直接走缓存,就不用走数据库了

这样就不用去打开连接, 获取连接池中的connection, 去查找 ,再关闭连接, 放回连接池,这些重复性的动作就可以省去

利用缓存可以提高查询的效率,有效缓解高并发问题, 比如是读的请求,我直接走缓存就行, 就不走数据库,而让缓存去找数据库

保持数据库和缓存中的信息相同, 就必须使用 读写分离 主从复制 机制

所以使用缓存就是为了减少与数据库的交互次数, 减少系统开销, 提高系统的响应速率

但要注意要将经常查询,但是不经常修改的数据放在缓存中是最佳的

MyBatis中的缓存

MyBatis包含一个非常强大的查询缓存特性,它可以很方便的定制和配置缓存,可以极大的提高查询的效率

MyBatis系统默认定义了俩种缓存, 一级缓存和二级缓存

• 默认情况下, 只有一级缓存开启(SqlSession级别的缓存,也就是表示当前有效,开启就有一旦close关闭就没有这个缓存了, 又称为本地缓存)

• 二级缓存需要手动开启和配置, 他是属于namespace级别的缓存, 也就是说一个nameapace就对应着一个二级缓存

• 默认情况下，只启用了本地的会话缓存，它仅仅对一个会话中的数据进行缓存。 要启用全局的二级缓存，只需要在你的 SQL 映射文件中添加一行：(注意要在开启缓存的情况下载sql映射文件中再添加下面一行代码才有效)

<cache/>

基本上就是这样。这个简单语句的效果如下:

• 映射语句文件中的所有 select 语句的结果将会被缓存。
• 映射语句文件中的所有 insert、update 和 delete 语句会刷新缓存。
• 缓存会使用最近最少使用算法（LRU, Least Recently Used）算法来清除不需要的缓存。
• 缓存不会定时进行刷新（也就是说，没有刷新间隔）。
• 缓存会保存列表或对象（无论查询方法返回哪种）的 1024 个引用。
• 缓存会被视为读/写缓存，这意味着获取到的对象并不是共享的，可以安全地被调用者修改，而不干扰其他调用者或线程所做的潜在修改。

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

这些属性可以通过 cache 元素的属性来修改。比如：

<cache
  eviction="FIFO"
  flushInterval="60000"
  size="512"
  readOnly="true"/>

这个更高级的配置创建了一个 FIFO 缓存，每隔 60 秒刷新，最多可以存储结果对象或列表的 512 个引用，而且返回的对象被认为是只读的，因此对它们进行修改可能会在不同线程中的调用者产生冲突。

可用的清除策略有：

• LRU – 最近最少使用：移除最长时间不被使用的对象。
• FIFO – 先进先出：按对象进入缓存的顺序来移除它们。
• SOFT – 软引用：基于垃圾回收器状态和软引用规则移除对象。
• WEAK – 弱引用：更积极地基于垃圾收集器状态和弱引用规则移除对象。

默认的清除策略是 LRU。

flushInterval（刷新间隔）属性可以被设置为任意的正整数，设置的值应该是一个以毫秒为单位的合理时间量。 默认情况是不设置，也就是没有刷新间隔，缓存仅仅会在调用语句时刷新。

size（引用数目）属性可以被设置为任意正整数，要注意欲缓存对象的大小和运行环境中可用的内存资源。默认值是 1024。

readOnly（只读）属性可以被设置为 true 或 false。只读的缓存会给所有调用者返回缓存对象的相同实例。 因此这些对象不能被修改。这就提供了可观的性能提升。而可读写的缓存会（通过序列化）返回缓存对象的拷贝。 速度上会慢一些，但是更安全，因此默认值是 false。

提示 二级缓存是事务性的。这意味着，当 SqlSession 完成并提交时，或是完成并回滚，但没有执行 flushCache=true 的 insert/delete/update 语句时，缓存会获得更新。

一级缓存演示

• 我设定二个线程使用同一个sqlsession去查同一条信息,会发现他只会在数据库中查找一次, 也就是说第二次查找是在一级缓存中查找的

    @org.junit.Test
    public void selectById2() throws InterruptedException {
        SqlSession sqlSession = DBUtil.getSqlSession();
        UserDao mapper = sqlSession.getMapper(UserDao.class);
        System.out.println(mapper.selectUserById(99));

        CountDownLatch countDownLatch = new CountDownLatch(1);
        Thread thread = new Thread(new Service(sqlSession, countDownLatch));
        thread.start();
        countDownLatch.await();
        System.out.println("关闭sqlSession");
        sqlSession.close();
    }

public class Service implements Runnable {

    private SqlSession sqlSession;
    private CountDownLatch countDownLatch;

    public Service(SqlSession sqlSession, CountDownLatch countDownLatch) {
        this.sqlSession = sqlSession;
        this.countDownLatch = countDownLatch;
    }

    @Override
    public void run() {
        System.out.println("*****额外线程开始执行*****");
        UserDao mapper = sqlSession.getMapper(UserDao.class);
        System.out.println(mapper.selectUserById(99));
        System.out.println("*****额外线程执行结束*****");
        countDownLatch.countDown();
    }
}

• 如果我在进行来此查找之前进行一次修改查找, 就会刷新缓冲区, 那么第二次查找就会在数据库中查找

    @org.junit.Test
    public void selectById() {
        SqlSession sqlSession = DBUtil.getSqlSession();
        UserDao mapper = sqlSession.getMapper(UserDao.class);
        System.out.println(mapper.selectUserById(99));
        System.out.println("********************************");
        System.out.println(mapper.update(99));
        System.out.println("*****修改完毕*****");
        System.out.println(mapper.selectUserById(99));
        sqlSession.close();
    }

• 注意事项

1. 在一个sqlsession关闭之前, 进行俩次相同内容的查询就会在日志中发现是走的缓存
2. 如果俩次查询的内容不一样, 肯定不会走缓存区找数据, 还是执行俩次的数据库查询
3. 增删改可能会影响原来的数据, 所以会刷新缓存, 也就是只要再俩次查询中间执行了数据库的增删改操作, 即使你俩次查询的是相同的内容, 第二次查询还是会走数据库去查询
4. 如果执行了手动清理缓存, 也就是sqlsession.clearcache方法,第二次就会去在数据库中查询
5. 如果关闭了这个sqlsqlsession, 就会关闭一级缓存, 即使查询俩次相同的内容还是去数据库中去查询俩次
6. 注意一级缓存默认是开始的, 不能关闭, 只在一次sqlsession关闭之前有效
7. 一级缓存相当于是一个map, 查到就放到一个map中, 只要进行了更新任何数据的操作, 就会刷新map中的数据,也就是全删掉

二级缓存演示

• 二级缓存也叫命名空间全局缓存

基于namespace级别的缓存, 也就是基于一个sql映射文件的缓存,一个命名空间对应一个二级缓存

工作机制

• 一个sqlsession查询了一条数据,这个数据会被放在当前会话的一级缓存中
• 如果当前会话关闭了,这个会话对应的一级缓存也就结束了
• 但是我们开启了二级缓存, 所以此时这条数据就会被放到对用的sql映射文件中的二级缓存
• 如果在在同一个映射文件中的其他sqlsession查询信息的话, 就可以在这个二级缓存中查询信息
• 不同的映射文件查出的数据会放在自己对应的二级缓存map中

开启二级缓存

1. 在MyBatis-config文件中使用setting开启全局缓存

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

2. 在sql映射文件中插入一行代码开启二级缓存

    <cache/>

3. 可以在标签中设置这个操作需不需要缓存, 需不需要刷新缓存
4. 使用俩个sqlsession 查同一条信息, 观察日志,注意二级缓存是在一级缓存死了一个才发挥作用,所以得将第一个sqlsession关闭才能看见效果

• 注意问题需要将实体序列化,不然就会报错

public class User implements Serializable {

    private int id;
    private String name;
    private String pwd;
}

• 下面演示我使用俩个线程,使用俩个sqlsession, 并且在第一个sqlsession关闭后, 进行查询相同的信息

    @org.junit.Test
    public void selectById22() throws InterruptedException {
        SqlSession sqlSession = DBUtil.getSqlSession();
        SqlSession sqlSession1 = DBUtil.getSqlSession();
        UserDao mapper = sqlSession.getMapper(UserDao.class);

        System.out.println(mapper.selectUserById(99));
        System.out.println("关闭sqlSession");
        sqlSession.close();

        CountDownLatch countDownLatch = new CountDownLatch(1);
        Thread thread = new Thread(new Service(sqlSession1, countDownLatch));
        thread.start();
        countDownLatch.await();
        System.out.println("关闭sqlSession1");
        sqlSession1.close();
    }

小结

• 只要开始了二级缓存, 在同一命名空间(namespcae)下就有效
• 所有的数据都会先放在一级缓存中, 只有当会话提交或者关闭的时候才会进入二级缓存

缓存原理

• 那么当我们一级和二级缓存都开启的时候,去读一条数据的时候, 这条数据的寻找过程到底是怎么样的呢?