mybatis源码解析之调用流程（一级缓存）

我不是女神ヾ 2022-08-29 11:59 184阅读 0赞

> 原创不易转载请注明出处

### 文章目录 ###

*   *   *  前言
         *  1.入口
         *  2.一级缓存
         *  总结

--------------------

### 前言 ###

在《[mybatis源码解析之调用流程（初探SqlSession创建）][mybatis_SqlSession]》一文中我们介绍完了SqlSession的创建，本文接着往下看看SqlSession是怎样执行的，看看mybatis一级缓存执行原理，在本文开始之前，我们要声明下，mybatis一级缓存只适应于单体项目，在这个微服务盛行的大环境下，mybatis一级缓存一般用不到（会有数据一致性问题，多节点部署就有这个问题），所以它默认也是关闭的。

### 1.入口 ###

上文中我们获取到了SqlSession，接下来就是执行了

// 获取sqlSession
    SqlSession sqlSession = getSqlSession(SqlSessionTemplate.this.sqlSessionFactory,
        SqlSessionTemplate.this.executorType, SqlSessionTemplate.this.exceptionTranslator);
    try { 
      // 执行，调用的是sqlSession 的方法
      Object result = method.invoke(sqlSession, args);
      if (!isSqlSessionTransactional(sqlSession, SqlSessionTemplate.this.sqlSessionFactory)) { 
        // force commit even on non-dirty sessions because some databases require
        // a commit/rollback before calling close()
        sqlSession.commit(true);
      }
      return result;
    }

我们这里为了方便看缓存部分的代码，将调用添加用户方法，变成查询单个用户信息，这样的话，就会走selectOne这个方法。

@Override
      public <T> T selectOne(String statement, Object parameter) { 
        // Popular vote was to return null on 0 results and throw exception on too many.
        // 查询list
        List<T> list = this.selectList(statement, parameter);
        // 集合大小是1 ，正常返回
        if (list.size() == 1) { 
          return list.get(0);
          //多个结果的话，抛出异常
        } else if (list.size() > 1) { 
          throw new TooManyResultsException("Expected one result (or null) to be returned by selectOne(), but found: " + list.size());
        } else { 
          return null;
        }
      }

你如果是查询结果是个实体啥的，它就认为你是查询一个，如果查询出来结果是多个的话，就会抛出TooManyResultsException 异常，这个异常我们开发中经常出现应该。  
它这里是调用的selectList方法，但是返回结果集的时候会判断下，是不是一个结果。  
我们看下这个selectList方法

@Override
      public <E> List<E> selectList(String statement, Object parameter, RowBounds rowBounds) { 
        try { 
          // 根据id从configuration获取statement
          MappedStatement ms = configuration.getMappedStatement(statement);
          // 进行查询
          return executor.query(ms, wrapCollection(parameter), rowBounds, Executor.NO_RESULT_HANDLER);
        } catch (Exception e) { 
          throw ExceptionFactory.wrapException("Error querying database. Cause: " + e, e);
        } finally { 
          ErrorContext.instance().reset();
        }
      }

根据statementId 去configuration中获取MappedStatement ，接着调用executor 的query方法，如果我们没有用插件包装的话，默认是走的CachingExecutor，也就是缓存的。

### 2.一级缓存 ###

我们看下CachingExecutor 的query方法。

// 查询
    @Override
    public <E> List<E> query(MappedStatement ms, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler) throws SQLException { 
      // 根据参数获取boundSql
      BoundSql boundSql = ms.getBoundSql(parameterObject);
      // 创建缓存key
      CacheKey key = createCacheKey(ms, parameterObject, rowBounds, boundSql);
      return query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
    }

`BoundSql boundSql = ms.getBoundSql(parameterObject);` 这行代码很重要，但是不是本文的重点，你就认为这里面是你要执行的sql就好了。  
接着就是创建缓存key了，最后调用自己的query方法

@Override
      public <E> List<E> query(MappedStatement ms, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql)
          throws SQLException { 
        // 这个cache 是需要在namespace 级别上配置的
        Cache cache = ms.getCache();
        if (cache != null) { 
          //判断如果需要刷新缓存的话，就要刷新缓存了
          flushCacheIfRequired(ms);
          // UseCache 这个东西select 语句的话，默认是true的
          if (ms.isUseCache() && resultHandler == null) { //如果使用缓存 并且 结果处理器是null
            ensureNoOutParams(ms, boundSql);
            @SuppressWarnings("unchecked")  //先去缓存中获取，如果不存在的话，就会走下面的查询操作，然后放入缓存中，如果已经存在了，直接返回即可
            List<E> list = (List<E>) tcm.getObject(cache, key);
            if (list == null) { 
              list = delegate.query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
              tcm.putObject(cache, key, list); // issue #578 and #116
            }
            return list;
          }
        }
        return delegate.query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
      }

这里是先是从statement获取缓存对象。如果这个缓存对象不是null的话，就会去这个缓存中获取一下，如果获取到了，就直接返回，如果获取不到的话，就说缓存中没有，这个时候就会调用delegate.query接着往下执行了。  
其实这个缓存就是所谓的一级缓存，它是namespace级别的，当然也可以多个namespce共用一个缓存对象。  
**问题一： 那么，它是怎么被开启的呢？（默认是不会自动开启一级缓存的）**  
只需要在`<mapper>`标签下添加一个`<cache/>`标签就可以了，它就会这个namespace 创建一个一级缓存。

<mapper namespace="com.example.testcanal.dao.UserDao" >
        <cache/>
        <insert id="addUser" useGeneratedKeys="true" keyProperty="id" parameterType="com.example.testcanal.model.UserEntity">
            insert into user  (username,password)  values (#{userName},#{password})
        </insert>
    </mapper>

就像上面这个mapper xml中配置的一样，当然它也有一堆参数。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3l1YW5zaGFuZ3NoZW5naHVv_size_16_color_FFFFFF_t_70]  
当然你也可以使用其他namespace中的一级缓存，共用一个，使用`<cache-ref namespace="xxxx"/>`,其中namespace就是你要与哪个namespace共用一个缓存对象。默认是缓存是LRU +map （也就是LruCache 包着PerpetualCache ）LruCache lru算法，PerpetualCache底层就是map。

**问题二： 一级缓存对象是什么时候被放入MappedStatement 中的呢？**  
在SqlSessionFactory初始化的时候，会解析我们的mapper xml 文件，会先从缓存标签开始解析，解析缓存引用标签， 最后解析我们的`insert|select|update|delete`标签，然后封装MappedStatement 对象，将缓存设置到MappedStatement中。  
关于这块可以《[mybatis源码解析之初始化（解析mapper文件）][mybatis_mapper]》这篇文章，专门介绍mapper xml解析的。

**问题三：查询出来的结果是怎样被放入缓存的？**  
上面query方法有这么一段

List<E> list = (List<E>) tcm.getObject(cache, key);
     if (list == null) { 
       list = delegate.query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
       tcm.putObject(cache, key, list); // issue #578 and #116
     }

先从一级缓存中获取，如果没有的话，就会接着往下调用查询，最后将结果放入缓存中  
tcm是一个事务缓存管理器。  
我们第一次肯定是没有的，我们看下它是怎么被放入的。  
也就是 `tcm.putObject(cache, key, list);` 方法

public void putObject(Cache cache, CacheKey key, Object value) { 
      getTransactionalCache(cache).putObject(key, value);
    }
    private TransactionalCache getTransactionalCache(Cache cache) { 
      return transactionalCaches.computeIfAbsent(cache, TransactionalCache::new);
    }

这里面transactionalCaches 是个map

private final Map<Cache, TransactionalCache> transactionalCaches = new HashMap<>();

map中如果没有cache对应的TransactionalCache 对象，就会创建一个TransactionalCache 对象，将咱们那个cache包起来。  
TransactionalCache 这个类一看就与事务相关。原理很简单，你这个时候putObject 设置缓存，它会暂存到自己维护的一个map中，到了你提交事务的时候，才会给你刷到底层的LruCache中，如果是回滚事务的话，就移除你底层LruCache 中的那个key。  
这里首先看下TransactionalCache 的成员。

private final Cache delegate;  // 我们的LruCache ，被TransactionalCache包了一层，算是委派吧
      private boolean clearOnCommit;// commit的时候是否要清除缓存。
      private final Map<Object, Object> entriesToAddOnCommit;  // 暂存我们缓存的kv， 当我们缓存的时候，它不会直接存到LruCache中，而是暂存到这里面，当我们提交事务的时候，就会被刷到底层的LruCache 中，如果是回滚了的话，里面的就会被清除了
      private final Set<Object> entriesMissedInCache;// 我们在获取某个key的缓存的时候，如果缓存中没有，这个key就会被记录到这个set中。

接下来，我们看下TransactionalCache 的putObject 方法，也就是我们设置缓存的方法：

@Override
    public void putObject(Object key, Object object) { 
      entriesToAddOnCommit.put(key, object);
    }

其实就是将我们要缓存的kv 暂存到了entriesToAddOnCommit 这个map中。

**问题四：怎样获取缓存内容的呢？（获取缓存流程）**

这个时候我们就要看看 `List<E> list = (List<E>) tcm.getObject(cache, key);` 这行是怎么执行的了。

public Object getObject(Cache cache, CacheKey key) { 
      return getTransactionalCache(cache).getObject(key);
    }
    private TransactionalCache getTransactionalCache(Cache cache) { 
      return transactionalCaches.computeIfAbsent(cache, TransactionalCache::new);
    }

其实是调用的TransactionalCache的getObject

@Override
    public Object getObject(Object key) { 
      // issue #116
      Object object = delegate.getObject(key);
      if (object == null) { 
        entriesMissedInCache.add(key);
      }
      // issue #146
      if (clearOnCommit) { 
        return null;
      } else { 
        return object;
      }
    }

先去我们的底层LruCache中获取，如果是null的话，就会将这个key方法entriesMissedInCache 这个set中，记录下这个key。  
这里返回之前判断了一下clearOnCommit 这个成员变量，如果是true的话，就会返回null。  
这里是什么意思呢？其实在去缓存查询之前，会判断下要不要清除缓存，如果要的话，就会将clearOnCommit 变成true，这里也好理解，都要清除缓存了，还去缓存中查出来有什么意义。

**问题五：什么时候会清除一级缓存呢？**  
还是在我们上面那个query方法中，在去缓存查询之前，先要执行这么一个方法： flushCacheIfRequired(ms);

private void flushCacheIfRequired(MappedStatement ms) { 
        Cache cache = ms.getCache();
        if (cache != null && ms.isFlushCacheRequired()) { 
          tcm.clear(cache);
        }
      }

如果缓存不是null，并且这个MappedStatement 设置刷缓存。  
默认情况下update ,insert ,delete 语句会flush缓存，也就是清理缓存。  
当然，你也可以在你的update ,insert,delete ,select 标签上手动控制是否要刷缓存。就是加flushCache属性  
例如：

<insert id="addUser" flushCache="true" parameterType="com.example.testcanal.model.UserEntity">
        insert into user  (username,password)  values (#{userName},#{password})
    </insert>

接着往下看 tcm.clear(cache) 方法。

public void clear() { 
      clearOnCommit = true;
      entriesToAddOnCommit.clear();
    }

将clearOnCommit 设置成true。清理暂存map。

**问题六：事务提交与回滚对一级缓存的影响**  
先来看看事务提交。

public void commit(boolean required) throws SQLException { 
      delegate.commit(required);
      tcm.commit();
    }

public void commit() { 
        for (TransactionalCache txCache : transactionalCaches.values()) { 
          txCache.commit();
        }
      }

这里为啥会有循环呢？不难理解，一个sqlSession 一个事务中，执行了多个namespace的缓存操作，比如单体项目，我下单逻辑，需要调用OrderMapper的add订单方法创建订单，同时需要调用StockMapper 的decrStock 预占库存方法，在一个sqlSession中，一个事务中，如果两个都启用一级缓存的话，就会有两个TransactionalCache ，一个缓存对应一个，这里不用太多关注。

public void commit() { 
        if (clearOnCommit) { 
          delegate.clear();
        }
        flushPendingEntries();
        reset();
      }

如果clearOnCommit =true， 说明要flush缓存，调用清空缓存。

private void flushPendingEntries() { 
        for (Map.Entry<Object, Object> entry : entriesToAddOnCommit.entrySet()) { 
          delegate.putObject(entry.getKey(), entry.getValue());
        }
        for (Object entry : entriesMissedInCache) { 
          if (!entriesToAddOnCommit.containsKey(entry)) { 
            delegate.putObject(entry, null);
          }
        }
      }

将暂存map中的kv刷到缓存中。

接下来再来看看回滚方法。

@Override
      public void rollback(boolean required) throws SQLException { 
        try { 
          delegate.rollback(required);
        } finally { 
          if (required) { 
            tcm.rollback();
          }
        }
      }

public void rollback() { 
        unlockMissedEntries();
        reset();
    }

这个unlockMissedEntries 方法其实就是去真实缓存中 删除那些放到entriesMissedInCache 集合中的key。  
删除那些缓存中没有查到的key。

### 总结 ###

本文主要是按照mybatis调用流程 走到CachingExecutor 中，并深度分析了mybatis实现原理。  
其实就是提交事务或者关闭sqlSession的时候会被刷到真实缓存中，这个一级缓存是namespace级别的，或者是多个namespace共享的。  
在微服务盛行的大环境下，这个一级缓存不能使用！！！会带来一致性问题。

[mybatis_SqlSession]: https://inetyoung.blog.csdn.net/article/details/119089202
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3l1YW5zaGFuZ3NoZW5naHVv_size_16_color_FFFFFF_t_70]: /images/20220829/b0fb72342679465499be5d854c0f0fe5.png
[mybatis_mapper]: https://inetyoung.blog.csdn.net/article/details/119078757