Written by honors

MyBatis二级缓存

一级缓存，是sqlSession级别的缓存，是默认开启的，
我们在使用MyBatis的时候其实就在使用，只是如果我们不去关注sql可能不会注意到它；
这篇文章我们就来了解一下另一个MyBatis内提供的缓存-二级缓存，
与一级缓存不同的二级缓存是mapper（namespace）级别的缓存，
也就是说多个sqlsession对同一个Mapper进行查询操作时是可以共享这个namespace中的缓存数据，
但是当我们去当前这个mapper中的进行增、删、改或者commit的时候，同样是会清空缓存的

从图中我们可以看出来，
sqlSession1在去查询数据的时候都会先去二级缓存中去查，
如果没有的话在去数据库中查询，同时会存入到二级缓存中，
等sqlsession2再去查询的时候，就可以直接从个缓存中拿了，
但是sqlsession3去查询之前sqlsession2去修改了查询的这个数据，
那么就会二级缓存就会被清空；这样才不会出现脏数据的情况。

好了接下来我们就去代码中去验证二级缓存存在，然后通过源码的方式来探究它的实现原理

MyBatis的二级缓存是需要手动开启的，这里需要两步配置

核心配置文件中（mybatis-config.xml）

file

映射文件中（UserMapper.xml）开启二级缓存,配置

file

测试代码

 /**
   * 使用二级缓存实体类要实现序列化接口
   *
   * @throws Exception
   */
  @Test
  public void testCache2() throws Exception {
    InputStream inputStream = Resources.getResourceAsStream("mybatis-config.xml");
    SqlSessionFactory build = new SqlSessionFactoryBuilder().build(inputStream);
    SqlSession sqlSession = build.openSession();
    UserMapper mapper = sqlSession.getMapper(UserMapper.class);
    System.out.println("===============第一次查询===================");
    User user = mapper.selectUserById(1);
    sqlSession.close();
    System.out.println(user);
    // 第二次查询
    System.out.println("===============第二次查询===================");
    SqlSession sqlSession2 = build.openSession();
    UserMapper mapper2 = sqlSession2.getMapper(UserMapper.class);
    User user2 = mapper2.selectUserById(1);
    System.out.println(user2);

    System.out.println("===============更新数据===================");
//        user.setName("嘿嘿");
//        user.setAge(21);
//        mapper2.updateUserByUserId(user);
//        sqlSession2.commit();
//        sqlSession2.close();
    // 第三次查询
    System.out.println("===============第三次查询==================");
    SqlSession sqlSession3 = build.openSession();
    UserMapper mapper1 = sqlSession3.getMapper(UserMapper.class);
    User user1 = mapper1.selectUserById(1);
    System.out.println(user1);
    sqlSession3.close();
  }

第一次查询

看下测试结果

===============第一次查询===================
Cache Hit Ratio [test.UserMapper]: 0.0
==>  Preparing: select * from t_user where id=?; 
==> Parameters: 1(Integer)
<==    Columns: id, name, age
<==        Row: 1, 哈哈1, 12
<==      Total: 1
User{id=1, username='null', age=12}
===============第二次查询===================
Cache Hit Ratio [test.UserMapper]: 0.5
User{id=1, username='null', age=12}
===============更新数据===================
===============第三次查询==================
Cache Hit Ratio [test.UserMapper]: 0.6666666666666666
User{id=1, username='null', age=12}

第一次查询的时候，出现了Cache Hit Ratio [test.UserMapper]: 0.0这个表示命中率的意思，0.0说明是缓存没有命中，并且发送了一条sql查询语句；第二查询的时候命中率是0.5说明两次查询命中了一次， 50%的命中率，更新操作被注释没有执行，第三次在此查询命中率是0,66666666说明是三次查询命中了2次，命中率约是66%，第二次和第三次查询都没有发送sql语句；说明二级缓存是存在并且生效的。

接着我们打开更新操作

===============第一次查询===================
==>  Preparing: select * from t_user where id=?; 
==> Parameters: 1(Integer)
<==    Columns: id, name, age
<==        Row: 1, 哈哈1, 12
<==      Total: 1
User{id=1, username='null', age=12}
===============第二次查询===================
Cache Hit Ratio [test.UserMapper]: 0.5
User{id=1, username='null', age=12}
===============更新数据===================
==>  Preparing: update t_user set name=?,age=? where id=? 
==> Parameters: 嘿嘿(String), 21(Integer), 1(Integer)
<==    Updates: 1
===============第三次查询==================
Cache Hit Ratio [test.UserMapper]: 0.3333333333333333
==>  Preparing: select * from t_user where id=?; 
==> Parameters: 1(Integer)
<==    Columns: id, name, age
<==        Row: 1, 嘿嘿, 21
<==      Total: 1
User{id=1, username='嘿嘿', age=21}

从结果中我们可以看出，前两次查询和上次是一样的，命中率是0.5，执行更新操作之后，命中率变成了0.33，而且有发送了一条sql语句，说明三次查询中命中了1次，结果看清了，但是背后到底是怎么一回事儿，我们还的好好掰扯掰扯

源码探秘

接下来就是源码环节

在mybatis开始解析映射文件的时候，会解析我们配置的标签，并把标签中的 相关属性保存到Configuration对象中，创建的执行器的时候会判断全局缓存开关，创建本地缓存开关

 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);
    }
    // 判断是否开启全局配置缓存默认开启，
    if (cacheEnabled) {
//      CachingExecutor是对SimpleExecutor类的装饰器类，给其加上二级缓存的功能
      executor = new CachingExecutor(executor);
    }
    // 拦截器链
    executor = (Executor) interceptorChain.pluginAll(executor);
    return executor;
  }

第一次查询我们就不再说了，前面已经说了很多次了，咱么直接进入第二次查询，跟着断点走，在查询方法前会有创建缓存key的方法

 @Override
  public CacheKey createCacheKey(MappedStatement ms, Object parameterObject, RowBounds rowBounds, BoundSql boundSql) {
    if (closed) {
      throw new ExecutorException("Executor was closed.");
    }
      // 创建缓存CacheKey对象，
    CacheKey cacheKey = new CacheKey();
    cacheKey.update(ms.getId());
    cacheKey.update(rowBounds.getOffset());
    cacheKey.update(rowBounds.getLimit());
    cacheKey.update(boundSql.getSql());
    List 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());
    }
      // 返回创建的cacheKey
    return cacheKey;
  }

最终经过以上多个参数的设置拼接成一个很长的cacheKey

后需在查询的时候直接先去二级缓存查

  public  List query(MappedStatement ms, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql)
      throws SQLException {
      // 获取缓存对象
    Cache cache = ms.getCache();
    if (cache != null) {
      flushCacheIfRequired(ms);
      if (ms.isUseCache() && resultHandler == null) {
        ensureNoOutParams(ms, boundSql);
        @SuppressWarnings("unchecked")
          // 从缓存中取
        List list = (List) tcm.getObject(cache, key);
        if (list == null) {
            // 如果二级缓存没有的话，回去进到这个查询方法中去一级缓存中找
          list = delegate.query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
            // 同时放到tcm事务缓存对象中
          tcm.putObject(cache, key, list); // issue #578 and #116
        }
        return list;
      }
    }
    return delegate.query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
  }

这次就直接从存储到的存储到二级缓存中直接查找，找到之后返回
这里是从事务对象tcm中查找，而这里的事务缓存也是经过层层委托的对象

执行更新操作

跟着断点走，进到updata方法

public int update(MappedStatement ms, Object parameterObject) throws SQLException {
   // 必要的时候刷新缓存
    flushCacheIfRequired(ms);
    // 执行更新操作
    return delegate.update(ms, parameterObject);
  }

进到上面刷新的方法，会看到

 public void clear() {
    // 将这个commit时清空设置成了true
    clearOnCommit = true;
    entriesToAddOnCommit.clear();
  }

继续跟着断点走的话，会发现在update()方法中只有清空一级缓存的缓存的方法，而真正清空缓存的方法是在commit方法中，所以二级缓存的使用一定注意提交事务，上面咱么说了他是委托了tcm对象管理管理缓存的

到这里基本二级缓存的内容就介绍完了，第三次查询和已经是清空缓存之后的查询，所以查询过程和第一次是一样的，这里就不再赘述

还有一点就是在解析完成标签之后，紧接着会解析标签，这个标签就是引用其他的mapper的缓存的，也就是可以多个mapper共用一个mapper内的缓存；但是这里有一问题就是，通常情况下，我们的查询都是涉及多张表的，所以这里就很可能出现脏数据的情况，所以这里通常不引用其他mapper，如果要集成其他第三方缓存或者自定义缓存的时候，可以使用。

这里给大家提示一下的是MyBatis的缓存是和整个应用运行在同一个JVM中的，共享同一块堆内存，所以如果要缓存的数据量很大的话，建议是用其他的缓存框架，如：Reids、Memcache

发表回复

您的电子邮箱地址不会被公开。 必填项已用*标注