<resultMap id="usermap" type="user" autoMapping="true">
    <!--關(guān)閉自動映射，那么沒有指定的列名不會出現(xiàn)在結(jié)果集中-->
    <id property="id" column="id"/>
    <result property="username" column="username"/>
    <result property="birthday" column="birthday"/>
    <result property="password" column="password"/>
</resultMap>

public class ResultMap {
  private Configuration configuration;
  // 唯一ID，一般是namespace+resultMap標簽的ID
  private String id;
  // 對應(yīng)的Java類型
  private Class<?> type;
  // resultMap標簽中的result標簽的集合
  private List<ResultMapping> resultMappings;
  // resultMap標簽中的id標簽的集合
  private List<ResultMapping> idResultMappings;
  // resultMap標簽中的constructor標簽的集合
  private List<ResultMapping> constructorResultMappings;
  // resultMap標簽中所有子標簽的集合
  private List<ResultMapping> propertyResultMappings;
  // 結(jié)果集中列名
  private Set<String> mappedColumns;
  // 對應(yīng)的Java對象的屬性名
  private Set<String> mappedProperties;
  // discriminator鑒別器會單獨被解析成該對象
  private Discriminator discriminator;
  // 是否是嵌套映射
  private boolean hasNestedResultMaps;
  // 是否嵌套查詢
  private boolean hasNestedQueries;
  // 是否自動映射
  private Boolean autoMapping;
}

public class DefaultResultHandler implements ResultHandler<Object> {
  private final List<Object> list;
  @Override
  public void handleResult(ResultContext<?> context) {
    list.add(context.getResultObject());
  }
  public List<Object> getResultList() {
    return list;
  }
}

public class DefaultResultContext<T> implements ResultContext<T> {
  private T resultObject;
  private int resultCount;
  private boolean stopped;
  public T getResultObject() {
    return resultObject;
  }
  public void nextResultObject(T resultObject) {
    resultCount++;
    this.resultObject = resultObject;
  }
}

private void handleResultSet(ResultSetWrapper rsw, ResultMap resultMap, List<Object> multipleResults, ResultMapping parentMapping) throws SQLException {
    if (parentMapping != null) {
      // 1. 處理resultSets標簽的邏輯
      handleRowValues(rsw, resultMap, null, RowBounds.DEFAULT, parentMapping);
    } else {
      // 2. 正常處理resultMap標簽。將結(jié)果集中的記錄映射為指定對象?？赡苌婕暗角短子成?。
      if (resultHandler == null) {
        // 默認都會走進該分支。
        // ResultSet是個集合嘛，那Result自然就是集合中的一條記錄啦。DefaultResultHandler是用來處理單條Result記錄的。
        DefaultResultHandler defaultResultHandler = new DefaultResultHandler(objectFactory);
        // 處理多行記錄的方法（重要?。。。。。。。?
        handleRowValues(rsw, resultMap, defaultResultHandler, rowBounds, null);
        multipleResults.add(defaultResultHandler.getResultList());
      } else {
        // 如果用戶自定義了 resultHandler 使用用戶自定義的
        handleRowValues(rsw, resultMap, resultHandler, rowBounds, null);
      }
    }
}

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);
  }
}

private void handleRowValuesForSimpleResultMap(ResultSetWrapper rsw, ResultMap resultMap, ResultHandler<?> resultHandler, RowBounds rowBounds, ResultMapping parentMapping)
    throws SQLException {
  // 第一步：經(jīng)過resultHandler處理過后，每行記錄會被映射成一個對象。該對象暫存在 這個Result上下文中。（暫存DefaultResultContext）
  DefaultResultContext<Object> resultContext = new DefaultResultContext<>();
  ResultSet resultSet = rsw.getResultSet();
  // 跳過指定的偏移量，相當(dāng)于limit只不過他是內(nèi)存分頁，一般用不到（RowBounds中指定的偏移量）
  skipRows(resultSet, rowBounds);
  // 第二步：結(jié)果集中會有很多記錄，通過該循環(huán)處理結(jié)果集中的每條記錄。每個記錄最后都會存儲到ResultHandler的List集合中。
  while (shouldProcessMoreRows(resultContext, rowBounds) && !resultSet.isClosed() && resultSet.next()) {
    // 處理discrimination標簽。類似于Java中的switch語法。如果resultMap標簽有鑒別器。則根據(jù)case的情況動態(tài)的獲取resultMap映射結(jié)果集
    ResultMap discriminatedResultMap = resolveDiscriminatedResultMap(resultSet, resultMap, null);
    // 第三步：獲取記錄映射的對象（重要?。。。。。。?
    Object rowValue = getRowValue(rsw, discriminatedResultMap, null);
    // 第四步：把對象存儲到上下文中。
    storeObject(resultHandler, resultContext, rowValue, parentMapping, resultSet);
  }
}

private Object getRowValue(ResultSetWrapper rsw, ResultMap resultMap, String columnPrefix) throws SQLException {
  final ResultLoaderMap lazyLoader = new ResultLoaderMap();
  // （重要方法?。。。。。。。。。。。。┍热绶祷亟Y(jié)果ResultType指定的是map，那么這里就會創(chuàng)建一個空Map對象，下面的if才是給map里添加元素。
  Object rowValue = createResultObject(rsw, resultMap, lazyLoader, columnPrefix);
  if (rowValue != null && !hasTypeHandlerForResultObject(rsw, resultMap.getType())) {
    final MetaObject metaObject = configuration.newMetaObject(rowValue);
    boolean foundValues = this.useConstructorMappings;
    if (shouldApplyAutomaticMappings(resultMap, false)) {
      // （重要方法?。。。。。。。。。。。。┦欠駪?yīng)該自動映射。比如說SQL返回結(jié)果集有10列，但是resultMap只配置了9個字段，剩下的那個字段，如果滿足返回列與映射列名稱相同，就會自動進行映射
      foundValues = applyAutomaticMappings(rsw, resultMap, metaObject, columnPrefix) || foundValues;
    }
    // （重要方法！?。。。。。。。。。。。┨幚韗esultMap標簽中的映射。把結(jié)果集根據(jù)resultMap中的映射關(guān)系生成最終的結(jié)果對象。屬性會被設(shè)置到metaObject中
    foundValues = applyPropertyMappings(rsw, resultMap, metaObject, lazyLoader, columnPrefix) || foundValues;
    foundValues = lazyLoader.size() > 0 || foundValues;
    // isReturnInstanceForEmptyRow是否啟用。如果開啟則返回空對象，否則返回null。
    // 注：這個空對象依賴于createResultObject方法創(chuàng)建出的對象是空還是null。
    rowValue = foundValues || configuration.isReturnInstanceForEmptyRow() ? rowValue : null;
  }
  return rowValue;
}

private void storeObject(ResultHandler<?> resultHandler, DefaultResultContext<Object> resultContext, Object rowValue, ResultMapping parentMapping, ResultSet rs) throws SQLException {
  if (parentMapping != null) {
    // 處理ResultSets標簽時走這個分支
    linkToParents(rs, parentMapping, rowValue);
  } else {
    callResultHandler(resultHandler, resultContext, rowValue);
  }
}
private void callResultHandler(ResultHandler<?> resultHandler, DefaultResultContext<Object> resultContext, Object rowValue) {
  resultContext.nextResultObject(rowValue);
  ((ResultHandler<Object>) resultHandler).handleResult(resultContext);
}

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();
  skipRows(resultSet, rowBounds);
  Object rowValue = previousRowValue;
  // 第二步: 遍歷結(jié)果集
  while (shouldProcessMoreRows(resultContext, rowBounds) && !resultSet.isClosed() && resultSet.next()) {
    final ResultMap discriminatedResultMap = resolveDiscriminatedResultMap(resultSet, resultMap, null);
    // 嵌套映射中的結(jié)果都會被存入到nestedResultObjects中。這里的CacheKey就是緩存對象唯一標識
    final CacheKey rowKey = createRowKey(discriminatedResultMap, rsw, null);
    // 映射過程中的對象也會被存入在此。
    Object partialObject = nestedResultObjects.get(rowKey);
    // 通常會走到該分支。獲取一行記錄處理后的對象（有可能是半成品）
    rowValue = getRowValue(rsw, discriminatedResultMap, rowKey, null, partialObject);
    if (partialObject == null) {
      storeObject(resultHandler, resultContext, rowValue, parentMapping, resultSet);
    }
  }
  if (rowValue != null && mappedStatement.isResultOrdered() && shouldProcessMoreRows(resultContext, rowBounds)) {
    storeObject(resultHandler, resultContext, rowValue, parentMapping, resultSet);
    previousRowValue = null;
  } else if (rowValue != null) {
    previousRowValue = rowValue;
  }
}

private Object getRowValue(ResultSetWrapper rsw, ResultMap resultMap, CacheKey combinedKey, String columnPrefix, Object partialObject) throws SQLException {
  final String resultMapId = resultMap.getId();
  Object rowValue = partialObject;
  // 映射第一次肯定一定為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();
    rowValue = createResultObject(rsw, resultMap, lazyLoader, columnPrefix);
    if (rowValue != null && !hasTypeHandlerForResultObject(rsw, resultMap.getType())) {
      final MetaObject metaObject = configuration.newMetaObject(rowValue);
      boolean foundValues = this.useConstructorMappings;
      if (shouldApplyAutomaticMappings(resultMap, true)) {
        foundValues = applyAutomaticMappings(rsw, resultMap, metaObject, columnPrefix) || foundValues;
      }
      foundValues = applyPropertyMappings(rsw, resultMap, metaObject, lazyLoader, columnPrefix) || foundValues;
      putAncestor(rowValue, resultMapId);
      foundValues = applyNestedResultMappings(rsw, resultMap, metaObject, columnPrefix, combinedKey, true) || foundValues;
      ancestorObjects.remove(resultMapId);
      foundValues = lazyLoader.size() > 0 || foundValues;
      rowValue = foundValues || configuration.isReturnInstanceForEmptyRow() ? rowValue : null;
    }
    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()) {
    final String nestedResultMapId = resultMapping.getNestedResultMapId();
    if (nestedResultMapId != null && resultMapping.getResultSet() == null) {
      // 獲取內(nèi)層對象
      rowValue = getRowValue(rsw, nestedResultMap, combinedKey, columnPrefix, rowValue);
      if (rowValue != null && !knownValue) {
        // 把內(nèi)層對象關(guān)聯(lián)到外層對象
        linkObjects(metaObject, resultMapping, rowValue);
        foundValues = true;
      }
    }
  }
  return foundValues;
}