1.前言
在上一篇文章中，分析了Executor的大概流程，到了最关键的步骤也就是去查询的时候，实际上用的还是StatementHandler。
StatementHandler作用：用于对Statement的操作，包括创建Statement、参数化，以及调用Statement的execute去数据执行sql语句。
下面代码是SimpleExecutor中doQuery的代码，也是用到StatementHandler的地方。
//select
@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
//这里看到ResultHandler传入了
StatementHandler handler = configuration.newStatementHandler(wrapper, ms, parameter, rowBounds, resultHandler, boundSql);
//准备语句
stmt = prepareStatement(handler, ms.getStatementLog());
//StatementHandler.query
return handler.<E>query(stmt, resultHandler);
} finally {
closeStatement(stmt);
}
}
所以这篇文章就分析StatementHandler接口下的类，以及是如何去处理sql的。
2.StatementHandler类关系介绍
2.1 接口
public interface StatementHandler {
//准备语句
Statement prepare(Connection connection)
throws SQLException;
//参数化
void parameterize(Statement statement)
throws SQLException;
//批处理
void batch(Statement statement)
throws SQLException;
//update
int update(Statement statement)
throws SQLException;
//select-->结果给ResultHandler
<E> List<E> query(Statement statement, ResultHandler resultHandler)
throws SQLException;
//得到绑定sql
BoundSql getBoundSql();
//得到参数处理器
ParameterHandler getParameterHandler();
}
上面就是StatementHandler的接口定义，顾名思义这个StatementHandler就是对数据库Statement的处理。包括了
1.创建Statement
2.参数化Statement
3.修改、查询
4.批处理（只有BatchExecutor才会用上）
2.2 类的关系图
这个类的继承结构以及实现的一些细节其实和Executor是很相似的。
例如：1.都是有个BaseXXXX
2.都有个代理模式的类，这里是RoutingStatementHandler，在Executor是CachingExecutor
那么说回它的类，分别介绍一下各个类的功能：
1.RoutingStatementHandler：代理StatementHandler的其他实现类，就是一个代理模式，根据MappedStatement的statementType来决定生成SimpleStatmentHandler、PreparedStatementHandler还是CallableStatementHandler，然后代理它。
2.BaseStatementHandler：StatementHandler的基类，包含了Executor、参数处理器、返回值处理器、MappedStatement等信息，以及一些公共的函数，方便子类使用。
3.SimpleStatementHandler：简单语句的处理器，适用于没有参数的sql。
4.PreparedStatementHandler：预处理语句处理器，用于需要预处理的语句，例如需要填充参数。这里通过ParameterHandler去填充参数。
5.CallableStatementHandler：存储过程语句处理器，一般不用，可以不需要了解。
3.创建StatementHandler
3.1 回到之前的SimpleExecutor的doQuery方法。里面有一行创建StatementHandler的方法。
StatementHandler handler = configuration.newStatementHandler(wrapper, ms, parameter, rowBounds, resultHandler, boundSql);
进入到里面configuration.newStatementHandler
//创建语句处理器
public StatementHandler newStatementHandler(Executor executor, MappedStatement mappedStatement, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) {
//创建路由选择语句处理器
StatementHandler statementHandler = new RoutingStatementHandler(executor, mappedStatement, parameterObject, rowBounds, resultHandler, boundSql);
//插件在这里插入
statementHandler = (StatementHandler) interceptorChain.pluginAll(statementHandler);
return statementHandler;
}
可以看到这里它是创建了RoutingStatementHandler，然后再使用拦截器拦截（插件机制），返回一个statementHandler。
3.2 那么我们可以进入到创建RoutingStatementHandler
public RoutingStatementHandler(Executor executor, MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) {
//根据语句类型，委派到不同的语句处理器(STATEMENT|PREPARED|CALLABLE)
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());
}
}
这里的实现也是比较简单的，就是判断MappedStatement的statementType，默认是使用的PREPARED，也就是会使用PreparedStatementHandler（预处理语句处理器）。如果我们的sql没有参数，想用SimpleStatementHandler，那么可以在mapper的xml中配置STATEMENT。
<select id="simpleList" resultType="com.learn.mybatis.learnmybatis.entity.User" statementType="STATEMENT">
select * from tt_user limit 10
</select>
4.创建、准备Statement
创建好了StatementHandler了后，就需要去创建和准备Statement，这个是需要和数据库交互的，所以也需要数据库的连接来创建。下面是prepareStatement(handler, ms.getStatementLog())的代码：
private Statement prepareStatement(StatementHandler handler, Log statementLog) throws SQLException {
Statement stmt;
Connection connection = getConnection(statementLog);
//调用StatementHandler.prepare
stmt = handler.prepare(connection);
//调用StatementHandler.parameterize
handler.parameterize(stmt);
return stmt;
}
这里一共三步，然后就可以获取到准备好的、参数化的Statement。
1.获取数据库连接
2.使用StatementHandler创建Statement
3.使用StatementHandler参数化Statement
4.1 创建Statment
进入 stmt = handler.prepare(connection);，这里由于我们是使用的带参数的sql=select * from tt_user where name=?，所以在之前创建的时候就是生成的PreparedStatementHandler的。
进入到PreparedStatementHandler的prepare，这里会调用基类BaseStatementHandler的prepare方法。
@Override
public Statement prepare(Connection connection) throws SQLException {
ErrorContext.instance().sql(boundSql.getSql());
Statement statement = null;
try {
//实例化Statement
statement = instantiateStatement(connection);
//设置超时
setStatementTimeout(statement);
//设置读取条数
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方法创建Statement，然后设置查询超时时间、设置查询条数然后返回。由于这个instantiateStatement方法是基类留给子类去实现的，所以就到PreparedStatementHandler的instantiateStatement方法。
@Override
protected Statement instantiateStatement(Connection connection) throws SQLException {
//调用Connection.prepareStatement
String sql = boundSql.getSql();
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() != null) {
return connection.prepareStatement(sql, mappedStatement.getResultSetType().getValue(), ResultSet.CONCUR_READ_ONLY);
} else {
return connection.prepareStatement(sql);
}
}
这里的逻辑也简单，就是调用connection.prepareStatement(...)方法，来创建一个Statement。这里就不再深入了，因为再下去就是mysql驱动的处理了。到了这里我们就创建好Statement了。
4.2 参数化Statement
上一步的4.1步骤，将Statement创建好，返回了以后就会调用handler.parameterize(stmt);。接下来就开始参数化，进入到PreparedStatementHandler.parameterize(...)的代码：
@Override
public void parameterize(Statement statement) throws SQLException {
//调用ParameterHandler.setParameters
parameterHandler.setParameters((PreparedStatement) statement);
}
看这代码，就这一句话，直接将statement交给了parameterHandler对象处理。
效果就是将sql参数化，比如将sql：select * from tt_user where name=? 变成 select * from tt_user where name=‘jiang’。
ParameterHandler这个接口是专门用于sql的参数化的，我们放在后面去分析，这里只需要知道它会将sql参数化。
5.执行sql
第4大步骤，我们可以得到了一个已经完全可以执行的Statement，这个时候SimpleExecutor的doQuery就执行完了 stmt = prepareStatement(handler, ms.getStatementLog());。那么接下来就到了下一步，去执行sql。也就是下面
//select
@Override
public <E> List<E> doQuery(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) throws SQLException {
// 省略
return handler.<E>query(stmt, resultHandler);
}
从上面的可以分析出来，这个handler就是PreparedStatementHandler。所以就进入PreparedStatementHandler的query。
@Override
public <E> List<E> query(Statement statement, ResultHandler resultHandler) throws SQLException {
PreparedStatement ps = (PreparedStatement) statement;
ps.execute();
return resultSetHandler.<E> handleResultSets(ps);
}
这里就能看的非常清楚了，调用了ps.execute()，这个就是jdbc的接口，会将statement给数据库去执行。
然后执行获取到结果后，使用resultSetHandler去处理结果。
这个resultSetHandler是ResultSetHandler接口的实现类，这个接口是专门用于数据查询返回值的解析处理。和ParameterHandler参数化解析对应。这个类我们也同样放到后分析。
那么到了这里就查询好了数据，也解析完成了，整个查询就完成了。
6.总结
1.StatementHandler有多个实现类，其中PreparedStatementHandler是最常用的用于参数化sql的语句处理器。
2.RoutingStatementHandler是代理类，用于代理其他的StatementHandler实现类
3.创建Statement，是通过BaseStatementHandler.instantiateStatement(..)，调用Connection的prepareStatement方法。
4.使用ParameterHandler的实现类对sql进行参数化。
5.PreparedStatementHandler的query里面会调用 ps.execute()方法，真正的去执行sql。
6. 使用ResultSetHandler的实现类对sql返回值进行解析处理。
