存在内存中的临时数据。
将用户经常查询的数据放在缓存（内存）中，用户去查询数据就不用从磁盘上(关系型数据库 数据文件)查询，从缓存中查询，从而提高查询效率，解决了高并发系统的性能问题。
1.2为何要使用缓存减少和数据库的交互次数，减少系统开销，提高系统效率。
1.3什么样的数据要使用缓存经常查询并且不经常改变的数据。
二、MyBatis缓存实例MyBatis 系统中默认定义了两级缓存： 一级缓存 和 二级缓存
默认情况下，只有一级缓存开启。（SqlSession级别的缓存，也称为本地缓存）
二级缓存需要手动开启和配置，他是基于namespace级别的缓存。（基于接口）
为了提高扩展性，MyBatis定义了缓存接口Cache。我们可以通过实现Cache接口来自定义二 级缓存。
2.1一级缓存实例
一个session中查询同一个没说在一个session中，user被缓存了，一级缓存就是一个 map。
2.2二级缓存实例显示开启全局缓存（二级缓存）:
默认情况下，只启用了本地的会话缓存，它仅仅对一个会话中的数据进行缓存。 要启用全局的二级缓存，只需要在你的 SQL 映射文件中添加一行：
SqlSession： 对外提供了用户和数据库之间交互需要的所有方法，隐藏了底层的细节。默认实现类是DefaultSqlSession。
Executor： SqlSession向用户提供操作数据库的方法，但和数据库操作有关的职责都会委托给Executor。Executor有两个实现类，和一级缓存关联的是BaseExecutor。
BaseExecutor： BaseExecutor是一个实现了Executor接口的抽象类，定义若干抽象方法，在执行的时候，把具体的操作委托给子类进行执行。
PerpetualCache：对Cache接口最基本实现，内部持有HashMap，对一级缓存的操作实则是对HashMap的操作。
SqlSession初始化时会创建Executor的实例，Mybatis默认使用的是SimpleExecutor，初始化代码如下所示:
public Executor newExecutor(Transaction transaction, ExecutorType executorType) {
executorType = executorType == null ? defaultExecutorType : executorType;
executorType = executorType == null ? ExecutorType.SIMPLE : executorType;
Executor 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);
}
//如果启用二级缓存，使用CahingExecutor装饰类
if (cacheEnabled) {
executor = new CachingExecutor(executor);
}
executor = (Executor) interceptorChain.pluginAll(executor);
return executor;
}
SqlSession在提交的时候会清空本地缓存，因为commit操作一般对应插入、更新或者删除操作，清空缓存防止读取脏数据。
@Override
public void commit(boolean required) throws SQLException {
if (closed) {
throw new ExecutorException("Cannot commit, transaction is already closed");
}
clearLocalCache();
flushStatements();
if (required) {
transaction.commit();
}
}
SqlSession的insert方法和delete方法，都会统一走update的流程。
@Override
public int insert(String statement, Object parameter) {
return update(statement, parameter);
}
@Override
public int delete(String statement) {
return update(statement, null);
}
update方法也是委托给了Executor执行。BaseExecutor的执行方法如下所示。
@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);
}
3.1一级缓存失效的原因同一个用户使用不同的SqlSession对象导致无法看到一级缓存工作。
DeptDao dao1 = session.getMapper(DeptDao.class);
Dept dept1 = dao1.findByDeptNo(10);
System.out.println("第一次查询的部门对象地址 " dept1);
//新建一个SqlSession
SqlSession session2 = factory.openSession();
DeptDao dao2 = session2.getMapper(DeptDao.class);
Dept dept2 = dao2.findByDeptNo(10);
System.out.println("第二次查询的部门对象地址 " dept2);
在一个SqlSession中使用条件查询不同一级缓存也会失效。
DeptDao dao1 = session.getMapper(DeptDao.class);
Dept dept1 = dao1.findByDeptNo(10);
System.out.println("第一次查询的部门对象地址 " dept1);
DeptDao dao2 = session.getMapper(DeptDao.class);
Dept dept2 = dao2.findByDeptNo(20);
System.out.println("第二次查询的部门对象地址 " dept2);
在一个SqlSession使用相同条件，但是，此时在查询之间进行数据修改操作会导致一级缓存失效。
DeptDao dao1 = session.getMapper(DeptDao.class);
Dept dept1 = dao1.findByDeptNo(10);
System.out.println("第一次查询的部门对象地址 " dept1);
//执行数据库修改
Dept dept = new Dept(40, "测试部门", "深圳");
dao1.deptAdd(dept);
DeptDao dao2 = session.getMapper(DeptDao.class);
Dept dept2 = dao2.findByDeptNo(10);
System.out.println("第二次查询的部门对象地址 " dept2);
session.commit();
在一个SqlSession使用相同查询条件此时手动刷新缓存时导致一级缓存失败。
DeptDao dao1 = session.getMapper(DeptDao.class);
Dept dept1 = dao1.findByDeptNo(10);
System.out.println("第一次查询的部门对象地址 " dept1);
//手动刷新用户一级缓存,导致用户一级缓存原有的内容消失掉
session.clearCache();
DeptDao dao2 = session.getMapper(DeptDao.class);
Dept dept2 = dao2.findByDeptNo(10);
System.out.println("第二次查询的部门对象地址 " dept2);
3.2一级缓存注意MyBatis一级缓存的生命周期和SqlSession一致。
MyBatis一级缓存内部设计简单，只是一个没有容量限定的HashMap，在缓存的功能性上有所欠缺。
MyBatis的一级缓存最大范围是SqlSession内部，有多个SqlSession或者分布式的环境下，数据库写操作会引起脏数据。
mybatis和spring整合后进行mapper代理开发，不支持一级缓存。
四、二级缓存分析4.1二级缓存介绍开启二级缓存后，会使用CachingExecutor装饰Executor，进入一级缓存的查询流程前，先在CachingExecutor进行二级缓存的查询，具体的工作流程如下所示:
二级缓存开启后，同一个namespace下的所有操作语句，都影响着同一个Cache，即二级缓存被多个SqlSession共享，是一个全局的变量。
当开启缓存后，数据的查询执行的流程就是 二级缓存 -> 一级缓存 -> 数据库。
4.1二级缓存开启开启全局缓存（二级缓存）:
在对应的Mapper文件中添加cache标签
cache标签属性
type：cache使用的类型，默认是PerpetualCache，这在一级缓存中提到过。
eviction： 定义回收的策略，常见的有FIFO，LRU。
flushInterval： 配置一定时间自动刷新缓存，单位是毫秒。
size： 最多缓存对象的个数。
readOnly： 是否只读，若配置可读写，则需要对应的实体类能够序列化。
blocking： 若缓存中找不到对应的key，是否会一直blocking，直到有对应的数据进入缓存。
cache-ref代表引用别的命名空间的Cache配置，两个命名空间的操作使用的是同一个Cache。
<cache-ref namespace="mapper.StudentMapper"/>
4.2二级缓存源码分析MyBatis在为SqlSession对象创建Excutor对象时候，会给Executor对象加上一个装饰者：CachingExecutor，这时SqlSession使用CachingExecutor对象来完成操作请求。CachingExecutor对于查询请求，会先判断该查询请求在二级缓存中是否有缓存，如果有则直接返回缓存结果；如果没有再交给真正的Executor对象来完成查询操作，之后CachingExecutor会将真正Executor返回的查询结果放置到缓存中，然后再返回给用户。
CachingExecutor的query方法，首先会从MappedStatement中获得在配置初始化时赋予的Cache。
以下是具体这些Cache实现类的介绍，他们的组合为Cache赋予了不同的能力。
SynchronizedCache： 同步Cache，实现比较简单，直接使用synchronized修饰方法。
LoggingCache： 日志功能，装饰类，用于记录缓存的命中率，如果开启了DEBUG模式，则会输出命中率日志。
SerializedCache： 序列化功能，将值序列化后存到缓存中。该功能用于缓存返回一份实例的Copy，用于保存线程安全。
LruCache： 采用了Lru算法的Cache实现，移除最近最少使用的key/value。
PerpetualCache： 作为为最基础的缓存类，底层实现比较简单，直接使用了HashMap。
可以为每条Mapper语句设置是否要刷新缓存,可以指定select语句是否使用缓存,如下所示:
<select ... flushCache="false" useCache="true"/>
<insert ... flushCache="true"/>
<update ... flushCache="true"/>
<delete ... flushCache="true"/>
判断是否刷新缓存
flushCacheIfRequired(ms);
在默认的设置的select语句是不会刷新缓存的，insert/update/delte会刷新缓存。
private void flushCacheIfRequired(MappedStatement ms) {
Cache cache = ms.getCache();
if (cache != null && ms.isFlushCacheRequired()) {
tcm.clear(cache);
}
}
CachingExecutor的查询语句:
public <E> List<E> query(MappedStatement ms, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql)
throws SQLException {
//从MappedStatement中获得在配置初始化时赋予的Cache
Cache cache = ms.getCache();
if (cache != null) {
//获取Mapper语句的flushCache配置 判断是否刷新缓存
flushCacheIfRequired(ms);
//ensureNoOutParams主要是用来处理存储过程的
if (ms.isUseCache() && resultHandler == null) {
ensureNoOutParams(ms, parameterObject, boundSql);
//从TransactionalCacheManager获取缓存的列表
//在getObject方法中，会把获取值的职责一路传递，最终到PerpetualCache。
List<E> list = (List<E>) tcm.getObject(cache, key);
//如果缓存中没有找到则调用实际的Executor执行查询语句，查询到数据，则调用tcm.putObject方法，往缓存中放入值
//tcm的put方法也不是直接操作缓存，只是在把这次的数据和key放入待提交的Map中
if (list == null) {
list = delegate.<E> query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
tcm.putObject(cache, key, list); // issue #578 and #116
}
return list;
}
}
return delegate.<E> query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
}
4.3二级缓存失效的原因flushCache属性在查询中作用针对二级缓存导致失效
//会话过程中第一次发送请求，从数据库中得到结果
//得到结果之后，mybatis自动将这个查询结果放入到当前用户的一级缓存
DeptDao dao = session.getMapper(DeptDao.class);
Dept dept = dao.findByDeptNo(10);
System.out.println("第一次查询得到部门对象 = " dept);
session.close();//触发MyBatis框架从当前一级缓存中将Dept对象保存到二级缓存
SqlSession session2 =factory.openSession();
DeptDao dao2 = session2.getMapper(DeptDao.class);
Dept dept2 = dao2.findByDeptNo(10);
System.out.println("第二次查询得到部门对象 = " dept2);
flushCache属性在查询中作用针对一级缓存导致失效
//会话过程中第一次发送请求，从数据库中得到结果
//得到结果之后，mybatis自动将这个查询结果放入到当前用户的一级缓存
DeptDao dao = session.getMapper(DeptDao.class);
Dept dept = dao.findByDeptNo(10);
System.out.println("第一次查询得到部门对象 = " dept);
DeptDao dao2 = session.getMapper(DeptDao.class);
Dept dept2 = dao2.findByDeptNo(10);
System.out.println("第二次查询得到部门对象 = " dept2);
flushCache属性在更新中作用导致两次查询结果完全一样
//会话过程中第一次发送请求，从数据库中得到结果
//得到结果之后，mybatis自动将这个查询结果放入到当前用户的一级缓存
DeptDao dao = session.getMapper(DeptDao.class);
Dept dept = dao.findByDeptNo(10);
System.out.println("第一次查询得到部门对象 = " dept.getDname());
Dept dept3 = new Dept(10,"部门20","北京");
dao.updateDept(dept3);
session.commit();
session.close();
SqlSession session2 = factory.openSession();
DeptDao dao2 = session2.getMapper(DeptDao.class);
Dept dept2 = dao2.findByDeptNo(10);
System.out.println("第二次查询得到部门对象 = " dept2.getDname());
五、 总结
MyBatis的二级缓存相对于一级缓存来说，实现了SqlSession之间缓存数据的共享，同时粒度更加的细，能够到namespace级别，通过Cache接口实现类不同的组合，对Cache的可控性也更强。
MyBatis在多表查询时，极大可能会出现脏数据，有设计上的缺陷，安全使用二级缓存的条件比较苛刻。
缺陷：分布式环境下使用二级缓存可能出现脏数据，因为二级缓存是对于本地的文件来说的，分布式环境建议使用memcache或者Redis。
