mybatis collection和association的区别解析

public class Test {

  public static void main(String[] args) throws IOException {

    try (InputStream inputStream = Resources.getResourceAsStream("mybatis-config.xml")) {
      // 构建session工厂 DefaultsqlSessionFactory
      SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
      SqlSession sqlSession = sqlSessionFactory.openSession();
      UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
      UserDO userDO = userMapper.getByUserId(1);
      System.out.println(userDO);
    }
  }

}

 public void handleRowValues(ResultSetWrapper rsw, ResultMap resultMap, ResultHandler<?> resultHandler, RowBounds rowBounds, ResultMapping parentMapping) throws SQLException {
    // 是否有嵌套的resultMaps
    if (resultMap.hasNestedResultMaps()) {
      ensureNoRowBounds();
      checkResultHandler();
      handleRowValuesForNestedResultMap(rsw, resultMap, resultHandler, rowBounds, parentMapping);
    } else {
      // 无嵌套
      handleRowValuesForSimpleResultMap(rsw, resultMap, resultHandler, rowBounds, parentMapping);
    }
  }

 private void handleRowValuesForNestedResultMap(ResultSetWrapper rsw, ResultMap resultMap, ResultHandler<?> resultHandler, RowBounds rowBounds, ResultMapping parentMapping) throws SQLException {
    final DefaultResultContext<Object> resultContext = new DefaultResultContext<>();
    ResultSet resultSet = rsw.getResultSet();
    // 跳过offset行
    skipRows(resultSet, rowBounds);
    // 上一次获取的数据
    Object rowValue = previousRowValue;
    // 已获取记录数量小于limit
    while (shouldProceSSMoreRows(resultContext, rowBounds) && !resultSet.isClosed() && resultSet.next()) {
      // 鉴别器解析
      final ResultMap discriminatedResultMap = resolveDiscriminatedResultMap(resultSet, resultMap, null);
      // 创建缓存key resultMapid + （columnName + columnValue）....
      final CacheKey rowKey = createRowKey(discriminatedResultMap, rsw, null);
      // 部分对象（可能存在对象内容缺失未完全合并）
      Object partialObject = nestedResultObjects.get(rowKey);
      // issue #577 && #542
      // 关于resultOrdered的理解，举例若查询得到四条记录a,a,b,a , 相同可以合并。
      // 那么当resultOrdered=true时，最后可以得到三条记录，第一条和第二条合并成一条、第三条单独一条、第四条也是单独一条记录
      // resultOrdered=false时，最后可以得到两条记录，第一条、第二条和第四条会合并成一条，第三条单独一条记录
      // 另外存储到resultHandler的时机也不一样，resultOrdered=true是等遇到不可合并的记录的时候才把之前已经合并的记录存储，
      // 而resultOrdered=false是直接存储的后续有合并的记录再处理添加到集合属性中
      if (mappedStatement.isResultOrdered()) {
        // partialObject为null，说明这一条记录不可与上一条记录进行合并了，那么清空nestedResultObjects防止之后出现有可合并的记录的时候继续合并
        // 然后将记录存储到resultHandler里面
        if (partialObject == null && rowValue != null) {
          nestedResultObjects.clear();
          storeObject(resultHandler, resultContext, rowValue, parentMapping, resultSet);
        }
        rowValue = getRowValue(rsw, discriminatedResultMap, rowKey, null, partialObject);
      } else {
        // 处理resultSet的当前这一条记录
        rowValue = getRowValue(rsw, discriminatedResultMap, rowKey, null, partialObject);
        if (partialObject == null) {
          // 将记录存储到resultHandler里面
          storeObject(resultHandler, resultContext, rowValue, parentMapping, resultSet);
        }
      }
    }

private Object getRowValue(ResultSetWrapper rsw, ResultMap resultMap, CacheKey combinedKey, String columnPrefix, Object partialObject) throws SQLException {
    final String resultMapId = resultMap.getId();
    Object rowValue = partialObject;
    // rowValue不等于null时，说明此条记录可合并
    if (rowValue != null) {
      final MetaObject metaObject = configuration.newMetaObject(rowValue);
      putAncestor(rowValue, resultMapId);
      applyNestedResultMappings(rsw, resultMap, metaObject, columnPrefix, combinedKey, false);
      ancestorObjects.remove(resultMapId);
    } else {
      final ResultLoaderMap lazyLoader = new ResultLoaderMap();
      // 创建result接收对象，本例中是UserDO对象
      rowValue = createResultObject(rsw, resultMap, lazyLoader, columnPrefix);
      if (rowValue != null && !hasTypeHandlerForResultObject(rsw, resultMap.getType())) {
        final MetaObject metaObject = configuration.newMetaObject(rowValue);
        boolean foundValues = this.useConstructORMappings;
        // 是否将查询出来的字段全部映射 默认false
        if (shouldApplyAutomaticMappings(resultMap, true)) {
          foundValues = applyAutomaticMappings(rsw, resultMap, metaObject, columnPrefix) || foundValues;
        }
        // 设置需要映射的属性值，不管有嵌套ResultMap的
        foundValues = applyPropertyMappings(rsw, resultMap, metaObject, lazyLoader, columnPrefix) || foundValues;
        // 存放第一条数据
        putAncestor(rowValue, resultMapId);
        // 处理有嵌套的resultMapping
        foundValues = applyNestedResultMappings(rsw, resultMap, metaObject, columnPrefix, combinedKey, true) || foundValues;
        ancestorObjects.remove(resultMapId);
        foundValues = lazyLoader.size() > 0 || foundValues;
        rowValue = foundValues || configuration.isReturnInstanceForEmptyRow() ? rowValue : null;
      }
      // 将最终结果放入到nestedResultObjects中
      if (combinedKey != CacheKey.NULL_CACHE_KEY) {
        nestedResultObjects.put(combinedKey, rowValue);
      }
    }
    return rowValue;
  }

private boolean applyNestedResultMappings(ResultSetWrapper rsw, ResultMap resultMap, MetaObject metaObject, String parentPrefix, CacheKey parentRowKey, boolean newObject) {
    boolean foundValues = false;
    for (ResultMapping resultMapping : resultMap.getPropertyResultMappings()) {
      // 嵌套id
      final String nestedResultMapId = resultMapping.getNestedResultMapId();
      // resultMapping有嵌套的map才继续 <association> <collection>
      if (nestedResultMapId != null && resultMapping.getResultSet() == null) {
        try {
          final String columnPrefix = getColumnPrefix(parentPrefix, resultMapping);
          // 获取嵌套（经过一次鉴权）的ResultMap
          final ResultMap nestedResultMap = getNestedResultMap(rsw.getResultSet(), nestedResultMapId, columnPrefix);
          if (resultMapping.getColumnPrefix() == null) {
            // try to fill circular reference only when columnPrefix
            // is not specified for the nested result map (issue #215)
            Object ancestorObject = ancestorObjects.get(nestedResultMapId);
            if (ancestorObject != null) {
              if (newObject) {
                linkObjects(metaObject, resultMapping, ancestorObject); // issue #385
              }
              continue;
            }
          }
          // 构建嵌套map的key
          final CacheKey rowKey = createRowKey(nestedResultMap, rsw, columnPrefix);
          // 合并cacheKey
          final CacheKey combinedKey = combineKeys(rowKey, parentRowKey);
          // 尝试获取之前是否已经创建过
          Object rowValue = nestedResultObjects.get(combinedKey);
          boolean knownValue = rowValue != null;
          // 实例化集合属性 list复制为空列表
          instantiateCollectionPropertyIfAppropriate(resultMapping, metaObject); // mandatory
          // 存在指定的非空列存在空值则返回false
          if (anyNotNullColumnHasValue(resultMapping, columnPrefix, rsw)) {
            rowValue = getRowValue(rsw, nestedResultMap, combinedKey, columnPrefix, rowValue);
            if (rowValue != null && !knownValue) {
              // 合并记录，设置对象-association或将对象添加到集合属性中-collection
              linkObjects(metaObject, resultMapping, rowValue);
              foundValues = true;
            }
          }
        } catch (SQLException e) {
          throw new ExecutorException("Error getting nested result map values for '" + resultMapping.getProperty() + "'.  Cause: " + e, e);
        }
      }
    }
    return foundValues;
  }

private void linkObjects(MetaObject metaObject, ResultMapping resultMapping, Object rowValue) {
    final Object collectionProperty = instantiateCollectionPropertyIfAppropriate(resultMapping, metaObject);
    // 属性是集合进行添加 <collection>
    if (collectionProperty != null) {
      final MetaObject targetMetaObject = configuration.newMetaObject(collectionProperty);
      targetMetaObject.add(rowValue);
    } else {
      // 否则是对象 直接进行setter设置 <association>
      metaObject.setValue(resultMapping.getProperty(), rowValue);
    }
  }