本系列文章会在我的个人公众号“兮一昂吧”和掘金同步更新，欢迎关注！
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 List query(Statement statement, ResultHandler resultHandler)21 throws SQLException;2223 Cursor queryCursor(Statement statement)24 throws SQLException;2526 // 获取BoundSql对象27 BoundSql getBoundSql();2829 // 获取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 List 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 //准备Statement10 stmt = prepareStatement(handler, ms.getStatementLog());11 //执行查询12 return handler.query(stmt, resultHandler);13 } finally {14 //关闭Statement15 closeStatement(stmt);16 }17 }1819 // org.apache.ibatis.executor.SimpleExecutor#prepareStatement20 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中的参数，这里使用了ParameterHandler27 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 }
CallableStatementHandler多了出参处理逻辑。
query流程
query方法用于处理select命令，同样由BaseStatementHandler的三个子类实现，主要有两个步骤：执行sql、处理返回结果，其中处理返回结果需要使用ResultSetHandler。过程比较简单，代码就不再贴出来了。
总结
在Mybatis中，StatementHandler起到了承上启下的作用，向上与mybatis框架整合在一起，在Executor的协调组织下处理请求，向下有效的组合ParameterHandler、ResultSetHandler等组件，通过不同Statement与JDBC进行“联络沟通”。
StatementHandler提供了对Statement生命周期控制及执行的方法，以接口方式暴露给上层的Executor使用。到了StatementHandler这一层，Mybatis也算完成了与JDBC的责任交接，接下来就是JDBC内部的逻辑了。
本文到这里就结束了，希望对您有用，如果觉得有用就点个赞吧，^_^！本人水平有限，如您发现有任何错误或不当之处，欢迎批评指正。也可以关注我的微信公众号：“兮一昂吧”。
207
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
