mybatis源码解读：executor包（结果处理功能）

清疚 2022-10-25 13:00 184阅读 0赞

欢迎关注本人公众号：

![20201220181855568.png][]

mybatis查询结果的处理需要完成的步骤有：

1.处理结果映射中的嵌套映射等逻辑

2.根据映射关系，生成结果对象

3.根据数据库查询记录对结果对象的属性进行赋值

4.将结果对象汇总为List,Map,Cursor等形式。

1.结果处理功能

其中executor包中的result子包将负责完成"将结果对象汇总为List,Map,Cursor等形式"的简单功能的一部分。

result子包中主要有3个类：DefaultResultContext类、DefaultResultHandler类、DefaultMapResultHandler类。

DefaultResultContext类用来存储一个结果对象，对应数据库的一条记录。

public class DefaultResultContext<T> implements ResultContext<T> {
         // 结果对象  private T resultObject;  // 结果计数（表明这是第几个结果对象）  private int resultCount;  // 使用完毕（结果已经被取走）  private boolean stopped;}

DefaultResultHandler类负责将DefaultResultContext类中的结果对象聚合成一个List返回。

public class DefaultResultHandler implements ResultHandler<Object> {
         private final List<Object> list;  public DefaultResultHandler() {
           list = new ArrayList<>();  }  @SuppressWarnings("unchecked")  public DefaultResultHandler(ObjectFactory objectFactory) {
           list = objectFactory.create(List.class);  }  @Override  public void handleResult(ResultContext<?> context) {
           list.add(context.getResultObject());  }  public List<Object> getResultList() {
           return list;  }}

DefualtMapResultHandler类负责将DefaultResultContext类中的结果对象聚合成一个Map返回。

public class DefaultMapResultHandler<K, V> implements ResultHandler<V> {
         // Map形式的映射结果  private final Map<K, V> mappedResults;  // Map的键。由用户指定，是结果对象中的某个属性名  private final String mapKey;  // 对象工厂  private final ObjectFactory objectFactory;  // 对象包装工厂  private final ObjectWrapperFactory objectWrapperFactory;  // 反射工厂  private final ReflectorFactory reflectorFactory;   /**   * 处理一个结果   * @param context 一个结果   */  @Override  public void handleResult(ResultContext<? extends V> context) {
           // 从结果上下文中取出结果对象    final V value = context.getResultObject();    // 获得结果对象的元对象    final MetaObject mo = MetaObject.forObject(value, objectFactory, objectWrapperFactory, reflectorFactory);    // 基于元对象取出key对应的值    final K key = (K) mo.getValue(mapKey);    mappedResults.put(key, value);  }  public Map<K, V> getMappedResults() {
           return mappedResults;  }}

2.结果集处理功能

其中executor包中的resultset子包负责的功能有：

1.处理结果映射中的嵌套映射等逻辑

2.根据映射关系，生成结果对象

3.根据数据库查询记录对结果对象的属性进行赋值

resultset子包主要有ResultSetWrapper结果封装类，ResultSetHandler和DefaultResultSetHandler分别是结果集处理器的接口和实现类。

ResultSetWrapper类是对java.sql.ResultSet接口的进一步封装，在此基础上扩展出更多的功能，用到了装饰器模式。

public class ResultSetWrapper {
         // 被装饰的resultSet对象  private final ResultSet resultSet;  // 类型处理器注册表  private final TypeHandlerRegistry typeHandlerRegistry;  // resultSet中各个列对应的列名列表  private final List<String> columnNames = new ArrayList<>();  // resultSet中各个列对应的Java类型名列表  private final List<String> classNames = new ArrayList<>();  // resultSet中各个列对应的JDBC类型列表  private final List<JdbcType> jdbcTypes = new ArrayList<>();  // <列名，< java类型，TypeHandler>>  // 这里的数据是不断组建起来的。java类型传入，然后去全局handlerMap索引java类型的handler放入map,然后在赋给列名。  // 每个列后面的java类型不应该是唯一的么？不是的  //    <resultMap id="userMapFull" type="com.example.demo.UserBean">  //        <result property="id" column="id"/>  //        <result property="schoolName" column="id"/>  //    </resultMap>  // 上面就可能不唯一，同一个列可以给不同的java属性  // 类型与类型处理器的映射表。结构为：Map<列名，Map<Java类型，类型处理器>>  private final Map<String, Map<Class<?>, TypeHandler<?>>> typeHandlerMap = new HashMap<>();  // 记录了所有的有映射关系的列。  // key为resultMap的id，后面的List为该resultMap中有映射的列的列表  // <resultMap的id，List<对象映射的列名>>  // 记录了所有的有映射关系的列。结构为：Map<resultMap的id，List<对象映射的列名>>  private final Map<String, List<String>> mappedColumnNamesMap = new HashMap<>();  // 记录了所有的无映射关系的列。  // key为resultMap的id，后面的List为该resultMap中无映射的列的列表  //  // <resultMap的id : List<对象映射的列名>>  // 记录了所有的无映射关系的列。结构为：Map<resultMap的id，List<对象映射的列名>>  private final Map<String, List<String>> unMappedColumnNamesMap = new HashMap<>();   /**   * 如果通过列名、属性类型找到之前存好的handler，则就是它   * 如果通过列名没找到：   *  1、通过列名找到其jdbc类型   *  2、根据java类型、jdbc类型，找到对应的handler   *   * @param propertyType   * @param columnName   * @return   */  public TypeHandler<?> getTypeHandler(Class<?> propertyType, String columnName) {
           TypeHandler<?> handler = null;    Map<Class<?>, TypeHandler<?>> columnHandlers = typeHandlerMap.get(columnName);    if (columnHandlers == null) {
             columnHandlers = new HashMap<>();      typeHandlerMap.put(columnName, columnHandlers);    } else {
             handler = columnHandlers.get(propertyType);    }    // 如果之前没有，则找到后放入备用    if (handler == null) {
             JdbcType jdbcType = getJdbcType(columnName);      // 根据类型去全局寻找对应的handler      handler = typeHandlerRegistry.getTypeHandler(propertyType, jdbcType);      if (handler == null || handler instanceof UnknownTypeHandler) {
               final int index = columnNames.indexOf(columnName);        final Class<?> javaType = resolveClass(classNames.get(index));        if (javaType != null && jdbcType != null) {
                 handler = typeHandlerRegistry.getTypeHandler(javaType, jdbcType);        } else if (javaType != null) {
                 handler = typeHandlerRegistry.getTypeHandler(javaType);        } else if (jdbcType != null) {
                 handler = typeHandlerRegistry.getTypeHandler(jdbcType);        }      }      if (handler == null || handler instanceof UnknownTypeHandler) {
               handler = new ObjectTypeHandler();      }      columnHandlers.put(propertyType, handler);    }    return handler;  }      }

ResultSetHandler是结果集处理器接口

public interface ResultSetHandler {
         // 将Statement的执行结果处理为List  <E> List<E> handleResultSets(Statement stmt) throws SQLException;  // 将Statement的执行结果处理为Map  <E> Cursor<E> handleCursorResultSets(Statement stmt) throws SQLException;  // 处理存储过程的输出结果  void handleOutputParameters(CallableStatement cs) throws SQLException;}

DefaultResultSetHandler类作为ResultSetHandler接口的默认也是唯一的实现类

/**   * 处理Statement得到的多结果集（也可能是单结果集，这是多结果集的一种简化形式），最终得到结果列表   * @param stmt Statement语句   * @return 结果列表   * @throws SQLException   */  @Override  public List<Object> handleResultSets(Statement stmt) throws SQLException {
           ErrorContext.instance().activity("handling results").object(mappedStatement.getId());    // 用以存储处理结果的列表    final List<Object> multipleResults = new ArrayList<>();    // 可能会有多个结果集，该变量用来对结果集进行计数    int resultSetCount = 0;    // 可能会有多个结果集，先取出第一个结果集    ResultSetWrapper rsw = getFirstResultSet(stmt);    // 查询语句对应的resultMap节点，可能含有多个    List<ResultMap> resultMaps = mappedStatement.getResultMaps();    int resultMapCount = resultMaps.size();    // 合法性校验（存在输出结果集的情况下，resultMapCount不能为0）    validateResultMapsCount(rsw, resultMapCount);    // 循环遍历每一个设置了resultMap的结果集    while (rsw != null && resultMapCount > resultSetCount) {
             // 获得当前结果集对应的resultMap      ResultMap resultMap = resultMaps.get(resultSetCount);      // 进行结果集的处理      handleResultSet(rsw, resultMap, multipleResults, null);      // 获取下一结果集      rsw = getNextResultSet(stmt);      // 清理上一条结果集的环境      cleanUpAfterHandlingResultSet();      resultSetCount++;    }    // 获取多结果集中所有结果集的名称    String[] resultSets = mappedStatement.getResultSets();    if (resultSets != null) {
             // 循环遍历每一个没有设置resultMap的结果集      while (rsw != null && resultSetCount < resultSets.length) {
               // 获取该结果集对应的父级resultMap中的resultMapping（注：resultMapping用来描述对象属性的映射关系）        ResultMapping parentMapping = nextResultMaps.get(resultSets[resultSetCount]);        if (parentMapping != null) {
                 // 获取被嵌套的resultMap的编号          String nestedResultMapId = parentMapping.getNestedResultMapId();          ResultMap resultMap = configuration.getResultMap(nestedResultMapId);          // 处理嵌套映射          handleResultSet(rsw, resultMap, null, parentMapping);        }        rsw = getNextResultSet(stmt);        cleanUpAfterHandlingResultSet();        resultSetCount++;      }    }    // 判断是否是单结果集：如果是则返回结果列表；如果否则返回结果集列表    return collapseSingleResultList(multipleResults);  }    /**   * 处理单一的结果集   * @param rsw ResultSet的包装   * @param resultMap resultMap节点的信息   * @param multipleResults 用来存储处理结果的list   * @param parentMapping   * @throws SQLException   */  private void handleResultSet(ResultSetWrapper rsw, ResultMap resultMap, List<Object> multipleResults, ResultMapping parentMapping) throws SQLException {
           try {
             if (parentMapping != null) { // 嵌套的结果        // 向子方法传入parentMapping。处理结果中的记录。        handleRowValues(rsw, resultMap, null, RowBounds.DEFAULT, parentMapping);      } else { // 非嵌套的结果        if (resultHandler == null) {
                 // defaultResultHandler能够将结果对象聚合成一个List返回          DefaultResultHandler defaultResultHandler = new DefaultResultHandler(objectFactory);          // 处理结果中的记录。          handleRowValues(rsw, resultMap, defaultResultHandler, rowBounds, null);          multipleResults.add(defaultResultHandler.getResultList());        } else {
                 handleRowValues(rsw, resultMap, resultHandler, rowBounds, null);        }      }    } finally {
             closeResultSet(rsw.getResultSet());    }  }     /**   * 处理单结果集中的属性   * @param rsw 单结果集的包装   * @param resultMap 结果映射   * @param resultHandler 结果处理器   * @param rowBounds 翻页限制条件   * @param parentMapping 父级结果映射   * @throws SQLException   */  public void handleRowValues(ResultSetWrapper rsw, ResultMap resultMap, ResultHandler<?> resultHandler,                              RowBounds rowBounds, ResultMapping parentMapping) throws SQLException {
           if (resultMap.hasNestedResultMaps()) {
             // 前置校验      ensureNoRowBounds();      checkResultHandler();      // 处理嵌套映射      handleRowValuesForNestedResultMap(rsw, resultMap, resultHandler, rowBounds, parentMapping);    } else {
             // 处理单层映射      handleRowValuesForSimpleResultMap(rsw, resultMap, resultHandler, rowBounds, parentMapping);    }  }     /**   * 处理非嵌套映射的结果集   * @param rsw 结果集包装   * @param resultMap 结果映射   * @param resultHandler 结果处理器   * @param rowBounds 翻页限制条件   * @param parentMapping 父级结果映射   * @throws SQLException   */  private void handleRowValuesForSimpleResultMap(ResultSetWrapper rsw, ResultMap resultMap, ResultHandler<?> resultHandler, RowBounds rowBounds, ResultMapping parentMapping)      throws SQLException {
           DefaultResultContext<Object> resultContext = new DefaultResultContext<>();    // 当前要处理的结果集    ResultSet resultSet = rsw.getResultSet();    // 根据翻页配置，跳过指定的行    skipRows(resultSet, rowBounds);    // 持续处理下一条结果，判断条件为：还有结果需要处理 && 结果集没有关闭 && 还有下一条结果    while (shouldProcessMoreRows(resultContext, rowBounds) && !resultSet.isClosed() && resultSet.next()) {
             // 经过鉴别器鉴别，确定经过鉴别器分析的最终要使用的resultMap      ResultMap discriminatedResultMap = resolveDiscriminatedResultMap(resultSet, resultMap, null);      // 拿到了一行记录，并且将其转化为一个对象      Object rowValue = getRowValue(rsw, discriminatedResultMap, null);      // 把这一行记录转化出的对象存起来      storeObject(resultHandler, resultContext, rowValue, parentMapping, resultSet);    }  }    /**   * 存储当前结果对象   * @param resultHandler 结果处理器   * @param resultContext 结果上下文   * @param rowValue 结果对象   * @param parentMapping 父级结果映射   * @param rs 结果集   * @throws SQLException   */  private void storeObject(ResultHandler<?> resultHandler, DefaultResultContext<Object> resultContext, Object rowValue, ResultMapping parentMapping, ResultSet rs) throws SQLException {
           if (parentMapping != null) {
             // 存在父级，则将这一行记录对应的结果对象绑定到父级结果上      linkToParents(rs, parentMapping, rowValue);    } else {
             // 使用resultHandler聚合该对象      callResultHandler(resultHandler, resultContext, rowValue);    }  }

可见在HandleResultSets方法中完成了生成结果对象，为结果对象属性赋值，将结果对象进行聚合或绑定等重要操作。

[20201220181855568.png]: /images/20221024/3d33cdaa261e4b7eb70d7a2def8fdce2.png