Mybatis源码解析（二）mapper-resultmap详解构造过程

勿以浮沙筑高台

---

config解析过程见文章：
Mybatis源码解析（一）newconfiguration构造过程
在上章的最后我们简单解析了一下mapper的过程。
1.转为流对象
2.创建一个mapper文件的解析对象
3.解析mapper配置文件
这张我们就详细解析一下构造过程。

//parent = mappers
 private void mapperElement(XNode parent) throws Exception {
 //判断有没有mappers元素
        if (parent != null) {
            Iterator var2 = parent.getChildren().iterator();
            while(true) {
                while(var2.hasNext()) {
                    XNode child = (XNode)var2.next();
                    String resource;
                    //判断是不是扫描形式的
                    if ("package".equals(child.getName())) {
                    	//是的话拿到name
                        resource = child.getStringAttribute("name");
                        //直接放入配置中心
                        //链接：AH-01
                        this.configuration.addMappers(resource);
                    } else {
                    	//如果不是
                    	//获取资源
                        resource = child.getStringAttribute("resource");
                        //url
                        String url = child.getStringAttribute("url");
                        //class
                        String mapperClass = child.getStringAttribute("class");
                        XMLMapperBuilder mapperParser;
                        InputStream inputStream;
                        //三者只能存在一个
                        if (resource != null && url == null && mapperClass == null) {
                        //如果是resource，resource指定的文件路径
                            ErrorContext.instance().resource(resource);
                            //把mapper配置文件转为一个输入流对象
                            inputStream = Resources.getResourceAsStream(resource);
                            //创建一个mapper文件的解析对象
                            //链接：AH-03
                            mapperParser = new XMLMapperBuilder(inputStream, this.configuration, resource, this.configuration.getSqlFragments());
                            //解析mapper配置文件
                            //链接：AH-04
                            mapperParser.parse();
                        } else if (resource == null && url != null && mapperClass == null) {
                        	//如果是url，url指定的文件路径
                            ErrorContext.instance().resource(url);
                            //将url指定的文件转为流
                            inputStream = Resources.getUrlAsStream(url);
                            mapperParser = new XMLMapperBuilder(inputStream, this.configuration, url, this.configuration.getSqlFragments());
                            mapperParser.parse();
                        } else {
                            if (resource != null || url != null || mapperClass == null) {
                                throw new BuilderException("A mapper element may only specify a url, resource or class, but not more than one.");
                            }
							//如果是class将mapper对应的接口类型添加进configuration配置中心
                            Class<?> mapperInterface = Resources.classForName(mapperClass);
                            this.configuration.addMapper(mapperInterface);
                        }
                    }
                }
                return;
            }
        }
    }

AH-01：org.apache.ibatis.binding.MapperRegistry#addMappers(java.lang.String, java.lang.Class<?>)

  public void addMappers(String packageName, Class<?> superType) {
  		//通过反射工具类
        ResolverUtil<Class<?>> resolverUtil = new ResolverUtil();
        //解析当前name的实例
        //这个在上一章解析过，找到所有的.class不是接口，不是二进制文件的类
        resolverUtil.find(new IsA(superType), packageName);
        //拿到类对象
        Set<Class<? extends Class<?>>> mapperSet = resolverUtil.getClasses();
        Iterator var5 = mapperSet.iterator();

        while(var5.hasNext()) {
            Class<?> mapperClass = (Class)var5.next();
            //遍历后加入集合
            //链接：AH-02
            this.addMapper(mapperClass);
        	//return AH-01
        }
    }

AH-02：org.apache.ibatis.binding.MapperRegistry#addMapper

   public <T> void addMapper(Class<T> type) {
   		//判断是不是接口，因为我们这个类下的映射关系必须是接口类型
        if (type.isInterface()) {
        	//判断我们集合中是否已经存储过了
            if (this.hasMapper(type)) {
                throw new BindingException("Type " + type + " is already known to the MapperRegistry.");
            }
            //完整度为false
            boolean loadCompleted = false;
            try {
            	//将类型和代理对象添加进集合
            	//MapperProxyFactory：创建这个接口实例的工厂代理对象
                this.knownMappers.put(type, new MapperProxyFactory(type));
                //获取mapper注解
                MapperAnnotationBuilder parser = new MapperAnnotationBuilder(this.config, type);
                //注解解析
                parser.parse();
                //解析完成
                loadCompleted = true;
                //return ：AH-02
            } finally {
                if (!loadCompleted) {
                    this.knownMappers.remove(type);
                }
            }
        }
    }

AH-03：org.apache.ibatis.builder.xml.XMLMapperBuilder#XMLMapperBuilder(java.io.InputStream, org.apache.ibatis.session.Configuration, java.lang.String, java.util.Map<java.lang.String,org.apache.ibatis.parsing.XNode>)

 public XMLMapperBuilder(InputStream inputStream, Configuration configuration, String resource, Map<String, XNode> sqlFragments) {
//将流转为文档对象
this(new XPathParser(inputStream, true, configuration.getVariables(), new XMLMapperEntityResolver()), configuration, resource, sqlFragments);
    }

private XMLMapperBuilder(XPathParser parser, Configuration configuration, String resource, Map<String, XNode> sqlFragments) {
        //更新一下父类当中的配置文件
        super(configuration);
        //创建一个助理对象
        //传入
        //当前的config对象和resource，资源路径
        this.builderAssistant = new MapperBuilderAssistant(configuration, resource);
        //
        this.parser = parser;
        //
        this.sqlFragments = sqlFragments;
        //
        this.resource = resource;
    	//return AH-03
    }

AH-04：org.apache.ibatis.builder.xml.XMLMapperBuilder#parse

public void parse() {
		//判断当前资源是否被解析过
		//解析过会将资源名称放入属性
        if (!this.configuration.isResourceLoaded(this.resource)) {
            //开始解析mapper配置文件
            //先转换为一个XNode节点
            //链接:AH-05
            this.configurationElement(this.parser.evalNode("/mapper"));
            this.configuration.addLoadedResource(this.resource);
            this.bindMapperForNamespace();
        }

        this.parsePendingResultMaps();
        this.parsePendingCacheRefs();
        this.parsePendingStatements();
    }

AH-05：org.apache.ibatis.builder.xml.XMLMapperBuilder#configurationElement

private void configurationElement(XNode context) {
        try {
        	//解析namespce，
        	//<mapper namespace="com.mybatis.demo.mapper.UserMapper">	
            String namespace = context.getStringAttribute("namespace");
            //namespace!=null
            if (namespace != null && !namespace.equals("")) {
            	//通过构建助手，namesapce设置进去
                this.builderAssistant.setCurrentNamespace(namespace);
                //解析缓存引用标签
                //链接：AH-06
                this.cacheRefElement(context.evalNode("cache-ref"));
                //链接：AH-08
                //构建缓存对象
                this.cacheElement(context.evalNode("cache"));
                this.parameterMapElement(context.evalNodes("/mapper/parameterMap"));
				
				//resultmao
				//构建映射关系对象
				//链接：AH-12
                this.resultMapElements(context.evalNodes("/mapper/resultMap"));
                //映射SQL语句关系
                this.sqlElement(context.evalNodes("/mapper/sql"));
                this.buildStatementFromContext(context.evalNodes("select|insert|update|delete"));
            } else {
                throw new BuilderException("Mapper's namespace cannot be empty");
            }
        } catch (Exception var3) {
            throw new BuilderException("Error parsing Mapper XML. The XML location is '" + this.resource + "'. Cause: " + var3, var3);
        }
    }

AH-06：org.apache.ibatis.builder.xml.XMLMapperBuilder#cacheRefElement

   private void cacheRefElement(XNode context) {
        if (context != null) {
            // <cache-ref namespace=""> <cache/>
            //判定指定的命名空间
            //保留当前命名空间和指定的命名空间
            this.configuration.addCacheRef(this.builderAssistant.getCurrentNamespace(), context.getStringAttribute("namespace"));
            
            CacheRefResolver cacheRefResolver = new CacheRefResolver(this.builderAssistant, context.getStringAttribute("namespace"));

            try {
            //开始对其进行解析
            //链接：AH-07
            //return AH-06
                cacheRefResolver.resolveCacheRef();
            } catch (IncompleteElementException var4) {
                this.configuration.addIncompleteCacheRef(cacheRefResolver);
            }
        }

    }

AH-07：``

public Cache resolveCacheRef() {
        return this.assistant.useCacheRef(this.cacheRefNamespace);
    }

   public Cache useCacheRef(String namespace) {
        if (namespace == null) {
            throw new BuilderException("cache-ref element requires a namespace attribute.");
        } else {
            try {
            	//不能解析
                this.unresolvedCacheRef = true;
                //通过名称到集合中拿
                Cache cache = this.configuration.getCache(namespace);
                if (cache == null) {
                //如果为空说明之前的构造没有成功
                    throw new IncompleteElementException("No cache for namespace '" + namespace + "' could be found.");
                } else {
                	//拿出缓存
                    this.currentCache = cache;
                    //可以解析
                    this.unresolvedCacheRef = false;
                    //return AH-07
                    return cache;
                }
            } catch (IllegalArgumentException var3) {
                throw new IncompleteElementException("No cache for namespace '" + namespace + "' could be found.", var3);
            }
        }
    }

AH-08：org.apache.ibatis.builder.xml.XMLMapperBuilder#cacheElement

  private void cacheElement(XNode context) {
        if (context != null) {
        	//拿到type属性，没有设置的话默认值为PERPETUAL
        	//之前的缓存集合里有特定的类型可以指定
        	//    <cache-ref namespace="">
			//		<cache type="LRU"/>
    		//	<cache/>
            String type = context.getStringAttribute("type", "PERPETUAL");
            //通过映射关系找到类型eg：LRU的对应的类型
            Class<? extends Cache> typeClass = this.typeAliasRegistry.resolveAlias(type);
            //寻找淘汰策略
            String eviction = context.getStringAttribute("eviction", "LRU");
            //找到类型 
            Class<? extends Cache> evictionClass = this.typeAliasRegistry.resolveAlias(eviction);
            //得到刷新的时间
            Long flushInterval = context.getLongAttribute("flushInterval");
            //设置的缓存大小
            Integer size = context.getIntAttribute("size");
            //是否分块读取
            boolean readWrite = !context.getBooleanAttribute("readOnly", false);
            //是否堵塞
            boolean blocking = context.getBooleanAttribute("blocking", false);
            //获取子属性集合
            Properties props = context.getChildrenAsProperties();
            //将生成的属性值，保存进构建助手对象中
            //AH-09
            this.builderAssistant.useNewCache(typeClass, evictionClass, flushInterval, size, readWrite, blocking, props);
            //return AH-08
        }
    }

AH-09：org.apache.ibatis.builder.MapperBuilderAssistant#useNewCache

public Cache useNewCache(Class<? extends Cache> typeClass, Class<? extends Cache> evictionClass, Long flushInterval, Integer size, boolean readWrite, boolean blocking, Properties props) {
		//链接：AH-09
        Cache cache = (new CacheBuilder(this.currentNamespace)).implementation((Class)this.valueOrDefault(typeClass, PerpetualCache.class)).addDecorator((Class)this.valueOrDefault(evictionClass, LruCache.class)).clearInterval(flushInterval).size(size).readWrite(readWrite).blocking(blocking).properties(props).build();
        //将缓存对象添加进config
        this.configuration.addCache(cache);
        //赋值
        this.currentCache = cache;
        //return AH-09
        return cache;
    }

AH-10：org.apache.ibatis.mapping.CacheBuilder#build

    public Cache build() {
        this.setDefaultImplementations();
        Cache cache = this.newBaseCacheInstance(this.implementation, this.id);
        //设置缓存的属性集合
        //链接：AH-10
        this.setCacheProperties((Cache)cache);
        //PerpetualCache.class这个类和当前缓存类型进行匹配
        if (PerpetualCache.class.equals(cache.getClass())) {
            Iterator var2 = this.decorators.iterator();
            while(var2.hasNext()) {
                Class<? extends Cache> decorator = (Class)var2.next();
                //反射生成一个装饰实例
                cache = this.newCacheDecoratorInstance(decorator, (Cache)cache);
                //设置入缓存
                this.setCacheProperties((Cache)cache);
            }
            cache = this.setStandardDecorators((Cache)cache);
            //判断是否是日志缓存派生的
        } else if (!LoggingCache.class.isAssignableFrom(cache.getClass())) {
            //如果不是，则创建一个日志缓存
            cache = new LoggingCache((Cache)cache);
        }
        //return AH-10
        return (Cache)cache;
    }

AH-11：org.apache.ibatis.mapping.CacheBuilder#setCacheProperties

private void setCacheProperties(Cache cache) {
        if (this.properties != null) {
        	//拿到元数据内部有各种获取属性设置反射的方法
            MetaObject metaCache = SystemMetaObject.forObject(cache);
            Iterator var3 = this.properties.entrySet().iterator();

            label76:
            while(true) {
                while(true) {
                    String name;
                    String value;
                    do {
                        if (!var3.hasNext()) {
                            break label76;
                        }
                        Entry<Object, Object> entry = (Entry)var3.next();
                        name = (String)entry.getKey();
                        value = (String)entry.getValue();
                    } while(!metaCache.hasSetter(name));

                    Class<?> type = metaCache.getSetterType(name);
                    //获取当前属性对应的类型
                    if (String.class == type) {
                    //setvalue的时候其实调用的就是反射区构建实例
                        metaCache.setValue(name, value);
                    } else if (Integer.TYPE != type && Integer.class != type) {
                        if (Long.TYPE != type && Long.class != type) {
                            if (Short.TYPE != type && Short.class != type) {
                                if (Byte.TYPE != type && Byte.class != type) {
                                    if (Float.TYPE != type && Float.class != type) {
                                        if (Boolean.TYPE != type && Boolean.class != type) {
                                            if (Double.TYPE != type && Double.class != type) {
                                                throw new CacheException("Unsupported property type for cache: '" + name + "' of type " + type);
                                            }

                                            metaCache.setValue(name, Double.valueOf(value));
                                        } else {
                                            metaCache.setValue(name, Boolean.valueOf(value));
                                        }
                                    } else {
                                        metaCache.setValue(name, Float.valueOf(value));
                                    }
                                } else {
                                    metaCache.setValue(name, Byte.valueOf(value));
                                }
                            } else {
                                metaCache.setValue(name, Short.valueOf(value));
                            }
                        } else {
                            metaCache.setValue(name, Long.valueOf(value));
                        }
                    } else {
                        metaCache.setValue(name, Integer.valueOf(value));
                    }
                }
            }
        }
        //判断你的缓存类是否是由InitializingObject接口派生的
         if (InitializingObject.class.isAssignableFrom(cache.getClass())) {
            try {
            //如果是这个派生的，调用initialize方法初始化属性值
                ((InitializingObject)cache).initialize();
            } catch (Exception var8) {
                throw new CacheException("Failed cache initialization for '" + cache.getId() + "' on '" + cache.getClass().getName() + "'", var8);
            }
        }
        //return AH-11
    }

AH-12:org.apache.ibatis.builder.xml.XMLMapperBuilder#resultMapElements

//会把resultmap下的所有节点返回回来
   private void resultMapElements(List<XNode> list) throws Exception {
        Iterator var2 = list.iterator();
		//遍历节点集合
        while(var2.hasNext()) {
            XNode resultMapNode = (XNode)var2.next();
            try {
            	//对resultmap的元素进行解读
            	//链接：AH-13
            	//return：AH-12
                this.resultMapElement(resultMapNode);
            } catch (IncompleteElementException var5) {
            }
        }
    }

AH-13:org.apache.ibatis.builder.xml.XMLMapperBuilder#resultMapElement(org.apache.ibatis.parsing.XNode, java.util.List<org.apache.ibatis.mapping.ResultMapping>, java.lang.Class<?>)

private ResultMap resultMapElement(XNode resultMapNode, List<ResultMapping> additionalResultMappings, Class<?> enclosingType) throws Exception {
        ErrorContext.instance().activity("processing " + resultMapNode.getValueBasedIdentifier());
        //首先拿取主键配置的ID值，构建一个string返回
        String id = resultMapNode.getStringAttribute("id", resultMapNode.getValueBasedIdentifier());
        //获取type属性可能是oftype，resulttype，javatype
        String type = resultMapNode.getStringAttribute("type", 
        resultMapNode.getStringAttribute("ofType", resultMapNode.getStringAttribute("resultType", resultMapNode.getStringAttribute("javaType"))));
        //获取继承属性值
        String extend = resultMapNode.getStringAttribute("extends");
        //自动根据小驼峰命名方式匹配
        Boolean autoMapping = resultMapNode.getBooleanAttribute("autoMapping");
        //解读当前别名称对象的类类型
        Class<?> typeClass = this.resolveClass(type);
        if (typeClass == null) {
        	//如果等于空，则找继承类型
            typeClass = this.inheritEnclosingType(resultMapNode, enclosingType);
        }
		//鉴别器
        Discriminator discriminator = null;
        //每一行映射关系就是一个resultmapping对象，构建一个resultmapping对象集合
        List<ResultMapping> resultMappings = new ArrayList();
        //将映射关系添加进resultMappings
        resultMappings.addAll(additionalResultMappings);
        //获得所有的子节点
        List<XNode> resultChildren = resultMapNode.getChildren();
        Iterator var12 = resultChildren.iterator();
		//对所有的子节点进行遍历
        while(var12.hasNext()) {
            XNode resultChild = (XNode)var12.next();
            //如果是构造器就按构造进行解析
            if ("constructor".equals(resultChild.getName())) {
                this.processConstructorElement(resultChild, typeClass, resultMappings);  
                //如果是鉴别器就鉴别器进行解析
            } else if ("discriminator".equals(resultChild.getName())) {
                discriminator = this.processDiscriminatorElement(resultChild, typeClass, resultMappings);
            } else {
              //如果是主键就主键器进行解析
                List<ResultFlag> flags = new ArrayList();
                if ("id".equals(resultChild.getName())) {
                    flags.add(ResultFlag.ID);
                }
                //将当前的结果，类型，和主键表示添加进resultMappings，构建一个resultMappings对象出来
                resultMappings.add(this.buildResultMappingFromContext(resultChild, typeClass, flags));
            }
        }
        
        //将生成的resultMappings集合和属性信息包装一下为ResultMapResolver 类
        ResultMapResolver resultMapResolver = new ResultMapResolver(this.builderAssistant, id, typeClass, extend, discriminator, resultMappings, autoMapping);

        try {
        //对继承resultmap的处理
        //链接：AH-14
        //return：AH-13
            return resultMapResolver.resolve();
        } catch (IncompleteElementException var15) {
            this.configuration.addIncompleteResultMap(resultMapResolver);
            throw var15;
        }
    }

AH-14：org.apache.ibatis.builder.MapperBuilderAssistant#addResultMap

  public ResultMap addResultMap(String id, Class<?> type, String extend, Discriminator discriminator, List<ResultMapping> resultMappings, Boolean autoMapping) {
		//获取命名空间
        id = this.applyCurrentNamespace(id, false);
        //获取继承关系
        extend = this.applyCurrentNamespace(extend, true);
        ResultMap resultMap;
        if (extend != null) {
        //如果id想到，则继承reusultmap
            if (!this.configuration.hasResultMap(extend)) {
                throw new IncompleteElementException("Could not find a parent resultmap with id '" + extend + "'");
            }
			//获取继承对象
            resultMap = this.configuration.getResultMap(extend);
            List<ResultMapping> extendedResultMappings = new ArrayList(resultMap.getResultMappings());
            extendedResultMappings.removeAll(resultMappings);
            boolean declaresConstructor = false;
            Iterator extendedResultMappingsIter = resultMappings.iterator();
			//进行整合
            while(extendedResultMappingsIter.hasNext()) {
                ResultMapping resultMapping = (ResultMapping)extendedResultMappingsIter.next();
                if (resultMapping.getFlags().contains(ResultFlag.CONSTRUCTOR)) {
                    declaresConstructor = true;
                    break;
                }
            }
			//构造器整理
            if (declaresConstructor) {
                extendedResultMappingsIter = extendedResultMappings.iterator();

                while(extendedResultMappingsIter.hasNext()) {
                    if (((ResultMapping)extendedResultMappingsIter.next()).getFlags().contains(ResultFlag.CONSTRUCTOR)) {
                        extendedResultMappingsIter.remove();
                    }
                }
            }
			//将整理好的信息放进集合中
            resultMappings.addAll(extendedResultMappings);
        }

        resultMap = (new org.apache.ibatis.mapping.ResultMap.Builder(this.configuration, id, type, resultMappings, autoMapping)).discriminator(discriminator).build();
        this.configuration.addResultMap(resultMap);
        //return AH-14
        return resultMap;
    }

总计：
1.AH-04：判断有没有mappers元素，创建一个xmlmapperbuiler对资源进行解析，将流转为文档对象。
2.解析文档对象，先接下namespace，和env的是否一致，一致则进行resultmap对象，获取所有子节点，根据子节点的名称选择不同的处理器进行处理。