解析封装
ResultMap 是和结果集相关的东西，最初在解析 XML 的时候，于 parseStatementNode 方法中，针对每一个 select 节点进行解析，转换为 MappedStatement（类似 Spring 的 bean 配置和 BeanDefinition 的关系）。
在 MapperBuilderAssistant 的 addMappedStatement 方法中，构建完statementBuilder，会调用 setStatementResultMap 方法给其设置 ResultMap。
setStatementResultMap(resultMap, resultType, resultSetType, statementBuilder);
private void setStatementResultMap(
String resultMap,
Class<?> resultType,
ResultSetType resultSetType,
MappedStatement.Builder statementBuilder) {
resultMap = applyCurrentNamespace(resultMap, true);
List<ResultMap> resultMaps = new ArrayList<ResultMap>();
if (resultMap != null) {
String[] resultMapNames = resultMap.split(",");
for (String resultMapName : resultMapNames) {
try {
resultMaps.add(configuration.getResultMap(resultMapName.trim()));
} catch (IllegalArgumentException e) {
throw new IncompleteElementException("Could not find result map " + resultMapName, e);
}
}
} else if (resultType != null) {
ResultMap.Builder inlineResultMapBuilder = new ResultMap.Builder(
configuration,
statementBuilder.id() + "-Inline",
resultType,
new ArrayList<ResultMapping>(),
null);
resultMaps.add(inlineResultMapBuilder.build());
}
statementBuilder.resultMaps(resultMaps);
statementBuilder.resultSetType(resultSetType);
}首先检查 resultMap，根据名称去 configuration 中取出对应的 resultMap 放到集合中；
如果 resultMap 不存在，就检查 resultType ，然后利用这个 resultType 构造一个 resultMap，如果两个都没有，那就走着瞧（resultMaps集合为空）。
中期调用
在 PreparedStatementHandler 的 query 方法中：
public <E> List<E> query(Statement statement, ResultHandler resultHandler) throws SQLException {
PreparedStatement ps = (PreparedStatement) statement;
ps.execute();
return resultSetHandler.<E> handleResultSets(ps);
}
而 resultSetHandler 于基类 BaseStatementHandler 中构造：
this.resultSetHandler = configuration.newResultSetHandler(executor, mappedStatement, rowBounds, parameterHandler, resultHandler, boundSql);
根据是否有嵌套的 ResultMaps 来确定创建 NestedResultSetHandler 还是 FastResultSetHandler:
public ResultSetHandler newResultSetHandler(Executor executor, MappedStatement mappedStatement, RowBounds rowBounds, ParameterHandler parameterHandler,
ResultHandler resultHandler, BoundSql boundSql) {
ResultSetHandler resultSetHandler = mappedStatement.hasNestedResultMaps() ? new NestedResultSetHandler(executor, mappedStatement, parameterHandler, resultHandler, boundSql,
rowBounds) : new FastResultSetHandler(executor, mappedStatement, parameterHandler, resultHandler, boundSql, rowBounds);
resultSetHandler = (ResultSetHandler) interceptorChain.pluginAll(resultSetHandler);
return resultSetHandler;
}影响这个判断的有几个点：
- 解析时期
public Builder resultMaps(List<ResultMap> resultMaps) {
mappedStatement.resultMaps = resultMaps;
for (ResultMap resultMap : resultMaps) {
mappedStatement.hasNestedResultMaps = mappedStatement.hasNestedResultMaps || resultMap.hasNestedResultMaps();
}
return this;
}- getBoundSql时期
for (ParameterMapping pm : boundSql.getParameterMappings()) {
String rmId = pm.getResultMapId();
if (rmId != null) {
ResultMap rm = configuration.getResultMap(rmId);
if (rm != null) {
hasNestedResultMaps |= rm.hasNestedResultMaps();
}
}
}后期处理
NestedResultSetHandler继承自FastResultSetHandler ，二者在handleResultSets是一致的（只是重写了 handleRowValues 等方法）：
public List<Object> handleResultSets(Statement stmt) throws SQLException {
final List<Object> multipleResults = new ArrayList<Object>();
final List<ResultMap> resultMaps = mappedStatement.getResultMaps();
int resultMapCount = resultMaps.size();
int resultSetCount = 0;
ResultSet rs = stmt.getResultSet();
while (rs == null) {
// move forward to get the first resultset in case the driver
// doesn't return the resultset as the first result (HSQLDB 2.1)
if (stmt.getMoreResults()) {
rs = stmt.getResultSet();
} else {
if (stmt.getUpdateCount() == -1) {
// no more results. Must be no resultset
break;
}
}
}
// 验证是否定义了resultType或者resultMap
validateResultMapsCount(rs, resultMapCount);
while (rs != null && resultMapCount > resultSetCount) {
final ResultMap resultMap = resultMaps.get(resultSetCount);
ResultColumnCache resultColumnCache = new ResultColumnCache(rs.getMetaData(), configuration);
handleResultSet(rs, resultMap, multipleResults, resultColumnCache);
rs = getNextResultSet(stmt);
cleanUpAfterHandlingResultSet();
resultSetCount++;
}
return collapseSingleResultList(multipleResults);
}处理模板
- validateResultMapsCount
resultMapCount 就是之前解析时构造的那个 ResultMap 集合的 size，如果没有配置 ResultMap 或 ResultType，这里就要报错了：
A query was run and no Result Maps were found for the Mapped Statement ……
- handleResultSet
传入构建的List类型的集合 multipleResults，调用 handleRowValues 处理从 ResultSet 获取的结果集。
- collapseSingleResultList
这个就不说了。
细节分析
FastResultSetHandler 用得相对较多，这里只针对其 handleRowValues 处理结果行进行分析：
protected void handleRowValues(ResultSet rs, ResultMap resultMap, ResultHandler resultHandler, RowBounds rowBounds, ResultColumnCache resultColumnCache) throws SQLException {
final DefaultResultContext resultContext = new DefaultResultContext();
skipRows(rs, rowBounds);
while (shouldProcessMoreRows(rs, resultContext, rowBounds)) {
final ResultMap discriminatedResultMap = resolveDiscriminatedResultMap(rs, resultMap, null);
Object rowValue = getRowValue(rs, discriminatedResultMap, null, resultColumnCache);
callResultHandler(resultHandler, resultContext, rowValue);
}
}1、RowBounds 与 分页
skipRows 就是跳过行，基于查询结果的分页使用，其中会直接调用 ResultSet 的 absolute 方法：
rs.absolute(rowBounds.getOffset());
而 shouldProcessMoreRows 方法就是判断是否应该获取更多的行：
protected boolean shouldProcessMoreRows(ResultSet rs, ResultContext context, RowBounds rowBounds) throws SQLException {
return !context.isStopped() && rs.next() && context.getResultCount() < rowBounds.getLimit();
}也对应了分页的limit字段，这种分页可以说是伪分页，查出来再分页。所以我们一般使用插件的形式来实现分页，基于sql的动态替换。
2、获取行数据
如果应该获取更多的行，就会逐行处理结果：
protected Object getRowValue(ResultSet rs, ResultMap resultMap, CacheKey rowKey, ResultColumnCache resultColumnCache) throws SQLException {
final ResultLoaderMap lazyLoader = instantiateResultLoaderMap();
Object resultObject = createResultObject(rs, resultMap, lazyLoader, null, resultColumnCache);
if (resultObject != null && !typeHandlerRegistry.hasTypeHandler(resultMap.getType())) {
final MetaObject metaObject = configuration.newMetaObject(resultObject);
boolean foundValues = resultMap.getConstructorResultMappings().size() > 0;
if (shouldApplyAutomaticMappings(resultMap, !AutoMappingBehavior.NONE.equals(configuration.getAutoMappingBehavior()))) {
final List<String> unmappedColumnNames = resultColumnCache.getUnmappedColumnNames(resultMap, null);
foundValues = applyAutomaticMappings(rs, unmappedColumnNames, metaObject, null, resultColumnCache) || foundValues;
}
final List<String> mappedColumnNames = resultColumnCache.getMappedColumnNames(resultMap, null);
foundValues = applyPropertyMappings(rs, resultMap, mappedColumnNames, metaObject, lazyLoader, null) || foundValues;
foundValues = (lazyLoader != null && lazyLoader.size() > 0) || foundValues;
resultObject = foundValues ? resultObject : null;
return resultObject;
}
return resultObject;
}主要就是根据相关参数创建结果对象，这里又分多钟情况：
- 原始对象的处理（如 Integer 等基本类型对象）
利用 ResultMap 中存储的返回结果类型信息，直接返回相应的值。
- 非原始对象（是自定义的对象）处理
运用反射构造实体对象（相当于一个带有零值的初始对象）。然后用该对象构造一个 MetaObject ，并查看是否需要根据映射自动填充对象。
如果需要通过自动映射来填充，取出 List 类型的属性名，根据这个同 SQL 中查出来一致的字段名，去 ResultSet 中拿出来然后填充到对象中，相关代码如下：
final String property = metaObject.findProperty(propertyName, configuration.isMapUnderscoreToCamelCase());
if (property != null) {
final Class<?> propertyType = metaObject.getSetterType(property);
if (typeHandlerRegistry.hasTypeHandler(propertyType)) {
final TypeHandler<?> typeHandler = resultColumnCache.getTypeHandler(propertyType, columnName);
final Object value = typeHandler.getResult(rs, columnName);
if (value != null || configuration.isCallSettersOnNulls()) { // issue #377, call setter on nulls
metaObject.setValue(property, value);
foundValues = true;
}
}
}这个处理完后，才是非映射列的处理。
3、结果映射
resultMap 元素是 MyBatis 中最重要最强大的元素。它可以让你从 90% 的 JDBC ResultSets 数据提取代码中解放出来, 并在一些情形下允许你做一些 JDBC 不支持的事情。
在 handleResultSets 方法中，取 ResultSet 元信息构造了一个 ResultColumnCache：
ResultColumnCache resultColumnCache = new ResultColumnCache(rs.getMetaData(), configuration);后面在映射列的时候分别调用了 getUnmappedColumnNames 和 getMappedColumnNames 方法来取列集合，对应于 ResultColumnCache 的 unMappedColumnNamesMap 和 mappedColumnNamesMap。如果集合为空，将调用下面的方法来构造：
private void loadMappedAndUnmappedColumnNames(ResultMap resultMap, String columnPrefix) throws SQLException {
List<String> mappedColumnNames = new ArrayList<String>();
List<String> unmappedColumnNames = new ArrayList<String>();
final String upperColumnPrefix = columnPrefix == null ? null : columnPrefix.toUpperCase(Locale.ENGLISH);
final Set<String> mappedColumns = prependPrefixes(resultMap.getMappedColumns(), upperColumnPrefix);
for (String columnName : columnNames) {
final String upperColumnName = columnName.toUpperCase(Locale.ENGLISH);
if (mappedColumns.contains(upperColumnName)) {
mappedColumnNames.add(upperColumnName);
} else {
unmappedColumnNames.add(columnName);
}
}
mappedColumnNamesMap.put(getMapKey(resultMap, columnPrefix), mappedColumnNames);
unMappedColumnNamesMap.put(getMapKey(resultMap, columnPrefix), unmappedColumnNames);
}通常情况下，loadMappedAndUnmappedColumnNames 只会调用一次（多行结果的列名是一样的），所以 ResultColumnCache 名副其实。
它区分是否是满足映射的列名是根据 mappedColumns 集合中是否有来判断的，而 mappedColumns 对应于 ResultMap 配置中的 column 属性。
所以自动映射针对的是没有配置 ResultMap 而使用了 ResultType 的情况；或者配置并使用了 ResultMap，但是 ResultMap 中的 column 属性集合不包含实际SQL字段名，也就是对不上的情况。这个时候是需要直接操作这个字段名，可能需要去除下划线等基于规则的演变，最后通过 MetaObject 来赋值。
那么非自动映射呢？就是配置并使用了 ResultMap，这个简单多了，直接按你配置的来，取 ResultMap 属性配置下的 property 名称，这个就是你实际的对象属性名，然后也是通过 MetaObject 来赋值。
分析到这里，已经比较明朗了，整体的脉络也在脑海中勾勒出来了。ResultMap 实际远不止这些，至于高级功能到时候用起来再具体分析吧。