上一篇文章《Mybatis源码之SqlSession》聊到了SqlSession其实是一个包工头儿，揽了活自己不干都安排给了执行器；而且在《Mybatis源码之SQL执行过程》中已经了解到，执行器通过对StatementHandler生命周期的调度与管理，最终完成SQL命令执行。 今天我们就来认识一下Mybatis的四大组件之一：Executor-执行器。提前说明一下，由于Executor涉及到Mybatis的一级缓存、二级缓存，这部分内容后面会单独分析，本文先不展开。 ### Executor简介 Executor位于executor包，Mybatis中所有的SQL命令都由它来调度执行。首先通过UML类图认识一下Executor家族：  * 最顶层是Executor接口，定义了查询、更新、事务、缓存操作相关的接口方法，Executor接口对外暴露，由SqlSession依赖，并受其调度与管理。 * 第二层左侧为BaseExecutor，它是一个抽象类，实现了大部分Executor的接口。它有三个子类，分别是SimpleExecutor、ReuseExecutor、BatchExecutor。BaseExecutor及其子类完成了一级缓存管理和与数据库交互有关的操作。 * 第二层右侧为CachingExecutor，缓存执行器，Mybatis二级缓存的核心处理类。CachingExecutor持有一个BaseExecutor的实现类（SimpleExecutor、ReuseExecutor或BatchExecutor）实例作为委托执行器。它主要完成Mybatis二级缓存处理逻辑，当缓存查询中不存在或查询不到结果时，会通过委托执行器查询数据库。 * 第三层就是BaseExecutor的三个子类。简单执行器为默认执行器，具备执行器的所有能力；可重用执行器，是相对简单执行器而言的，它具备MappedStatement的缓存与复用能力，即在一个SqlSession会话内重复执行同一个命令，可以直接复用已缓存的MappedStatement；批量执行器，即一次可以执行多个命令。 Executor的核心功能是调度执行SQL，参与了全过程；为了提高查询性能，Mybatis在Executor中设计了一级缓存和二级缓存，一级缓存由BaseExecutor及其子类实现，二级缓存由CachingExecutor实现。一级缓存是默认开启的，二级缓存需要启用配置。由于CachingExecutor负责缓存管理，真正的数据库查询是由BaseExecutor完成的，所以对外来看，Executor有三种类型SIMPLE、REUSE、BATCH，默认是SIMPLE，我们可以在配置文件或创建SqlSession时指定参数修改默认执行器类型。以下为Mybatis中ExecutorType定义： ~~~java public enum ExecutorType { // 简单执行器 SIMPLE, // 可重用的执行器 REUSE, // 批处理执行器 BATCH } 复制代码 ~~~ ### 创建过程分析 前面已经说到，SqlSession依赖Executor，Executor接受SqlSession的请求并执行，而且Executor的创建是随着SqlSession的创建而创建的。Executor的创建流程始于DefaultSqlSessionFactory#openSession()及其重载方法，代码如下： ~~~java @Override public SqlSession openSession() { //这里使用默认的执行器类型：SIMPLE return openSessionFromDataSource(configuration.getDefaultExecutorType(), null, false); } private SqlSession openSessionFromDataSource(ExecutorType execType, TransactionIsolationLevel level, boolean autoCommit) { Transaction tx = null; try { final Environment environment = configuration.getEnvironment(); final TransactionFactory transactionFactory = getTransactionFactoryFromEnvironment(environment); tx = transactionFactory.newTransaction(environment.getDataSource(), level, autoCommit); //通过configuration.newExecutor方法创建执行器 final Executor executor = configuration.newExecutor(tx, execType); return new DefaultSqlSession(configuration, executor, autoCommit); } catch (Exception e) { closeTransaction(tx); // may have fetched a connection so lets call close() throw ExceptionFactory.wrapException("Error opening session. Cause: " + e, e); } finally { ErrorContext.instance().reset(); } } 复制代码 ~~~ 简单分析一下这段代码：这里采用了无参openSession方法，其内部使用Configuration#defaultExecutorType作为执行器类型调用openSessionFromDataSource方法；后者对execType未做处理调用了Configuration#newExecutor()执行Executor创建流程。 Configuration#defaultExecutorType默认值为SIMPLE，它会在Mybatis解析配置文件时被修改。若配置文件未涉及executorType的配置，默认值不会改变。另外，可以调用openSession的重载方法指定执行器类型。两种设置方式如下所示： * Mybatis默认（缺省）的执行器类型是SIMPLE，我们可以在配置文件中进行修改设置： ~~~xml <settings> <setting name="defaultExecutorType" value="SIMPLE"/> </settings> 复制代码 ~~~ * 或者通过代码进行设置： ~~~java // 指定执行器类型为REUSE try (SqlSession sqlSession = sqlSessionFactory.openSession(ExecutorType.REUSE)) { //…… } 复制代码 ~~~ 了解了ExecutorType的设置方式，接着看Configuration#newExecutor()方法： ~~~java //Executor执行器创建方法 public Executor newExecutor(Transaction transaction, ExecutorType executorType) { //executorType为null：使用默认执行器，否则按照入参类型 //看Configuration代码，其实有： protected ExecutorType defaultExecutorType = ExecutorType.SIMPLE; executorType = executorType == null ? defaultExecutorType : executorType; //executorType和defaultExecutorType都为null，默认使用SIMPLE executorType = executorType == null ? ExecutorType.SIMPLE : executorType; Executor executor; //按照executorType创建不同的执行器。 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); } //这里判断是否开启了二级缓存，默认值是true。 //所以如果没有修改配置文件的话，这个if语句是会进入执行的 if (cacheEnabled) { //创建缓存执行器，同时把上面创建的executor作为其委托执行器 executor = new CachingExecutor(executor); } //这里是加载与Executor有关的插件。 executor = (Executor) interceptorChain.pluginAll(executor); return executor; } 复制代码 ~~~ 总结一下执行过程： * 首先：处理执行器类型参数，确保其不为空，最终以SIMPLE兜底； * 其次：根据执行器类型调用对应的执行器实现类做初始化，执行器可以为SimpleExecutor、ReuseExecutor、BatchExecutor中的一个； * 然后：如果启用了二级缓存（cacheEnabled默认是true，但是如果不设置cache的相关参数，二级缓存是不起作用的），创建缓存执行器，同时把上面创建的executor作为缓存执行器的委托执行器； * 最后：加载与Executor有关的插件。 默认情况下，会返回一个CachingExecutor对象，其内部包装了BaseExecutor的某个子类对象。  ### query流程 Executor接口中query方法有两个重载，我们从参数少的这个开始入手，它内部也会调用到另外一个。默认情况下会使用CachingExecutor，所以我们从CachingExecutor#query()开始： ~~~java 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); // 调用重载query方法 return query(ms, parameterObject, rowBounds, resultHandler, key, boundSql); } public <E> List<E> 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<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; } } //默认情况没有开启二级缓存，会直接走到这里 //delegate即BaseExecutor三个子类的其中一个 return delegate.query(ms, parameterObject, rowBounds, resultHandler, key, boundSql); } 复制代码 ~~~ 进入CachingExecutor#query，首先通过MappedStatement获取BoundSql，创建缓存key，然后调用了重载的query方法。重载query查询在不考虑缓存的情况下，会直接通过委托执行器的query方法进行查询。 这里的委托执行器为BaseExecutor的子类，而BaseExecutor实现了query方法，所以我们先进入BaseExecutor#query()（同样先忽略一级缓存部分的逻辑）： ~~~java 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++; //从一级缓存（本地缓存）中查询 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 <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; } 复制代码 ~~~ 两个方法比较长，大部分是缓存处理。忽略缓存的情况下（直接看我注释的部分），从query方法调用了数据库查询方法queryFromDatabase，但是，真正查询的逻辑是在抽象方法doQuery中实现的，doQuery由BaseExecutor子类实现。我们依次看下子类实现逻辑： #### SimpleExecutor#doQuery ~~~java @Override public <E> List<E> doQuery(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) throws SQLException { Statement stmt = null; try { //获取配置对象 Configuration configuration = ms.getConfiguration(); //创建StatementHandler StatementHandler handler = configuration.newStatementHandler(wrapper, ms, parameter, rowBounds, resultHandler, boundSql); //准备Statement stmt = prepareStatement(handler, ms.getStatementLog()); //执行查询 return handler.query(stmt, resultHandler); } finally { //关闭Statement closeStatement(stmt); } } private Statement prepareStatement(StatementHandler handler, Log statementLog) throws SQLException { Statement stmt; Connection connection = getConnection(statementLog); stmt = handler.prepare(connection, transaction.getTimeout()); handler.parameterize(stmt); return stmt; } 复制代码 ~~~ SimpleExecutor#doQuery方法代码比较简单，过程清晰明了，简单说明一下： * 从MappedStatement对象获取全局Configuration配置对象； * 调用Configuration#newStatementHandler创建StatementHandler对象； * 创建并初始化Statement对象； * 调用StatementHandler#query执行Statement，并使用resultHandler解析返回值； * 最后关闭Statement。 从上述流程可知，doQuery方法调度StatementHandler完成了对Statement的初始化、参数设置、执行、结果处理与关闭，是对Statement整个生命周期的管理与控制，与前文所说的Executor参与了SQL语句执行的全过程名副其实。 #### ReuseExecutor#doQuery ~~~java //Statement缓存 private final Map<String, Statement> statementMap = new HashMap<>(); @Override public <E> List<E> doQuery(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) throws SQLException { Configuration configuration = ms.getConfiguration(); StatementHandler handler = configuration.newStatementHandler(wrapper, ms, parameter, rowBounds, resultHandler, boundSql); Statement stmt = prepareStatement(handler, ms.getStatementLog()); return handler.query(stmt, resultHandler); } private Statement prepareStatement(StatementHandler handler, Log statementLog) throws SQLException { Statement stmt; BoundSql boundSql = handler.getBoundSql(); String sql = boundSql.getSql(); //检查缓存中是否存在当前sql if (hasStatementFor(sql)) { //如果有，就直接拿出来用 stmt = getStatement(sql); applyTransactionTimeout(stmt); } else { //如果没有，就新建一个 Connection connection = getConnection(statementLog); stmt = handler.prepare(connection, transaction.getTimeout()); //然后，缓存起来。 putStatement(sql, stmt); } handler.parameterize(stmt); return stmt; } 复制代码 ~~~ ReuseExecutor#doQuery与SimpleExecutor#doQuery的逻辑基本一致，不同点在于prepareStatement方法的实现逻辑。prepareStatement使用statementMap对执行过的sql进行缓存，只有statementMap中不存在当前sql的时候才会执行创建流程，对性能有一定的提升。需要注意的是，Executor对象是SqlSession的组成部分，所以这个缓存与SqlSession的生命周期一致。 #### BatchExecutor#doQuery ~~~java @Override public <E> List<E> doQuery(MappedStatement ms, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) throws SQLException { Statement stmt = null; try { //批量执行，目前我理解是为了把之前批量更新的语句执行掉 flushStatements(); //获取Configuration对象 Configuration configuration = ms.getConfiguration(); //创建StatementHandler StatementHandler handler = configuration.newStatementHandler(wrapper, ms, parameterObject, rowBounds, resultHandler, boundSql); //创建Statement Connection connection = getConnection(ms.getStatementLog()); stmt = handler.prepare(connection, transaction.getTimeout()); //设置Statement参数 handler.parameterize(stmt); //执行并返回结果 return handler.query(stmt, resultHandler); } finally { closeStatement(stmt); } } 复制代码 ~~~ BatchExecutor#doQuery方法除了多执行flushStatements方法外，与SimpleExecutor基本一致，不再展开。 ### update()流程 update()方法的对应了insert、update、delete等不同的命令，其执行流程与query()方法流程类似。同样是经过CachingExecutor->BaseExecutor->SimpleExecutor/ReuseExecutor/BatchExecutor。把整个过程的代码一起贴出来分析（注释）： ~~~java //org.apache.ibatis.executor.CachingExecutor#update @Override public int update(MappedStatement ms, Object parameterObject) throws SQLException { // 刷新缓存：开启缓存时，update命令默认情况是需要刷新缓存的 flushCacheIfRequired(ms); //调用委托执行器进行update return delegate.update(ms, parameterObject); } //org.apache.ibatis.executor.BaseExecutor#update @Override public int update(MappedStatement ms, Object parameter) throws SQLException { ErrorContext.instance().resource(ms.getResource()).activity("executing an update").object(ms.getId()); if (closed) { throw new ExecutorException("Executor was closed."); } // 清空缓存，然后调用子类的doUpdate方法 clearLocalCache(); //调用抽象方法执行数据库更新操作 return doUpdate(ms, parameter); } 复制代码 ~~~ Mybatis的缓存机制仅对查询有效，所以Executor能做的就是：使缓存失效、请求中转，最终调用doUpdate执行数据库操作，所以： * CachingExecutor#update首先使二级缓存失效，然后调用委托执行器执行update操作。 * BaseExecutor#update也是首先使得一级缓存失效，然后调用抽象方法doUpdate执行数据库的更新操作。 #### SimpleExecutor#doUpdate SimpleExecutor#doUpdate与doQuery完全一致，不再说明了。 #### ReuseExecutor#doUpdate ReuseExecutor#doUpdate与doQuery完全一致，不再说明了。 #### BatchExecutor#doUpdate BatchExecutor的执行与前两个不一样，它用于执行批量的sql命令，所以多了一些批量准备工作。为了减少与数据库的交互次数，BatchExecutor会批量执行sql命令。代码如下： ~~~java @Override public int doUpdate(MappedStatement ms, Object parameterObject) throws SQLException { //获取Configuration对象 final Configuration configuration = ms.getConfiguration(); //创建StatementHandler final StatementHandler handler = configuration.newStatementHandler(this, ms, parameterObject, RowBounds.DEFAULT, null, null); //获取sql对象 final BoundSql boundSql = handler.getBoundSql(); //获取sql与酒 final String sql = boundSql.getSql(); final Statement stmt; //如果当前命令与上一次执行一样，就不再重复创建Statement，性能提升 if (sql.equals(currentSql) && ms.equals(currentStatement)) { //取出最后一条的索引 int last = statementList.size() - 1; //取出最后一个Statement对象 stmt = statementList.get(last); applyTransactionTimeout(stmt); //设置Statement参数 handler.parameterize(stmt);//fix Issues 322 //获取BatchResult BatchResult batchResult = batchResultList.get(last); //设置BatchResult参数对象 batchResult.addParameterObject(parameterObject); } else { //如果当前命令与上一次执行不一样，重新创建 Connection connection = getConnection(ms.getStatementLog()); //初始化、准备Statement stmt = handler.prepare(connection, transaction.getTimeout()); //设置参数 handler.parameterize(stmt); //fix Issues 322 //设置当前执行的sql命令信息 currentSql = sql; currentStatement = ms; //存起来 statementList.add(stmt); //保存结果对象 batchResultList.add(new BatchResult(ms, sql, parameterObject)); } //批量处理 handler.batch(stmt); return BATCH_UPDATE_RETURN_VALUE; } 复制代码 ~~~ BatchExecutor#doUpdate方法完成了Statement执行前的准备工作，在准备Statement时与上一次要执行的Statement进行对比，如果一致则不再执行重新创建Statement的流程。所以，使用BatchExecutor时应该尽量执行相同的sql命令。 但是，BatchExecutor#doUpdate并未进行数据库的执行操作，它需要通过SqlSession#flushStatements进行触发，然后调用到BatchExecutor#doFlushStatements执行最终的操作，这里就不再展开了。 ### Executor总结 本文从源码角度对Executor的创建流程、query流程、update流程进行了详细梳理，了解了Executor执行update/query的执行流程，重点说明了其与数据库交互的过程，即Statement的调度管理，Executor的缓存机制我们并没有展开。Executor是Mybatis四大组件之一，虽然还没有研究其他三个，但是已经对Mybatis的SQL执行过程有了整体的了解，由此可见Executor的作用举足轻重。 作者：码路印记 链接：https://juejin.cn/post/6883840514861301773 来源：掘金 著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。