StatementHandler 接口是 MyBatis 的核心接口之一，它完成了 MyBatis 中最核心的工作，也是 Executor 接口实现的基础。

StatementHandler 接口中的功能很多，例如创建 Statement 对象，为 SQL 语句绑定实参，执行 select、insert、update、delete 等多种类型的 SQL 语句，批量执行 SQL 语句，将结果集映射成结果对象。

  1. public interface StatementHandler {
  3.   // 从连接中获取一个Statement
  4.   Statement prepare(Connection connection, Integer transactionTimeout)
  5.       throws SQLException;
  7.   // 绑定statement执行时所需的实参
  8.   void parameterize(Statement statement)
  9.       throws SQLException;
  11.   // 批量执行SQL语句
  12.   void batch(Statement statement)
  13.       throws SQLException;
  15.   // 执行update/insert/delete语句
  16.   int update(Statement statement)
  17.       throws SQLException;
  19.   // 执行select语句
  20.   <E> List<E> query(Statement statement, ResultHandler resultHandler)
  21.       throws SQLException;
  23.   <E> Cursor<E> queryCursor(Statement statement)
  24.       throws SQLException;
  26.   BoundSql getBoundSql();
  28.   // 获取参数处理器
  29.   ParameterHandler getParameterHandler();
  31. }

RoutingStatementHandler

RoutingStatementHandler 使用了策略模式，RoutingStatementHandler 是策略类，而 SimpleStatementHandler、PreparedStatementHandler、CallableStatementHandler 则是实现了具体算法的实现类，RoutingStatementHandler 对象会根据 MappedStatement 对象的 StatementType 属性值选择使用相应的策略去执行。

  1. public class RoutingStatementHandler implements StatementHandler {
  3.   // 持有的真正实现StatementHandler接口功能的对象
  4.   private final StatementHandler delegate;
  6.   public RoutingStatementHandler(Executor executor, MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) {
  7.     // RoutingStatementHandler的作用就是根据ms的配置，生成一个相对应的StatementHandler对象
  8.     // 并设置到持有的delegate属性中，本对象的所有方法都是通过调用delegate的相应方法实现的
  9.     switch (ms.getStatementType()) {
  10.       case STATEMENT:
  11.         delegate = new SimpleStatementHandler(executor, ms, parameter, rowBounds, resultHandler, boundSql);
  12.         break;
  13.       case PREPARED:
  14.         delegate = new PreparedStatementHandler(executor, ms, parameter, rowBounds, resultHandler, boundSql);
  15.         break;
  16.       case CALLABLE:
  17.         delegate = new CallableStatementHandler(executor, ms, parameter, rowBounds, resultHandler, boundSql);
  18.         break;
  19.       default:
  20.         throw new ExecutorException("Unknown statement type: " + ms.getStatementType());
  21.     }
  23.   }
  25.   @Override
  26.   public Statement prepare(Connection connection, Integer transactionTimeout) throws SQLException {
  27.     return delegate.prepare(connection, transactionTimeout);
  28.   }
  30.   @Override
  31.   public void parameterize(Statement statement) throws SQLException {
  32.     delegate.parameterize(statement);
  33.   }
  35.   @Override
  36.   public void batch(Statement statement) throws SQLException {
  37.     delegate.batch(statement);
  38.   }
  40.   @Override
  41.   public int update(Statement statement) throws SQLException {
  42.     return delegate.update(statement);
  43.   }
  45.   @Override
  46.   public <E> List<E> query(Statement statement, ResultHandler resultHandler) throws SQLException {
  47.     return delegate.query(statement, resultHandler);
  48.   }
  50.   @Override
  51.   public <E> Cursor<E> queryCursor(Statement statement) throws SQLException {
  52.     return delegate.queryCursor(statement);
  53.   }
  55.   @Override
  56.   public BoundSql getBoundSql() {
  57.     return delegate.getBoundSql();
  58.   }
  60.   @Override
  61.   public ParameterHandler getParameterHandler() {
  62.     return delegate.getParameterHandler();
  63.   }
  64. }

BaseStatementHandler

看它以 Base 开头，就可以猜到 它是一个实现了 StatementHandler 接口的抽象类，这个类只提供了一些参数绑定相关的方法，并没有实现操作数据库的方法。

  1. public abstract class BaseStatementHandler implements StatementHandler {
  3.   // 持有的这些属性都是通过构造方法完成初始化的，typeHandlerRegistry、
  4.   // objectFactory、parameterHandler等则是通过configuration属性获得的
  5.   protected final Configuration configuration;
  6.   protected final ObjectFactory objectFactory;
  7.   protected final TypeHandlerRegistry typeHandlerRegistry;
  8.   protected final ResultSetHandler resultSetHandler;
  9.   // parameterHandler的功能主要是为SQL语句绑定实参，也就是使用传入的实参
  10.   // 替换SQL语句中的占位符"?"
  11.   protected final ParameterHandler parameterHandler;
  13.   // 用来执行SQL语句的执行器
  14.   protected final Executor executor;
  15.   protected final MappedStatement mappedStatement;
  16.   // 记录了用户设置的offset和limit，用于在结果集中定位
  17.   // 映射的起始位置和结束位置
  18.   protected final RowBounds rowBounds;
  20.   protected BoundSql boundSql;
  22.   // BaseStatementHandler的构造方法主要用于属性的初始化
  23.   protected BaseStatementHandler(Executor executor, MappedStatement mappedStatement, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) {
  24.     this.configuration = mappedStatement.getConfiguration();
  25.     this.executor = executor;
  26.     this.mappedStatement = mappedStatement;
  27.     this.rowBounds = rowBounds;
  29.     this.typeHandlerRegistry = configuration.getTypeHandlerRegistry();
  30.     this.objectFactory = configuration.getObjectFactory();
  32.     if (boundSql == null) { // issue #435, get the key before calculating the statement
  33.       // 其中调用了KeyGenerator的processBefore()方法
  34.       // 用于初始化SQL语句的主键
  35.       generateKeys(parameterObject);
  36.       boundSql = mappedStatement.getBoundSql(parameterObject);
  37.     }
  39.     this.boundSql = boundSql;
  41.     this.parameterHandler = configuration.newParameterHandler(mappedStatement, parameterObject, boundSql);
  42.     this.resultSetHandler = configuration.newResultSetHandler(executor, mappedStatement, rowBounds, parameterHandler, resultHandler, boundSql);
  43.   }
  45.   protected void generateKeys(Object parameter) {
  46.     KeyGenerator keyGenerator = mappedStatement.getKeyGenerator();
  47.     ErrorContext.instance().store();
  48.     keyGenerator.processBefore(executor, mappedStatement, null, parameter);
  49.     ErrorContext.instance().recall();
  50.   }
  52.   @Override
  53.   public BoundSql getBoundSql() {
  54.     return boundSql;
  55.   }
  57.   @Override
  58.   public ParameterHandler getParameterHandler() {
  59.     return parameterHandler;
  60.   }
  62.   @Override
  63.   public Statement prepare(Connection connection, Integer transactionTimeout) throws SQLException {
  64.     ErrorContext.instance().sql(boundSql.getSql());
  65.     Statement statement = null;
  66.     try {
  67.       // 这是一个抽象方法，用于初始化java.sql.Statement对象
  68.       statement = instantiateStatement(connection);
  69.       // 为Statement对象设置超时时间及fetchSize
  70.       setStatementTimeout(statement, transactionTimeout);
  71.       setFetchSize(statement);
  72.       return statement;
  73.     } catch (SQLException e) {
  74.       closeStatement(statement);
  75.       throw e;
  76.     } catch (Exception e) {
  77.       closeStatement(statement);
  78.       throw new ExecutorException("Error preparing statement.  Cause: " + e, e);
  79.     }
  80.   }
  82.   protected abstract Statement instantiateStatement(Connection connection) throws SQLException;
  84.   protected void setStatementTimeout(Statement stmt, Integer transactionTimeout) throws SQLException {
  85.     Integer queryTimeout = null;
  86.     if (mappedStatement.getTimeout() != null) {
  87.       queryTimeout = mappedStatement.getTimeout();
  88.     } else if (configuration.getDefaultStatementTimeout() != null) {
  89.       queryTimeout = configuration.getDefaultStatementTimeout();
  90.     }
  91.     if (queryTimeout != null) {
  92.       stmt.setQueryTimeout(queryTimeout);
  93.     }
  94.     StatementUtil.applyTransactionTimeout(stmt, queryTimeout, transactionTimeout);
  95.   }
  97.   protected void setFetchSize(Statement stmt) throws SQLException {
  98.     Integer fetchSize = mappedStatement.getFetchSize();
  99.     if (fetchSize != null) {
  100.       stmt.setFetchSize(fetchSize);
  101.       return;
  102.     }
  103.     Integer defaultFetchSize = configuration.getDefaultFetchSize();
  104.     if (defaultFetchSize != null) {
  105.       stmt.setFetchSize(defaultFetchSize);
  106.     }
  107.   }
  109.   protected void closeStatement(Statement statement) {
  110.     try {
  111.       if (statement != null) {
  112.         statement.close();
  113.       }
  114.     } catch (SQLException e) {
  115.       //ignore
  116.     }
  117.   }
  119. }

BaseStatementHandler 主要实现了 StatementHandler 接口中的 prepare()方法，BaseStatementHandler 依赖两个重要的组件，ParameterHandler 和 ResultSetHandler。

ParameterHandler 系列组件

我们要执行的 SQL 语句中可能包含占位符”?”，而每个”?”都对应了 BoundSql 中 parameterMappings 集合中的一个元素，在该 ParameterMapping 对象中记录了对应的参数名称以及该参数的相关属性。ParameterHandler 接口定义了一个非常重要的方法 setParameters()，该方法主要负责调用 PreparedStatement 的 set＊()系列方法，为 SQL 语句绑定实参。MyBatis 只为 ParameterHandler 接口提供了唯一一个实现类 DefaultParameterHandler。

  1. public interface ParameterHandler {
  3.   // 获取用户传入的实参对象
  4.   Object getParameterObject();
  6.   // 本方法主要负责调用PreparedStatement.set*()方法，为SQL语句绑定实参。
  7.   void setParameters(PreparedStatement ps)
  8.       throws SQLException;
  10. }
  13. public class DefaultParameterHandler implements ParameterHandler {
  15.   // 管理mybatis中所有的TypeHandler对象
  16.   private final TypeHandlerRegistry typeHandlerRegistry;
  18.   // 其中记录了SQL节点相应的配置信息
  19.   private final MappedStatement mappedStatement;
  20.   // 用户传入的实参对象
  21.   private final Object parameterObject;
  22.   // 其中记录了要执行的SQL语句，及参数信息
  23.   private final BoundSql boundSql;
  24.   private final Configuration configuration;
  26.   // 构造方法主要为持有的属性 进行初始化
  27.   public DefaultParameterHandler(MappedStatement mappedStatement, Object parameterObject, BoundSql boundSql) {
  28.     this.mappedStatement = mappedStatement;
  29.     this.configuration = mappedStatement.getConfiguration();
  30.     this.typeHandlerRegistry = mappedStatement.getConfiguration().getTypeHandlerRegistry();
  31.     this.parameterObject = parameterObject;
  32.     this.boundSql = boundSql;
  33.   }
  35.   @Override
  36.   public Object getParameterObject() {
  37.     return parameterObject;
  38.   }
  40.   // 为PreparedStatement对象要执行的SQL语句中的占位符 设置对应的参数值
  41.   @Override
  42.   public void setParameters(PreparedStatement ps) {
  43.     ErrorContext.instance().activity("setting parameters").object(mappedStatement.getParameterMap().getId());
  44.     // 获取参数列表
  45.     List<ParameterMapping> parameterMappings = boundSql.getParameterMappings();
  46.     if (parameterMappings != null) {
  47.       for (int i = 0; i < parameterMappings.size(); i++) {
  48.         ParameterMapping parameterMapping = parameterMappings.get(i);
  49.         // 过滤掉存储过程中的输出参数
  50.         if (parameterMapping.getMode() != ParameterMode.OUT) {
  51.           // 记录绑定的实参
  52.           Object value;
  53.           // 获取参数对应的属性名
  54.           String propertyName = parameterMapping.getProperty();
  55.           // 根据属性名 获取 实参值
  56.           if (boundSql.hasAdditionalParameter(propertyName)) { // issue #448 ask first for additional params
  57.             value = boundSql.getAdditionalParameter(propertyName);
  58.           // 整个实参为空
  59.           } else if (parameterObject == null) {
  60.             value = null;
  61.           // 如果实参可以直接通过TypeHandler转换成JdbcType
  62.           } else if (typeHandlerRegistry.hasTypeHandler(parameterObject.getClass())) {
  63.             value = parameterObject;
  64.           } else {
  65.             // 获取对象中相应的属性值 或查找Map对象中的值
  66.             MetaObject metaObject = configuration.newMetaObject(parameterObject);
  67.             value = metaObject.getValue(propertyName);
  68.           }
  69.           // 获取当前parameterMapping中的TypeHandler对象 及JdbcType对象
  70.           TypeHandler typeHandler = parameterMapping.getTypeHandler();
  71.           JdbcType jdbcType = parameterMapping.getJdbcType();
  72.           if (value == null && jdbcType == null) {
  73.             jdbcType = configuration.getJdbcTypeForNull();
  74.           }
  75.           try {
  76.             // TypeHandler的setParameter()方法会调用PreparedStatement对象的
  77.             // set*()系列方法，为SQL语句绑定相应的实参
  78.             typeHandler.setParameter(ps, i + 1, value, jdbcType);
  79.           } catch (TypeException | SQLException e) {
  80.             throw new TypeException("Could not set parameters for mapping: " + parameterMapping + ". Cause: " + e, e);
  81.           }
  82.         }
  83.       }
  84.     }
  85.   }
  87. }

为 SQL 语句绑定完实参之后，就可以调用 Statement 对象 相应的 execute 方法，将 SQL 语句交给数据库执行了。

SimpleStatementHandler

SimpleStatementHandler 继承了 BaseStatementHandler 抽象类。其底层使用 java.sql.Statement 来完成数据库的相关操作，所以 SQL 语句中不存在占位符，所以 SimpleStatementHandler 的 parameterize()方法是空实现。SimpleStatementHandler 的 instantiateStatement()方法直接通过 JDBC Connection 创建 Statement 对象。

  1. public class SimpleStatementHandler extends BaseStatementHandler {
  3.   // 构造方法主要用于属性的初始化
  4.   public SimpleStatementHandler(Executor executor, MappedStatement mappedStatement, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) {
  5.     super(executor, mappedStatement, parameter, rowBounds, resultHandler, boundSql);
  6.   }
  8.   // 直接通过Connection创建Statement对象
  9.   @Override
  10.   protected Statement instantiateStatement(Connection connection) throws SQLException {
  11.     if (mappedStatement.getResultSetType() == ResultSetType.DEFAULT) {
  12.       // 如果结果集类型是DEFAULT默认的，则直接用connection创建Statement对象
  13.       return connection.createStatement();
  14.     } else {
  15.       // 否则，设置结果集类型，设置结果集 只读
  16.       return connection.createStatement(mappedStatement.getResultSetType().getValue(), ResultSet.CONCUR_READ_ONLY);
  17.     }
  18.   }
  20.   // 上面创建的Statement对象会被本方法用于完成数据库查询操作
  21.   @Override
  22.   public <E> List<E> query(Statement statement, ResultHandler resultHandler) throws SQLException {
  23.     // 获取SQL语句
  24.     String sql = boundSql.getSql();
  25.     // 发送请求 执行SQL语句
  26.     statement.execute(sql);
  27.     // 从statement中获取结果集，并进行映射处理
  28.     return resultSetHandler.handleResultSets(statement);
  29.   }
  31.   // 下面的batch()及queryCursor()方法的实现与上面的query()方法非常类似
  32.   @Override
  33.   public void batch(Statement statement) throws SQLException {
  34.     String sql = boundSql.getSql();
  35.     statement.addBatch(sql);
  36.   }
  38.   @Override
  39.   public <E> Cursor<E> queryCursor(Statement statement) throws SQLException {
  40.     String sql = boundSql.getSql();
  41.     statement.execute(sql);
  42.     return resultSetHandler.handleCursorResultSets(statement);
  43.   }
  45.   // 本方法用于执行insert、delete、update等类型的SQL语句，并且会根据配置的
  46.   // KeyGenerator获取数据库生成的主键
  47.   @Override
  48.   public int update(Statement statement) throws SQLException {
  49.     // 获取SQL语句 及parameterObject
  50.     String sql = boundSql.getSql();
  51.     Object parameterObject = boundSql.getParameterObject();
  52.     // 获取配置的KeyGenerator 数据库主键生成器
  53.     KeyGenerator keyGenerator = mappedStatement.getKeyGenerator();
  54.     int rows;
  55.     if (keyGenerator instanceof Jdbc3KeyGenerator) {
  56.       // 执行SQL语句
  57.       statement.execute(sql, Statement.RETURN_GENERATED_KEYS);
  58.       // 获取更新的条数
  59.       rows = statement.getUpdateCount();
  60.       // 将数据库生成的主键添加到parameterObject中
  61.       keyGenerator.processAfter(executor, mappedStatement, statement, parameterObject);
  62.     } else if (keyGenerator instanceof SelectKeyGenerator) {
  63.       // 执行SQL语句
  64.       statement.execute(sql);
  65.       // 获取更新的条数
  66.       rows = statement.getUpdateCount();
  67.       // 执行<selectKey>节点中配置的SQL语句，将从数据库获取到的主键 添加到parameterObject中
  68.       keyGenerator.processAfter(executor, mappedStatement, statement, parameterObject);
  69.     } else {
  70.       statement.execute(sql);
  71.       rows = statement.getUpdateCount();
  72.     }
  73.     return rows;
  74.   }
  76.   @Override
  77.   public void parameterize(Statement statement) {
  78.     // N/A
  79.   }
  81. }

PreparedStatementHandler

PreparedStatementHandler 底层依赖于 java.sql.PreparedStatement 来完成数据库的相关操作。其中的 parameterize()方法中，会调用前面介绍的 ParameterHandler 的 setParameters()方法 完成 SQL 语句的参数绑定。instantiateStatement()方法直接调用 JDBC Connection 的 prepareStatement()方法创建 PreparedStatement 对象。

  1. public class PreparedStatementHandler extends BaseStatementHandler {
  3.   // 构造方法主要用于属性的初始化
  4.   public PreparedStatementHandler(Executor executor, MappedStatement mappedStatement, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) {
  5.     super(executor, mappedStatement, parameter, rowBounds, resultHandler, boundSql);
  6.   }
  8.   @Override
  9.   protected Statement instantiateStatement(Connection connection) throws SQLException {
  10.     // 获取SQL语句
  11.     String sql = boundSql.getSql();
  12.     // 根据mappedStatement持有的KeyGenerator的类型进行不同的处理
  13.     if (mappedStatement.getKeyGenerator() instanceof Jdbc3KeyGenerator) {
  14.       // 获取主键列
  15.       String[] keyColumnNames = mappedStatement.getKeyColumns();
  16.       if (keyColumnNames == null) {
  17.         // 返回数据库生成的主键
  18.         return connection.prepareStatement(sql, PreparedStatement.RETURN_GENERATED_KEYS);
  19.       } else {
  20.         // 在insert语句执行完后，会将keyColumnNames指定的列返回
  21.         return connection.prepareStatement(sql, keyColumnNames);
  22.       }
  23.     } else if (mappedStatement.getResultSetType() == ResultSetType.DEFAULT) {
  24.       // 如果结果集类型是DEFAULT默认的，则直接通过connection获取PreparedStatement对象
  25.       return connection.prepareStatement(sql);
  26.     } else {
  27.       // 否则，设置结果集类型，设置结果集为只读
  28.       return connection.prepareStatement(sql, mappedStatement.getResultSetType().getValue(), ResultSet.CONCUR_READ_ONLY);
  29.     }
  30.   }
  32.   // 因为是PrepareStatement对象，所以需要处理占位符"?"
  33.   // 使用了前面介绍的ParameterHandler组件完成
  34.   @Override
  35.   public void parameterize(Statement statement) throws SQLException {
  36.     parameterHandler.setParameters((PreparedStatement) statement);
  37.   }
  39.   // 下面的这些方法，除了多了一步 将Statement对象强转成PreparedStatement对象
  40.   // 其它的几乎与SimpleStatementHandler一样
  41.   @Override
  42.   public <E> List<E> query(Statement statement, ResultHandler resultHandler) throws SQLException {
  43.     PreparedStatement ps = (PreparedStatement) statement;
  44.     ps.execute();
  45.     return resultSetHandler.handleResultSets(ps);
  46.   }
  48.   @Override
  49.   public void batch(Statement statement) throws SQLException {
  50.     PreparedStatement ps = (PreparedStatement) statement;
  51.     ps.addBatch();
  52.   }
  54.   @Override
  55.   public <E> Cursor<E> queryCursor(Statement statement) throws SQLException {
  56.     PreparedStatement ps = (PreparedStatement) statement;
  57.     ps.execute();
  58.     return resultSetHandler.handleCursorResultSets(ps);
  59.   }
  61.   @Override
  62.   public int update(Statement statement) throws SQLException {
  63.     PreparedStatement ps = (PreparedStatement) statement;
  64.     ps.execute();
  65.     int rows = ps.getUpdateCount();
  66.     Object parameterObject = boundSql.getParameterObject();
  67.     KeyGenerator keyGenerator = mappedStatement.getKeyGenerator();
  68.     keyGenerator.processAfter(executor, mappedStatement, ps, parameterObject);
  69.     return rows;
  70.   }
  72. }

另外，StatementHandler 接口还有一个 CallableStatementHandler 的实现。其底层依赖于 java.sql.CallableStatement 调用指定的存储过程，其 parameterize()方法也会调用 ParameterHandler 的 setParameters()方法完成 SQL 语句的参数绑定，并指定输出参数的索引位置和 JDBC 类型。其余方法与前面介绍的 ResultSetHandler 实现类似，唯一区别是会调用 ResultSetHandler 的 handleOutputParameters()方法 处理输出参数。

看到这里，我们可以发现 StatementHandler 组件依赖 ParameterHandler 组件 和 ResultSetHandler 组件 完成了 MyBatis 的核心功能，它控制着参数绑定、SQL 语句执行、结果集映射等一系列核心流程。