注：本笔记是根据尚硅谷的MyBatis视频记录的
 
对于任何一个持久层框架，都有缓存机制；缓存在电脑中有一块真实的存储空间（https://baike.baidu.com/item/%E7%BC%93%E5%AD%98/100710?fr=aladdin）；
 
两个关于mybatis缓存额外的链接：
 
关于Mybatis的一级缓存和二级缓存执行顺序具体可参考：Mybatis的一级缓存和二级缓存执行顺序
 
 Mybatis整合第三方缓存步骤具体可参考：Mybatis整合第三方缓存ehcache
 
缓存原理图：
 
 
一、一级缓存（本地缓存）
 
sqlSession级别的缓存。（相当于一个方法内的缓存）
 
每一次会话都对应自己的一级缓存，作用范围比较小，一旦会话关闭就查询不到了；
 
一级缓存默认是一直开启的，是SqlSession级别的一个Map；
 与数据库同一次会话期间查询到的数据会放在本地缓存中。
 以后如果需要获取相同的数据，直接从缓存中拿，没必要再去查询数据库；
 
测试：
 
 
取缓存中的数据：
 
 
说明：当再次查询发现已经有数据了，就直接在缓存中返回之前查的数据，而不再访问数据库；
 
二、一级缓存失效的四种情况：
 
没有使用到当前一级缓存的情况，效果就是：还需要再向数据库发出查询
 
1、sqlsession不同（会话不同）
 
 
结果：
 
 
说明：不同的会话的缓存不共享数据
 
2、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);
		
		//sqlSession相同，查询条件不同
		Employee emp03 = mapper.getEmpById(3);
		System.out.println(emp03);
		System.out.println(emp01==emp03);

	}finally{
		openSession.close();
	}
}
 
结果：
 
 
说明：当缓存中没有数据时，会重新查数据库
 
3、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);
		
		//sqlSession相同，两次查询之间执行了增删改操作(这次增删改可能对当前数据有影响)
		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();
	}
}
 
结果：
 
 
说明：为了防止增删改对当前数据的影响，即使查的同一个对象，也会重新查数据库
 
原因：每个增删改标签都有默认清空缓存配置：flushCache="true"，不过这是默认的是一级和二级缓存都清空
 
 
4、sqlsession相同，但手动清楚了一级缓存（缓存清空）
 
清空缓存：openSession.clearCache();
 
@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);
		
		//sqlSession相同，手动清除了一级缓存（缓存清空）
		openSession.clearCache();
		
		Employee emp02 = mapper.getEmpById(1);
		System.out.println(emp02);
		System.out.println(emp01==emp02);
		
	}finally{
		openSession.close();
	}
}
 
结果：
 
 
说明：手动清空缓存后，需要重新查数据库
 
三、二级缓存（全局缓存）
 
基于namespace名称空间级别的缓存：一个namespace对应一个二级缓存
 
即一个mapper.xml对应一个缓存：
 
 
1、工作机制：
 
*         1、一个会话，查询一条数据，这个数据就会被放在当前会话的一级缓存中；
 *         2、如果会话关闭；一级缓存中的数据会被保存到二级缓存中；新的会话查询信息，就可以参照二级缓存中的内容；
 *         3、sqlSession===EmployeeMapper==>Employee
 *                         DepartmentMapper===>Department
 *             不同namespace查出的数据会放在自己对应的缓存中（map）
 *             效果：数据会从二级缓存中获取
 *                 查出的数据都会被默认先放在一级缓存中。
 *                 只有会话提交或者关闭以后，一级缓存中的数据才会转移到二级缓存中
 
2、 使用：
 *             1）、开启全局二级缓存配置：<setting name="cacheEnabled" value="true"/>
 *             2）、去mapper.xml中配置使用二级缓存：
 *                 <cache></cache>
 *             3）、我们的POJO需要实现序列化接口
 
1）在mybatis全局配置文件中开启全局二级缓存配置：<setting name="cacheEnabled" value="true"/>
 
 
2）在mapper.xml中配置使用二级缓存
 
直接加上： <cache><cache/>
 
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
 PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
 "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.atguigu.mybatis.dao.EmployeeMapper">
	
	 <cache><cache/>

 	<!--public Map<Integer, Employee> getEmpByLastNameLikeReturnMap(String lastName);  -->
 	<select id="getEmpByLastNameLikeReturnMap" resultType="com.atguigu.mybatis.bean.Employee">
 		select * from tbl_employee where last_name like #{lastName}
 	</select>
</mapper>
 
或者 <cache>中配置一些参数：
 
eviction:缓存的回收策略：
     • LRU – 最近最少使用的：移除最长时间不被使用的对象。
     • FIFO – 先进先出：按对象进入缓存的顺序来移除它们。
     • SOFT – 软引用：移除基于垃圾回收器状态和软引用规则的对象。
     • WEAK – 弱引用：更积极地移除基于垃圾收集器状态和弱引用规则的对象。
     • 默认的是 LRU。
 flushInterval：缓存刷新间隔
     缓存多长时间清空一次，默认不清空，设置一个毫秒值
 readOnly:是否只读：
     true：只读；mybatis认为所有从缓存中获取数据的操作都是只读操作，不会修改数据。
              mybatis为了加快获取速度，直接就会将数据在缓存中的引用交给用户。不安全，速度快
     false：非只读：mybatis觉得获取的数据可能会被修改。
             mybatis会利用序列化&反序列的技术克隆一份新的数据给你。安全，速度慢
 size：缓存存放多少元素；
 type=""：指定自定义缓存的全类名；
         实现Cache接口即可；
 
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
 PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
 "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.atguigu.mybatis.dao.EmployeeMapper">

	 <cache eviction="FIFO" flushInterval="60000" readOnly="false" size="1024"></cache> 
 
 	<!--public Map<Integer, Employee> getEmpByLastNameLikeReturnMap(String lastName);  -->
 	<select id="getEmpByLastNameLikeReturnMap" resultType="com.atguigu.mybatis.bean.Employee">
 		select * from tbl_employee where last_name like #{lastName}
 	</select>
</mapper>
 
3）POJO需要实现序列化接口
 
 
测试：
 
注意：需要openSession.close();后，才能从二级缓存中查数据；
 
@Test
public void testSecondLevelCache() throws IOException{
	SqlSessionFactory sqlSessionFactory = getSqlSessionFactory();
	SqlSession openSession = sqlSessionFactory.openSession();
	SqlSession openSession2 = sqlSessionFactory.openSession();
	try{

		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{
		
	}
}
 
结果：
 
 
 
说明：第二次查询是从二级缓存中拿到的数据，并没有发送新的sql;
 
注意：
 
如果openSession.close();在第二次查询之后才关闭，则第二次查询会从一级缓存中查，如果不是一个session，则查询不到数据：
 
@Test
public void testSecondLevelCache() throws IOException{
	SqlSessionFactory sqlSessionFactory = getSqlSessionFactory();
	SqlSession openSession = sqlSessionFactory.openSession();
	SqlSession openSession2 = sqlSessionFactory.openSession();
	try{

		EmployeeMapper mapper = openSession.getMapper(EmployeeMapper.class);
		EmployeeMapper mapper2 = openSession2.getMapper(EmployeeMapper.class);
		
		Employee emp01 = mapper.getEmpById(1);
		System.out.println(emp01);
		
		Employee emp02 = mapper2.getEmpById(1);
		System.out.println(emp02);
		openSession.close();
		openSession2.close();
		
	}finally{
		
	}
}
 
结果：
 
 
说明：第二次又重新发送了sql，因为从二级缓存中取数据时，会话没关闭所以二级缓存中没数据，所以又去一级缓存中查询，也没有数据则发送了sql查数据库;
 
所以，只有会话关闭或提交后，一级缓存中的数据才会转移到二级缓存中,然后因为是同一个namespace所以可以获取到数据；
 
关于Mybatis的一级缓存和二级缓存执行顺序具体可参考：Mybatis的一级缓存和二级缓存执行顺序
 
四、和缓存有关的设置/属性
 
1）、mybatis全局配置文件中配置全局缓存开启和清空
 
1.1）控制二级缓存的开启和关闭
 
         <setting name="cacheEnabled" value="true"/>
 
         cacheEnabled=true：开启缓存；false：关闭缓存（二级缓存关闭）(一级缓存一直可用的)
 
1.2）控制一级缓存的开启和关闭
 
         <setting name="localCacheScope" value="SESSION"/>
 
         localCacheScope：本地缓存作用域（一级缓存SESSION）；
 
         当前会话的所有数据保存在会话缓存中；STATEMENT：可以禁用一级缓存；
 
注意：一级缓存关闭后，二级缓存自然也无法使用；  
 
2）、方法中sqlSession清除缓存测试
 
sqlSession.clearCache();只是清除当前session的一级缓存；
 
如果openSession清空了缓存，即执行了openSession.clearCache()方法：
 
 
结果：
 
 
 说明：openSession清空缓存不影响二级缓存；只清空了一级缓存；因为在openSession.close()时，就将一级缓存保存至了二级缓存； 
 
3）、mapper.xml中也可以配置一级和二级缓存开启和使用
 
3.1）每个select标签都默认配置了useCache="true"：
          如果useCache= false：则表示不使用缓存（一级缓存依然使用，二级缓存不使用）
 3.2）每个增删改标签默认配置了flushCache="true"：（一级二级都会清除）
 

 增删改执行完成后就会清除缓存；
 
测试：默认flushCache="true"：一级缓存和二级缓存都会被清空；
 
执行增加操作：
 
 
结果：
 
 
注意：查询标签<select>默认flushCache="false"：如果flushCache=true;每次查询之后都会清空缓存；一级和二级缓存都无法使用；
 
五、整合第三方缓存
 
mybatis通过map实现的缓存，很不专业；此时可以通过整合第三方缓存来达到缓存的目的；
 
做法：实现Cache.java接口中的方法即可：
 
如实现putObject（）方法，往缓存中写数据；实现getObject()方法，从缓存中获取数据；至于什么时候调用，由mybatis决定；
 
 
 具体可参考：Mybatis整合第三方缓存ehcache

上一篇：21-Mybatis二级缓存https://blog.csdn.net/fsjwin/article/details/109685894
 
缓存相关的设置
	1.  <setting name="cacheEnabled" value="false"/> 关闭二级缓存，一级缓存可正常使用
	2. <select useCache="false">  关闭二级缓存，一级缓存可正常使用
	3. <select  flushCache="true"> ：一二级均被清空
	4. sqlsession.clearCache(); 仅对sqlsession有影响，即清除一级缓存
	5. localCacheScope：默认：session
		-  MyBatis 利用本地缓存机制（Local Cache）防止循环引用和加速重复的嵌套查询。 默认值为 SESSION，会缓存一个会话中执行的所有查询。 若设置值为 STATEMENT，本地缓存将仅用于执行语句，对相同 SqlSession 的不同查询将不会进行缓存。
 
 
1. cacheEnabled:false 关闭二级缓存，一级缓存可正常使用
 
settings>
        <setting name="logImpl" value="STDOUT_LOGGING"/>
        <!--开启二级缓存https://mybatis.org/mybatis-3/zh/configuration.html-->
        <setting name="cacheEnabled" value="false"/>
    </settings>
 
 
1.一级缓存可正常使用
 
 
2.关闭二级缓存
 
 
2. select useCache=“false” 关闭二级缓存，一级缓存可正常使用
 
 <settings>
        <setting name="logImpl" value="STDOUT_LOGGING"/>
        <!--开启二级缓存https://mybatis.org/mybatis-3/zh/configuration.html-->
        <setting name="cacheEnabled" value="true"/>
    </settings>
 
 
1.一级缓存可正常使用
 
 
2.关闭二级缓存
 
 
3. select flushCache=“true”>：一二级均被清空
 
 <settings>
        <setting name="logImpl" value="STDOUT_LOGGING"/>
        <!--开启二级缓存https://mybatis.org/mybatis-3/zh/configuration.html-->
        <setting name="cacheEnabled" value="true"/>
    </settings>
 
 
1.一级缓存被清空
 
 
2.二级缓存被清空
 
 
4. sqlsession.clearCache(); 仅对sqlsession有影响，即清除一级缓存
 
 <settings>
        <setting name="logImpl" value="STDOUT_LOGGING"/>
        <!--开启二级缓存https://mybatis.org/mybatis-3/zh/configuration.html-->
        <setting name="cacheEnabled" value="true"/>
    </settings>
 
 
1.一级缓存被清空
 
 
2.二级缓存被无影响
 
 
5. localCacheScope：默认：session
 
修改为statement
 
 
 <settings>
        <setting name="logImpl" value="STDOUT_LOGGING"/>
        <!--开启二级缓存https://mybatis.org/mybatis-3/zh/configuration.html-->
        <setting name="cacheEnabled" value="true"/>
        <setting name="localCacheScope" value="STATEMENT"/>
    </settings>

 
 
6. 总结
 
5个标签，均要知道，面试可能会问到哦！
 <select  flushCache="false"> ：重要。。
 
 
下一篇：23-Mybatis集成第三方缓存框架EHCache https://blog.csdn.net/fsjwin/article/details/109686032

MyBatis自带的缓存有一级缓存和二级缓存
 
一级缓存
 
Mybatis的一级缓存是指Session缓存。一级缓存的作用域默认是一个SqlSession。Mybatis默认开启一级缓存。
 也就是在同一个SqlSession中，执行相同的查询SQL，第一次会去数据库进行查询，并写到缓存中；
 第二次以后是直接去缓存中取。
 当执行SQL查询中间发生了增删改的操作，MyBatis会把SqlSession的缓存清空。
 
一级缓存的范围有SESSION和STATEMENT两种，默认是SESSION，如果不想使用一级缓存，可以把一级缓存的范围指定为STATEMENT，这样每次执行完一个Mapper中的语句后都会将一级缓存清除。
 如果需要更改一级缓存的范围，可以在Mybatis的配置文件中，在下通过localCacheScope指定。
 
 
1
 
 
<setting name="localCacheScope" value="STATEMENT"/>
 
建议不需要修改
 
需要注意的是
 当Mybatis整合Spring后，直接通过Spring注入Mapper的形式，如果不是在同一个事务中每个Mapper的每次查询操作都对应一个全新的SqlSession实例，这个时候就不会有一级缓存的命中，但是在同一个事务中时共用的是同一个SqlSession。
 如有需要可以启用二级缓存。
 
二级缓存
 
Mybatis的二级缓存是指mapper映射文件。二级缓存的作用域是同一个namespace下的mapper映射文件内容，多个SqlSession共享。Mybatis需要手动设置启动二级缓存。
 
二级缓存是默认启用的(要生效需要对每个Mapper进行配置)，如想取消，则可以通过Mybatis配置文件中的元素下的子元素来指定cacheEnabled为false。
 
 
1
 
2
 
3
 
 
<settings>
 
  <setting name="cacheEnabled" value="false" />
 
</settings>
 
cacheEnabled默认是启用的，只有在该值为true的时候，底层使用的Executor才是支持二级缓存的CachingExecutor。具体可参考Mybatis的核心配置类org.apache.ibatis.session.Configuration的newExecutor方法实现。
 可以通过源码看看
 
 
1
 
2
 
3
 
4
 
5
 
6
 
7
 
8
 
9
 
10
 
11
 
12
 
13
 
14
 
15
 
16
 
17
 
18
 
19
 
20
 
21
 
22
 
23
 
24
 
25
 
 
...
 
    public Executor newExecutor(Transaction transaction) {
 
        return this.newExecutor(transaction, this.defaultExecutorType);
 
    }
 
 
 
    public Executor newExecutor(Transaction transaction, ExecutorType executorType) {
 
        executorType = executorType == null ? this.defaultExecutorType : executorType;
 
        executorType = executorType == null ? ExecutorType.SIMPLE : executorType;
 
        Object executor;
 
        if (ExecutorType.BATCH == executorType) {
 
            executor = new BatchExecutor(this, transaction);
 
        } else if (ExecutorType.REUSE == executorType) {
 
            executor = new ReuseExecutor(this, transaction);
 
        } else {
 
            executor = new SimpleExecutor(this, transaction);
 
        }
 
 
 
        if (this.cacheEnabled) {//设置为true才执行的
 
            executor = new CachingExecutor((Executor)executor);
 
        }
 
 
 
        Executor executor = (Executor)this.interceptorChain.pluginAll(executor);
 
        return executor;
 
    }
 
...
 
要使用二级缓存除了上面一个配置外，我们还需要在我们每个DAO对应的Mapper.xml文件中定义需要使用的cache
 
 
1
 
2
 
3
 
4
 
5
 
 
...
 
<mapper namespace="...UserMapper">
 
    <cache/><!-- 加上该句即可，使用默认配置、还有另外一种方式，在后面写出 -->
 
    ...
 
</mapper>
 
具体可以看org.apache.ibatis.executor.CachingExecutor类的以下实现
 其中使用的cache就是我们在对应的Mapper.xml中定义的cache。
 
 
1
 
2
 
3
 
4
 
5
 
6
 
7
 
8
 
9
 
10
 
11
 
12
 
13
 
14
 
15
 
16
 
17
 
18
 
19
 
20
 
21
 
22
 
23
 
24
 
 
public <E> List<E> query(MappedStatement ms, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler) throws SQLException {
 
    BoundSql boundSql = ms.getBoundSql(parameterObject);
 
    CacheKey key = this.createCacheKey(ms, parameterObject, rowBounds, boundSql);
 
    return this.query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
 
}
 
 
 
public <E> List<E> query(MappedStatement ms, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql) throws SQLException {
 
    Cache cache = ms.getCache();
 
    if (cache != null) {//第一个条件 定义需要使用的cache 
 
        this.flushCacheIfRequired(ms);
 
        if (ms.isUseCache() && resultHandler == null) {//第二个条件 需要当前的查询语句是配置了使用cache的，即下面源码的useCache()是返回true的  默认是true
 
            this.ensureNoOutParams(ms, parameterObject, boundSql);
 
            List<E> list = (List)this.tcm.getObject(cache, key);
 
            if (list == null) {
 
                list = this.delegate.query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
 
                this.tcm.putObject(cache, key, list);
 
            }
 
 
 
            return list;
 
        }
 
    }
 
 
 
    return this.delegate.query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
 
}
 
还有一个条件就是需要当前的查询语句是配置了使用cache的，即上面源码的useCache()是返回true的，默认情况下所有select语句的useCache都是true，如果我们在启用了二级缓存后，有某个查询语句是我们不想缓存的，则可以通过指定其useCache为false来达到对应的效果。
 如果我们不想该语句缓存，可使用useCache="false
 
 
1
 
2
 
3
 
4
 
5
 
6
 
 
<select id="selectByPrimaryKey" resultMap="BaseResultMap" parameterType="java.lang.String" useCache="false">
 
        select
 
        <include refid="Base_Column_List"/>
 
        from tuser
 
        where id = #{id,jdbcType=VARCHAR}
 
    </select>
 
cache定义的两种使用方式
 
上面说了要想使用二级缓存，需要在每个DAO对应的Mapper.xml文件中定义其中的查询语句需要使用cache来缓存数据的。
 这有两种方式可以定义，一种是通过cache元素定义，一种是通过cache-ref元素来定义。
需要注意的是
 对于同一个Mapper来讲，只能使用一个Cache，当同时使用了和时，定义的优先级更高(后面的代码会给出原因)。
 Mapper使用的Cache是与我们的Mapper对应的namespace绑定的，一个namespace最多只会有一个Cache与其绑定。
 
cache元素定义
 
使用cache元素来定义使用的Cache时，最简单的做法是直接在对应的Mapper.xml文件中指定一个空的元素(看前面的代码)，这个时候Mybatis会按照默认配置创建一个Cache对象，准备的说是PerpetualCache对象，更准确的说是LruCache对象（底层用了装饰器模式）。
 具体的可看org.apache.ibatis.builder.xml.XMLMapperBuilder中的cacheElement()方法解析cache元素的逻辑。
 
 
1
 
2
 
3
 
4
 
5
 
6
 
7
 
8
 
9
 
10
 
11
 
12
 
13
 
14
 
15
 
16
 
17
 
18
 
19
 
20
 
21
 
22
 
23
 
24
 
25
 
26
 
27
 
28
 
29
 
30
 
31
 
32
 
33
 
34
 
35
 
36
 
37
 
38
 
39
 
40
 
41
 
42
 
43
 
44
 
45
 
46
 
47
 
48
 
49
 
 
...
 
    private void configurationElement(XNode context) {
 
        try {
 
            String namespace = context.getStringAttribute("namespace");
 
            if (namespace.equals("")) {
 
                throw new BuilderException("Mapper's namespace cannot be empty");
 
            } else {
 
                this.builderAssistant.setCurrentNamespace(namespace);
 
                this.cacheRefElement(context.evalNode("cache-ref"));
 
                this.cacheElement(context.evalNode("cache"));//执行在后面
 
                this.parameterMapElement(context.evalNodes("/mapper/parameterMap"));
 
                this.resultMapElements(context.evalNodes("/mapper/resultMap"));
 
                this.sqlElement(context.evalNodes("/mapper/sql"));
 
                this.buildStatementFromContext(context.evalNodes("select|insert|update|delete"));
 
            }
 
        } catch (Exception var3) {
 
            throw new BuilderException("Error parsing Mapper XML. Cause: " + var3, var3);
 
        }
 
    }
 
...
 
    private void cacheRefElement(XNode context) {
 
        if (context != null) {
 
            this.configuration.addCacheRef(this.builderAssistant.getCurrentNamespace(), context.getStringAttribute("namespace"));
 
            CacheRefResolver cacheRefResolver = new CacheRefResolver(this.builderAssistant, context.getStringAttribute("namespace"));
 
 
 
            try {
 
                cacheRefResolver.resolveCacheRef();
 
            } catch (IncompleteElementException var4) {
 
                this.configuration.addIncompleteCacheRef(cacheRefResolver);
 
            }
 
        }
 
 
 
    }
 
 
 
    private void cacheElement(XNode context) throws Exception {
 
        if (context != null) {
 
            String type = context.getStringAttribute("type", "PERPETUAL");
 
            Class<? extends Cache> typeClass = this.typeAliasRegistry.resolveAlias(type);
 
            String eviction = context.getStringAttribute("eviction", "LRU");
 
            Class<? extends Cache> evictionClass = this.typeAliasRegistry.resolveAlias(eviction);
 
            Long flushInterval = context.getLongAttribute("flushInterval");
 
            Integer size = context.getIntAttribute("size");
 
            boolean readWrite = !context.getBooleanAttribute("readOnly", false).booleanValue();
 
            Properties props = context.getChildrenAsProperties();
 
            this.builderAssistant.useNewCache(typeClass, evictionClass, flushInterval, size, readWrite, props);
 
//如果同时存在<cache>和<cache-ref>，这里的设置会覆盖前面的cache-ref的缓存
 
        }
 
 
 
    }
 
空cache元素定义会生成一个采用最近最少使用算法最多只能存储1024个元素的缓存，而且是可读写的缓存，即该缓存是全局共享的，任何一个线程在拿到缓存结果后对数据的修改都将影响其它线程获取的缓存结果，因为它们是共享的，同一个对象。
 
cache元素可指定如下属性，每种属性的指定都是针对都是针对底层Cache的一种装饰，采用的是装饰器的模式。
 
blocking：默认为false，当指定为true时将采用BlockingCache进行封装，blocking，阻塞的意思，使用BlockingCache会在查询缓存时锁住对应的Key，如果缓存命中了则会释放对应的锁，否则会在查询数据库以后再释放锁，这样可以阻止并发情况下多个线程同时查询数据，详情可参考BlockingCache的源码。
 简单理解，也就是设置true时，在进行增删改之后的并发查询，只会有一条去数据库查询，而不会并发 
 
 
 
eviction：eviction，驱逐的意思。也就是元素驱逐算法，默认是LRU，对应的就是LruCache，其默认只保存1024个Key，超出时按照最近最少使用算法进行驱逐，详情请参考LruCache的源码。如果想使用自己的算法，则可以将该值指定为自己的驱逐算法实现类，只需要自己的类实现Mybatis的Cache接口即可。除了LRU以外，系统还提供了FIFO（先进先出，对应FifoCache）、SOFT（采用软引用存储Value，便于垃圾回收，对应SoftCache）和WEAK（采用弱引用存储Value，便于垃圾回收，对应WeakCache）这三种策略。
 这里，根据个人需求选择了，没什么要求的话，默认的LRU即可
 
 
flushInterval：清空缓存的时间间隔，单位是毫秒，默认是不会清空的。当指定了该值时会再用ScheduleCache包装一次，其会在每次对缓存进行操作时判断距离最近一次清空缓存的时间是否超过了flushInterval指定的时间，如果超出了，则清空当前的缓存，详情可参考ScheduleCache的实现。
 
 
readOnly：是否只读
 默认为false。当指定为false时，底层会用SerializedCache包装一次，其会在写缓存的时候将缓存对象进行序列化，然后在读缓存的时候进行反序列化，这样每次读到的都将是一个新的对象，即使你更改了读取到的结果，也不会影响原来缓存的对象，即非只读，你每次拿到这个缓存结果都可以进行修改，而不会影响原来的缓存结果；
 当指定为true时那就是每次获取的都是同一个引用，对其修改会影响后续的缓存数据获取，这种情况下是不建议对获取到的缓存结果进行更改，意为只读(不建议设置为true)。
 这是Mybatis二级缓存读写和只读的定义，可能与我们通常情况下的只读和读写意义有点不同。每次都进行序列化和反序列化无疑会影响性能，但是这样的缓存结果更安全，不会被随意更改，具体可根据实际情况进行选择。详情可参考SerializedCache的源码。
 
 
size：用来指定缓存中最多保存的Key的数量。其是针对LruCache而言的，LruCache默认只存储最多1024个Key，可通过该属性来改变默认值，当然，如果你通过eviction指定了自己的驱逐算法，同时自己的实现里面也有setSize方法，那么也可以通过cache的size属性给自定义的驱逐算法里面的size赋值。
 
 
type：type属性用来指定当前底层缓存实现类，默认是PerpetualCache，如果我们想使用自定义的Cache，则可以通过该属性来指定，对应的值是我们自定义的Cache的全路径名称。
 
cache-ref元素定义
 
cache-ref元素可以用来指定其它Mapper.xml中定义的Cache，有的时候可能我们多个不同的Mapper需要共享同一个缓存的
 是希望在MapperA中缓存的内容在MapperB中可以直接命中的，这个时候我们就可以考虑使用cache-ref，这种场景只需要保证它们的缓存的Key是一致的即可命中，二级缓存的Key是通过Executor接口的createCacheKey()方法生成的，其实现基本都是BaseExecutor，源码如下。
 
 
1
 
2
 
3
 
4
 
5
 
6
 
7
 
8
 
9
 
10
 
11
 
12
 
13
 
14
 
15
 
16
 
17
 
18
 
19
 
20
 
21
 
22
 
23
 
24
 
25
 
26
 
27
 
28
 
29
 
30
 
31
 
32
 
33
 
34
 
35
 
 
public CacheKey createCacheKey(MappedStatement ms, Object parameterObject, RowBounds rowBounds, BoundSql boundSql) {
 
    if (this.closed) {
 
        throw new ExecutorException("Executor was closed.");
 
    } else {
 
        CacheKey cacheKey = new CacheKey();
 
        cacheKey.update(ms.getId());
 
        cacheKey.update(rowBounds.getOffset());
 
        cacheKey.update(rowBounds.getLimit());
 
        cacheKey.update(boundSql.getSql());
 
        List<ParameterMapping> parameterMappings = boundSql.getParameterMappings();
 
        TypeHandlerRegistry typeHandlerRegistry = ms.getConfiguration().getTypeHandlerRegistry();
 
 
 
        for(int i = 0; i < parameterMappings.size(); ++i) {
 
            ParameterMapping parameterMapping = (ParameterMapping)parameterMappings.get(i);
 
            if (parameterMapping.getMode() != ParameterMode.OUT) {
 
                String propertyName = parameterMapping.getProperty();
 
                Object value;
 
                if (boundSql.hasAdditionalParameter(propertyName)) {
 
                    value = boundSql.getAdditionalParameter(propertyName);
 
                } else if (parameterObject == null) {
 
                    value = null;
 
                } else if (typeHandlerRegistry.hasTypeHandler(parameterObject.getClass())) {
 
                    value = parameterObject;
 
                } else {
 
                    MetaObject metaObject = this.configuration.newMetaObject(parameterObject);
 
                    value = metaObject.getValue(propertyName);
 
                }
 
 
 
                cacheKey.update(value);
 
            }
 
        }
 
 
 
        return cacheKey;
 
    }
 
}
 
打个比方我想在MenuMapper.xml中的查询都使用在UserMapper.xml中定义的Cache，则可以通过cache-ref元素的namespace属性指定需要引用的Cache所在的namespace，即UserMapper.xml中的定义的namespace，假设在UserMapper.xml中定义的namespace是cn.chenhaoxiang.dao.UserMapper，则在MenuMapper.xml的cache-ref应该定义如下。
 
 
1
 
 
<cache-ref namespace="cn.chenhaoxiang.dao.UserMapper"/>
 
这样这两个Mapper就共享同一个缓存了
 
自定义cache就不介绍了。
 
测试二级缓存
 
 
查询测试
 
 
1
 
2
 
3
 
4
 
5
 
6
 
7
 
8
 
9
 
10
 
11
 
12
 
13
 
14
 
15
 
16
 
17
 
18
 
19
 
20
 
21
 
22
 
23
 
24
 
25
 
26
 
27
 
28
 
 
<br />/**
 
 * Created with IntelliJ IDEA.
 
 * User: 陈浩翔.
 
 * Date: 2018/1/10.
 
 * Time: 下午 10:15.
 
 * Explain:
 
 */
 
@RunWith(SpringJUnit4ClassRunner.class)
 
//配置了@ContextConfiguration注解并使用该注解的locations属性指明spring和配置文件之后
 
@ContextConfiguration(locations = {"classpath:spring.xml","classpath:spring-mybatis.xml"})
 
public class MyBatisTestBySpringTestFramework {
 
 
 
    //注入userService
 
    @Autowired
 
    private UserService userService;
 
 
 
    @Test
 
    public void testGetUserId(){
 
        String userId = "4e07f3963337488e81716cfdd8a0fe04";
 
        User user = userService.getUserById(userId);
 
        System.out.println(user);
 
 
 
 
 
        //前面说到spring和MyBatis整合
 
        User user2 = userService.getUserById(userId);
 
        System.out.println("user2:"+user2);
 
    }
 
}
 
 
接下来我们把Mapper中的cache元素删除，不使用二级缓存
 
 
再运行测试
 
 
对二级缓存进行了以下测试，获取两个不同的SqlSession(前面有说，Spring和MyBatis集成，每次都是不同的SqlSession)执行两条相同的SQL，在未指定Cache时Mybatis将查询两次数据库，在指定了Cache时Mybatis只查询了一次数据库，第二次是从缓存中拿的。
 
Cache Hit Ratio 表示缓存命中率。
 开启二级缓存后，每执行一次查询，系统都会计算一次二级缓存的命中率。
 第一次查询也是先从缓存中查询，只不过缓存中一定是没有的。
 所以会再从DB中查询。由于二级缓存中不存在该数据，所以命中率为0.但第二次查询是从二级缓存中读取的，所以这一次的命中率为1/2=0.5。
 当然，若有第三次查询，则命中率为1/3=0.66
 0.5这个值可以从上面开启cache的图看出来，0.0的值未截取到~漏掉了~
 
注意:
 增删改操作，无论是否进行提交sqlSession.commit()，均会清空一级、二级缓存，使查询再次从DB中select。
 说明：
 二级缓存的清空，实质上是对所查找key对应的value置为null，而非将对，即entry对象删除。
 从DB中进行select查询的条件是：缓存中根本不存在这个key或者缓存中存在该key所对应的entry对象，但value为null。
 
设置增删改操作不刷新二级缓存：
 若要使某个增、删或改操作不清空二级缓存，则需要在其或或中添加属性flushCache="false"，默认为true。
 
二级缓存的使用原则
 
只能在一个命名空间下使用二级缓存
 由于二级缓存中的数据是基于namespace的，即不同namespace中的数据互不干扰。在多个namespace中若均存在对同一个表的操作，那么这多个namespace中的数据可能就会出现不一致现象。
在单表上使用二级缓存
 如果一个表与其它表有关联关系，那么久非常有可能存在多个namespace对同一数据的操作。而不同namespace中的数据互补干扰，所以就有可能出现多个namespace中的数据不一致现象。
查询多于修改时使用二级缓存
 在查询操作远远多于增删改操作的情况下可以使用二级缓存。因为任何增删改操作都将刷新二级缓存，对二级缓存的频繁刷新将降低系统性能。

 
介绍
 
要想回答这个问题，必须把一级缓存和二级缓存的实现搞明白，详细介绍一下
 
我们知道Mybatis有一级缓存和二级缓存，底层都是用HashMap实现的
 key为CacheKey对象（后续说原因），value为从数据库中查出来的值。
 
Mybatis的二级缓存模块是装饰器的典型实现，不清楚装饰者模式的看如下文章
 
面试官：说一下装饰者模式的作用，以及哪些地方用到了装饰者模式吧
 
画一个简易的装饰者模式类图
 
 
Component（组件）：组件接口或抽象类定义了全部组件实现类以及所有装饰器实现的行为。
 
ConcreteComponent（具体组件实现类）：具体组件实现类实现了Component接口或抽象类。通常情况下，具体组件实现类就是被装饰器装饰的原始对象，该类提供了Component接口中定义的最基本的功能，其他高级功能或后序添加的新功能，都是通过装饰器的方式添加到该类的对象之上的。
 
ConcreteDecorator（具体的装饰器）：该实现类要向被装饰对象添加某些功能
 
mybatis中caceh模块的类图
 
 其中只有PerpetualCache是具组件实现类，提供了Cache接口的基本实现。而FifoCache
 ，LoggingCache等都是具体装饰者，在具体实现上加额外功能
 
测试一级缓存
 
测试的具体过程引用自参考博客
 
github地址：https://github.com/kailuncen/mybatis-cache-demo
 
接下来通过实验，了解MyBatis一级缓存的效果，每个单元测试后都请恢复被修改的数据。
 
首先是创建示例表student，创建对应的POJO类和增改的方法，具体可以在entity包和mapper包中查看。
 
CREATE TABLE `student` (
  `id` int(11) unsigned NOT NULL AUTO_INCREMENT,
  `name` varchar(200) COLLATE utf8_bin DEFAULT NULL,
  `age` tinyint(3) unsigned DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=4 DEFAULT CHARSET=utf8 COLLATE=utf8_bin;
 
在以下实验中，id为1的学生名称是凯伦
 
实验1
 
开启一级缓存，范围为会话级别，调用三次getStudentById，代码如下所示：
 
public void getStudentById() throws Exception {
        SqlSession sqlSession = factory.openSession(true); // 自动提交事务
        StudentMapper studentMapper = sqlSession.getMapper(StudentMapper.class);
        System.out.println(studentMapper.getStudentById(1));
        System.out.println(studentMapper.getStudentById(1));
        System.out.println(studentMapper.getStudentById(1));
    }
 
执行结果：
 
 我们可以看到，只有第一次真正查询了数据库，后续的查询使用了一级缓存。
 
实验2
 
增加了对数据库的修改操作，验证在一次数据库会话中，如果对数据库发生了修改操作，一级缓存是否会失效。
 
@Test
public void addStudent() throws Exception {
        SqlSession sqlSession = factory.openSession(true); // 自动提交事务
        StudentMapper studentMapper = sqlSession.getMapper(StudentMapper.class);
        System.out.println(studentMapper.getStudentById(1));
        System.out.println("增加了" + studentMapper.addStudent(buildStudent()) + "个学生");
        System.out.println(studentMapper.getStudentById(1));
        sqlSession.close();
}
 
执行结果：
 

 我们可以看到，在修改操作后执行的相同查询，查询了数据库，一级缓存失效。
 
实验3
 
开启两个SqlSession，在sqlSession1中查询数据，使一级缓存生效，在sqlSession2中更新数据库，验证一级缓存只在数据库会话内部共享。（这个实验在原文上略有修改）
 
@Test
public void testLocalCacheScope() throws Exception {
	SqlSession sqlSession1 = factory.openSession(true); // 自动提交事务
	SqlSession sqlSession2 = factory.openSession(true); // 自动提交事务

    StudentMapper studentMapper1 = sqlSession1.getMapper(StudentMapper.class);
    StudentMapper studentMapper2 = sqlSession2.getMapper(StudentMapper.class);

	System.out.println("studentMapper1读取数据: " + studentMapper1.getStudentById(1));
	System.out.println("studentMapper2读取数据: " + studentMapper2.getStudentById(1));
	System.out.println("studentMapper2更新了" + studentMapper2.updateStudentName("小岑",1) + "个学生的数据");
	System.out.println("studentMapper1读取数据: " + studentMapper1.getStudentById(1));
	System.out.println("studentMapper2读取数据: " + studentMapper2.getStudentById(1));

}
 
输出如下
 
DEBUG [main] - Cache Hit Ratio [mapper.StudentMapper]: 0.0
DEBUG [main] - ==>  Preparing: SELECT id,name,age FROM student WHERE id = ? 
DEBUG [main] - ==> Parameters: 1(Integer)
TRACE [main] - <==    Columns: id, name, age
TRACE [main] - <==        Row: 1, 凯伦, 16
DEBUG [main] - <==      Total: 1
studentMapper1读取数据: StudentEntity{id=1, name='凯伦', age=16, className='null'}
DEBUG [main] - Cache Hit Ratio [mapper.StudentMapper]: 0.0
DEBUG [main] - ==>  Preparing: SELECT id,name,age FROM student WHERE id = ? 
DEBUG [main] - ==> Parameters: 1(Integer)
TRACE [main] - <==    Columns: id, name, age
TRACE [main] - <==        Row: 1, 凯伦, 16
DEBUG [main] - <==      Total: 1
studentMapper2读取数据: StudentEntity{id=1, name='凯伦', age=16, className='null'}
DEBUG [main] - ==>  Preparing: UPDATE student SET name = ? WHERE id = ? 
DEBUG [main] - ==> Parameters: 小岑(String), 1(Integer)
DEBUG [main] - <==    Updates: 1
studentMapper2更新了1个学生的数据
DEBUG [main] - Cache Hit Ratio [mapper.StudentMapper]: 0.0
studentMapper1读取数据: StudentEntity{id=1, name='凯伦', age=16, className='null'}
DEBUG [main] - Cache Hit Ratio [mapper.StudentMapper]: 0.0
DEBUG [main] - ==>  Preparing: SELECT id,name,age FROM student WHERE id = ? 
DEBUG [main] - ==> Parameters: 1(Integer)
TRACE [main] - <==    Columns: id, name, age
TRACE [main] - <==        Row: 1, 小岑, 16
DEBUG [main] - <==      Total: 1
studentMapper2读取数据: StudentEntity{id=1, name='小岑', age=16, className='null'}
 
sqlSession1和sqlSession2读的时相同的数据，但是都查询了数据库，说明了一级缓存只在数据库会话层面共享
 
sqlSession2更新了id为1的学生的姓名，从凯伦改为了小岑，但sqlSession1之后的查询中，id为1的学生的名字还是凯伦，出现了脏数据，也证明了之前的设想，一级缓存只在数据库会话层面共享
 
一级缓存
 
一级缓存的生命周期与SqlSession相同，如果你对SqlSession不熟悉，你可以把它类比为JDBC编程中的Connection，即数据库的一次会话。
 
 
要想了解缓存，就必须得了解一下Executor，这个Executor是干嘛的呢？你可以理解为要执行的SQL都会经过这个类的方法，在这个类的方法中调用StatementHandler最终执行SQL
 
Executor的实现也是一个典型的装饰者模式
 

 我相信你已经看出来，SimpleExecutor，BatchExecutor是具体组件实现类，而CachingExecutor是具体的装饰器。可以看到具体组件实现类有一个父类BaseExecutor，而这个父类是一个模板模式的典型应用，操作一级缓存的操作都在这个类中，而具体的操作数据库的功能则让子类去实现。
 
至此终于搞明白了，一级缓存的所有操作都在BaseExecutor这个类中啊，看看具体操作
 
query方法
 
  @Override
  public <E> List<E> query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler) throws SQLException {
    BoundSql boundSql = ms.getBoundSql(parameter);
    CacheKey key = createCacheKey(ms, parameter, rowBounds, boundSql);
    return query(ms, parameter, rowBounds, resultHandler, key, boundSql);
 }
 
当执行select操作，会先生成一个CacheKey，如果根据CacheKey能从HashMap中拿到值则放回，如果拿不到值则先查询数据库，从数据库中查出来后再放到HashMap中。追一下
 query方法就知道了，代码就不贴了，比较简单
 
update方法
 
  @Override
  public int update(MappedStatement ms, Object parameter) throws SQLException {
    ErrorContext.instance().resource(ms.getResource()).activity("executing an update").object(ms.getId());
    if (closed) {
      throw new ExecutorException("Executor was closed.");
    }
    clearLocalCache();
    return doUpdate(ms, parameter);
  }
 
当执行update操作时，可以看到会调用clearLocalCache()方法，而这个方法则会清空一级缓存，即清空HashMap
 
总结
 
MyBatis一级缓存的生命周期和SqlSession一致。
MyBatis一级缓存内部设计简单，只是一个没有容量限定的HashMap，在缓存的功能性上有所欠缺。
MyBatis的一级缓存最大范围是SqlSession内部，有多个SqlSession或者分布式的环境下，数据库写操作会引起脏数据，建议设定缓存级别为Statement，即进行如下配置
 
<setting name="localCacheScope" value="STATEMENT"/>
 
原因也很简单，看BaseExecutor的query()方法，当配置成STATEMENT时，每次查询完都会清空缓存
 
   if (configuration.getLocalCacheScope() == LocalCacheScope.STATEMENT) {
	// issue #482
	clearLocalCache();
  }
 
mybatis和spring整合的一些注意事项
 
在未开启事物的情况之下，每次查询，spring都会关闭旧的sqlSession而创建新的sqlSession，因此此时的一级缓存是没有起作用的
在开启事物的情况之下，spring使用threadLocal获取当前资源绑定同一个sqlSession，因此此时一级缓存是有效的
 
CacheKey
 
前面说到缓存的key是CacheKey对象，因为Mybatis中涉及动态SQL等多方面的因素，缓存的key不能仅仅通过String来表示，而是通过一个updateList，只有updateList的元素完全相同，则认为这2个CacheKey相同
 
public class CacheKey implements Cloneable, Serializable {

  // 参与hash计算的乘数
  private final int multiplier;
  // CacheKey的hash值，在update函数中实时运算出来的，这些值都是为了方便更快的比较，具体可以看equals函数
  private int hashcode;
  // 校验和，hash值的和
  private long checksum;
  // updateList中的元素个数
  private int count;
  // 将判等的对象放到这个list中
  private List<Object> updateList;
}
 
CacheKey的其他属性都是为了加快比较的速度，具体可以看这个类的equals函数
 
CacheKey的updateList放置了如下几个对象
 
mappedStatment的id
指定查询结构集的范围
查询所使用SQL语句
用户传递给SQL语句的实际参数值
 
怎么知道CacheKey是这些对象呢？你可以参考BaseExecutor的createCacheKey方法
 
  @Override
  public CacheKey createCacheKey(MappedStatement ms, Object parameterObject, RowBounds rowBounds, BoundSql boundSql) {
    if (closed) {
      throw new ExecutorException("Executor was closed.");
    }
    CacheKey cacheKey = new CacheKey();
    cacheKey.update(ms.getId());
    cacheKey.update(rowBounds.getOffset());
    cacheKey.update(rowBounds.getLimit());
    cacheKey.update(boundSql.getSql());
    List<ParameterMapping> parameterMappings = boundSql.getParameterMappings();
    TypeHandlerRegistry typeHandlerRegistry = ms.getConfiguration().getTypeHandlerRegistry();
    // mimic DefaultParameterHandler logic
    for (ParameterMapping parameterMapping : parameterMappings) {
      if (parameterMapping.getMode() != ParameterMode.OUT) {
        Object value;
        String propertyName = parameterMapping.getProperty();
        if (boundSql.hasAdditionalParameter(propertyName)) {
          value = boundSql.getAdditionalParameter(propertyName);
        } else if (parameterObject == null) {
          value = null;
        } else if (typeHandlerRegistry.hasTypeHandler(parameterObject.getClass())) {
          value = parameterObject;
        } else {
          MetaObject metaObject = configuration.newMetaObject(parameterObject);
          value = metaObject.getValue(propertyName);
        }
        cacheKey.update(value);
      }
    }
    if (configuration.getEnvironment() != null) {
      // issue #176
      cacheKey.update(configuration.getEnvironment().getId());
    }
    return cacheKey;
  }
 
测试二级缓存
 
测试的具体过程引用自参考博客
 
二级缓存是基于namespace实现的，即一个mapper映射文件用一个缓存
 
在本实验中，id为1的学生名称初始化为点点。
 
实验1
 
测试二级缓存效果，不提交事务，sqlSession1查询完数据后，sqlSession2相同的查询是否会从缓存中获取数据。
 
@Test
public void testCacheWithoutCommitOrClose() throws Exception {
        SqlSession sqlSession1 = factory.openSession(true); 
        SqlSession sqlSession2 = factory.openSession(true); 
        
        StudentMapper studentMapper = sqlSession1.getMapper(StudentMapper.class);
        StudentMapper studentMapper2 = sqlSession2.getMapper(StudentMapper.class);

        System.out.println("studentMapper读取数据: " + studentMapper.getStudentById(1));
        System.out.println("studentMapper2读取数据: " + studentMapper2.getStudentById(1));
}
 
执行结果：
 
 我们可以看到，当sqlsession没有调用commit()方法时，二级缓存并没有起到作用。
 
实验2
 
测试二级缓存效果，当提交事务时，sqlSession1查询完数据后，sqlSession2相同的查询是否会从缓存中获取数据。
 
@Test
public void testCacheWithCommitOrClose() throws Exception {
        SqlSession sqlSession1 = factory.openSession(true); 
        SqlSession sqlSession2 = factory.openSession(true); 
        
        StudentMapper studentMapper = sqlSession1.getMapper(StudentMapper.class);
        StudentMapper studentMapper2 = sqlSession2.getMapper(StudentMapper.class);

        System.out.println("studentMapper读取数据: " + studentMapper.getStudentById(1));
        sqlSession1.commit();
        System.out.println("studentMapper2读取数据: " + studentMapper2.getStudentById(1));
}
 

 从图上可知，sqlsession2的查询，使用了缓存，缓存的命中率是0.5。
 
实验3
 
测试update操作是否会刷新该namespace下的二级缓存。
 
@Test
public void testCacheWithUpdate() throws Exception {
        SqlSession sqlSession1 = factory.openSession(true); 
        SqlSession sqlSession2 = factory.openSession(true); 
        SqlSession sqlSession3 = factory.openSession(true); 
        
        StudentMapper studentMapper = sqlSession1.getMapper(StudentMapper.class);
        StudentMapper studentMapper2 = sqlSession2.getMapper(StudentMapper.class);
        StudentMapper studentMapper3 = sqlSession3.getMapper(StudentMapper.class);
        
        System.out.println("studentMapper读取数据: " + studentMapper.getStudentById(1));
        sqlSession1.commit();
        System.out.println("studentMapper2读取数据: " + studentMapper2.getStudentById(1));
        
        studentMapper3.updateStudentName("方方",1);
        sqlSession3.commit();
        System.out.println("studentMapper2读取数据: " + studentMapper2.getStudentById(1));
}
 
 
我们可以看到，在sqlSession3更新数据库，并提交事务后，sqlsession2的StudentMapper namespace下的查询走了数据库，没有走Cache。
 
实验4
 
验证MyBatis的二级缓存不适应用于映射文件中存在多表查询的情况。
 
CREATE TABLE `student` (
  `id` int(11) unsigned NOT NULL AUTO_INCREMENT,
  `name` varchar(200) COLLATE utf8_bin DEFAULT NULL,
  `age` tinyint(3) unsigned DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=8 DEFAULT CHARSET=utf8 COLLATE=utf8_bin;


INSERT INTO `student` (`id`, `name`, `age`) 
VALUES (1,'点点',16),(2,'平平',16),(3,'美美',16),(4,'团团',16);

CREATE TABLE `class` (
  `id` int(11) unsigned NOT NULL AUTO_INCREMENT,
  `name` varchar(20) COLLATE utf8_bin DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=3 DEFAULT CHARSET=utf8 COLLATE=utf8_bin;

INSERT INTO `class` (`id`, `name`) VALUES (1,'一班'),(2,'二班');

CREATE TABLE `classroom` (
  `id` int(11) unsigned NOT NULL AUTO_INCREMENT,
  `class_id` int(11) DEFAULT NULL,
  `student_id` int(11) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=5 DEFAULT CHARSET=utf8 COLLATE=utf8_bin;

INSERT INTO `classroom` (`id`, `class_id`, `student_id`)
VALUES (1,1,1),(2,1,2),(3,2,3),(4,2,4);

 
getStudentByIdWithClassInfo的定义如下
 
<select id="getStudentByIdWithClassInfo" parameterType="int" resultType="entity.StudentEntity">
	SELECT  s.id,s.name,s.age,class.name as className
	FROM classroom c
	JOIN student s ON c.student_id = s.id
	JOIN class ON c.class_id = class.id
	WHERE s.id = #{id};
</select>
 
通常我们会为每个单表创建单独的映射文件，由于MyBatis的二级缓存是基于namespace的，多表查询语句所在的namspace无法感应到其他namespace中的语句对多表查询中涉及的表进行的修改，引发脏数据问题。
 
@Test
public void testCacheWithDiffererntNamespace() throws Exception {
    SqlSession sqlSession1 = factory.openSession(true); 
    SqlSession sqlSession2 = factory.openSession(true); 
    SqlSession sqlSession3 = factory.openSession(true); 
    
    StudentMapper studentMapper = sqlSession1.getMapper(StudentMapper.class);
    StudentMapper studentMapper2 = sqlSession2.getMapper(StudentMapper.class);
    ClassMapper classMapper = sqlSession3.getMapper(ClassMapper.class);
        
    System.out.println("studentMapper读取数据: " + studentMapper.getStudentByIdWithClassInfo(1));
    sqlSession1.close();
    System.out.println("studentMapper2读取数据: " + studentMapper2.getStudentByIdWithClassInfo(1));

    classMapper.updateClassName("特色一班",1);
    sqlSession3.commit();
    System.out.println("studentMapper2读取数据: " + studentMapper2.getStudentByIdWithClassInfo(1));
}
 
执行结果：
 
 
在这个实验中，我们引入了两张新的表，一张class，一张classroom。class中保存了班级的id和班级名，classroom中保存了班级id和学生id。我们在StudentMapper中增加了一个查询方法getStudentByIdWithClassInfo，用于查询学生所在的班级，涉及到多表查询。在ClassMapper中添加了updateClassName，根据班级id更新班级名的操作。
 
当sqlsession1的studentmapper查询数据后，二级缓存生效。保存在StudentMapper的namespace下的cache中。当sqlSession3的classMapper的updateClassName方法对class表进行更新时，updateClassName不属于StudentMapper的namespace，所以StudentMapper下的cache没有感应到变化，没有刷新缓存。当StudentMapper中同样的查询再次发起时，从缓存中读取了脏数据。
 
实验5
 
为了解决实验4的问题呢，可以使用Cache ref，让ClassMapper引用StudenMapper命名空间，这样两个映射文件对应的SQL操作都使用的是同一块缓存了。
 
mapper文件中的配置如下
 
<cache-ref namespace="mapper.StudentMapper"/>
 
执行结果：
 

 不过这样做的后果是，缓存的粒度变粗了，多个Mapper namespace下的所有操作都会对缓存使用造成影响。
 
二级缓存的实现
 
前面说了一级缓存的实现在BaseExecutor中，那么二级缓存的实现在哪呢？提示一下，前面提到的Executor。没错，就是CachingExecutor。下面详细介绍一下
 
 
二级缓存的相关配置有如下3个
 
1.mybatis-config.xml
 
<settings>
	<setting name="cacheEnabled" value="true"/>
</settings>
 
这个是二级缓存的总开关，只有当该配置项设置为true时，后面两项的配置才会有效果
 
从Configuration类的newExecutor方法可以看到，当cacheEnabled为true，就用缓存装饰器装饰一下具体组件实现类，从而让二级缓存生效
 
// 开启二级缓存，用装饰器模式装饰一下
if (cacheEnabled) {
  executor = new CachingExecutor(executor);
}
 
2.mapper映射文件中
 mapper映射文件中如果配置了<cache>和<cache-ref>中的任意一个标签，则表示开启了二级缓存功能，没有的话表示不开启
 
<cache type="" eviction="FIFO" size="512"></cache>
 
二级缓存的部分配置如上，type就是填写一个全类名，你看我上面画的图，二级缓存是用Cache表示的，一级缓存是用HashMap表示的。这就说明二级缓存的实现类你可以可以自己提供的，不一定得用默认的HashMap（对，二级缓存默认是用HashMap实现的），Mybatis能和Redis，ehcache整合的原因就在这
 
这个eviction表示缓存清空策略，可填选项如下
 
选项
解释
装饰器类
LRU
最近最少使用的:移除最长时间不被使用的对象
LruCache
FIFO
先进先出:按对象进入缓存的顺序来移除它们
FifoCache
SOFT
软引用:移除基于垃圾回收器状态和软引用规则的对象
SoftCache
WEAK
弱引用:更积极地移除基于垃圾收集器状态和弱引用规则的对象
WeakCache
可以看到在Mybatis中换缓存清空策略就是换装饰器。还有就是如果面试官让你写一个FIFO算法或者LRU算法，这不就是现成的实现吗？
 
3.<select>节点中的useCache属性
 
该属性表示查询产生的结果是否要保存的二级缓存中，useCache属性的默认值为true，这个配置可以将二级缓存细分到语句级别
 
CachingExecutor利用了2个组件TransactionalCacheManager和TransactionalCache来管理二级缓存，为什么要多这2个组件呢？因为二级缓存不像一级缓存那样查询完直接放入一级缓存，而是要等事务提交时才会将查询出来的数据放到二级缓存中。
 
因为如果事务1查出来直接放到二级缓存，此时事务2从二级缓存中拿到了事务1缓存的数据，但是事务1回滚了，此时事务2不就发生了脏读了吗？
 
二级缓存的具体实现也不难，追一下CachingExecutor，TransactionalCacheManager，TransactionalCache就明白了，可以参考《Mybatis技术内幕一书》
 
总结
 
MyBatis的二级缓存相对于一级缓存来说，实现了SqlSession之间缓存数据的共享
MyBatis在多表查询时，极大可能会出现脏数据，有设计上的缺陷，安全使用二级缓存的条件比较苛刻
在分布式环境下，由于默认的MyBatis Cache实现都是基于本地的，分布式环境下必然会出现读取到脏数据，需要使用集中式缓存将MyBatis的Cache接口实现，有一定的开发成本，直接使用Redis、Memcached等分布式缓存可能成本更低，安全性也更高。
 
问题回答
 
 
一级缓存和二级缓存的生命周期分别是？
 一级缓存的生命周期是会话级别，因为一级缓存是存在Sqlsession的成员变量Executor的成员变量localCache中的。而二级缓存的生命周期是整个应用级别，因为二级缓存是存在Configuration对象中，而这个对象在应用启动后一直存在
 
 
同时配置一级缓存和二级缓存后，先查询哪个缓存？
 当然是先查询二级缓存再查询一级缓存啊，因为一级缓存的实现在BaseExecutor，而二级缓存的实现在CachingExecutor，CachingExecutor是BaseExecutor的装饰器
 
 
参考博客
 
[1]https://tech.meituan.com/2018/01/19/mybatis-cache.html
 [2]https://blog.csdn.net/u013887008/article/details/80379938
 [3]http://www.justdojava.com/2019/07/29/mybatis-secondcache/