优质博文：IT-BLOG-CN
一、一级缓存配置
MyBatis一级缓存默认是开启的。如果需要显示的开启，需要在MyBaits配置文件中<settings>标签中添加如下语句：
<settings>
<setting name="localCacheScope" value="SESSION"/>
</settings>
value共有两个选项，SESSION或者STATEMENT，默认是SESSION级别，即在一个MyBatis会话中执行的所有语句，都会共享这一个缓存。一种是STATEMENT级别，可以理解为缓存只对当前执行的这一个Statement有效。
一级缓存基于SqlSession举个例子：
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));
}
执行结果：我们可以看到，只有第一次真正查询了数据库，后续的查询使用了一级缓存。
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, 小明, 13
DEBUG [main] - <== Total: 1
StudentEntity{id=1, name='小明', age=13}
StudentEntity{id=1, name='小明', age=13}
二、一级缓存可重复读现象
两个SqlSession操作当前行，一级缓存的可重复读案例。具体在sqlSession1中查询数据，使一级缓存生效，在sqlSession2中更新数据库，验证一级缓存只在数据库会话内部共享。
@Test
public void testLocalCacheScope() 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.getStudentById(1));
System.out.println("更新了" + studentMapper2.updateStudentName("小花",1) + "名学生的数据");
System.out.println(studentMapper.getStudentById(1));
System.out.println(studentMapper2.getStudentById(1));
}
sqlSession2更新了id为1的学生的姓名，从小明改为了小花，但session1之后的查询中，id为1的学生的名字还是小明，出现了重复读，说明一级缓存只在数据库会话内部共享。
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, 小明, 13
DEBUG [main] - <== Total: 1
StudentEntity{id=1, name='小明', age=13}
DEBUG [main] - ==> Preparing: INSERT INTO student(name,age) VALUES(?,?)
DEBUG [main] - ==> Parameters: 小花(String), 13(Integer)
DEBUG [main] - <== Updates: 1
更新了1名学生的数据 --SqlSession2更新了数据
StudentEntity{id=1, name='小明', age=13} --SqlSession1读到了缓存中的数据
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, 小花, 13
DEBUG [main] - <== Total: 1
StudentEntity{id=1, name='小花', age=13}
如果你的业务不希望让MyBatis的一级缓存进行可重复读，就需要进行一级缓存清除。
三、一级缓存清除方法
【推荐】在映射文件xml中添加<select flushCache="true"></select>
【了解】执行SqlSession的close（会释放掉一级缓存PerpetualCache对象）或clearCache（会清空PerpetualCache对象中的数据）方法
【了解】执行SqlSession的commit（执行插入、更新、删除操作后）
这里的更新指的是当前SqlSession进行了增删改查操作。举个例子：
@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();
}
执行结果：我们可以看到，在修改操作后执行的相同查询，查询了数据库，一级缓存失效。
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, 小明, 13
DEBUG [main] - <== Total: 1
StudentEntity{id=1, name='小明', age=13}
DEBUG [main] - ==> Preparing: INSERT INTO student(name,age) VALUES(?,?)
DEBUG [main] - ==> Parameters: 小李(String), 14(Integer)
DEBUG [main] - <== Updates: 1
添加1名学生
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, 小明, 13 -- 这里数据虽然一样，但是它是查询数据库获取的。
DEBUG [main] - <== Total: 1
四、源码分析
通过上面的使用，能够清楚的发现，一级缓存主要是基于SqlSession的，所以我们主要对SqlSession的原理进行说明。
如下图所示，MyBatis一次会话对应一个SqlSession对象。SqlSession对象中包含一个Executor，Executor对象中创建一个本地缓存local cache，对于每一次查询，都会尝试根据执行的语句生成的MappedStatement 的Hash值去本地缓存中查找，如果在缓存中，就直接从缓存中取出，然后返回给用户；否则，从数据库读取数据，将查询结果存入缓存并返回给用户。
如上所示SqlSession将它的工作交给了Executor执行器这个角色来完成，负责完成对数据库的各种操作。当创建了一个SqlSession对象时，MyBatis会为这个SqlSession对象创建一个新的Executor执行器，而缓存信息就被维护在这个Executor执行器中，MyBatis将缓存和对缓存相关的操作封装成了Cache接口中。具体实现类的类关系图如下图所示：
根据依赖关系图，可知Session级别的一级缓存实际上就是使用PerpetualCache维护的，我们就看看PerpetualCache实现原理，其内部就是通过一个简单的HashMap<k,v>来实现的，没有其他的任何限制。如下是PerpetualCache的实现代码：
package org.apache.ibatis.cache.impl;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.locks.ReadWriteLock;
import org.apache.ibatis.cache.Cache;
import org.apache.ibatis.cache.CacheException;
/**
* 使用简单的HashMap来维护缓存
* @author Clinton Begin
*/
public class PerpetualCache implements Cache {
private String id;
private Map<Object, Object> cache = new HashMap<Object, Object>();
public PerpetualCache(String id) {
this.id = id;
}
public String getId() {
return id;
}
public int getSize() {
return cache.size();
}
public void putObject(Object key, Object value) {
cache.put(key, value);
}
public Object getObject(Object key) {
return cache.get(key);
}
public Object removeObject(Object key) {
return cache.remove(key);
}
public void clear() {
cache.clear();
}
public ReadWriteLock getReadWriteLock() {
return null;
}
public boolean equals(Object o) {
if (getId() == null) throw new CacheException("Cache instances require an ID.");
if (this == o) return true;
if (!(o instanceof Cache)) return false;
Cache otherCache = (Cache) o;
return getId().equals(otherCache.getId());
}
public int hashCode() {
if (getId() == null) throw new CacheException("Cache instances require an ID.");
return getId().hashCode();
}
}
疑问：MyBatis的一级缓存通过HashMap存储的那么他的key是怎么生成的尼？
对于每次的查询请求，Executor都会根据传递的参数信息以及动态生成的SQL语句，将上面的条件根据一定的计算规则，创建一个对应的CacheKey对象。
CacheKey的构建被放置到了Executor接口的实现类BaseExecutor中，定义如下：
/**
* 所属类: org.apache.ibatis.executor.BaseExecutor
* 功能 : 根据传入信息构建CacheKey
*/
public CacheKey createCacheKey(MappedStatement ms, Object parameterObject, RowBounds rowBounds, BoundSql boundSql) {
if (closed) throw new ExecutorException("Executor was closed.");
CacheKey cacheKey = new CacheKey();
//1.statementId
cacheKey.update(ms.getId());
//2. rowBounds.offset
cacheKey.update(rowBounds.getOffset());
//3. rowBounds.limit
cacheKey.update(rowBounds.getLimit());
//4. SQL语句
cacheKey.update(boundSql.getSql());
//5. 将每一个要传递给JDBC的参数值也更新到CacheKey中
List<ParameterMapping> parameterMappings = boundSql.getParameterMappings();
TypeHandlerRegistry typeHandlerRegistry = ms.getConfiguration().getTypeHandlerRegistry();
for (int i = 0; i < parameterMappings.size(); i++) { // mimic DefaultParameterHandler logic
ParameterMapping parameterMapping = parameterMappings.get(i);
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);
}
//将每一个要传递给JDBC的参数值也更新到CacheKey中
cacheKey.update(value);
}
}
return cacheKey;
}
刚才已经提到，Cache接口的实现，本质上是使用的HashMap<k,v>,而构建CacheKey的目的就是为了作为HashMap<k,v>中的key值。而HashMap是通过key值的hashcode来组织和存储的，那么，构建CacheKey的过程实际上就是构造其hashCode的过程。下面的代码就是CacheKey的核心hashcode生成算法，可以看一下：
public void update(Object object) {
if (object != null && object.getClass().isArray()) {
int length = Array.getLength(object);
for (int i = 0; i < length; i++) {
Object element = Array.get(object, i);
doUpdate(element);
}
} else {
doUpdate(object);
}
}
private void doUpdate(Object object) {
//1. 得到对象的hashcode;
int baseHashCode = object == null ? 1 : object.hashCode();
//对象计数递增
count++;
checksum += baseHashCode;
//2. 对象的hashcode 扩大count倍
baseHashCode *= count;
//3. hashCode * 拓展因子（默认37）+拓展扩大后的对象hashCode值
hashcode = multiplier * hashcode + baseHashCode;
updateList.add(object);
}
MyBatis认为的完全相同的查询，不是指使用sqlSession查询时传递给算起来Session的所有参数值完完全全相同，你只要保证statementId，rowBounds,最后生成的SQL语句，以及这个SQL语句所需要的参数完全一致就可以了。
五、总结
一级缓存执行的时序图，如下图所示
