mybatis之执行sql语句

写在前面

通过这篇文章的分析，已经生成了可以执行的sql语句了，本文来分析SQL语句具体的执行过程。
想要系统学习的，可以参考这篇文章，重要！！！。

入口

当我们执行一次数据查询的时候，mybatis会通过org.apache.ibatis.executor.Executor的API完成调用，其中接口源码如下：

public interface Executor {

  ResultHandler NO_RESULT_HANDLER = null;
  // 更新操作
  int update(MappedStatement ms, Object parameter) throws SQLException;
  // 查询
  <E> List<E> query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, CacheKey cacheKey, BoundSql boundSql) throws SQLException;
  // 查询
  <E> List<E> query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler) throws SQLException;
  
  List<BatchResult> flushStatements() throws SQLException;
  // 提交事务
  void commit(boolean required) throws SQLException;
  // 回滚事务
  void rollback(boolean required) throws SQLException;

  CacheKey createCacheKey(MappedStatement ms, Object parameterObject, RowBounds rowBounds, BoundSql boundSql);
  // 是否已经缓存
  boolean isCached(MappedStatement ms, CacheKey key);
  // 清空本地缓存
  void clearLocalCache();
  // 延迟加载
  void deferLoad(MappedStatement ms, MetaObject resultObject, String property, CacheKey key, Class<?> targetType);
  // 获取事务对象
  Transaction getTransaction();

  void close(boolean forceRollback);

  boolean isClosed();
  
  void setExecutorWrapper(Executor executor);

}

这个也是我们的入口类。具体参考1：CachingExecutor。

1：CachingExecutor

关于执行器，详细可以参考这篇文章。

CachingExecutor是org.apache.ibatis.executor.Executor的子类，这里我们分为查询和更新两种情况来进行分析，不管哪种情况执行的入口都是在CachingExecutor类中。关于查询的场景，参考1.1：查询场景分析,关于更新的场景，参考1.2：更新场景分析。

1.1：查询场景分析

假设有如下的配置：

<select id="getByQueryParamter" resultMap="myResultMap">
   select * from test_mapper_sql2222 where id=#{id}
select>

源码如下：

public <E> List<E> query(MappedStatement ms, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler) throws SQLException {
  // 通过MappedStatement获取BoundSql对象，这是一个封装sql和相关参数等信息的对象
  // <2021-08-19 17:31:53>
  BoundSql boundSql = ms.getBoundSql(parameterObject);
  // 创建CacheKey，用于后续查询的缓存工作
  // <2021-08-19 17:38:37>
  CacheKey key = createCacheKey(ms, parameterObject, rowBounds, boundSql);
  // 2021-08-20 13:43:18
  return query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
}

<2021-08-19 17:31:53>处是通过MappedStatement获取BoundSql对象，具体可以参考这篇文章。如下图是一个可能的结果：

<2021-08-19 17:38:37>处是创建缓存键，具体参考1.1.1：创建缓存key。2021-08-20 13:43:18处是通过带有缓存逻辑的查询方法查询数据，具体参考1.1.3：查询数据。

1.1.1：创建缓存key

源码如下：

public CacheKey createCacheKey(MappedStatement ms, Object parameterObject, RowBounds rowBounds, BoundSql boundSql) {
  // 2021-08-19 17:38:37
  return delegate.createCacheKey(ms, parameterObject, rowBounds, boundSql);
}

2021-08-19 17:38:37处源码如下：

org.apache.ibatis.executor.BaseExecutor#createCacheKey
// ms: 当前执行的statement对应的对象
// parameterObject：当前执行的statemnet中的SQL语句参数信息
// rowBounds：查询偏移量和查询数量对象，默认offset->0，limit->2147483647，可以认为是不限制
// boundSql：封装要执行的sql语句以及其需要的参数等信息的对象
public CacheKey createCacheKey(MappedStatement ms, Object parameterObject, RowBounds rowBounds, BoundSql boundSql) {
  if (closed) throw new ExecutorException("Executor was closed.");
  CacheKey cacheKey = new CacheKey();
  // 添加需要作为缓存键的信息到CacheKey中
  // 如下是一个可能的toString CacheKey的结果：
  // 61930333:1684626551:yudaosourcecode.mybatis.mapper.TestMapperSqlMapper.getByQueryParamter:0:2147483647:select * from test_mapper_sql2222 where id=?
  // 2021-08-19 17:55:38
  // 添加当前statement的id到CacheKey中，作为缓存键的一部分
  cacheKey.update(ms.getId());
  // 添加偏移量到CacheKey中，作为缓存键的一部分
  cacheKey.update(rowBounds.getOffset());
  // 添加limit到CacheKey中，作为缓存键的一部分
  cacheKey.update(rowBounds.getLimit());
  // 添加当前的sql语句到CacheKey中，作为缓存键的一部分
  cacheKey.update(boundSql.getSql());
  // 获取参数映射
  List<ParameterMapping> parameterMappings = boundSql.getParameterMappings();
  // 获取类型处理器的注册器
  // 会注册“数据库类型->Java类型”类型处理器信息，也会注册"java类型->数据库类型"类型处理器信息
  // 在向数据库写入数据，或者是从数据库读取数据时会使用相关的组合key获取对应的类型处理器
  TypeHandlerRegistry typeHandlerRegistry = ms.getConfiguration().getTypeHandlerRegistry();
  // 循环遍历所有的参数对象信息，获取参数值，更新的cacheKey对象中，作为缓存键的一部分
  for (int i = 0; i < parameterMappings.size(); i++) {
    // 当前的参数信息
    ParameterMapping parameterMapping = parameterMappings.get(i);
    // 非OUT类型参数才处理
    if (parameterMapping.getMode() != ParameterMode.OUT) {
      // 当前参数的值
      Object value;
      // 获取当前参数#{xxx}中的属性名称
      String propertyName = parameterMapping.getProperty();
      // 如果是在额外自动生成参数中包含当前属性，则优先从其获取
      if (boundSql.hasAdditionalParameter(propertyName)) {
        value = boundSql.getAdditionalParameter(propertyName);
      // 如果是没有用户传入参数，则赋值为null
      } else if (parameterObject == null) {
        // 赋值为null
        value = null;
      } else if (typeHandlerRegistry.hasTypeHandler(parameterObject.getClass())) {
        value = parameterObject;
      } else {
        // 获取传入参数值，一般走这里的逻辑
        MetaObject metaObject = configuration.newMetaObject(parameterObject);
        value = metaObject.getValue(propertyName);
      }
      // 将当前值更新到cacheKey中，作为缓存键的一部分，用于后续的缓存工作
      cacheKey.update(value);
    }
  }
  // 返回缓存key
  return cacheKey;
}    

2021-08-19 17:55:38处通过update方法添加缓存键信息到CacheKey中，具体参考1.1.2：添加CacheKey的缓存键信息。

1.1.2：添加CacheKey的缓存键信息

源码如下：

org.apache.ibatis.cache.CacheKey#update
public void update(Object object) {
  // 如果是数组，则循环每个元素处理
  if (object != null && object.getClass().isArray()) {
    int length = Array.getLength(object);
    for (int i = 0; i < length; i++) {
      Object element = Array.get(object, i);
      doUpdate(element);
    }
  } else {
    // 2021-08-19 17:57:59
    doUpdate(object);
  }
}

2021-08-19 17:57:59处是更新相关属性，以便影响最终生成缓存键，源码如下：

org.apache.ibatis.cache.CacheKey#doUpdate
private void doUpdate(Object object) {
  // 计算缓存键相关内容
  int baseHashCode = object == null ? 1 : object.hashCode();

  count++;
  checksum += baseHashCode;
  baseHashCode *= count;

  hashcode = multiplier * hashcode + baseHashCode;
  // 添加当前值到缓存键的集合中，最终会循环该集合生成键值，参考如下toString:
  /*
  public String toString() {
    StringBuilder returnValue = new StringBuilder().append(hashcode).append(':').append(checksum);
    for (int i = 0; i < updateList.size(); i++) {
      returnValue.append(':').append(updateList.get(i));
    }

    return returnValue.toString();
  }
  */
  updateList.add(object);
}

1.1.3：查询数据

源码如下：

public <E> List<E> query(MappedStatement ms, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql)
      throws SQLException {
 // 获取二级缓存org.apache.ibatis.cache.Cache
 // 2021-08-20 13:50:45
 Cache cache = ms.getCache();
 // 如果是配置了二级缓存
 if (cache != null) {
   // 必要时刷新缓存
   // 2021-08-20 13:56:32
   flushCacheIfRequired(ms);
   // ms.isUseCache():对应的是xml中userCache配置，或者是注解中@Options(useCache = false)
   // 配置的值，默认为false
   // resultHandler:查询一般为null
   // 如果最终结果为true，则从二级缓存中获取数据
   if (ms.isUseCache() && resultHandler == null) {
     // 检查存储过程是否包含参数类型为OUT的参数
     // 2021-08-20 14:23:07
     ensureNoOutParams(ms, parameterObject, boundSql);
     // 从二级缓存中获取结果
     @SuppressWarnings("unchecked")
     List<E> list = (List<E>) tcm.getObject(cache, key);
     // 如果是二级缓存中没有，则直接查询
     if (list == null) {
       // 调用数据库查询数据库
       // 2021-08-20 15:17:44
       list = delegate.<E> query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
       
       tcm.putObject(cache, key, list);
     }
     return list;
   }
 }
 return delegate.<E> query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
}

2021-08-20 13:50:45处是获取配置二级缓存对象org.apache.ibatis.cache.Cache，配置的的方式是在mapper xml中配置标签，如下是我本地获取的对象：

2021-08-20 13:56:32处是必要时进行刷新缓存的操作，源码如下：

private void flushCacheIfRequired(MappedStatement ms) {
  Cache cache = ms.getCache();
  // 缓存对象不为null，并且配置了刷新缓存则刷新
  // 这里ms.isFlushCacheRequired()的值获取的是statement中flushCache属性配置的值
  // 默认是false，即不刷新缓存，注解形式大概为"@Options(flushCache = Options.FlushCachePolicy.TRUE)"
  if (cache != null && ms.isFlushCacheRequired()) {
    // 清空缓存，因为二级缓存是跨SqlSession的，因此在本事务提交前影响的清空的仅仅是本事务
    // 产生的缓存数据，不会影响已产生的缓存，只有在事务提交时才会真正的清空当前命名空间的缓存
    tcm.clear(cache);
  }
}

2021-08-20 14:23:07处是判断当为存储过程时是否包含类型为OUT的参数，源码如下：

private void ensureNoOutParams(MappedStatement ms, Object parameter, BoundSql boundSql) {
  // 存储过程才继续判断
  if (ms.getStatementType() == StatementType.CALLABLE) {
    // 遍历所有的参数
    for (ParameterMapping parameterMapping : boundSql.getParameterMappings()) {
      // 一旦发现不是IN的则直接异常，这里异常的原因是，数据库的出参是不确定的，
      // 所以没有办法进行缓存，或者说已经查询过了再去缓存也没有任何意义
      if (parameterMapping.getMode() != ParameterMode.IN) {
        throw new ExecutorException("Caching stored procedures with OUT params is not supported.  Please configure useCache=false in " + ms.getId() + " statement.");
      }
    }
  }
}

2021-08-20 15:17:4处是通过数据库查询数据，具体参考1.1.4：通过数据库查询数据。

1.1.4：通过数据库查询数据

源码如下：

public <E> List<E> query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql) throws SQLException {
  // 创建ErroContext对象并链式调用方法设置相关信息
  // resource：maper 路径信息
  // ms.getId()：statement的id属性值
  ErrorContext.instance().resource(ms.getResource()).activity("executing a query").object(ms.getId());
  // 执行器已经关闭，则异常
  if (closed) throw new ExecutorException("Executor was closed.");
  // 如果是queryStack为0，并且ms.isFlushCacheRequired()为true，
  // 该参数通过statement中flushCache设置，或者是注解中的@Options(flushCache = Options.FlushCachePolicy.TRUE)设置，默认为false，即使用缓存
  if (queryStack == 0 && ms.isFlushCacheRequired()) {
    // 清空缓存
    // 2021-08-20 15:34:43
    clearLocalCache();
  }
  // 结果
  List<E> list;
  try {
    queryStack++;
    // 从一级缓存中获取
    // 比如我这里的key：-2003544970:1684626552:yudaosourcecode.mybatis.mapper.TestMapperSqlMapper.getByQueryParamter:0:2147483647:select * from test_mapper_sql2222 where id=?:1
    // protected PerpetualCache localCache;
    // 构造函数初始化：this.localCache = new PerpetualCache("LocalCache");
    // 到这里才从一级缓存中查询可以看出，二级缓存的优先级是高于一级缓存的
    list = resultHandler == null ? (List<E>) localCache.getObject(key) : null;
    // 如果是一级缓存中有
    if (list != null) {
      // 处理存储过程相关内容，可以忽略
      handleLocallyCachedOutputParameters(ms, key, parameter, boundSql);
    } else {
      // 一级缓存中没有，从数据库查询
      // 2021-08-20 15:52:10
      list = queryFromDatabase(ms, parameter, rowBounds, resultHandler, key, boundSql);
    }
  } finally {
    queryStack--;
  }
  if (queryStack == 0) {
    for (DeferredLoad deferredLoad : deferredLoads) {
      deferredLoad.load();
    }
    deferredLoads.clear(); // issue #601
    if (configuration.getLocalCacheScope() == LocalCacheScope.STATEMENT) {
      clearLocalCache(); // issue #482
    }
  }
  return list;
}

2021-08-20 15:34:43处是清空本地的一级缓存，源码如下：

org.apache.ibatis.executor.BaseExecutor#clearLocalCache
public void clearLocalCache() {
  if (!closed) {
    // 清空一级缓存localCache
    // protected PerpetualCache localCache;
    // 构造函数赋值：this.localCache = new PerpetualCache("LocalCache");
    localCache.clear();
    // 清空一级缓存localOutputParameterCache
    localOutputParameterCache.clear();
  }
}

2021-08-20 15:52:10处是真正的从数据库中查询数据,具体参考1.1.5：真正的从数据库查询数据。

1.1.5：真正的从数据库查询数据

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 {
    // 查询数据
    // 2021-08-20 16:00:02
    list = doQuery(ms, parameter, rowBounds, resultHandler, boundSql);
  } finally {
    // 查询过程中发生了异常则删除缓存key
    localCache.removeObject(key);
  }
  // 将查询结果放到一级缓存中
  localCache.putObject(key, list);
  // 存储过程时，忽略
  if (ms.getStatementType() == StatementType.CALLABLE) {
    localOutputParameterCache.putObject(key, parameter);
  }
  return list;
}

2021-08-20 16:00:02处源码如下：

public <E> List<E> doQuery(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) throws SQLException {
  // java.sql.Statement，JDBC的API
  Statement stmt = null;
  try {
    // 获取全局配置文件对应的org.apache.ibatis.session.Configuration对象
    Configuration configuration = ms.getConfiguration();
    // 通过全局配置文件的configuration对象创建StatementHanlder对象，该对象负责利用JDBC的API执行数据库查询
    // 2021-08-20 16:15:42
    StatementHandler handler = configuration.newStatementHandler(wrapper, ms, parameter, rowBounds, resultHandler, boundSql);
    // 获取Statement
    // 2021-08-20 17:10:32
    stmt = prepareStatement(handler, ms.getStatementLog());
    // 从数据库查询数据
    // 2021-08-20 18:03:16
    return handler.<E>query(stmt, resultHandler);
  } finally {
    closeStatement(stmt);
  }
}

2021-08-20 16:15:42处是创建StatementHandler，具体参考2.1：通过configuration创建StatementHandler。
2021-08-20 17:10:32处是获取Statement，源码如下：

private Statement prepareStatement(StatementHandler handler, Log statementLog) throws SQLException {
  Statement stmt;
  // 获取JDBC的连接对象
  Connection connection = getConnection(statementLog);
  // 创建Statement
  // 2021-08-20 17:17:27
  stmt = handler.prepare(connection);
  // 设置statement的参数
  // 2021-08-20 17:35:52
  handler.parameterize(stmt);
  return stmt;
}

2021-08-20 17:17:27处是创建Statement，具体参考2.2：prepare方法生成Statement。2021-08-20 17:35:52处是设置statement的参数，具体参考2.3：parameterize设置参数信息。2021-08-20 18:03:16处是真真正正的从数据库查询数据，具体参考1.1.6：真真正正的从数据库查询数据。

1.1.6：真真正正的从数据库查询数据

源码如下：

org.apache.ibatis.executor.statement.RoutingStatementHandler#query
public <E> List<E> query(Statement statement, ResultHandler resultHandler) throws SQLException {
  // 通过代理类查询数据，如果是statementType="PREPARED"，则这里就是PreparedStatementHandler
  // 2021-08-20 18:05:56
  return delegate.<E>query(statement, resultHandler);
}

2021-08-20 18:05:56处源码如下：

org.apache.ibatis.executor.statement.PreparedStatementHandler#query
public <E> List<E> query(Statement statement, ResultHandler resultHandler) throws SQLException {
  // 强转为PreparedStatement
  PreparedStatement ps = (PreparedStatement) statement;
  // 执行查询，此时ps中就已经有数据了
  ps.execute();
  // 使用ResultSetHandler处理查询结果集
  // 2021-08-20 18:09:17
  return resultSetHandler.<E> handleResultSets(ps);
}

2021-08-20 18:09:17处是使用ResultSetHandler处理结果集并返回，具体参考4.1：handleResultSets处理结果集。

1.2：更新场景分析

如下的mapper xml:

<parameterMap id="myParameterMap" type="yudaosourcecode.mybatis.dto.TestResultmapCollectionManyDto">
   
   <parameter property="id" javaType="integer" jdbcType="INTEGER"/>
   <parameter property="manyname" javaType="string" jdbcType="VARCHAR"/>
   <parameter property="manynage" javaType="integer" jdbcType="INTEGER"/>
   <parameter property="oneid" javaType="integer" jdbcType="INTEGER"/>
parameterMap>

<insert id="insertByQueryParamter" parameterMap="myParameterMap">
    INSERTINTO `test_resultmap_collection_many`
    (`manyname`,
     `manyage`,
     `oneid`)
    VALUES (#{manyname},
            #{manyage},
            #{oneid})
insert>

当我们执行插入的时候，首先会通过会话对象org.apache.ibatis.session.SqlSession对象执行操作，具体调用的是org.apache.ibatis.session.DefaultSqlSession#insert(String statement, Object parameter)方法，我们就从这里开始分析吧，源码如下：

org.apache.ibatis.session.defaults.DefaultSqlSession#insert(java.lang.String, java.lang.Object)
public int insert(String statement, Object parameter) {
  // 2021-08-27 16:28:51
  return update(statement, parameter);
}

2021-08-27 16:28:51调用更新方法插入也是一种更新，源码如下：

org.apache.ibatis.session.defaults.DefaultSqlSession#update(java.lang.String, java.lang.Object)
public int update(String statement, Object parameter) {
  try {
    dirty = true;
    //根据statement的id获取对应的MappedStatement对象
    MappedStatement ms = configuration.getMappedStatement(statement);
    // 通过执行器更新
    // 2021-08-27 16:39:44
    return executor.update(ms, wrapCollection(parameter));
  } catch (Exception e) {
    throw ExceptionFactory.wrapException("Error updating database.  Cause: " + e, e);
  } finally {
    ErrorContext.instance().reset();
  }
}

2021-08-27 16:39:44处是通过执行器org.apache.ibatis.executor.Executor，执行更新，具体参考1.2.1：通过执行器执行更新操作。

1.2.1：通过执行器执行更新操作

源码如下：

org.apache.ibatis.executor.CachingExecutor#update
public int update(MappedStatement ms, Object parameterObject) throws SQLException {
  // 刷新缓存如果需要的话，具体在本文搜索"2021-08-20 13:56:32"查看
  flushCacheIfRequired(ms);
  // 通过代理执行器类执行更新
  // 2021-08-27 16:43:41
  return delegate.update(ms, parameterObject);
}

2021-08-27 16:43:41处源码如下：

org.apache.ibatis.executor.BaseExecutor#update
public int update(MappedStatement ms, Object parameter) throws SQLException {
  // 创建ErrorContext，并通过构造器方式设置相关需要的属性
  ErrorContext.instance().resource(ms.getResource()).activity("executing an update").object(ms.getId());
  // 检测处理器是否关闭
  if (closed) throw new ExecutorException("Executor was closed.");
  // 更新操作，默认清空一级缓存信息
  clearLocalCache();
  // 执行更新
  // 2021-08-27 17:17:34
  return doUpdate(ms, parameter);
}

2021-08-27 17:17:34处是执行更新，具体参考1.2.2：执行更新。

1.2.2：执行更新

源码如下：

org.apache.ibatis.executor.SimpleExecutor#doUpdate
public int doUpdate(MappedStatement ms, Object parameter) throws SQLException {
  Statement stmt = null;
  try {
    // 获取全局配置文件对应的Configuration对象
    Configuration configuration = ms.getConfiguration();
    // 创建StatementHandler，这里创建的是RoutingStatementHandler
    StatementHandler handler = configuration.newStatementHandler(this, ms, parameter, RowBounds.DEFAULT, null, null);
    // 准备JDBC的Statement对象
    stmt = prepareStatement(handler, ms.getStatementLog());
    // statement处理器使用JDBC的Statement执行更新
    // 2021-08-27 17:38:20
    return handler.update(stmt);
  } finally {
    closeStatement(stmt);
  }
}

2021-08-27 17:38:20处是使用statement处理器执行更新，具体参考1.2.3：使用statement处理器执行更新。

1.2.3：使用statement处理器执行更新

源码如下：

org.apache.ibatis.executor.statement.RoutingStatementHandler#update
public int update(Statement statement) throws SQLException {
  // 2021-08-27 17:40:28
  return delegate.update(statement);
}

2021-08-27 17:40:28处delagate源码如下：

org.apache.ibatis.executor.statement.PreparedStatementHandler#update
public int update(Statement statement) throws SQLException {
  // 强转为java.sql.PreparedStatement
  PreparedStatement ps = (PreparedStatement) statement;
  // 执行更新！！！
  ps.execute();
  // 获取影响的行数
  int rows = ps.getUpdateCount();
  // 通过org.apache.ibatis.mapping.BoundSql获取传入的参数对象
  Object parameterObject = boundSql.getParameterObject();
  // 获取主键生成对象TODO
  KeyGenerator keyGenerator = mappedStatement.getKeyGenerator();
  // 通过主键生成器KeyGenerator生成主键值并设置到传入实体中
  // 2021-08-28 09:33:22
  keyGenerator.processAfter(executor, mappedStatement, ps, parameterObject);
  return rows;
}

2021-08-28 09:33:22处是通过主键生成器org.apache.ibattis.executor.keygen.KeyGenerator，生成主键，具体参考这篇文章。

2：StatementHandler

对应接口为org.apche.ibatis.executor.statement.StatementHandler，源码如下：

org.apache.ibatis.executor.statement.StatementHandler
public interface StatementHandler {
  // 准备操作，可理解为创建JDBC的Statement
  Statement prepare(Connection connection)
      throws SQLException;
  // 设置JDBC的Statment对应的参数
  void parameterize(Statement statement)
      throws SQLException;
  // 设置JDBC的Statement的批量操作
  void batch(Statement statement)
      throws SQLException;
  // 更新操作
  int update(Statement statement)
      throws SQLException;
  // 查询操作
  <E> List<E> query(Statement statement, ResultHandler resultHandler)
      throws SQLException;
  // 获取BoundSql对象
  BoundSql getBoundSql();
  // 获取用于处理参数的参数处理器
  ParameterHandler getParameterHandler();

}

主要实现类如下图：

2.1：通过configuration创建StatementHandler

源码如下：

org.apache.ibatis.session.Configuration#newStatementHandler
public StatementHandler newStatementHandler(Executor executor, MappedStatement mappedStatement, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) {
  // 构造函数创建对象
  // 2021-08-20 16:24:49
  StatementHandler statementHandler = new RoutingStatementHandler(executor, mappedStatement, parameterObject, rowBounds, resultHandler, boundSql);
  // 应用插件，关于插件，暂时忽略
  statementHandler = (StatementHandler) interceptorChain.pluginAll(statementHandler);
  // 返回statementhandler
  return statementHandler;
}

2021-08-20 16:24:49处源码如下：

private final StatementHandler delegate;
public RoutingStatementHandler(Executor executor, MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) {
  // 装饰器设置模式，动态设置被装饰类为对应的StatementHandler
  switch (ms.getStatementType()) {
    case STATEMENT:
      delegate = new SimpleStatementHandler(executor, ms, parameter, rowBounds, resultHandler, boundSql);
      break;
    case PREPARED:
      delegate = new PreparedStatementHandler(executor, ms, parameter, rowBounds, resultHandler, boundSql);
      break;
    case CALLABLE:
      delegate = new CallableStatementHandler(executor, ms, parameter, rowBounds, resultHandler, boundSql);
      break;
    default:
      throw new ExecutorException("Unknown statement type: " + ms.getStatementType());
  }

}

2.2：prepare方法生成Statement

源码如下：

org.apache.ibatis.executor.statement.BaseStatementHandler#prepare
public Statement prepare(Connection connection) throws SQLException {
  // 创建ErrorContext实例，并设置当前执行的sql信息
  ErrorContext.instance().sql(boundSql.getSql());
  // 结果
  Statement statement = null;
  try {
    // 初始化Statement
    // 2021-08-20 17:19:23
    statement = instantiateStatement(connection);
    // 设置超时时长
    // 2021-08-20 17:30:07
    setStatementTimeout(statement);
    // 设置每次获取数据量
    // 2021-08-20 17:32:07
    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);
  }
}

2021-08-20 17:19:23处是初始化statement，具体参考2.2.1：初始化Statement,2021-08-20 17:30:07处是设置Statement的超时时长，源码如下：

protected void setStatementTimeout(Statement stmt) throws SQLException {
  // 分别获取statement中配置的超时时长，和全局配置文件中配置的超时时长，并分别设置
  Integer timeout = mappedStatement.getTimeout();
  Integer defaultTimeout = configuration.getDefaultStatementTimeout();
  if (timeout != null) {
    stmt.setQueryTimeout(timeout);
  } else if (defaultTimeout != null) {
    stmt.setQueryTimeout(defaultTimeout);
  }
}

2021-08-20 17:32:07处是设置fetcheSize，源码如下：

protected void setFetchSize(Statement stmt) throws SQLException {
  // 获取statement中配置的fetchSize，并进行设置
  Integer fetchSize = mappedStatement.getFetchSize();
  if (fetchSize != null) {
    stmt.setFetchSize(fetchSize);
  }
}

2.2.1：初始化Statement

源码如下：

org.apache.ibatis.executor.statement.PreparedStatementHandler#instantiateStatement
// 最终创建的就是JDBC的Statement的API。如PreparedStatement
protected Statement instantiateStatement(Connection connection) throws SQLException {
  // 获取待执行的sql语句
  String sql = boundSql.getSql();
  // 处理Jdbc3KeyGenerator的情况
  if (mappedStatement.getKeyGenerator() instanceof Jdbc3KeyGenerator) {
    String[] keyColumnNames = mappedStatement.getKeyColumns();
    if (keyColumnNames == null) {
      return connection.prepareStatement(sql, PreparedStatement.RETURN_GENERATED_KEYS);
    } else {
      return connection.prepareStatement(sql, keyColumnNames);
    }
  } else if (mappedStatement.getResultSetType() != null) {
    return connection.prepareStatement(sql, mappedStatement.getResultSetType().getValue(), ResultSet.CONCUR_READ_ONLY);
  } else {
    return connection.prepareStatement(sql);
  }
}

2.3：parameterize设置参数信息

源码如下：

org.apache.ibatis.executor.statement.RoutingStatementHandler#parameterize
public void parameterize(Statement statement) throws SQLException {
  // 调用被代理类执行具体设置参数操作
  // 2021-08-20 17:38:10
  delegate.parameterize(statement);
}

2021-08-20 17:38:10处源码是调用具体类设置参数，具体参考2.3.4：设置参数。

2.3.4：设置参数

源码如下：

org.apache.ibatis.executor.statement.PreparedStatementHandler#parameterize
public void parameterize(Statement statement) throws SQLException {
  // 通过paramterHandler具体设置参数
  // 2021-08-20 17:40:08
  parameterHandler.setParameters((PreparedStatement) statement);
}

2021-08-20 17:40:08处是通过ParamterHander设置参数，具体参考3.1：ParameterHandler设置参数。

3：ParameterHandler

该接口用于定义向Statement中设置参数信息的操作，源码如下：

org.apache.ibatis.executor.parameter.ParameterHandler
public interface ParameterHandler {

  Object getParameterObject();

  void setParameters(PreparedStatement ps)
      throws SQLException;

}

3.1：ParameterHandler设置参数

源码如下：

public void setParameters(PreparedStatement ps) throws SQLException {
	// 创建ErrorContext实例，并通过链式调用的方式设置相关参数
	// activity：正在进行的活动信息
	// object：parameterMap的id信息
    ErrorContext.instance().activity("setting parameters").object(mappedStatement.getParameterMap().getId());
    // 获取所有#{xx}对应的参数信息对象
    List<ParameterMapping> parameterMappings = boundSql.getParameterMappings();
    if (parameterMappings != null) {
      // 循环遍历，处理每一个参数的信息 
      for (int i = 0; i < parameterMappings.size(); i++) {
        ParameterMapping parameterMapping = parameterMappings.get(i);
        // 非OUT才处理，一般只有存储过程才会有这种情况
        if (parameterMapping.getMode() != ParameterMode.OUT) {
          // 结果值
          Object value;
          // 获取#{xxx}中配置的属性名称
          String propertyName = parameterMapping.getProperty();
          // 优先使用动态生成的参数
          if (boundSql.hasAdditionalParameter(propertyName)) { 
            value = boundSql.getAdditionalParameter(propertyName);
          } else if (parameterObject == null) {
            value = null;
          } else if (typeHandlerRegistry.hasTypeHandler(parameterObject.getClass())) {
            value = parameterObject;
          // 直接使用用户传入的参数
          } else {
            MetaObject metaObject = configuration.newMetaObject(parameterObject);
            value = metaObject.getValue(propertyName);
          }
          // 获取当前#{xxx}的类型处理器
          TypeHandler typeHandler = parameterMapping.getTypeHandler();
          // 获取#{xxx}中配置的数据库类型
          JdbcType jdbcType = parameterMapping.getJdbcType();
          // 为null的情况
          if (value == null && jdbcType == null) jdbcType = configuration.getJdbcTypeForNull();
          // 使用类型处理的方法设置参数到PreparedStatement中，如果是当前mybatis默认提供的类型处理器
          // 不支持转换到对应的数据库字段类型，如java类型是枚举，而数据库类型是VARCHAR，此时就需要自定义了
          // ,当然一般情况下是不需要的
          typeHandler.setParameter(ps, i + 1, value, jdbcType);
        }
      }
    }
}	

4：ResultSetHandler

该接口用于处理Statement中的结果集，接口定义如下：

org.apache.ibatis.executor.resultset.ResultSetHandler
public interface ResultSetHandler {

  <E> List<E> handleResultSets(Statement stmt) throws SQLException;

  void handleOutputParameters(CallableStatement cs) throws SQLException;

}

4.1：handleResultSets处理结果集

源码如下：

org.apache.ibatis.executor.resultset.DefaultResultSetHandler#handleResultSets
public List<Object> handleResultSets(Statement stmt) throws SQLException {
  // 创建ErrorContext对象，并通过链式调用的方式设置当前正在
  // 进行的活动信息和主体对象信息
  // activity：handling results
  // object：mappedStatment.getId()
  ErrorContext.instance().activity("handling results").object(mappedStatement.getId());
  // 最终的结果，正常如果不是存储过程的话，这里的结果是1，内部是一个集合元素
  final List<Object> multipleResults = new ArrayList<Object>();

  int resultSetCount = 0;
  // 获取第一个ResultSet并封装为ResultSetWraper
  // 正常如果不是存储过程的话，也只有一个，这里是考虑了
  // 存储过程的情况，这里可以忽略存储过程，认为只有一个
  // 2021-08-21 10:23:35
  ResultSetWrapper rsw = getFirstResultSet(stmt);
  // 获取resultMap的信息，id值，字段映射ResultMapping信息，用于生成
  // 结果对象，可以认为只有一个
  List<ResultMap> resultMaps = mappedStatement.getResultMaps();
  // resultMap的个数，认为只有1个
  int resultMapCount = resultMaps.size();
  // 验证配置信息
  // 2021-08-22 10:18:58
  validateResultMapsCount(rsw, resultMapCount);
  // 按照一个resultSet对应一个resultMao的方式依次处理
  // 但是这认为resultSet和resultMap都只有一个就可以了
  while (rsw != null && resultMapCount > resultSetCount) {
    // 获取当前的resultMap信息，即使用标签配置的信息
    ResultMap resultMap = resultMaps.get(resultSetCount);
    // 通过resultMap信息处理当前的resultSet信息，并将结果添加到multipleResults集合中
    // 此处执行完毕之后，当前ResultSet的数据就封装到相关的对象中了，比如封装到List集合中
    // 2021-08-22 10:29:30
    handleResultSet(rsw, resultMap, multipleResults, null);
    // 获取下一个ResultSet，这里认为没有下一个
    rsw = getNextResultSet(stmt);
    // 清空相关辅助获取数据信息
    cleanUpAfterHandlingResultSet();
    // 增加处理结果集的个数
    resultSetCount++;
  }
  // 存储过程才会有值，此处忽略即可
  String[] resultSets = mappedStatement.getResulSets();
  if (resultSets != null) {
    while (rsw != null && resultSetCount < resultSets.length) {
      ResultMapping parentMapping = nextResultMaps.get(resultSets[resultSetCount]);
      if (parentMapping != null) {
        String nestedResultMapId = parentMapping.getNestedResultMapId();
        ResultMap resultMap = configuration.getResultMap(nestedResultMapId);
        handleResultSet(rsw, resultMap, null, parentMapping);
      }
      rsw = getNextResultSet(stmt);
      cleanUpAfterHandlingResultSet();
      resultSetCount++;
    }
  }
  // 如果是单元素，则取首元素返回，源码如下：
  /*
  private List