Mybatis源码之StatementHandler

本系列文章会在我的个人公众号“兮一昂吧”和掘金同步更新，欢迎关注！

StatementHandler介绍

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

 1public interface StatementHandler {
 2
 3  // 使用Connection创建Statement对象，设置事务超时时间
 4  Statement prepare(Connection connection, Integer transactionTimeout)
 5      throws SQLException;
 6
 7  // 为Statement绑定参数，
 8  // 其中会使用ParameterHandler进行参数绑定
 9  void parameterize(Statement statement)
10      throws SQLException;
11
12  void batch(Statement statement)
13      throws SQLException;
14
15  // 执行insert/update/delete类型的sql语句
16  int update(Statement statement)
17      throws SQLException;
18
19  // 执行select语句
20  <E> List<E> query(Statement statement, ResultHandler resultHandler)
21      throws SQLException;
22
23  <E> Cursor<E> queryCursor(Statement statement)
24      throws SQLException;
25
26  // 获取BoundSql对象
27  BoundSql getBoundSql();
28
29  //  获取ParameterHandler对象
30  ParameterHandler getParameterHandler();
31}

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方法创建的，跟着源码走下流程：

 1  //org.apache.ibatis.session.Configuration#newStatementHandler
 2  public StatementHandler newStatementHandler(Executor executor, MappedStatement mappedStatement, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) {
 3    // 创建StatementHandler时，首先创建的是RoutingStatementHandler这个路由对象；
 4    // RoutingStatementHandler会根据ms的类型动态创建相应的StatementHandler
 5    StatementHandler statementHandler = new RoutingStatementHandler(executor, mappedStatement, parameterObject, rowBounds, resultHandler, boundSql);
 6    statementHandler = (StatementHandler) interceptorChain.pluginAll(statementHandler);
 7    return statementHandler;
 8  }
 9
10  //org.apache.ibatis.executor.statement.RoutingStatementHandler#RoutingStatementHandler
11  // 根据statementType创建不同的Handler
12  public RoutingStatementHandler(Executor executor, MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) {
13    switch (ms.getStatementType()) {
14      case STATEMENT:
15        delegate = new SimpleStatementHandler(executor, ms, parameter, rowBounds, resultHandler, boundSql);
16        break;
17      case PREPARED:
18        delegate = new PreparedStatementHandler(executor, ms, parameter, rowBounds, resultHandler, boundSql);
19        break;
20      case CALLABLE:
21        delegate = new CallableStatementHandler(executor, ms, parameter, rowBounds, resultHandler, boundSql);
22        break;
23      default:
24        throw new ExecutorException("Unknown statement type: " + ms.getStatementType());
25    }
26  }

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

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

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

1<select
2  id="selectPerson"
3  resultMap="personResultMap"
4  statementType="PREPARED或STATEMENT或CALLABLE">

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

prepare流程

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

 1  @Override
 2  public <E> List<E> doQuery(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) throws SQLException {
 3    Statement stmt = null;
 4    try {
 5      //获取配置对象
 6      Configuration configuration = ms.getConfiguration();
 7      //创建StatementHandler
 8      StatementHandler handler = configuration.newStatementHandler(wrapper, ms, parameter, rowBounds, resultHandler, boundSql);
 9      //准备Statement
10      stmt = prepareStatement(handler, ms.getStatementLog());
11      //执行查询
12      return handler.query(stmt, resultHandler);
13    } finally {
14      //关闭Statement
15      closeStatement(stmt);
16    }
17  }
18
19  // org.apache.ibatis.executor.SimpleExecutor#prepareStatement
20  private Statement prepareStatement(StatementHandler handler, Log statementLog) throws SQLException {
21    Statement stmt;
22    Connection connection = getConnection(statementLog);
23    // 创建Statement对象，这里使用BaseStatementHandler的模板方法按照流程创建并设置参数；
24    // 创建Statement对象的具体逻辑由BaseStatementHandler的子类实现
25    stmt = handler.prepare(connection, transaction.getTimeout());
26    // 设置Statement中的参数，这里使用了ParameterHandler
27    handler.parameterize(stmt);
28    return stmt;
29  }

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

 1  //org.apache.ibatis.executor.statement.BaseStatementHandler#prepare
 2  public Statement prepare(Connection connection, Integer transactionTimeout) throws SQLException {
 3    ErrorContext.instance().sql(boundSql.getSql());
 4    Statement statement = null;
 5    try {
 6      //实例化：抽象方法由子类实现
 7      statement = instantiateStatement(connection);
 8      setStatementTimeout(statement, transactionTimeout);
 9      setFetchSize(statement);
10      return statement;
11    } catch (SQLException e) {
12      closeStatement(statement);
13      throw e;
14    } catch (Exception e) {
15      closeStatement(statement);
16      throw new ExecutorException("Error preparing statement.  Cause: " + e, e);
17    }
18  }

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

SimpleStatementHandler#instantiateStatement

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

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

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

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

CallableStatementHandler#instantiateStatement

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

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

parameterize流程

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

 1  @Override
 2  public void parameterize(Statement statement) {
 3    // N/A
 4  }
 5
 6  //PreparedStatementHandler#parameterize
 7  @Override
 8  public void parameterize(Statement statement) throws SQLException {
 9    parameterHandler.setParameters((PreparedStatement) statement);
10  }
11
12  //CallableStatementHandler#parameterize
13  @Override
14  public void parameterize(Statement statement) throws SQLException {
15    // 设置输出参数
16    registerOutputParameters((CallableStatement) statement);
17    // 与PreparedStatementHandler方式一致
18    parameterHandler.setParameters((CallableStatement) statement);
19  }

update流程

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

SimpleStatementHandler#update

 1  @Override
 2  public int update(Statement statement) throws SQLException {
 3    String sql = boundSql.getSql();
 4    Object parameterObject = boundSql.getParameterObject();
 5    //获取mappedStatement的主键生成方式
 6    KeyGenerator keyGenerator = mappedStatement.getKeyGenerator();
 7    int rows;
 8      // 主键自增方式
 9    if (keyGenerator instanceof Jdbc3KeyGenerator) {
10      statement.execute(sql, Statement.RETURN_GENERATED_KEYS);
11      rows = statement.getUpdateCount();
12      //执行完成后，处理返回主键值
13      keyGenerator.processAfter(executor, mappedStatement, statement, parameterObject);
14    } else if (keyGenerator instanceof SelectKeyGenerator) {
15        // Sequence Key
16      statement.execute(sql);
17      rows = statement.getUpdateCount();
18        //执行完成后，处理返回主键值
19      keyGenerator.processAfter(executor, mappedStatement, statement, parameterObject);
20    } else {
21        // 无主键返回要求
22      statement.execute(sql);
23      rows = statement.getUpdateCount();
24    }
25    return rows;
26  }

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

PreparedStatementHandler#update

 1  @Override
 2  public int update(Statement statement) throws SQLException {
 3    PreparedStatement ps = (PreparedStatement) statement;
 4    ps.execute();
 5    int rows = ps.getUpdateCount();
 6    Object parameterObject = boundSql.getParameterObject();
 7    KeyGenerator keyGenerator = mappedStatement.getKeyGenerator();
 8    keyGenerator.processAfter(executor, mappedStatement, ps, parameterObject);
 9    return rows;
10  }

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

CallableStatementHandler#update

 1  @Override
 2  public int update(Statement statement) throws SQLException {
 3    CallableStatement cs = (CallableStatement) statement;
 4    cs.execute();
 5    int rows = cs.getUpdateCount();
 6    Object parameterObject = boundSql.getParameterObject();
 7    KeyGenerator keyGenerator = mappedStatement.getKeyGenerator();
 8    keyGenerator.processAfter(executor, mappedStatement, cs, parameterObject);
 9    resultSetHandler.handleOutputParameters(cs);
10    return rows;
11  }