mybatis一级缓存详解

mybatis缓存分为一级缓存，二级缓存和自定义缓存。本文重点讲解一级缓存

一：前言

在介绍缓存之前，先了解下mybatis的几个核心概念：

* SqlSession：代表和数据库的一次会话，向用户提供了操作数据库的方法

* MapperedStatement：代表要往数据库发送的要执行的指令，可以理解为sql的抽象表示

* Executor：用来和数据库交互的执行器，接收MapperedStatement作为参数

二：一级缓存

1.一级缓存的介绍：

mybatis一级缓存有两种：一种是SESSION级别的，针对同一个会话SqlSession中，执行多次条件完全相同的同一个sql，那么会共享这一缓存，默认是SESSION级别的缓存；一种是STATEMENT级别的，缓存只针对当前执行的这一statement有效。

对于一级缓存的流程，看下图：

整个流程是这样的：

* 针对某个查询的statement，生成唯一的key

* 在Local Cache 中根据key查询数据是否存在

* 如果存在，则命中，跳过数据库查询，继续往下走

* 如果没命中：

* 去数据库中查询，得到查询结果

* 将key和查询结果放到Local Cache中

* 将查询结果返回

* 判断是否是STATEMENT级别缓存，如果是，则清除缓存

接下来针对一级缓存的几种情况，来进行验证。

情况1：SESSION级别缓存，同一个Mapper代理对象执行条件相同的同一个查询sql

SqlSession sqlSession = getSqlSessionFactory().openSession();
        GoodsDao goodsMapper = sqlSession.getMapper(GoodsDao.class);
        goodsMapper.selectGoodsById("1");
        goodsMapper.selectGoodsById("1");

结果：

Setting autocommit to false on JDBC Connection [com.mysql.jdbc.JDBC4Connection@3dd44d5e]
==>  Preparing: select * from goods where id = ?
==> Parameters: 1(String)
<==    Columns: id, name, detail, remark
<==        Row: 1, title1, null, null
<==      Total: 1

总结：只向数据库进行了一次查询，第二次用了缓存

情况2：SESSION级别缓存，同一个Mapper代理对象执行条件不同的同一个查询sql

    public void selectGoodsTest(){
        SqlSession sqlSession = getSqlSessionFactory().openSession();
        GoodsDao goodsMapper = sqlSession.getMapper(GoodsDao.class);
        goodsMapper.selectGoodsById("1");
        goodsMapper.selectGoodsById("2");
    }

结果：

==>  Preparing: select * from goods where id = ?
==> Parameters: 1(String)
<==    Columns: id, name, detail, remark
<==        Row: 1, title1, null, null
<==      Total: 1
==>  Preparing: select * from goods where id = ?
==> Parameters: 2(String)
<==    Columns: id, name, detail, remark
<==        Row: 2, title2, null, null
<==      Total: 1

总结：因为查询条件不同，所以是两个不同的statement，生成了两个不同key，缓存中是没有的

情况3：SESSION级别缓存，针对同一个Mapper接口生成两个代理对象，然后执行查询条件完全相同的同一条sql

    public void selectGoodsTest(){
        SqlSession sqlSession = getSqlSessionFactory().openSession();
        GoodsDao goodsMapper = sqlSession.getMapper(GoodsDao.class);
        GoodsDao goodsMapper2 = sqlSession.getMapper(GoodsDao.class);
        goodsMapper.selectGoodsById("1");
        goodsMapper2.selectGoodsById("1");
    }

结果：

==> Preparing: select * from goods where id = ?
==> Parameters: 1(String)
<== Columns: id, name, detail, remark
<== Row: 1, title1, null, null
<== Total: 1

总结：这种情况满足：同一个SqlSession会话，查询条件完全相同的同一条sql。所以，第二次查询是从缓存中查找的。

情况4：SESSION级别缓存，在同一次会话中，对数据库进行了修改操作，一级缓存是否是失效。

    // 这里对id=2的数据进行了upate操作，发现id=1的一级缓存也被清除，因为它们是在同一个SqlSession中
    @Test
    public void selectGoodsTest(){
        SqlSession sqlSession = getSqlSessionFactory().openSession();
        GoodsDao goodsMapper = sqlSession.getMapper(GoodsDao.class);
        Goods goods = new Goods();
        goods.setId("2");
        goods.setName("篮球");
        goodsMapper.selectGoodsById("1");
        goodsMapper.updateGoodsById(goods);
        goodsMapper.selectGoodsById("1");
    }

结果：

==>  Preparing: select * from goods where id = ?
==> Parameters: 1(String)
<==    Columns: id, name, detail, remark
<==        Row: 1, title1, null, null
<==      Total: 1
==>  Preparing: update goods set name = ? where id = ?
==> Parameters: 篮球(String), 2(String)
<==    Updates: 1
==>  Preparing: select * from goods where id = ?
==> Parameters: 1(String)
<==    Columns: id, name, detail, remark
<==        Row: 1, title1, null, null
<==      Total: 1

总结：在同一个SqlSession会话中，如果对数据库进行了修改操作，那么该会话中的缓存都会被清除。但是，并不会影响其它会话中的缓存。

情况5：SESSION级别缓存，开启两个SqlSession，在SqlSession1中查询操作，在SqlSession2中执行修改操作，那么SqlSession1中的一级缓存是否仍然有效？

@Test
    public void selectGoodsTest(){
        SqlSession sqlSession = getSqlSessionFactory().openSession();
        GoodsDao goodsMapper = sqlSession.getMapper(GoodsDao.class);
        SqlSession sqlSession2 = getSqlSessionFactory().openSession();
        GoodsDao goodsMapper2 = sqlSession2.getMapper(GoodsDao.class);
        Goods goods = new Goods();
        goods.setId("1");
        goods.setName("篮球");
        Goods goods1 = goodsMapper.selectGoodsById("1");
        System.out.println("name="+goods1.getName());
        System.out.println("******************************************************");
        goodsMapper2.updateGoodsById(goods);
        Goods goodsResult = goodsMapper.selectGoodsById("1");
        System.out.println("******************************************************");
        System.out.println("name="+goodsResult.getName());
    }

结果：

==>  Preparing: select * from goods where id = ?
==> Parameters: 1(String)
<==    Columns: id, name, detail, remark
<==        Row: 1, title1, null, null
<==      Total: 1
name=title1
******************************************************
Opening JDBC Connection
Created connection 644010817.
Setting autocommit to false on JDBC Connection [com.mysql.jdbc.JDBC4Connection@2662d341]
==>  Preparing: update goods set name = ? where id = ?
==> Parameters: 篮球(String), 1(String)
<==    Updates: 1
******************************************************
name=title1

总结：在SqlSession2中对id=1的数据做了修改，但是在SqlSession1中的最后一次查询中，仍然是从一级缓存中取得数据，说明了一级缓存只在SqlSession内部共享，SqlSession对数据库的修改操作不影响其它SqlSession中的一级缓存。

情况6：SqlSession的缓存级别设置为STATEMENT，即在配置文件中添加如下代码：

<settings>
    <setting name="localCacheScope" value="STATEMENT"/>
</settings>

执行代码：

    @Test
    public void selectGoodsTest(){
        SqlSession sqlSession = getSqlSessionFactory().openSession();
        GoodsDao goodsMapper = sqlSession.getMapper(GoodsDao.class);
        goodsMapper.selectGoodsById("1");
        System.out.println("****************************************");
        goodsMapper.selectGoodsById("1");
    }

结果：

==>  Preparing: select * from goods where id = ?
==> Parameters: 1(String)
<==    Columns: id, name, detail, remark
<==        Row: 1, title1, null, null
<==      Total: 1
****************************************
==>  Preparing: select * from goods where id = ?
==> Parameters: 1(String)
<==    Columns: id, name, detail, remark
<==        Row: 1, title1, null, null
<==      Total: 1

总结：STATEMENT级别的缓存，只针对当前执行的这一statement有效

2.一级缓存是如何被存取的？

我们知道，当与数据库建立一次连接，就会创建一个SqlSession对象，默认是DefaultSqlSession这个实现，这个对象给用户提供了操作数据库的各种方法，与此同时，也会创建一个Executor执行器，缓存信息就是维护在Executor中，Executor有一个抽象子类BaseExecutor，这个类中有个属性PerpetualCache类，这个类就是真正用于维护一级缓存的地方。通过看源码，可以知道如何根据cacheKey，取出和存放缓存的。

在查询数据库前，先从缓存中查找，进入BaseExecutor类的query方法：

//这是BaseExecutor的一个属性，用于存放一级缓存
protected PerpetualCache localCache;

 @SuppressWarnings("unchecked")
  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++;
      // 根据CacheKey作为key，查询HashMap中的value值，也就是缓存，这就是取出缓存的过程
      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();
      }
      deferredLoads.clear(); // issue #601
      if (configuration.getLocalCacheScope() == LocalCacheScope.STATEMENT) {
        clearLocalCache(); // issue #482
      }
    }
    return list;
  }

当从数据库中查询到数据后，需要把数据存放到缓存中的，然后再返回数据，这个就是存放缓存的过程，进入queryFromDatabase方法：

 private <E> List<E> queryFromDatabase(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql) throws SQLException {
    List<E> list;
    localCache.putObject(key, EXECUTION_PLACEHOLDER);
    try {
      // 从数据库中查询到数据
      list = doQuery(ms, parameter, rowBounds, resultHandler, boundSql);
    } finally {
      localCache.removeObject(key);
    }
    // 把数据放到缓存中，这就是存房缓存的动作
    localCache.putObject(key, list);
    if (ms.getStatementType() == StatementType.CALLABLE) {
      localOutputParameterCache.putObject(key, parameter);
    }
    return list;
  }

3.CacheKey是如何确定唯一的？

我们知道，如果两次查询完全相同，那么第二次查询就从缓存中取数据，换句话说，怎么判断两次查询是不是相同的？是否相同是根据CacheKey来判断的，那么看下CacheKey的生成过程，就知道影响CacheKey是否相同的元素有哪些了。

进入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();
    // statement id
    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();
    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);
        }
        // 传递的每一个参数
        cacheKey.update(value);
      }
    }
    return cacheKey;
  }    

所以影响Cachekey是否相同的因素有：statementId，offset，limit，sql语句，参数

接下来进入cacheKey.update方法，看它如何处理以上这五个元素的：

  private void doUpdate(Object object) {
    // 获取对象的HashCode
    int baseHashCode = object == null ? 1 : object.hashCode();
    // 计数器+1
    count++;
    checksum += baseHashCode;
    // baseHashCode扩大count倍
    baseHashCode *= count;
    // 对HashCode进一步做处理
    hashcode = multiplier * hashcode + baseHashCode;
    // 把以上五个元素存放到集合中
    updateList.add(object);
  }

CahceKey的属性和构造方法：

private int multiplier;

private int hashcode;

private long checksum; 

  private int count;

  private List<Object> updateList;

public CacheKey() {
    this.hashcode = DEFAULT_HASHCODE;
    this.multiplier = DEFAULT_MULTIPLYER;
    this.count = 0;
    this.updateList = new ArrayList<Object>();
  }

CacheKey中最重要的一个方法来了，如何判断两个CacheKey是否相等？

public boolean equals(Object object) {
    if (this == object)
      return true;
    if (!(object instanceof CacheKey))
      return false;

    final CacheKey cacheKey = (CacheKey) object;
    // 判断HashCode是否相等
    if (hashcode != cacheKey.hashcode)
      return false;
    // 判断checksum是否相等
    if (checksum != cacheKey.checksum)
      return false;
    // 判断count是否相等
    if (count != cacheKey.count)
      return false;
    // 逐一判断以上五个元素是否相等
    for (int i = 0; i < updateList.size(); i++) {
      Object thisObject = updateList.get(i);
      Object thatObject = cacheKey.updateList.get(i);
      if (thisObject == null) {
        if (thatObject != null)
          return false;
      } else {
        if (!thisObject.equals(thatObject))
          return false;
      }
    }
    return true;
  }
 // 只有以上所有的判断都相等时，两个CacheKey才相等

4.一级缓存的生命周期是多长？

开始：mybatis建立一次数据库会话时，就会生成一系列对象：SqlSession--->Executor--->PerpetualCache,也就开启了对一级缓存的维护。

结束： 

         * 会话结束，会释放掉以上生成的一系列对象，缓存也就不可用了。

* 调用sqlSession.close方法，会释放掉PerpetualCache对象，一级缓存不可用

* 调用sqlSession.clearCache方法，会清空PerpetualCache对象中的缓存数据，该对象可用，一级缓存不可用

* 调用sqlSession的update,insert，delete方法，会清空PerpetualCache对象中的缓存数据，该对象可用，一级缓存不可用

参考资料：https://blog.csdn.net/luanlouis/article/details/41280959