*************************************优雅的分割线 **********************************
分享一波:程序员赚外快-必看的巅峰干货
如果以上内容对你觉得有用,并想获取更多的赚钱方式和免费的技术教程
请关注微信公众号:HB荷包
一个能让你学习技术和赚钱方法的公众号,持续更新
*************************************优雅的分割线 **********************************
SimpleExecutor
接上一章博客继续。
SImpleExecutor继承了BaseExecutor类，是最简单的Executor实现。Executor使用了模板方法模式，所以SimpleExecutor不必在关心一级缓存等操作，只需要实现基本的4个方法。
首先看doQuery
/*** 执行查询操作* @param ms* @param parameter* @param rowBounds* @param resultHandler* @param boundSql* @param <E>* @return* @throws SQLException*/
@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();// 创建RoutingStatementHandler，根据MappedStatement.statementType决定选择具体的StatementHandlerStatementHandler handler = configuration.newStatementHandler(wrapper, ms, parameter, rowBounds, resultHandler, boundSql);// 完成Statement的初始化。先创建对应的StatementHandler，再调用parameterize方法处理占位符stmt = prepareStatement(handler, ms.getStatementLog());// 调用StatementHandler.query方法执行SQLreturn handler.query(stmt, resultHandler);} finally {closeStatement(stmt);}
}/*** 创建Statement并处理占位符* @param handler* @param statementLog* @return* @throws SQLException*/
private Statement prepareStatement(StatementHandler handler, Log statementLog) throws SQLException {Statement stmt;Connection connection = getConnection(statementLog);// 创建Statementstmt = handler.prepare(connection, transaction.getTimeout());// 处理占位符handler.parameterize(stmt);return stmt;
}
代码很简单，先获取配置对象，再创建RoutingStatementHandler对象，对Statement进行初始化，最后调用query方法完成查询操作。doQueryCursor、update方法与之类似，不进行介绍。SimpleExecutor不提供批量处理SQL的功能所以doFlushStatement方法直接返回空集合。
ReuseExecutor
传统的JDBC编程中，Statement对象重用是最常见的一种优化手段，这样可以减少SQL的预编译以及创建、销毁Statement对象的开销，从而提高性能。
ReuseExecutor提供了Statement重用的功能，通过statementMap字段缓存使用过的Statement对象，key是sql，value是statement。
该类中的doQuery、doQueryCursor、doUpdate与SimpleExecutor中的实现一样， 不同的是PrepareStatement方法。SimpleExecutor每次都会通过JDBC的Connection创建新的Statement，而ReuseExecutor则先尝试从statementMap中查找缓存的对象。
/*** 默认会从缓存中查找Statement* @param handler* @param statementLog* @return* @throws SQLException*/
private Statement prepareStatement(StatementHandler handler, Log statementLog) throws SQLException {Statement stmt;BoundSql boundSql = handler.getBoundSql();// 获取SQLString sql = boundSql.getSql();if (hasStatementFor(sql)) {stmt = getStatement(sql);// 修改事务超时时间applyTransactionTimeout(stmt);} else {// 获取数据库连接Connection connection = getConnection(statementLog);// 创建新的Statement放到statementMapstmt = handler.prepare(connection, transaction.getTimeout());putStatement(sql, stmt);}handler.parameterize(stmt);return stmt;
}
当事务提交、回滚、连接关闭时，需要销毁这些缓存的Statement对象。在BaseExecutor中commit、rollback、close方法中，都会调用doFlushStatement方法，所以在doFlushStatement方法中关闭Statement比较合适。方法实现如下。
@Override
public List<BatchResult> doFlushStatements(boolean isRollback) {for (Statement stmt : statementMap.values()) {closeStatement(stmt);}statementMap.clear();return Collections.emptyList();
}
BatchExecutor
系统在执行一条sql语句的时候，会将SQQL语句以及相关参数通过网络发送到数据库。对于频繁操作数据库的系统，如果执行一条SQl就向数据库发送一次请求，在网络通信上会有很多性能折损。因此使用批量处理的方式进行优化，缓存多条SQL语句，在合适的时机将多条SQL打包发送给数据库执行，从而减少网络方面的开销，提高性能。
需要注意，批量执行SQL的时候，每次向数据库发送的SQL语句条数是有上限的，如果超出了这个上限，数据库会拒绝执行这些SQL并抛出异常。
BatchExecutor实现了批量处理SQL的功能，核心字段如下。
/*** 缓存多个Statement，每个Statement都缓存了多条SQL*/
private final List<Statement> statementList = new ArrayList<>();
/*** 记录批处理的结果*/
private final List<BatchResult> batchResultList = new ArrayList<>();
/*** 记录当前执行的SQL*/
private String currentSql;
/*** 记录当前执行的MappedStatement*/
private MappedStatement currentStatement;
JDBC只支持insert、update、delete的批处理，select不存在批处理一说，因此这里主要分析doUpdate方法。
doUpdate方法在添加一条SQL的时候，会先将currentSql字段记录的SQl以及currentStatement记录的MappedStatement对象与当前添加的SQL对比，如果相同则添加到同一个Statement对象中等待执行，不同则创建新的Statement对象并缓存到statementList集合中等待执行，代码如下。
@Override
public int doUpdate(MappedStatement ms, Object parameterObject) throws SQLException {final Configuration configuration = ms.getConfiguration();final StatementHandler handler = configuration.newStatementHandler(this, ms, parameterObject, RowBounds.DEFAULT, null, null);final BoundSql boundSql = handler.getBoundSql();final String sql = boundSql.getSql();final Statement stmt;// 如果sql和当前sql相同，这里的sql还有问号占位符，并且MappedStatement和当前Statement相同，就添加到同一个Statement对象中等待执行if (sql.equals(currentSql) && ms.equals(currentStatement)) {// 获取最后一个Statement对象int last = statementList.size() - 1;stmt = statementList.get(last);applyTransactionTimeout(stmt);// 绑定实参，处理?占位符handler.parameterize(stmt);//fix Issues 322// 查找对应的BatchResult，记录用户传入的实参BatchResult batchResult = batchResultList.get(last);batchResult.addParameterObject(parameterObject);} else {// 否则创建新的Statement缓存到statementList中等待执行Connection connection = getConnection(ms.getStatementLog());// 创建Statementstmt = handler.prepare(connection, transaction.getTimeout());handler.parameterize(stmt); //fix Issues 322currentSql = sql;currentStatement = ms;// 添加到statementListstatementList.add(stmt);// 添加新的BatchResultbatchResultList.add(new BatchResult(ms, sql, parameterObject));}handler.batch(stmt);return BATCH_UPDATE_RETURN_VALUE;
}
JDBC的Statement可以添加不同模式的SQL，每添加一个新模式的SQl就会触发一次编译操作。而PrepareStatement中只能添加统一模式的SQL语句，只触发一次编译操作，但是可以通过绑定多组不同的参数实现批处理。而BatchExecutor做的就是这件事，将连续添加的、相同模式的SQL语句添加到同一个Statement对象中，从而有效地减少编译次数。
在添加完待执行的SQL之后，doFlushStatement方法会处理这些SQL语句。
@Override
public List<BatchResult> doFlushStatements(boolean isRollback) throws SQLException {try {// 记录批处理的结果List<BatchResult> results = new ArrayList<>();// 如果明确指定了要回滚事务，则直接返回空集合，忽略statementList中记录的sqlif (isRollback) {return Collections.emptyList();}// 遍历StatementListfor (int i = 0, n = statementList.size(); i < n; i++) {Statement stmt = statementList.get(i);applyTransactionTimeout(stmt);BatchResult batchResult = batchResultList.get(i);try {// 调用批量执行方法，返回int数组，每个元素都表示每条sql影响的记录条数batchResult.setUpdateCounts(stmt.executeBatch());MappedStatement ms = batchResult.getMappedStatement();List<Object> parameterObjects = batchResult.getParameterObjects();// 获取配置的KeyGeneratorKeyGenerator keyGenerator = ms.getKeyGenerator();if (Jdbc3KeyGenerator.class.equals(keyGenerator.getClass())) {Jdbc3KeyGenerator jdbc3KeyGenerator = (Jdbc3KeyGenerator) keyGenerator;// 获取数据库生成的主键，并配置到parameterObjectsjdbc3KeyGenerator.processBatch(ms, stmt, parameterObjects);} else if (!NoKeyGenerator.class.equals(keyGenerator.getClass())) { //issue #141// 其他类型的KeyGenerator，调用其processAfterfor (Object parameter : parameterObjects) {keyGenerator.processAfter(this, ms, stmt, parameter);}}// Close statement to close cursor #1109closeStatement(stmt);} catch (BatchUpdateException e) {StringBuilder message = new StringBuilder();message.append(batchResult.getMappedStatement().getId()).append(" (batch index #").append(i + 1).append(")").append(" failed.");if (i > 0) {message.append(" ").append(i).append(" prior sub executor(s) completed successfully, but will be rolled back.");}throw new BatchExecutorException(message.toString(), e, results, batchResult);}// 将BatchResult添加到resultsresults.add(batchResult);}return results;} finally {for (Statement stmt : statementList) {closeStatement(stmt);}currentSql = null;statementList.clear();batchResultList.clear();}
}
结语
Executor接口的内容有点多，因此就分成了两篇博客进行介绍，而最后的CachingExecutor是为Mybatis实现二级缓存功能，其中使用了装饰器模式。Mybatis的二级缓存功能在实际开发中很少会使用，因此这里就不进行介绍，感兴趣的朋友可以自己摸索。
*************************************优雅的分割线 **********************************
分享一波:程序员赚外快-必看的巅峰干货
如果以上内容对你觉得有用,并想获取更多的赚钱方式和免费的技术教程
请关注微信公众号:HB荷包
一个能让你学习技术和赚钱方法的公众号,持续更新
*************************************优雅的分割线 **********************************
