MyBatis 源码分析（八）：执行器

执行器 Executor 是 MyBatis 的核心接口之一，接口层提供的相关数据库操作，都是基于 Executor 的子类实现的。

Executor体系

创建执行器

在创建 sql 会话时，MyBatis 会调用 Configuration#newExecutor 方法创建执行器。枚举类 ExecutorType 定义了三种执行器类型，即 SIMPLE、REUSE 和 Batch，这些执行器的主要区别在于：

• SIMPLE 在每次执行完成后都会关闭 statement 对象；
• REUSE 会在本地维护一个容器，当前 statement 创建完成后放入容器中，当下次执行相同的 sql 时会复用 statement 对象，执行完毕后也不会关闭；
• BATCH 会将修改操作记录在本地，等待程序触发或有下一次查询时才批量执行修改操作。

public Executor newExecutor(Transaction transaction, ExecutorType executorType) {
  // 默认类型为 simple
  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 代理执行器
    executor = new CachingExecutor(executor);
  }
  // 应用插件
  executor = (Executor) interceptorChain.pluginAll(executor);
  return executor;
}

执行器创建后，如果全局缓存配置是有效的，则会将执行器装饰为 CachingExecutor。

基础执行器

SimpleExecutor、ReuseExecutor、BatchExecutor 均继承自 BaseExecutor。BaseExecutor 实现了 Executor 的全部方法，对缓存、事务、连接处理等提供了一些模板方法，但是针对具体的数据库操作留下了四个抽象方法交由子类实现。

  /**
   * 更新
   */
  protected abstract int doUpdate(MappedStatement ms, Object parameter)
      throws SQLException;

  /**
   * 刷新 statement
   */
  protected abstract List doFlushStatements(boolean isRollback)
      throws SQLException;

  /**
   * 查询
   */
  protected abstract  List doQuery(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql)
      throws SQLException;

  /**
   * 查询获取游标对象
   */
  protected abstract  Cursor doQueryCursor(MappedStatement ms, Object parameter, RowBounds rowBounds, BoundSql boundSql)
      throws SQLException;

基础执行器的查询逻辑如下：

  @Override
  public  List 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 list;
    try {
      queryStack++;
      list = resultHandler == null ? (List) 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) {
      // 存储过程类型，查询缓存
      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) {
            // 参数类型为 OUT 或 INOUT 的，组装结果集
            final String parameterName = parameterMapping.getProperty();
            final Object cachedValue = metaCachedParameter.getValue(parameterName);
            metaParameter.setValue(parameterName, cachedValue);
          }
        }
      }
    }
  }

  /**
   * 查询数据库获取结果集
   */
  private  List queryFromDatabase(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql) throws SQLException {
    List list;
    // 放一个 placeHolder 标志
    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;
  }

执行查询时 MyBatis 首先会根据 CacheKey 查询本地缓存，CacheKey 由本次查询的参数生成，本地缓存由 PerpetualCache 实现，这就是 MyBatis 的一级缓存。一级缓存维护对象 localCache 是基础执行器的本地变量，因此只有相同 sql 会话的查询才能共享一级缓存。当一级缓存中没有对应的数据，基础执行器最终会调用 doQuery 方法交由子类去获取数据。

而执行 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.");
    }
    // 清空本地缓存
    clearLocalCache();
    // 调用子类执行器逻辑
    return doUpdate(ms, parameter);
  }

简单执行器

简单执行器是 MyBatis 的默认执行器。其封装了对 JDBC 的操作，对于查询方法 doQuery 的实现如下，其主要包括创建 statement 处理器、创建 statement、执行查询、关闭 statement。

  @Override
  public  List doQuery(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) throws SQLException {
    Statement stmt = null;
    try {
      Configuration configuration = ms.getConfiguration();
      // 创建 statement 处理器
      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);
    }
  }

创建 statement 处理器

全局配置类 Configuration 提供了方法 newStatementHandler 用于创建 statement 处理器：

  /**
   * 创建 statement 处理器
   */
  public StatementHandler newStatementHandler(Executor executor, MappedStatement mappedStatement, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) {
    // StatementHandler 包装对象，根据 statement 类型创建代理处理器，并将实际操作委托给代理处理器处理
    StatementHandler statementHandler = new RoutingStatementHandler(executor, mappedStatement, parameterObject, rowBounds, resultHandler, boundSql);
    // 应用插件
    statementHandler = (StatementHandler) interceptorChain.pluginAll(statementHandler);
    return statementHandler;
  }

实际每次创建的 statement 处理器对象都是由 RoutingStatementHandler 创建的，RoutingStatementHandler 根据当前 MappedStatement 的类型创建具体的 statement 类型处理器。StatementType 定义了 3 个 statement 类型枚举，分别对应 JDBC 的普通语句、预编译语句和存储过程语句。

  public RoutingStatementHandler(Executor executor, MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) {
    // 根据 statement 类型选择对应的 statementHandler
    switch (ms.getStatementType()) {
      case STATEMENT:
        delegate = new SimpleStatementHandler(executor, ms, parameter, rowBounds, resultHandler, boundSql);
        break;
      case PREPARED:
        delegate = new PreparedStatementHandler(executor, ms, parameter, rowBounds, resultHandler, boundSql);
        break;
      case CALLABLE:
        delegate = new CallableStatementHandler(executor, ms, parameter, rowBounds, resultHandler, boundSql);
        break;
      default:
        throw new ExecutorException("Unknown statement type: " + ms.getStatementType());
    }
  }

创建 statement

简单执行器中的 Statement 对象是根据上述步骤中生成的 statement 处理器获取的。

  private Statement prepareStatement(StatementHandler handler, Log statementLog) throws SQLException {
    Statement stmt;
    // 获取代理连接对象
    Connection connection = getConnection(statementLog);
    // 创建 statement 对象
    stmt = handler.prepare(connection, transaction.getTimeout());
    // 设置 statement 参数
    handler.parameterize(stmt);
    return stmt;
  }

    @Override
  public Statement prepare(Connection connection, Integer transactionTimeout) throws SQLException {
    ErrorContext.instance().sql(boundSql.getSql());
    Statement statement = null;
    try {
      // 从连接中创建 statement 对象
      statement = instantiateStatement(connection);
      // 设置超时时间
      setStatementTimeout(statement, transactionTimeout);
      // 设置分批获取数据数量
      setFetchSize(statement);
      return statement;
    } catch (SQLException e) {
      closeStatement(statement);
      throw e;
    } catch (Exception e) {
      closeStatement(statement);
      throw new ExecutorException("Error preparing statement.  Cause: " + e, e);
    }
  }

执行查询

创建 statement 对象完成即可通过 JDBC 的 API 执行数据库查询，并从 statement 对象中获取查询结果，根据配置进行转换。

  @Override
  public  List query(Statement statement, ResultHandler resultHandler) throws SQLException {
    PreparedStatement ps = (PreparedStatement) statement;
    // 执行查询
    ps.execute();
    // 处理结果集
    return resultSetHandler.handleResultSets(ps);
  }

  /**
   * 处理结果集
   */
  @Override
  public List