MyBatis 执行 SQL 的核心接口为 SqlSession 接口，该接口提供了一些 CURD 及控制事务的方法，另外还可以通过 SqlSession 先获取 Mapper 接口的实例，然后通过 Mapper 接口执行 SQL，Mapper 接口方法的执行最终还是委托到 SqlSession 中的方法。因此可以由 SqlSession 入手分析 SQL 执行流程。

SQL 执行流程分析

MyBatis 中的 SQL 都是由 SqlSession 进行执行，由于日常工作中使用的 SQL 类型多为查询，并且 MyBatis 中的查询也最为复杂，因此本篇以SqlSession#selectList(String, Object, RowBounds)作为入口进行分析，中间穿插 SqlSession 的其他 API 介绍，重要的组件将在后面的章节中单独列出。

public interface SqlSession extends Closeable {
    <E> List<E> selectList(String statement, Object parameter, RowBounds rowBounds);  
}

#selectList 的方法定义如上所示，该方法查询数据库然后将结果转换为用户需要的类型。各参数的具体含义如下：

• statement：表示 SQL 语句的标识，Mapper 接口中的方法调用时会使用 接口全限定名.方法名，对应 Mapper xml 配置中mapper节点namespace.select节点id。
• parameter：MyBatis SQL 语句中的参数，可以是原生类型或原生类型的包装类，可以是 Map ，也可以是其他的 Object，如果 Mapper 接口方法中包含多个参数将转换为 Map，MyBatis 取 Map 或 Object 中的字段值替换 Mapper xml 文件中的 ${paramName}或将#{paramName} 指定的 SQL 参数设置为对应的字段值。
• rowBounds：分页信息，包含 offset 和 limit ，MyBatis 在内存中对返回的结果进行分页。

了解方法的功能后，我们再看方法的实现，MyBatis 中 SqlSession 默认的实现为 DefaultSqlSession，跟踪源码。

public class DefaultSqlSession implements SqlSession {
    // Mybatis 配置
    private final Configuration configuration;
    // 执行器
    private final Executor executor;

    @Override
    public <E> List<E> selectList(String statement, Object parameter, RowBounds rowBounds) {
        try {
            MappedStatement ms = configuration.getMappedStatement(statement);
            return executor.query(ms, wrapCollection(parameter), rowBounds, Executor.NO_RESULT_HANDLER);
        } catch (Exception e) {
            throw ExceptionFactory.wrapException("Error querying database.  Cause: " + e, e);
        } finally {
            ErrorContext.instance().reset();
        }
    }
}

SqlSession 进行数据库查询时先从配置中获取表示 SQL 语句的 MappedStatement，然后使用执行器 Executor 进行执行。调用的 Executor#query 方法定义如下：

public interface Executor {
    <E> List<E> query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler) throws SQLException;
}

Executor 执行查询时多了一个新的参数 ResultHandler，它用于处理每一行数据库记录对应的 Java 对象，例如可以将结果保存到 List 或者 Map 中。Executor 作为接口具有多个实现，CachingExecutor 和其他 Executor 相比仅多了 Statement 级别缓存的支持，因此我们跟踪 BaseExecutor#query 方法的实现。

public abstract class BaseExecutor implements Executor {
    @Override
    public <E> List<E> query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler) throws SQLException {
        BoundSql boundSql = ms.getBoundSql(parameter);
        CacheKey key = createCacheKey(ms, parameter, rowBounds, boundSql);
        return query(ms, parameter, rowBounds, resultHandler, key, boundSql);
    }
}

BaseExecutor 先使用 MappedStatement 获取到 BoundSql 的实例，然后创建了表示当前查询的 CacheKey，最后调用了另一个 #query 方法。

• BoundSql：MappedStatement 包含 MyBatis 执行 SQL 需要的完整元数据，如结果映射、参数映射、动态 SQL 等，MappedStatement 将动态 SQL 解析后生成 BoundSql，BoundSql 仅包含最终执行的 SQL 及参数信息。
• CacheKey：MyBatis 可以将每个 SQL 的查询结果缓存下来，CacheKey 就是用来表示缓存的 key 值，它由 SQL、参数、分页等构成，当下次使用相同的条件查询数据库时可以优先从缓存获取到查询结果。

了解完这些参数后再看调用的 #query 方法：

public abstract class BaseExecutor implements Executor {
    public <E> List<E> query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql) throws SQLException {
        ... 省略校验及缓存处理代码
        List<E> list;
        try {
            queryStack++;
            // 优先从缓存获取
            list = resultHandler == null ? (List<E>) localCache.getObject(key) : null;
            if (list != null) {
            	// 处理存储过程 OUT 参数
                handleLocallyCachedOutputParameters(ms, key, parameter, boundSql);
            } else {
                // 缓存中没有数据，从数据库中查询
                list = queryFromDatabase(ms, parameter, rowBounds, resultHandler, key, boundSql);
            }
        } finally {
            queryStack--;
        }
        ... 省略缓存处理相关代码
        return list;
    }
}

为了将重点放在主要流程，上面的代码省略了部分缓存处理的方法，关于缓存处理将在后面单独分析。#query 方法优先从缓存中获取查询结果，如果没有获取到则会从数据库进行查询，再看数据库查询的代码。

public abstract class BaseExecutor implements Executor {

    private <E> List<E> queryFromDatabase(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql) throws SQLException {
        List<E> list;
        localCache.putObject(key, EXECUTION_PLACEHOLDER);
        try {
        	// 执行数据库查询
            list = doQuery(ms, parameter, rowBounds, resultHandler, boundSql);
        } finally {
            localCache.removeObject(key);
        }
        // 将查询结果缓存
        localCache.putObject(key, list);
        if (ms.getStatementType() == StatementType.CALLABLE) {
            localOutputParameterCache.putObject(key, parameter);
        }
        return list;
    }
    
    protected abstract <E> List<E> doQuery(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql)
        throws SQLException;    
}

#queryFromDatabase 调用 #doQuery 方法进行数据库查询，然后将查询结果缓存下来。#doQuery 是一个抽象方法，我们看其在默认使用的 SimpleExecutor 中的实现。

public class SimpleExecutor extends BaseExecutor {
    @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 handler = configuration.newStatementHandler(wrapper, ms, parameter, rowBounds, resultHandler, boundSql);
            // 创建 Statement，设置 SQL 参数
            stmt = prepareStatement(handler, ms.getStatementLog());
            // 使用 StatementHandler 执行查询
            return handler.query(stmt, resultHandler);
        } finally {
            closeStatement(stmt);
        }
    }
    // 准备好 Statement
    private Statement prepareStatement(StatementHandler handler, Log statementLog) throws SQLException {
        Statement stmt;
        Connection connection = getConnection(statementLog);
        // 创建 Statement
        stmt = handler.prepare(connection, transaction.getTimeout());
        // 设置 SQL 参数
        handler.parameterize(stmt);
        return stmt;
    }
}

到了这里，终于看到了熟悉的 JDBC API。#doQuery 方法先使用配置创建了一个 StatementHandler，使用 StatementHandler 创建 Statement 并设置了 SQL 的参数后就开始调用 #StatementHandler#query 执行数据库查询。StatementHandler 用于创建 StatementHandler、设置参数、执行 SQL，如果没有指定则使用 PreparedStatementHandler。

先看 StatementHandler 创建 Statement 的方法 #prepared。

public abstract class BaseStatementHandler implements StatementHandler {
    @Override
    public Statement prepare(Connection connection, Integer transactionTimeout) throws SQLException {
        ErrorContext.instance().sql(boundSql.getSql());
        Statement statement = null;
        try {
        	// 实例化 Statement
            statement = instantiateStatement(connection);
            // 设置 Statement 的数据库参数
            setStatementTimeout(statement, transactionTimeout);
            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);
        }
    }
	// 实例化 Statement
    protected abstract Statement instantiateStatement(Connection connection) throws SQLException;
}

StatementHandler#prepared 方法由基类 BaseStatementHandler 实现，先调用了模板方法 #instantiateStatement 实例化 Statement，然后设置 Statement，模板方法由具体的子类实现，如 PreparedStatementHandler 会实例化出 PreparedStatement。

再跟踪 StatementHandler 的实现 PreparedStatementHandler 设置参数的 #parameterize 方法。

public class PreparedStatementHandler extends BaseStatementHandler {
    @Override
    public void parameterize(Statement statement) throws SQLException {
        parameterHandler.setParameters((PreparedStatement) statement);
    }
}

PreparedStatementHandler 先调用 PreparedStatement#execute 方法执行 SQL，然后使用 ResultSetHandler 将查询结果转换为需要的类型。ResultSetHandler 会根据 resultMap 将数据库记录转换为 Mapper 接口方法返回的对象，由于其内部实现比较复杂，这里暂不进行分析。