Mybatis源码阅读（四）：核心接口4.2——Executor（下）

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决定选择具体的StatementHandler
            StatementHandler handler = configuration.newStatementHandler(wrapper, ms, parameter, rowBounds, resultHandler, boundSql);
            // 完成Statement的初始化。先创建对应的StatementHandler，再调用parameterize方法处理占位符
            stmt = prepareStatement(handler, ms.getStatementLog());
            // 调用StatementHandler.query方法执行SQL
            return 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);
        // 创建Statement
        stmt = 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();
        //  获取SQL
        String sql = boundSql.getSql();
        if (hasStatementFor(sql)) {
            stmt = getStatement(sql);
            // 修改事务超时时间
            applyTransactionTimeout(stmt);
        } else {
            // 获取数据库连接
            Connection connection = getConnection(statementLog);
            // 创建新的Statement放到statementMap
            stmt = 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());
            // 创建Statement
            stmt = handler.prepare(connection, transaction.getTimeout());
            handler.parameterize(stmt);    //fix Issues 322
            currentSql = sql;
            currentStatement = ms;
            // 添加到statementList
            statementList.add(stmt);
            // 添加新的BatchResult
            batchResultList.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中记录的sql
            if (isRollback) {
                return Collections.emptyList();
            }
            // 遍历StatementList
            for (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();
                    // 获取配置的KeyGenerator
                    KeyGenerator keyGenerator = ms.getKeyGenerator();
                    if (Jdbc3KeyGenerator.class.equals(keyGenerator.getClass())) {
                        Jdbc3KeyGenerator jdbc3KeyGenerator = (Jdbc3KeyGenerator) keyGenerator;
                        // 获取数据库生成的主键，并配置到parameterObjects
                        jdbc3KeyGenerator.processBatch(ms, stmt, parameterObjects);
                    } else if (!NoKeyGenerator.class.equals(keyGenerator.getClass())) { //issue #141
                        // 其他类型的KeyGenerator，调用其processAfter
                        for (Object parameter : parameterObjects) {
                            keyGenerator.processAfter(this, ms, stmt, parameter);
                        }
                    }
                    // Close statement to close cursor #1109
                    closeStatement(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添加到results
                results.add(batchResult);
            }
            return results;
        } finally {
            for (Statement stmt : statementList) {
                closeStatement(stmt);
            }
            currentSql = null;
            statementList.clear();
            batchResultList.clear();
        }
    }

结语

Executor接口的内容有点多，因此就分成了两篇博客进行介绍，而最后的CachingExecutor是为Mybatis实现二级缓存功能，其中使用了装饰器模式。Mybatis的二级缓存功能在实际开发中很少会使用，因此这里就不进行介绍，感兴趣的朋友可以自己摸索。