缓存就是内存中的数据，常常来自对数据库查询结果的保存，使用缓存，我们可以避免频繁的与数据库进行交互，进而提高响应速度。
mybatis也提供了对缓存的支持，分为一级缓存和二级缓存，可以通过下图来理解：
- 一级缓存是SqlSession级别的缓存。在操作数据库时需要构造sqlSeeion对象，在对象中有一个数据结构（HashMap）用于存储数据。不同的sqlSeeion之前的缓存数据结构区域（HashMap）是互相不影响的。
- 二级缓存是mapper级别的缓存，多个SqlSession去操作同一个Mapper的Sql语句，多个SqlSession去操作同一个Mapper的sql语句，多个SqlSession可以共用耳机缓存，二级缓存是跨SqlSession的。
1. 一级缓存
a. 我们在一个sqlSession中，对User表根据id进行两次查询，查看他们发出sql语句的情况。
@Test
public void test1(){
// 根据sqlSessionFactory 获取session
SqlSession sqlSession = sessionFactory.openSession();
UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
//第一次查询，发出sql语句，并将查询结果放入缓存中
User u1 = userMapper.selectUserByUserId(1);
System.out.println(u1);
//第二次查询，由于是同一个sqlSession，会在缓存中查询结果
//如果有，直接从缓存中取出来，不和数据库进行交互
User u2 = userMapper.selectUserByUserId(1);
System.out.println(u2);
sqlSession.close();
}
查看控制台打印
b. 同样对user表进行两次查询，只不过两次查询之前进行一次update操作
@Test
public void test2(){
//根据sqlSessionFactory 获取session
SqlSession sqlSession = sessionFactory.openSession();
UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
//第一次查询，发出sql语句，并将查询结果放入缓存中
User u1 = userMapper.selectUserByUserId( 1 );
System.out.println(u1);
//第二步进行了一次更新操作，sqlSession.commit()
u1.setSex("女");
userMapper.updateUserByUserId(u1);
sqlSession.commit();
//第二次查询，由于是同一个sqlSession.commit()，会清空缓存信息
//则此次查询也会发出sql语句
User u2 = userMapper.selectUserByUserId(1);
System.out.println(u2);
sqlSession.close();
}
控制台打印：
c. 总结
- 第一次发起查询用户为1的用户信息，先去缓存中是否有id为1的用户信息，如没有，从数据库查询用户信息，得到用户信息，将用户信息存储到一级缓存中。
- 如果中间sqlSession去执行commit操作（执行插入、更新、删除），则会清空SqlSession中的一级缓存，这样做的目的是为了让缓存中的存储的是最新的信息，避免脏读。
-
第二次发起查询用户id为1的用户信息，先去缓存中找是否为1的用户信息，如果有，直接从缓存中获取用户信息。
一级缓存原理探究和源码分析
一级缓存到底是什么？一级缓存什么时候被创建、一级缓存的工作流程是怎么样的？
大家可以这样想，上面我们一直提到一级缓存，那么提到一级缓存就绕不开SqlSession，所以我们索性就直接从Sqlsession看看有没有创建缓存或者与缓存有关的属性或者方法。
观察了下，似乎只有clearCache()方法和缓存沾点边，那么就从这个方法入手，分析源码时，我们要看它（此类）是谁，它的父类和子类分别又是谁，对如上关系了解了，才会对这个类有更深的认识，分析了一圈，你可能会得到如下这个流程图。
再深入分析，流程走到PerpetualCache中的clear方法中，会调用其
cache.clear()方法，那么这个cache是什么东西呢？点进去发现，cache其实就是
private Map<Object, Object> cache = new HashMap();
也就是一个Map，所以cache.clear()其实就是map.clear()，也就是说，缓存其实就是本地存放的一个map对象，每一个SqlSession都会存放一个map对象的引用，那么这个cache是什么时候创建的呢？
最有可能创建缓存的地方在哪里呢，我觉得是Executor，为什么这么认为？因为Executor是执行器，用于执行sql请求，而且清除缓存的方法也是在Exectuor中执行，所以很可能创建缓存也在Executor之中，看了一圈发现Executor有一个createCacheKey方法，这个方法名，跟进去看看你会发现creatCacheKey是由BaseExecutor执行的，代码如下
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();
//MappedStatement 的id
//id就是sql语句的所在位置 包名+类名+SQL名称
cacheKey.update(ms.getId());
//offset 就是0
cacheKey.update(rowBounds.getOffset());
//limit 就是 Integer.MAXVALUE
cacheKey.update(rowBounds.getLimit());
//具体的SQL语句
cacheKey.update(boundSql.getSql());
List<ParameterMapping> parameterMappings = boundSql.getParameterMappings();
TypeHandlerRegistry typeHandlerRegistry = ms.getConfiguration().getTypeHandlerRegistry();
Iterator var8 = parameterMappings.iterator();
while(var8.hasNext()) {
ParameterMapping parameterMapping = (ParameterMapping)var8.next();
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);
}
//update了sql中带的参数
cacheKey.update(value);
}
}
if (this.configuration.getEnvironment() != null) {
cacheKey.update(this.configuration.getEnvironment().getId());
}
return cacheKey;
}
}
创建缓存key会经过一系列的update方法，update方法由一个createKey这个对象来执行，这个update方法最终由updateList的list来把五个值存进去，对照上面的代码和下面的图示，你应该可以理解这五个值是什么
这里需要注意一下最后一个值，cacheKey.update(this.configuration.getEnvironment().getId()); 这是什么什么，这其实是定义在mybatis-config.xml中的标签，如下
那么我们回归正题，那么创建完缓存之后该用在何处呢？总不会凭空创建一个缓存不使用吧？经过我们对一级缓存的探究后，我们发现一级缓存更多是用于查询操作，毕竟一级缓存也叫做查询缓存，为什么叫查询缓存一会说，先来看一下这个缓存到底用在哪了，我们跟踪到query方法，
public <E> List<E> query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler) throws SQLException {
BoundSql boundSql = ms.getBoundSql(parameter);
//创建缓存
CacheKey key = this.createCacheKey(ms, parameter, rowBounds, boundSql);
return this.query(ms, parameter, rowBounds, resultHandler, key, boundSql);
}
public <E> List<E> query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql) throws SQLException {
ErrorContext.instance().resource(ms.getResource()).activity("executing a query").object(ms.getId());
...
list = resultHandler == null ? (List)this.localCache.getObject(key) : null;
if (list != null) {
//处理存储过程
this.handleLocallyCachedOutputParameters(ms, key, parameter, boundSql);
} else {
list = this.queryFromDatabase(ms, parameter, rowBounds, resultHandler, key, boundSql);
}
}
...
}
queryFromDatabase方法
private <E> List<E> queryFromDatabase(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql) throws SQLException {
this.localCache.putObject(key, ExecutionPlaceholder.EXECUTION_PLACEHOLDER);
List list;
try {
list = this.doQuery(ms, parameter, rowBounds, resultHandler, boundSql);
} finally {
this.localCache.removeObject(key);
}
this.localCache.putObject(key, list);
if (ms.getStatementType() == StatementType.CALLABLE) {
this.localOutputParameterCache.putObject(key, parameter);
}
return list;
}
如果查不到的话，就去数据库查询，在queryFromDatabase中会对localCache进行写入，localCache对象的put方法最终会交给Map进行存放
public void putObject(Object key, Object value) {
this.cache.put(key, value);
}
2. 二级缓存
二级缓存的原理和一级缓存一样，第一次查询会将数据放入到缓存中，然后第二次查询直接会从缓存中取，但是一级缓存是基于sqlSession的，而二级缓存是基于mapper的namespace的，也就是说多个sqlSession可以共享一个mapper的二级缓存区域，并且如果两个mapper的namespace相同，即使是两个mapper，那么这两个的mapper中执行sql查询到的数据也将存在相同的二级缓存区域中。
如何使用二级缓存
a. 开启二级缓存
和一级缓存默认开启不一样，二级缓存需要手动开启
首先在全局配置文件sqlMapConfig.xml文件中加入代码：
<!--开启二级缓存 -->
<settings>
<setting name="cacheEnabled" value="true"/>
</settings>
其次在UserMapper.xml文件中开启缓存
<!--开启二级缓存 -->
<cache></cache>
我们可以看到mapper.xml文件中就这么一个空标签，其实这里可以配置，PerpetualCache这个类是mybatis默认实现缓存功能的类，我们不写type就是用mybatis默认的缓存，也可以实现Cache接口来自定义Cache接口来自定义缓存。
public class PerpetualCache implements Cache {
private final String id;
private Map<Object, Object> cache = new HashMap();
public PerpetualCache(String id) {
this.id = id;
}
我们可以看到二级缓存底层还是HashMap的结构
b. po类实现Serializable序列化就接口
开启了二级缓存后，还需要将要缓存的pojo实现Serializable接口，为了将缓存数据取出反序列化操作，因为二级缓存介质多种多样，不一定存在内存中，也有可能存在硬盘中，如果我们要取这个缓存，就需要反序列化，所以mybatis中的pojo都会去实现Serializable接口。
c. 测试
- 测试二级缓存和SqlSession无关
@Test
public` `void` `testTwoCache(){
//根据 sqlSessionFactory 产生 session
SqlSession sqlSession1 = sessionFactory.openSession();
SqlSession sqlSession2 = sessionFactory.openSession();
UserMapper userMapper1 = sqlSession1.getMapper(UserMapper. class );
UserMapper userMapper2 = sqlSession2.getMapper(UserMapper. class );
//第一次查询，发出sql语句，并将查询得结果放入缓存中
User u1 = userMapper1.selectUserByUserId(1);
System.out.println(u1);
sqlSession1.close(); //第一次查询完后关闭sqlSession
//第二次查询，即使sqlSession1已经关闭了，这次查询依然不发出sql语句
User u2 = userMapper2.selectUserByUserId(1);
System.out.println(u2);
sqlSession2.close();
可以看出上面两个不同的sqlSession，第一个关闭了，第二次查询依然依然不发出sql语句。
- 测试执行commit方法，二级缓存数据清空
@Test
public` `void` `testTwoCache(){
//根据sqlSessionFactory 产生 session
SqlSession sqlSession1 = sessionFactory.openSession();
SqlSession sqlSession2 = sessionFactory.openSession();
SqlSession sqlSession3 = sessionFactory.openSession();
String statement = "com.lagou.pojo.UserMapper.selectUserByUserId" ;
UserMapper userMapper1 = sqlSession1.getMapper(UserMapper. class );
UserMapper userMapper2 = sqlSession2.getMapper(UserMapper. class );
UserMapper userMapper3 = sqlSession2.getMapper(UserMapper. class );
//第一次查询，发出sql语句，并将查询得结果放入缓存中
User u1 = userMapper1.selectUserByUserId( 1 );
System.out.println(u1);
sqlSession1.close(); //ᒫӞེັᧃਠىݸᳮsqlSession
//执行更新操作，commit()
u1.setUsername( "aaa" );
userMapper3.updateUserByUserId(u1);
sqlSession3.commit();
//第二次查询，由于上次更新操作，缓存数据已经清空（防止数据脏读），这里必须再次发出sql语句
User u2 = userMapper2.selectUserByUserId( 1 );
System.out.println(u2);
sqlSession2.close();
查看控制台情况，
d. useCache和flushCache
mybatis还可以配置userCache和flush等配置项，userCache是用来设置是否禁用二级缓存，在statenent 中设置useCache=false可以禁用当前select语句的二级缓存，即每次查询都会发出sql去查询，默认情况是false，即该sql使用二级缓存。
这种情况是针对每次查询都需要最新的数据sql，要设置成useCache=false，禁用二级缓存，直接从数据库获取。
在mapper的同一个namespace中，如果有其他的insert、update、delete操作数据后需要刷新缓存，如果不执行刷新缓存会出现脏读。
设置statement配置中的flushCache=“true”属性，默认情况下为true，即刷新缓存，如果改成false则不会刷新。使用缓存时如果手动修改数据库表中的查询数据会出现脏读。
<select id="selectUserByUserId" flushCache="true" useCache="false"
resultType="com.lagou.pojo.User" parameterType="int">
select * from user where id=#{id}
</select>
一般执行完commit操作都需要刷新缓存，flushCache=true表示刷新缓存，这也可以避免数据库脏读。所以不用设置默认即可。
