Mybatis一级缓存

1. 为什么要用一级缓存？

Mybatis在开始使用一次数据库的时候，会创建一个新的SqlSession，简称一次会话。

在对数据库的一次会话中，有时候会反复快速地执行完全相同的查询语句，如果没一级缓存的话，每一次查询都会查询一次数据库,那么它们的结果极有可能完全相同，由于查询一次数据库的代价很大，这有可能造成很大的资源浪费。如果使用一级缓存的话，会将每次查询结果缓存起来，当下次查询的时候，会判断是否存在完全一样的查询，存在的话直接从缓存中将结果取出，返回给用户，不存在的话再去数据库中查，接着将查询结果缓存起来。 

    2. Mybatis一级缓存怎么存储的？

其实每次Mybatis的查询与更新都是Executor这个接口来完成， Executor的实现类BaseExecutor中拥有一个Cache接口的实现类PerpetualCache，如下所示： 

 

 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());
    if (closed) {
      throw new ExecutorException("Executor was closed.");
    }
    if (queryStack == 0 && ms.isFlushCacheRequired()) {
      clearLocalCache();
    }
    List<E> list;
    try {
      queryStack++;
      //每次查询都会调用PerpetualCache的getObject()方法来验证先前是否有相同的查询
      list = resultHandler == null ? (List<E>) 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();
      if (configuration.getLocalCacheScope() == LocalCacheScope.STATEMENT) {
        // issue #482
        clearLocalCache();
      }
    }
    return list;
  }
//如果先前有相同的查询，会调用这个方法
private void handleLocallyCachedOutputParameters(MappedStatement ms, CacheKey key, Object parameter, BoundSql boundSql) {
    if (ms.getStatementType() == StatementType.CALLABLE) {
      //调用PerpetualCache的getObject()的方法来获取相同查询的查询结果
      final Object cachedParameter = localOutputParameterCache.getObject(key);
      if (cachedParameter != null && parameter != null) {
        final MetaObject metaCachedParameter = configuration.newMetaObject(cachedParameter);
        final MetaObject metaParameter = configuration.newMetaObject(parameter);
        for (ParameterMapping parameterMapping : boundSql.getParameterMappings()) {
          if (parameterMapping.getMode() != ParameterMode.IN) {
            final String parameterName = parameterMapping.getProperty();
            final Object cachedValue = metaCachedParameter.getValue(parameterName);
            metaParameter.setValue(parameterName, cachedValue);
          }
        }
      }
    }
  }

 

所以Mybatis的一级缓存实际上是 PerpetualCache来实现，PerpetualCache其实也是靠HashMap来存储一级缓存，代码如下：

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);
  }
 //Mybatis的任何一个update操作(update()、delete()、insert()) ，都会
 //调用这个方法，清空PerpetualCache对象存储的一级缓存数据
  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();
  }
 
}

 3. 怎么判断查询是否相同？ 

PerpetualCache将每次查询的特征作为key,查询的结果作为value存储到Map中。所以看下key是怎么生成的，就知道怎么判断了。通过源码，发现key是通过BaseExecutor的createCacheKey的方法生成，代码如下： 

public CacheKey createCacheKey(MappedStatement ms, Object parameterObject, RowBounds rowBounds, BoundSql boundSql) {
    if (closed) {
      throw new ExecutorException("Executor was closed.");
    }
    CacheKey cacheKey = new CacheKey();
    //statementId
    cacheKey.update(ms.getId());
    //rowBounds的Offset()
    cacheKey.update(rowBounds.getOffset());
    //rowBounds的Limit()
    cacheKey.update(rowBounds.getLimit());
    //SQL语句
    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;
  }

 从上面的代码中可以看出，如果下面条件一样，就可以判断为两个相同的查询，条件如下：

       1、statementId ；2、RowBounds的offset、limit的结果集分页属性；3、SQL语句；4、传给JDBC的参数值

对了还有一点，添加一些无关的参数值（比如添加Student的age的参数，但查询条件没有age这个参数），还是相同的两个查询；只要statementId，rowBounds,最后生成的SQL语句，以及这个SQL语句所需要的参数完全一致就是两个相同的查询。