【Mybatis源码】一级缓存

参考：

五月的仓颉：【MyBatis源码解析】MyBatis一二级缓存

凯伦：聊聊MyBatis缓存机制

Mybatis一级缓存配置：

value有两个值可选：

session：缓存对一次会话中所有的执行语句有效，也就是SqlSession级别的。

statement：缓存只对当前执行的这一个Statement有效。

在一级缓存中对缓存的查询和写入是在Executor中完成的，以BaseExecutor为例，查看query方法：

public abstract class BaseExecutor implements Executor {

  private static final Log log = LogFactory.getLog(BaseExecutor.class);

  protected Transaction transaction;
  protected Executor wrapper;

  protected ConcurrentLinkedQueue deferredLoads;
  protected PerpetualCache localCache; //缓存
  protected PerpetualCache localOutputParameterCache;
  protected Configuration configuration;

  protected int queryStack;
  private boolean closed;

......
  @Override
  public  List query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler) throws SQLException {
    BoundSql boundSql = ms.getBoundSql(parameter);
    //构建CacheKey
    CacheKey key = createCacheKey(ms, parameter, rowBounds, boundSql);
    return query(ms, parameter, rowBounds, resultHandler, key, boundSql);//调用了下面的query方法
 }

  @SuppressWarnings("unchecked")
  @Override
  public  List 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());
    if (closed) {
      throw new ExecutorException("Executor was closed.");
    }
    //如果queryStack为0或者并且有必要刷新缓存
    if (queryStack == 0 && ms.isFlushCacheRequired()) {
      clearLocalCache();//清空本地缓存
    }
    List list;
    try {
      queryStack++;
      //从缓存中获取数据，key的类型为CacheKey
      list = resultHandler == null ? (List) localCache.getObject(key) : null;
      if (list != null) {
        //处理本地缓存输出参数
        handleLocallyCachedOutputParameters(ms, key, parameter, boundSql);
      } else {//如果获取结果为空，从数据库中查找
        list = queryFromDatabase(ms, parameter, rowBounds, resultHandler, key, boundSql);
      }
    } finally {
      queryStack--;
    }
    if (queryStack == 0) {
      for (DeferredLoad deferredLoad : deferredLoads) {
        deferredLoad.load();
      }
      // issue #601
      deferredLoads.clear();
      //如果是STATEMENT级别的缓存
      if (configuration.getLocalCacheScope() == LocalCacheScope.STATEMENT) {
        // 清空缓存
        clearLocalCache();
      }
    }
    return list;
  }
}

（1）从BaseExecutor的成员变量中，可以看到有一个类型为PerpetualCache变量名为localCache的字段，缓存就是用它来实现的。PerpetualCache类的成员变量也很简单，包含一个id和一个HashMap，缓存数据就存储在HashMap中。

public class PerpetualCache implements Cache {

  private final String id;

  private Map cache = new HashMap();//使用一个map做存储

   get set方法省略
   ......
}

（2）在BaseExecutor的quey方法中，有一个构建CacheKey的语句，既然缓存数据存储在HashMap中，那么数据格式一定是键值对的形式，这个CacheKey就是HashMap中的key，value是数据库返回的数据。

CacheKey key = createCacheKey(ms, parameter, rowBounds, boundSql);

（3）第二个query方法中，当执行查询时，首先通过localCache.getObject(key)从缓存中获取数据，如果获取的数据为空，再从数据库中查找。

//从缓存中获取数据，key的类型为CacheKey
      list = resultHandler == null ? (List) localCache.getObject(key) : null;

//如果获取结果为空，从数据库中查找
        list = queryFromDatabase(ms, parameter, rowBounds, resultHandler, key, boundSql);

（4）如果开启了flushcache，将会清空缓存

 //如果queryStack为0或者并且有必要刷新缓存
    if (queryStack == 0 && ms.isFlushCacheRequired()) {
      clearLocalCache();//清空本地缓存
    }

配置flushcache：

  
    ……  
  

（5）如果一级缓存的级别为Statement,将会清空缓存，这也是如果设置一级缓存的级别为Statement时缓存只对当前执行的这一个Statement有效的原因。

//如果是STATEMENT级别的缓存
      if (configuration.getLocalCacheScope() == LocalCacheScope.STATEMENT) {
        // 清空缓存
        clearLocalCache();
      }

配置：

CacheKey如何生存的

（1）在query方法中，调用了createCacheKey方法生成CacheKey，然后多次调用了cachekey的update方法，将标签的ID、分页信息、SQL语句、参数等信息作为参数传入：

@Override
  public CacheKey createCacheKey(MappedStatement ms, Object parameterObject, RowBounds rowBounds, BoundSql boundSql) {
    if (closed) {
      throw new ExecutorException("Executor was closed.");
    }
    CacheKey cacheKey = new CacheKey();
    //设置ID，也就是标签所在的Mapper的namespace + 标签的id
    cacheKey.update(ms.getId());
    //偏移量，Mybatis自带分页类RowBounds中的属性
    cacheKey.update(rowBounds.getOffset());
    //每次查询大小，同样是Mybatis自带分页类RowBounds中的属性
    cacheKey.update(rowBounds.getLimit());
    //标签中定义的SQL语句
    cacheKey.update(boundSql.getSql());
    //获取参数
    List parameterMappings = boundSql.getParameterMappings();
    TypeHandlerRegistry typeHandlerRegistry = ms.getConfiguration().getTypeHandlerRegistry();
    // 处理SQL中的参数
    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;
  }

（2）通过源码，看一下CacheKey的update方法，update方法中记录了调用update传入参数的次数、每个传入参数的hashcode之和checksum、以及计算CacheKey的成员变量hashcode的值。

public class CacheKey implements Cloneable, Serializable {

  private static final long serialVersionUID = 1146682552656046210L;

  public static final CacheKey NULL_CACHE_KEY = new NullCacheKey();

  private static final int DEFAULT_MULTIPLYER = 37;
  private static final int DEFAULT_HASHCODE = 17;

  private final int multiplier;//一个乘数
  private int hashcode;//hashcode
  private long checksum;//update方法中传入参数的hashcode之和
  private int count; //调用update方法向updatelist添加参数的的次数
  private List