Mybatis源码之StatementHandler

公众号搜索“码路印记”，点关注不迷路！

StatementHandler介绍

StatementHandler 是Mybatis四大组件中另外一个重要的对象，它负责操作Statement对象与数据库进行交流，在工作时会使用 ParameterHandler对参数进行映射，使用ResultSetHandler对结果进行实体类的绑定。通过接口定义初步了解StatementHandler的功能。

public interface StatementHandler {

  // 使用Connection创建Statement对象，设置事务超时时间
  Statement prepare(Connection connection, Integer transactionTimeout)
      throws SQLException;

  // 为Statement绑定参数，
  // 其中会使用ParameterHandler进行参数绑定
  void parameterize(Statement statement)
      throws SQLException;

  void batch(Statement statement)
      throws SQLException;

  // 执行insert/update/delete类型的sql语句
  int update(Statement statement)
      throws SQLException;

  // 执行select语句
  <E> List<E> query(Statement statement, ResultHandler resultHandler)
      throws SQLException;

  <E> Cursor<E> queryCursor(Statement statement)
      throws SQLException;

  // 获取BoundSql对象
  BoundSql getBoundSql();

  //  获取ParameterHandler对象
  ParameterHandler getParameterHandler();
}

StatementHandler接口方法不多，围绕Statement的创建与执行进行设计，通过查看接口定义，可以了解到其主要作用有：

• 创建Statement对象、绑定Statement参数；
• 执行select、update、insert、delete以及其他类型的sql语句；
• 批量执行SQL语句
• 完成结果集向结果对象的转换；

StatementHandler的继承体系如图所示，该接口有两个实现类，其结构与Executor有异曲同工之妙：

• BaseStatementHandler：主要提供了构造方法完成对所有字段的初始化工作；实现了prepare接口，以模板化方式创建Statement对象，其中Statement的创建工作由其子类实现。BaseStatementHandler包含三个子类：
  • SimpleStatementHandler：处理不需要预编译的SQL语句，类似于JDBC中的Statement；
  • PreparedStatementHandler：处理需要预编译的SQL语句，类似于JDBC中的PreparedStatement；
  • CallableStatementHandler：处理存储过程，类似于JDBC中的CallableStatement；
• RoutingStatementHandler：看了它的实现就会知道，它除了根据statementType创建对应的Handler完成以上三个子类处理器的创建与路由，剩下的就是对接口进行路由，也是“名副其实”。

StatementHandler的生命周期由Executor调度管理，其中使用StatementHandler的流程都在doXxxx方法中，接下来结合源码对StatementHandler的流程进行分析。

创建流程

由doXxxx方法可知，StatementHandler是通过Configuration#newStatementHandler方法创建的，跟着源码走下流程：

  //org.apache.ibatis.session.Configuration#newStatementHandler
  public StatementHandler newStatementHandler(Executor executor, MappedStatement mappedStatement, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) {
    // 创建StatementHandler时，首先创建的是RoutingStatementHandler这个路由对象；
    // RoutingStatementHandler会根据ms的类型动态创建相应的StatementHandler
    StatementHandler statementHandler = new RoutingStatementHandler(executor, mappedStatement, parameterObject, rowBounds, resultHandler, boundSql);
    statementHandler = (StatementHandler) interceptorChain.pluginAll(statementHandler);
    return statementHandler;
  }

  //org.apache.ibatis.executor.statement.RoutingStatementHandler#RoutingStatementHandler
  // 根据statementType创建不同的Handler
  public RoutingStatementHandler(Executor executor, MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) {
    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());
    }
  }

newStatementHandler方法非常简单，只有三行：创建RoutingStatementHandler、加载插件、返回已创建的statementHandler对象。

通过“介绍”我们知道RoutingStatementHandler是一个路由类，其内部创建了真正工作的StatementHandler，完成这一工作的就是它的构造方法。从源码可知，它根据ms.getStatementType()对应的StatementType创建具体的StatementHandler。那****ms.getStatementType()是什么类型呢？

默认情况下，MappedStatement.Builder#Builder把statementType设置为PREPARED。若要修改statementType类型，我们需要在mapper文件的select、insert、update、delete标签中设置statementType属性，以select为例：

<select
  id="selectPerson"
  resultMap="personResultMap"
  statementType="PREPARED或STATEMENT或CALLABLE">

OK，创建流程分析完成，我们得到了一个RoutingStatementHandler对象，它内部含有对具体StatementHandler的引用。

prepare流程

在sql命令执行之前，需要完成Statement的创建及初始化工作，完成这一工作的方式就是方法StatementHandler#prepare。以SimpleExecutor#doQuery为例，来看下prepare流程：

  @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);
    }
  }

  // org.apache.ibatis.executor.SimpleExecutor#prepareStatement
  private Statement prepareStatement(StatementHandler handler, Log statementLog) throws SQLException {
    Statement stmt;
    Connection connection = getConnection(statementLog);
    // 创建Statement对象，这里使用BaseStatementHandler的模板方法按照流程创建并设置参数；
    // 创建Statement对象的具体逻辑由BaseStatementHandler的子类实现
    stmt = handler.prepare(connection, transaction.getTimeout());
    // 设置Statement中的参数，这里使用了ParameterHandler
    handler.parameterize(stmt);
    return stmt;
  }

从doQuery到prepareStatement，里面调用了StatementHandler#prepare方法，具体实现类取决于当前handler的类型。默认情况下，会通过RoutingStatementHandler调用到BaseStatementHandler#prepare，它是一个模板方法，通过代码可知它完成三件工作：实例化Statement、设置超时参数、设置返回数据量范围。

  //org.apache.ibatis.executor.statement.BaseStatementHandler#prepare
  public Statement prepare(Connection connection, Integer transactionTimeout) throws SQLException {
    ErrorContext.instance().sql(boundSql.getSql());
    Statement statement = null;
    try {
      //实例化：抽象方法由子类实现
      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);
    }
  }

其中，实例化方法instantiateStatement是抽象方法，由BaseStatementHandler的子类实现，大体实现方式类似，我们逐个看下。

SimpleStatementHandler#instantiateStatement

// org.apache.ibatis.executor.statement.SimpleStatementHandler#instantiateStatement
  @Override
  protected Statement instantiateStatement(Connection connection) throws SQLException {
    // resultSetType默认值，直接使用connection创建Statement
    if (mappedStatement.getResultSetType() == ResultSetType.DEFAULT) {
      return connection.createStatement();
    } else {
      // 否则：按照结果集类型及并发模式（只读）创建
      return connection.createStatement(mappedStatement.getResultSetType().getValue(), ResultSet.CONCUR_READ_ONLY);
    }
  }

SimpleStatementHandler的实现只关心ResultSetType，如果是默认（UNSET）则使用不带参数的createStatement；如果则使用只读方式创建Statement。

ResultSetType设置ResultSet对象的类型标示可滚动，或者是不可滚动。FORWARD_ONLY：结果集仅能向前滚动；SCROLL_INSENSITIVE：结果集前后都可以滚动，但是对数据修改无感知；SCROLL_SENSITIVE：结果集前后都可以滚动，感知对数据修改。

如果PreparedStatement对象初始化时resultSetType参数设置为FORWARD_ONLY，在从ResultSet（结果集）中读取记录的时，对于访问过的记录就自动释放了内存。而设置为SCROLL_INSENSITIVE或SCROLL_SENSITIVE时为了保证能游标能向上移动到任意位置，已经访问过的所有都保留在内存中不能释放。所以大量数据加载的时候，就OOM了。

PreparedStatementHandler#instantiateStatement

// org.apache.ibatis.executor.statement.PreparedStatementHandler#instantiateStatement
// PreparedStatementHandler的实现比SimpleStatementHandler的实现多了对keyGenerator的判断
  @Override
  protected Statement instantiateStatement(Connection connection) throws SQLException {
    String sql = boundSql.getSql();
    // 如果是自增主键并且无keyColumns则设置返回自增值。
    if (mappedStatement.getKeyGenerator() instanceof Jdbc3KeyGenerator) {
      String[] keyColumnNames = mappedStatement.getKeyColumns();
      if (keyColumnNames == null) {
        return connection.prepareStatement(sql, PreparedStatement.RETURN_GENERATED_KEYS);
      } else {
        return connection.prepareStatement(sql, keyColumnNames);
      }
    } else if (mappedStatement.getResultSetType() == ResultSetType.DEFAULT) {
      return connection.prepareStatement(sql);
    } else {
      return connection.prepareStatement(sql, mappedStatement.getResultSetType().getValue(), ResultSet.CONCUR_READ_ONLY);
    }
  }

PreparedStatementHandler的实现与SimpleStatementHandler的区别就是增加了数据库主键生成器的判断逻辑，仅适用于insert和update语句，这会令 MyBatis 使用 JDBC 的 getGeneratedKeys 方法来取出由数据库内部生成的主键。

CallableStatementHandler#instantiateStatement

// org.apache.ibatis.executor.statement.CallableStatementHandler#instantiateStatement
// 存储过程的处理逻辑。
  @Override
  protected Statement instantiateStatement(Connection connection) throws SQLException {
    String sql = boundSql.getSql();
    if (mappedStatement.getResultSetType() == ResultSetType.DEFAULT) {
      return connection.prepareCall(sql);
    } else {
      return connection.prepareCall(sql, mappedStatement.getResultSetType().getValue(), ResultSet.CONCUR_READ_ONLY);
    }
  }

CallableStatementHandler处理存储过程相关的准备工作。

parameterize流程

parameterize方法用于sql命令的参数设置，它需要使用ParameterHandler完成对SQL语句中参数占位符的赋值工作。ParameterHandler的工作原理单独说明，这里不再展开。看下三个实现差别：

  @Override
  public void parameterize(Statement statement) {
    // N/A
  }

  //PreparedStatementHandler#parameterize
  @Override
  public void parameterize(Statement statement) throws SQLException {
    parameterHandler.setParameters((PreparedStatement) statement);
  }

  //CallableStatementHandler#parameterize
  @Override
  public void parameterize(Statement statement) throws SQLException {
    // 设置输出参数
    registerOutputParameters((CallableStatement) statement);
    // 与PreparedStatementHandler方式一致
    parameterHandler.setParameters((CallableStatement) statement);
  }

update流程

update()方法用于执行insert/update/delete命令，日常开发使用频率较高，RoutingStatementHandler仅做代理转发，BaseStatementHandler本身没有实现这个方法，而是由其三个子类直接实现。下面分别看下其实现过程。

SimpleStatementHandler#update

  @Override
  public int update(Statement statement) throws SQLException {
    String sql = boundSql.getSql();
    Object parameterObject = boundSql.getParameterObject();
    //获取mappedStatement的主键生成方式
    KeyGenerator keyGenerator = mappedStatement.getKeyGenerator();
    int rows;
      // 主键自增方式
    if (keyGenerator instanceof Jdbc3KeyGenerator) {
      statement.execute(sql, Statement.RETURN_GENERATED_KEYS);
      rows = statement.getUpdateCount();
      //执行完成后，处理返回主键值
      keyGenerator.processAfter(executor, mappedStatement, statement, parameterObject);
    } else if (keyGenerator instanceof SelectKeyGenerator) {
        // Sequence Key
      statement.execute(sql);
      rows = statement.getUpdateCount();
        //执行完成后，处理返回主键值
      keyGenerator.processAfter(executor, mappedStatement, statement, parameterObject);
    } else {
        // 无主键返回要求
      statement.execute(sql);
      rows = statement.getUpdateCount();
    }
    return rows;
  }

SimpleStatementHandler#update根据mappedStatement的KeyGenerator类型分为三种情况进行处理，重点在于主键值的生成方式，通过processAfter方法设置数据库返回的主键值。

PreparedStatementHandler#update

  @Override
  public int update(Statement statement) throws SQLException {
    PreparedStatement ps = (PreparedStatement) statement;
    ps.execute();
    int rows = ps.getUpdateCount();
    Object parameterObject = boundSql.getParameterObject();
    KeyGenerator keyGenerator = mappedStatement.getKeyGenerator();
    keyGenerator.processAfter(executor, mappedStatement, ps, parameterObject);
    return rows;
  }

PrepareStatementHandler处理的是PreparedStatement，调用execute方法后，处理返回主键值。

CallableStatementHandler#update

  @Override
  public int update(Statement statement) throws SQLException {
    CallableStatement cs = (CallableStatement) statement;
    cs.execute();
    int rows = cs.getUpdateCount();
    Object parameterObject = boundSql.getParameterObject();
    KeyGenerator keyGenerator = mappedStatement.getKeyGenerator();
    keyGenerator.processAfter(executor, mappedStatement, cs, parameterObject);
    resultSetHandler.handleOutputParameters(cs);
    return rows;
  }

CallableStatementHandler的多了出参处理逻辑。

query流程

query方法用于处理select命令，同样由BaseStatementHandler的三个子类实现，主要有两个步骤：执行sql、处理返回结果，其中处理返回结果需要使用ResultSetHandler。过程比较简单，代码就不再贴出来了。

总结

在Mybatis中，StatementHandler起到了承上启下的作用，向上与mybatis框架整合在一起，在Executor的协调组织下处理请求，向下有效的组合ParameterHandler、ResultSetHandler等组件，通过不同Statement与JDBC进行“联络沟通”。

StatementHandler提供了对Statement生命周期控制及执行的方法，以接口方式暴露给上层的Executor使用。到了StatementHandler这一层，Mybatis也算完成了与JDBC的责任交接，接下来就是JDBC内部的逻辑了。

本文到这里就结束了，希望对您有用，如果觉得有用就点个赞吧，^_^！本人水平有限，如您发现有任何错误或不当之处，欢迎批评指正。

公众号搜索“码路印记”，点关注不迷路！