MyBatis系统中默认定义了两级缓存。
一级缓存和二级缓存。
- 默认情况下，只有一级缓存（SqlSession级别的缓存，也称为本地缓存）开启。
- 二级缓存需要手动开启和配置，他是基于namespace级别的缓存。
- 为了提高扩展性。MyBatis定义了缓存接口Cache。我们可以通过实现Cache接口来自定义二级缓存

一级缓存

一级缓存：（本地缓存）：sqlSession级别的缓存。一级缓存是一直开启的,关闭不了的；SqlSession级别的一个Map
与数据库同一次会话期间查询到的数据会放在本地缓存中。
以后如果需要获取相同的数据，直接从缓存中拿，没必要再去查询数据库；

我们先来看看一级缓存:

    @Test
    public void testFirstLevelCache() throws IOException{
        SqlSessionFactory sqlSessionFactory = getSqlSessionFactory();
        SqlSession openSession = sqlSessionFactory.openSession();
        try{
            EmployeeMapper mapper = openSession.getMapper(EmployeeMapper.class);
            Employee emp01 = mapper.getEmpById(1);
            System.out.println(emp01);
            Employee emp02 = mapper.getEmpById(1);
            System.out.println(emp02);
            System.out.println(emp01==emp02);
        }finally{
            openSession.close();
        }
    }

可以看到查询了两次只发了一条SQL语句,第二次查询时用的是第一次查询缓存下来的对象
这里写图片描述
这就是一级缓存

一级缓存失效的四种情况

就是没有使用到当前一级缓存的情况，效果就是，还需要再向数据库发出查询：

sqlSession不同

    @Test
    public void testFirstLevelCache() throws IOException{
        SqlSessionFactory sqlSessionFactory = getSqlSessionFactory();
        SqlSession openSession = sqlSessionFactory.openSession();
        try{
            EmployeeMapper mapper = openSession.getMapper(EmployeeMapper.class);
            Employee emp01 = mapper.getEmpById(1);
            System.out.println(emp01);

            //xxxxx
            //1、sqlSession不同。
            SqlSession openSession2 = sqlSessionFactory.openSession();
            EmployeeMapper mapper2 = openSession2.getMapper(EmployeeMapper.class);

            Employee emp02 = mapper2.getEmpById(1);
            System.out.println(emp02);
            System.out.println(emp01==emp02);

            openSession2.close();
        }finally{
            openSession.close();
        }
    }

可以看到这里发送了两条SQL语句
这里写图片描述

sqlSession相同，查询条件不同.(原因是当前一级缓存中还没有这个数据)

    @Test
    public void testFirstLevelCache() throws IOException{
        SqlSessionFactory sqlSessionFactory = getSqlSessionFactory();
        SqlSession openSession = sqlSessionFactory.openSession();
        try{
            EmployeeMapper mapper = openSession.getMapper(EmployeeMapper.class);
            Employee emp01 = mapper.getEmpById(1);
            System.out.println(emp01);

            Employee emp03 = mapper.getEmpById(2);
            System.out.println(emp03);

            System.out.println(emp01==emp03);
        }finally{
            openSession.close();
        }
    }

可以看到这里发送了两条SQL语句,查询一号和二号员工
这里写图片描述

sqlSession相同，两次查询之间执行了增删改操作(这次增删改可能对当前数据有影响)

    @Test
    public void testFirstLevelCache() throws IOException{
        SqlSessionFactory sqlSessionFactory = getSqlSessionFactory();
        SqlSession openSession = sqlSessionFactory.openSession();
        try{
            EmployeeMapper mapper = openSession.getMapper(EmployeeMapper.class);
            Employee emp01 = mapper.getEmpById(1);
            System.out.println(emp01);

            mapper.addEmp(new Employee(null, "testCache", "cache", "1"));
            System.out.println("数据添加成功");

            Employee emp02 = mapper.getEmpById(1);
            System.out.println(emp02);
            System.out.println(emp01==emp02);
        }finally{
            openSession.close();
        }
    }

可以看到下面两条SQL语句之间进行了添加操作
这里写图片描述

sqlSession相同，手动清除了一级缓存（缓存清空）

    @Test
    public void testFirstLevelCache() throws IOException{
        SqlSessionFactory sqlSessionFactory = getSqlSessionFactory();
        SqlSession openSession = sqlSessionFactory.openSession();
        try{
            EmployeeMapper mapper = openSession.getMapper(EmployeeMapper.class);
            Employee emp01 = mapper.getEmpById(1);
            System.out.println(emp01);

            //4、sqlSession相同，手动清除了一级缓存（缓存清空）
            openSession.clearCache();

            Employee emp02 = mapper.getEmpById(1);
            System.out.println(emp02);
            System.out.println(emp01==emp02);
        }finally{
            openSession.close();
        }
    }

这里写图片描述

二级缓存

我们先来画个图理解一下二级缓存:
这里写图片描述
二级缓存：（全局缓存）：基于namespace级别的缓存：一个namespace对应一个二级缓存：

二级缓存的工作机制:
- 一个会话，查询一条数据，这条数据就会被放在当前会话的一级缓存中；
- 如果会话关闭；一级缓存中的数据会被保存到二级缓存中；新的会话查询信息，就可以参照二级缓存中的内容；
- 不同namespace查出的数据会放在自己对应的缓存中（map）
  - 比如说一个sqlSession会话中既有EmployeeMapper的数据Employee,又有DepartmentMapper的数据Department,那么这时查出来的Employee会放到EmployeeMapper对应的缓存中,Department会放到DepartmentMapper对应的缓存中

注意:查出的数据都会被默认先放在一级缓存中。只有会话提交或者关闭以后，一级缓存中的数据才会转移到二级缓存中

二级缓存的使用

开启全局二级缓存配置：
1. 到全局配置文件中在<settings>标签中加入<setting name="cacheEnabled" value="true"/>
去想使用二级缓存的mapper.xml中配置使用二级缓存：
1. 像这样配置:<cache eviction="FIFO" flushInterval="60000" readOnly="false" size="1024"></cache>,可以自己按照下面的属性可以用的值按需配置,或者像<cache></cache>这样使用默认配置也可以
2. 使用是用<cache>标签(以下是<cache>标签中的属性以及属性中可用的值)
  1. eviction:缓存的回收策略(有四种,默认的是 LRU)：
    1. LRU – 最近最少使用的：移除最长时间不被使用的对象。
    2. FIFO – 先进先出：按对象进入缓存的顺序来移除它们。
    3. SOFT – 软引用：移除基于垃圾回收器状态和软引用规则的对象。
    4. WEAK – 弱引用：更积极地移除基于垃圾收集器状态和弱引用规则的对象。
  2. flushInterval：缓存刷新间隔
    1. 缓存多长时间清空一次，默认不清空，设置一个毫秒值
  3. readOnly:缓存是否只读：
    1. true：只读；mybatis认为所有从缓存中获取数据的操作都是只读操作，不会修改数据。这时 mybatis为了加快获取速度，直接就会将数据在缓存中的引用交给用户。不安全，速度快
    2. false(默认是false)：非只读：mybatis觉得获取的数据可能会被修改。这时mybatis会利用序列化&反序列的技术克隆一份新的数据给你。安全，速度慢
  4. size：缓存存放多少元素；
  5. type=""：指定自定义缓存的全类名,实现Cache接口即可；
我们的POJO需要实现序列化接口
下面就是给Employee类实现了Serializable这个接口

public class Employee implements Serializable {
    //省略....
}

给Department也实现接口

public class Department implements Serializable {
    //省略....
}

然后我们去测试一下:

    @Test
    public void testSecondLevelCache() throws IOException{
        SqlSessionFactory sqlSessionFactory = getSqlSessionFactory();
        SqlSession openSession = sqlSessionFactory.openSession();
        SqlSession openSession2 = sqlSessionFactory.openSession();
        try{
            //1、
            EmployeeMapper mapper = openSession.getMapper(EmployeeMapper.class);
            EmployeeMapper mapper2 = openSession2.getMapper(EmployeeMapper.class);

            Employee emp01 = mapper.getEmpById(1);
            System.out.println(emp01);
            openSession.close();

            //第二次查询是从二级缓存中拿到的数据，并没有发送新的sql
            Employee emp02 = mapper2.getEmpById(1);
            System.out.println(emp02);
            openSession2.close();

        }finally{

        }
    }

可以看到在上面进行了两次查询,在第一次查询完后我们就把openSession给关闭了,然后开了一个新的openSession2进行第二次查询,但是从下图的结果来看,只是在第一次时发送了一条SQL语句,第二次查询没有发SQL语句而是去第一次会话的缓存中查的,下图中的第一个绿色圆圈中的0.0代表第一次查询零次命中,就是0/1=0.0,第二个绿色圆圈代表的是第二次查询一次命中,就是1/2=0.5
结果:
这里写图片描述

缓存有关的设置及属性

cacheEnabled=true/false：false是关闭缓存（只关闭二级缓存）(一级缓存一直可用的)
每个select标签都有useCache="true"：false：不使用缓存（一级缓存依然使用，二级缓存不使用）
每个增删改标签()的：flushCache="true"：增删改执行完成后就会清除缓存；（一级二级都会清除）
执行sqlSession.clearCache();只是清楚当前session的一级缓存；
localCacheScope：本地缓存作用域,有两个属性,SESSION:当前会话的所有数据保存在会话缓存(一级缓存)中；STATEMENT：可以禁用一级缓存；

缓存的顺序

MyBatis都是先去看二级缓存,然后再去看一级缓存,如果这两个缓存中都没有数据,才会到数据库中查询

MyBatis_缓存

目录

缓存简介