前言

在上篇文章 Mybatis 解析 SQL 源码分析一 介绍了 Maper.xml 配置文件的解析，但是没有解析 resultMap 节点，因为该解析比较复杂，也比较难理解，所有单独拿出来进行解析。

在使用 Mybatis 的时候，都会使用resultMap节点来绑定列与bean属性的对应关系，但是一般就只会使用其简单的属性，他还有一些比较复杂的属性可以实现一些高级的功能，在没查看源码之前，我也只会简单的使用，很多高级的用法都没有使用过，通过这次学习，希望能在工作使用，能够写出简洁高效的SQL。

resultMap的定义

先来看看 resultMap 节点的官方定义：

简单的使用：

<resultMap id="userResultMap" type="User">
 <id property="id" column="user_id" />
 <result property="username" column="user_name"/>
 <result property="password" column="hashed_password"/>
</resultMap>

会把列名和属性名进行绑定，该节点一共有 4 个属性：

1. id ：表示该 resultMap，共其他的语句调用

2. type：表示其对于的pojo类型，可以使用别名，也可以使用全限定类名

3. autoMapping：如果设置这个属性，MyBatis将会为这个ResultMap开启或者关闭自动映射。这个属性会覆盖全局的属性 autoMappingBehavior。默认值为：unset。

4. extends：继承，一个 resultMap 可以继承另一个 resultMap，这个属性是不是没有用过 ? ^^

接下来看下它可以有哪些子节点：

• constructor - 用于注入结果到构造方法中
• id – 标识ID列
• result – 表示一般列
• association – 关联查询
• collection – 查询集合
• discriminator - 鉴别器：mybatis可以使用discriminator判断某列的值，然后根据某列的值改变封装行为

constructor

在查询数据库得到数据后，会把对应列的值赋值给javabean对象对应的属性，默认情况下mybatis会调用实体类的无参构造方法创建一个实体类，然后再给各个属性赋值，如果没有构造方法的时候，可以使用 constructor 节点进行绑定，如现有如下的构造方法：

public Person(int id, String name, String job, int age) {
 this.id = id;
 this.name = name;
 this.job = job;
 this.age = age;
 }

则，可以使用 constructor 节点进行绑定：

<resultMap id="queryPersonMap" type="mybatis.pojo.Person" >
 <constructor>
 <idArg column="id" javaType="int"/>
 <arg column="name" javaType="string" />
 <arg column="job" javaType="string" />
 <arg column="age" javaType="int" />
 </constructor>
 </resultMap>

association

关联查询，在级联中有一对一、一对多、多对多等关系，association主要是用来解决一对一关系的，association 可以有多种使用方式：

比如现在有一个 Person 类，它有一个 Address 属性，关联 Address 对象：

public class Person implements Serializable {
 private int id;
 private String name;
 private String job;
 private int age;
 private Address address;
}
public class Address {
 private int id;
 private String name;
 private long number;
}

关联查询方式一：

<resultMap id="queryPersonMap" type="mybatis.pojo.Person" >
 <id column="id" property="id"/>
 <result column="name" property="name" />
 <result column="job" property="job" />
 <result column="age" property="age"/>
 <association property="address" column="address_id" javaType="mybatis.pojo.Address" select="queryAddress" />
 </resultMap>
 <select id="queryAddress" resultType="mybatis.pojo.Address">
 select * from address where id = #{id}
 </select>

关联查询方式二：

<resultMap id="queryPersonMap" type="mybatis.pojo.Person" >
 <id column="id" property="id"/>
 <result column="name" property="name" />
 <result column="job" property="job" />
 <result column="age" property="age"/>
 <association property="address" column="address_id" javaType="mybatis.pojo.Address" resultMap="addressMap"/>
 </resultMap>
 
 <resultMap id="addressMap" type="mybatis.pojo.Address">
 <id column="id" property="id"/>
 <result column="name" property="name"/>
 <result column="number" property="number"/>
 </resultMap>

关联查询方式三：

<resultMap id="queryPersonMap" type="mybatis.pojo.Person" >
 <id column="id" property="id"/>
 <result column="name" property="name" />
 <result column="job" property="job" />
 <result column="age" property="age"/>
 <association property="address" javaType="mybatis.pojo.Address">
 <id column="id" property="id"/>
 <result column="name" property="name"/>
 <result column="number" property="number"/>
 </association>
 </resultMap>

collection

collection 集合，如果pojo对象有一个属性是集合类型的，可以使用collection 来进行查询：

public class Person implements Serializable {
 private int id;
 private String name;
 private String job;
 private int age;
 private List<Address> addressList;
}
 <resultMap id="queryPersonMap" type="mybatis.pojo.Person" >
 <id column="id" property="id"/>
 <result column="name" property="name" />
 <result column="job" property="job" />
 <result column="age" property="age"/>
 <collection property="addressList" javaType="ArrayList" ofType="mybatis.pojo.Address">
 <id column="id" property="id"/>
 <result column="name" property="name"/>
 <result column="number" property="number"/>
 </collection>
 </resultMap>

当然还有其他的方法，具体可以参考官网。

discriminator

鉴别器，mybatis可以使用discriminator判断某列的值，然后根据某列的值改变封装行为，有点像 Java的 switch 语句，鉴别器指定了 column 和 javaType 属性。 列是 MyBatis 查找比较值的地方。 JavaType 是需要被用来保证等价测试的合适类型，

比如某列的值等于多少，则返回1，等于多少返回2等等。

<resultMap id="vehicleResult" type="Vehicle">
 <id property="id" column="id" />
 <result property="vin" column="vin"/>
 <result property="year" column="year"/>
 <result property="make" column="make"/>
 <result property="model" column="model"/>
 <result property="color" column="color"/>
 <discriminator javaType="int" column="vehicle_type">
 <case value="1" resultMap="carResult"/>
 <case value="2" resultMap="truckResult"/>
 <case value="3" resultMap="vanResult"/>
 <case value="4" resultMap="suvResult"/>
 </discriminator>
</resultMap>

以上就是 resultMap 节点的全部使用方法，下面是一个比较复杂的例子，源码解析会按照其来解析，例子来自于官方文档。

<resultMap id="detailedBlogResultMap" type="Blog">
 <constructor>
 <idArg column="blog_id" javaType="int"/>
 <arg column="name" javaType="string" />
 </constructor>
 <id column="id" property="id" />
 <result property="title" column="blog_title"/>
 <association property="author" javaType="Author">
 <id property="id" column="author_id"/>
 <result property="username" column="author_username"/>
 </association>
 <collection property="posts" ofType="Post">
 <id property="id" column="post_id"/>
 <result property="subject" column="post_subject"/>
 </collection>
 
 <discriminator javaType="int" column="draft">
 <case value="1" resultType="DraftPost"/>
 </discriminator>
</resultMap>

resultMap 源码解析

首先需要说明的是，一个 resultMap 节点会解析成一个 ResultMap 对象，而每个子节点（除了discriminator节点）会被解析成 ResultMapping 对象，即一个 ResultMap 包含的是 ResultMapping 对象的集合。

先来看看 ResultMapping 的一个声明：

public class ResultMapping {
 // configuration 对象
 private Configuration configuration;
 private String property;
 private String column;
 private Class<?> javaType;
 private JdbcType jdbcType;
 private TypeHandler<?> typeHandler;
 // 对应的是 resultMap 属性，通过id来引用其他的resultMap
 private String nestedResultMapId;
 // 对应的是 select 属性，通过id来引用其他的select节点的定义
 private String nestedQueryId;
 private Set<String> notNullColumns;
 private String columnPrefix;
 // 处理后的标志，标志有两个 id和constructor
 private List<ResultFlag> flags;
 // 对应节点的column属性拆分后生成的结果，composites.size()>0会使column为null
 private List<ResultMapping> composites;
 private String resultSet;
 private String foreignColumn;
 private boolean lazy;
|

ResultMap 的声明如下：

public class ResultMap {
 // ID，表示一个resultMap
 private String id;
 // 该resultMap对应的Javabean类型
 private Class<?> type;
 // 对应的是除了discriminator节点外的其他节点
 private List<ResultMapping> resultMappings;
 // id 节点的映射集合
 private List<ResultMapping> idResultMappings;
 // 构造节点的集合
 private List<ResultMapping> constructorResultMappings;
 // 记录了映射关系中 不带有contructot节点的的映射关系
 private List<ResultMapping> propertyResultMappings;
 // column集合
 private Set<String> mappedColumns;
 // discriminator 节点
 private Discriminator discriminator;
 private boolean hasNestedResultMaps;
 private boolean hasNestedQueries;
 private Boolean autoMapping;
}

解析：

resultMapElements(context.evalNodes("/mapper/resultMap"));
 private void resultMapElements(List<XNode> list) throws Exception {
 for (XNode resultMapNode : list) {
 try {
 // 解析每个 resultMap 节点
 resultMapElement(resultMapNode);
 } catch (IncompleteElementException e) {
 // ignore, it will be retried
 }
 }
 }
 private ResultMap resultMapElement(XNode resultMapNode) throws Exception {
 // 注意这里传入的是一个空的集合
 return resultMapElement(resultMapNode, Collections.<ResultMapping> emptyList());
 }

主要的解析方法：

private ResultMap resultMapElement(XNode resultMapNode, List<ResultMapping> additionalResultMappings) throws Exception {
 ErrorContext.instance().activity("processing " + resultMapNode.getValueBasedIdentifier());
 // ID 属性
 String id = resultMapNode.getStringAttribute("id", resultMapNode.getValueBasedIdentifier());
 // type属性
 String type = resultMapNode.getStringAttribute("type",resultMapNode.getStringAttribute("ofType", resultMapNode.getStringAttribute("resultType",resultMapNode.getStringAttribute("javaType"))));
 // extends 属性
 String extend = resultMapNode.getStringAttribute("extends");
 // autoMapping 属性
 Boolean autoMapping = resultMapNode.getBooleanAttribute("autoMapping");
 // 从注册的类型管理器里面查找对应的类型
 Class<?> typeClass = resolveClass(type);
 // discriminator 节点
 Discriminator discriminator = null;
 List<ResultMapping> resultMappings = new ArrayList<ResultMapping>();
 resultMappings.addAll(additionalResultMappings);
 // 处理子节点
 List<XNode> resultChildren = resultMapNode.getChildren();
 for (XNode resultChild : resultChildren) {
 if ("constructor".equals(resultChild.getName())) {
 // 处理 constructor 节点
 processConstructorElement(resultChild, typeClass, resultMappings);
 } else if ("discriminator".equals(resultChild.getName())) {
 // 处理discriminator节点
 discriminator = processDiscriminatorElement(resultChild, typeClass, resultMappings);
 } else {
 List<ResultFlag> flags = new ArrayList<ResultFlag>();
 if ("id".equals(resultChild.getName())) {
 flags.add(ResultFlag.ID);
 }
 // 处理其他节点，创建 resultMapping 对象并添加到集合中
 resultMappings.add(buildResultMappingFromContext(resultChild, typeClass, flags));
 }
 }
 ResultMapResolver resultMapResolver = new ResultMapResolver(builderAssistant, id, typeClass, extend, discriminator, resultMappings, autoMapping);
 try {
 // 创建代表该 resultMap 节点的 ResultMap 对象并添加到 ResultMap 集合中。
 return resultMapResolver.resolve();
 } catch (IncompleteElementException e) {
 // 解析失败，添加到集合，重新解析
 configuration.addIncompleteResultMap(resultMapResolver);
 throw e;
 }
 }

处理 constructor 节点：

private void processConstructorElement(XNode resultChild, Class<?> resultType, List<ResultMapping> resultMappings) throws Exception {
 List<XNode> argChildren = resultChild.getChildren();
 for (XNode argChild : argChildren) {
 List<ResultFlag> flags = new ArrayList<ResultFlag>();
 // 向集合中添加 contrucator 标志
 flags.add(ResultFlag.CONSTRUCTOR);
 if ("idArg".equals(argChild.getName())) {
 // 添加id标志
 flags.add(ResultFlag.ID);
 }
 // 创建 ResultMapping 对象并添加到集合中
 resultMappings.add(buildResultMappingFromContext(argChild, resultType, flags));
 }
 }

创建 ResultMapping 对象：

private ResultMapping buildResultMappingFromContext(XNode context, Class<?> resultType, List<ResultFlag> flags) throws Exception {
 // 解析节点的属性
 String property = context.getStringAttribute("property");
 String column = context.getStringAttribute("column");
 String javaType = context.getStringAttribute("javaType");
 String jdbcType = context.getStringAttribute("jdbcType");
 String nestedSelect = context.getStringAttribute("select");
 String nestedResultMap = context.getStringAttribute("resultMap",
 processNestedResultMappings(context, Collections.<ResultMapping> emptyList()));
 String notNullColumn = context.getStringAttribute("notNullColumn");
 String columnPrefix = context.getStringAttribute("columnPrefix");
 String typeHandler = context.getStringAttribute("typeHandler");
 String resultSet = context.getStringAttribute("resultSet");
 String foreignColumn = context.getStringAttribute("foreignColumn");
 boolean lazy = "lazy".equals(context.getStringAttribute("fetchType", configuration.isLazyLoadingEnabled() ? "lazy" : "eager"));
 Class<?> javaTypeClass = resolveClass(javaType);
 @SuppressWarnings("unchecked")
 // 对应的 typeHandler 类型
 Class<? extends TypeHandler<?>> typeHandlerClass = (Class<? extends TypeHandler<?>>) resolveClass(typeHandler);
 JdbcType jdbcTypeEnum = resolveJdbcType(jdbcType);
 // 创建 ResultMapping 对象
 return builderAssistant.buildResultMapping(resultType, property, column, javaTypeClass, jdbcTypeEnum, nestedSelect, nestedResultMap, notNullColumn, columnPrefix, typeHandlerClass, flags, resultSet, foreignColumn, lazy);
 }

之后是创建 ResultMapped 对象并添加到集合中：

ResultMapResolver resultMapResolver = new ResultMapResolver(builderAssistant, id, typeClass, extend, discriminator, resultMappings, autoMapping);
// 调用的使用 builderAssistant 的 addResultMap 方法
return resultMapResolver.resolve();
 public ResultMap addResultMap(String id, Class<?> type, String extend, Discriminator discriminator, List<ResultMapping> resultMappings, Boolean autoMapping) {
 // 为 id 加上 namespace即 namespace.id
 id = applyCurrentNamespace(id, false);
 extend = applyCurrentNamespace(extend, true);
 if (extend != null) {
 if (!configuration.hasResultMap(extend)) {
 throw new IncompleteElementException("Could not find a parent resultmap with id '" + extend + "'");
 }
 // 获取父级的resultMap
 ResultMap resultMap = configuration.getResultMap(extend);
 List<ResultMapping> extendedResultMappings = new ArrayList<ResultMapping>(resultMap.getResultMappings());
 // 因为上面添加过一次，现在要删除重复的
 extendedResultMappings.removeAll(resultMappings);
 // Remove parent constructor if this resultMap declares a constructor.
 boolean declaresConstructor = false;
 for (ResultMapping resultMapping : resultMappings) {
 if (resultMapping.getFlags().contains(ResultFlag.CONSTRUCTOR)) {
 declaresConstructor = true;
 break;
 }
 }
 if (declaresConstructor) {
 Iterator<ResultMapping> extendedResultMappingsIter = extendedResultMappings.iterator();
 while (extendedResultMappingsIter.hasNext()) {
 if (extendedResultMappingsIter.next().getFlags().contains(ResultFlag.CONSTRUCTOR)) {
 extendedResultMappingsIter.remove();
 }
 }
 }
 resultMappings.addAll(extendedResultMappings);
 }
 // 创建 resultMap 
 ResultMap resultMap = new ResultMap.Builder(configuration, id, type, resultMappings, autoMapping)
 .discriminator(discriminator)
 .build();
 // 添加到集合
 configuration.addResultMap(resultMap);
 return resultMap;
 }

到这里，就把 resultMap 节点解析完毕了，之后在解析 Mapper.xml 文件的其他节点