MyBatis 的秘密（二）Executor

Executor

在MyBatis中有关Executor的配置如下：

设置名	描述	有效值	默认值
defaultExecutorType	配置默认的执行器。SIMPLE 就是普通的执行器；REUSE 执行器会重用预处理语句（prepared statements）； BATCH 执行器将重用语句并执行批量更新。	SIMPLE REUSE BATCH	SIMPLE

也就是说，在MyBatis中有三种Executor:

• SimpleExecutor: 就是普通的执行器。

• ReuseExecutor : 执行器会重用预处理语句（PreparedStatement）

• BatchExecutor : 批量执行器,底层调用JDBC 中Statement#batch()

---

Executor的作用？

首先看SqlSession的一个查询方法的源代码：

DefaultSqlSession#selectList()

@Override
public <E> List<E> selectList(String statement, Object parameter, RowBounds rowBounds){
    //获取对应的配置
    MappedStatement ms = configuration.getMappedStatement(statement);
    //调用`Executor`的查询
    return executor.query(ms, wrapCollection(parameter), rowBounds, Executor.NO_RESULT_HANDLER);
}

从上面的源码我们可以看出来，Executor实际上就是一个打工仔。所有SqlSession执行的方法，基本上都是委托给Executor执行的。

那以上3中执行器代码中有什么不同呢？

---

在MyBatis中，如果开启了二级缓存，那么会使用MyBatis的二级缓存，而这个二级缓存的作用点，便在于Executor的其中一个。

换一种意思便是，在MyBatis中，Executor的实现一共有4个，另外一个为CachingExecutor

CacheingExecutor作为其他3个Executor的装饰者，本身维护了一套缓存机制，底层的调用依然是使用的其他3个Executor，因此这里暂时先跳过；

其他3个Executor都继承自BaseExecutor，BaseExecutor中实现了一些通用的方法，

在Executor中，所有的SQL都被归为两类 : 修改(增，删，改) 和 查询 (查)，因此Executor中将所有的SQL操作都归为了两个方法

BaseExecutor

BaseExecutor 很像是设计模式中的模板方法模式，它实现了Executor的一些通用方法，比如正常的逻辑判断，一级缓存，日志等，然后在真正需要调用逻辑的时候再调用abstract方法,比如：

@Override
public int update(MappedStatement ms, Object parameter) throws SQLException {
    //添加日志信息
    ErrorContext.instance().resource(ms.getResource()).activity("executing an update").object(ms.getId());
    //逻辑判断
    if (closed) {
        throw new ExecutorException("Executor was closed.");
    }
    //清空一级缓存
    clearLocalCache();
    //获取结果
    return doUpdate(ms, parameter);
}

其中doUpdate()便是需要子类自己实现

SimpleExecutor

SimpleExecutor是一个最简单的执行器，没有做额外的操作。

首先看Executor的update()方法

SimpleExecutor#doUpdate()

@Override
public int doUpdate(MappedStatement ms, Object parameter) throws SQLException {
    Statement stmt = null;
    try {
        //获取配置
        Configuration configuration = ms.getConfiguration();
        //创建`StatementHandler`
        StatementHandler handler = configuration.newStatementHandler(this, ms, parameter, RowBounds.DEFAULT, null, null);
        //初始化statement
        stmt = prepareStatement(handler, ms.getStatementLog());
        //执行具体的方法
        return handler.update(stmt);
    } finally {
        closeStatement(stmt);
    }
}

可以看到这里大概就是获取配置，创建StatementHandler，初始化Statement，然后获取结果。

几乎所有的操作都交给了StatementHandler操作了，为什么还有分一层Executor呢？

答案在于prepareStatement和调用handler的方法。

前面说过3种Executor的不同功能，对于ReuseExecutor 会重用Statement,对于BatchExecutor会执行批处理。

下面看看体现这些功能的代码：

ReuseExecutor#prepareStatement()

private Statement prepareStatement(StatementHandler handler, Log statementLog) throws SQLException {
    Statement stmt;
    //获取处理SQL
    BoundSql boundSql = handler.getBoundSql();
    String sql = boundSql.getSql();
    //查看缓存中时候已经有statement
    //如果存在，则直接使用
    if (hasStatementFor(sql)) {
        stmt = getStatement(sql);
        applyTransactionTimeout(stmt);
    } else {
        //如果不存在，则新建statement，并缓存起来
        Connection connection = getConnection(statementLog);
        stmt = handler.prepare(connection, transaction.getTimeout());
        putStatement(sql, stmt);
    }
    handler.parameterize(stmt);
    return stmt;
}

BatchExecutor

BatchExecutor是在我们需要循环/批量执行某些操作的时候，可以进行试用，其底层使用的statment#addBatch()方法，一般对于mysql,要想此方法发挥其性能的优点，需要在连接的时候添加以下两个命令：

useServerPrepStmts=false
rewriteBatchedStatements=true

BatchExecutor#doUpdate()

@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
    //并且statment是否也相同
    //如果相同，则继续执行addBatch()
    //否则进行新建
    if (sql.equals(currentSql) && ms.equals(currentStatement)) {
        //获取最后一个statement的坐标
        //为什么不用栈？？？
        int last = statementList.size() - 1;
        //获取最后一次添加的statement
        stmt = statementList.get(last);
        //设置statement超时时间
        //取事务和statement设置的较小值
        applyTransactionTimeout(stmt);
        //设置参数
        handler.parameterize(stmt);
        //保存参数，后续其他业务逻辑需要，比如KeyGenerator
        BatchResult batchResult = batchResultList.get(last);
        batchResult.addParameterObject(parameterObject);
    } else {
        //否则，新建一个statement
        Connection connection = getConnection(ms.getStatementLog());
        stmt = handler.prepare(connection, transaction.getTimeout());
        handler.parameterize(stmt);    //fix Issues 322
        currentSql = sql;
        currentStatement = ms;
        //每新建一个statement，都将其放在List中
        //方便后续处理
        statementList.add(stmt);
        batchResultList.add(new BatchResult(ms, sql, parameterObject));
    }
    //调用statement 的batch方法
    handler.batch(stmt);
    return BATCH_UPDATE_RETURN_VALUE;
}

可能有人不大理解这段代码。先贴出 JDBC 的batch使用方式：

//插入1000条测试代码
 PreparedStatement psts = conn.prepareStatement(sql);  
for(int i=0;i<1000;i++){
    psts.setString(1,"123");  
    psts.setString(2,"1234");
    psts.addBatch(); 
}
psts.executeBatch();
psts.commit();

可以看到，JDBC的addBatch需要不断的向PreparedStatement添加参数，然后调用addBatch()方法。

上面的逻辑便是，首先判断添加的参数是不是需要循环添加的，如果是，则继续添加，如果SQL不一样了，那么需要新建一个Statement，然后再继续添加参数。

---

继续看我们可以看到，JDBC在添加完参数以后，还需要执行依据executeBatch()去真正的批量执行SQL,那么MyBatis将这一步放在哪里了呢？

---

BatchExecutor#doFlushStatements()

@Override
public List<BatchResult> doFlushStatements(boolean isRollback) throws SQLException {
    try {
        List<BatchResult> results = new ArrayList<>();
        //判断是否已经回滚
        if (isRollback) {
            return Collections.emptyList();
        }
        //遍历处理所有的statement
        for (int i = 0, n = statementList.size(); i < n; i++) {
            Statement stmt = statementList.get(i);
            //设置超时时间
            applyTransactionTimeout(stmt);
            BatchResult batchResult = batchResultList.get(i);
            try {
                //执行executeBatch
                batchResult.setUpdateCounts(stmt.executeBatch());
                //获取对应的statmenment
                MappedStatement ms = batchResult.getMappedStatement();
                //获取参数
                List<Object> parameterObjects = batchResult.getParameterObjects();
                //获取对应的主键处理器
                KeyGenerator keyGenerator = ms.getKeyGenerator();
                //处理主键
                if (Jdbc3KeyGenerator.class.equals(keyGenerator.getClass())) {
                    Jdbc3KeyGenerator jdbc3KeyGenerator = (Jdbc3KeyGenerator) keyGenerator;
                    jdbc3KeyGenerator.processBatch(ms, stmt, parameterObjects);
                } else if (!NoKeyGenerator.class.equals(keyGenerator.getClass())) { //issue #141
                    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);
            }
            results.add(batchResult);
        }
        return results;
    } finally {
        for (Statement stmt : statementList) {
            closeStatement(stmt);
        }
        currentSql = null;
        statementList.clear();
        batchResultList.clear();
    }
}

可以看到，这里代码虽然多，但是其实就是做了两个动作：

• 执行executeBatch()
• 处理执行完后的主键

而这个flushStatement()方法同时会在commit()方法中被调用，因此一般也不需要我们手动调用。

---

ReuseExecutor

ReuseExecutor 是作为一个能将Statement缓存起来进行复用的执行器。和其他执行主要不同的地方在于prepareStatement:

ReuseExecutor#prepareStatement()

private Statement prepareStatement(StatementHandler handler, Log statementLog) throws SQLException {
    Statement stmt;
    BoundSql boundSql = handler.getBoundSql();
    String sql = boundSql.getSql();
    //通过sql 查询是否有缓存的`statement`
    if (hasStatementFor(sql)) {
        //如果有，直接进行复用
        stmt = getStatement(sql);
        //设置超时的值
        applyTransactionTimeout(stmt);
    } else {
        //没有则新建，并进行缓存
        Connection connection = getConnection(statementLog);
        stmt = handler.prepare(connection, transaction.getTimeout());
        putStatement(sql, stmt);
    }
    handler.parameterize(stmt);
    return stmt;
}

可以看到，这样是节约了新建statement的时间，对于PreperStatement来说，同时也节约了预编译SQL的时间。

但是我们可以发现一般默认的Executor并不是REUSE，而是SIMPLE,为什么呢？因为从MyBatis的执行流程来看，一个Executor属于一个SqlSession，而在MyBatis中，并不推荐SqlSession复用，一般一个方法对应于有一个SqlSession,使用完以后需要关闭，因此很少存在能命中的情况。

当然如果是for循环执行的话，那么应该建议改成ReuseExecutor或者<for>改写SQL，因此一般默认SIMPLE级别就足够使用。

---

以上便是MyBatis中Executor的秘密。这里我们再总结下已经查看的知识：

• MyBatis为了方便控制数据库的事务，通过在中间添加了一层Transaction,使得MyBatis可以接受其他的方式控制事务
• 对于MyBatis的默认事务配置，直接使用JDBC即可，也就是最简单的事务控制。
• MyBatis中设有3种不同的Executor，分别是SIMPLE,REUSE,BATCH ,默认为SIMPLE,REUSE缓存了statment， BATCH底层使用了JDBC的addBatch()对应的方法
• 如果要使得BATCH发挥效率，需要在MySql的链接命令中添加useServerPrepStmts=false&rewriteBatchedStatements=true