mybatis 源码解析之配置文件的解析

上一篇文章讲了初始化的一个大致过程，这篇来写下配置文件的解析过程。
源码如下:

## XMLConfigBuilder.java

private void parseConfiguration(XNode root) {
    try {
        //issue #117 read properties first
        propertiesElement(root.evalNode("properties"));
        Properties settings = settingsAsProperties(root.evalNode("settings"));
        loadCustomVfs(settings);
        typeAliasesElement(root.evalNode("typeAliases"));
        pluginElement(root.evalNode("plugins"));
        objectFactoryElement(root.evalNode("objectFactory"));
        objectWrapperFactoryElement(root.evalNode("objectWrapperFactory"));
        reflectorFactoryElement(root.evalNode("reflectorFactory"));
        settingsElement(settings);
        // read it after objectFactory and objectWrapperFactory issue #631
        environmentsElement(root.evalNode("environments"));
        databaseIdProviderElement(root.evalNode("databaseIdProvider"));
        typeHandlerElement(root.evalNode("typeHandlers"));
        mapperElement(root.evalNode("mappers"));
    } catch (Exception e) {
        throw new BuilderException("Error parsing SQL Mapper Configuration. Cause: " + e, e);
    }
}

properties 节点的解析过程

节点定义如下：

<properties resource="jdbc.properties">
    <property name="username" value="root"/>
    <property name="password" value="root_pwd"/>
</properties>

解析过程：

## XMLConfigBuilder.java

private void propertiesElement(XNode context) throws Exception {
    if (context != null) {
        //　读取　properties　的所有子节点
        Properties defaults = context.getChildrenAsProperties();
        //　读取　properties　节点上的 resource 属性
        String resource = context.getStringAttribute("resource");
        //　读取　properties　节点上的 url 属性
        String url = context.getStringAttribute("url");
        // resource 和　url 不可同时存在
        if (resource != null && url != null) {
            throw new BuilderException("The properties element cannot specify
                    both a URL and a resource based property file reference.
                    Please specify one or the other.");
        }
        if (resource != null) {
            // 把　resource 指向的 properties 文件中的键对值读取出来并放置到 defaults 中
            defaults.putAll(Resources.getResourceAsProperties(resource));
        } else if (url != null) {
            // 把　url 指向的 properties 文件中的键对值读取出来并放置到 defaults 中
            defaults.putAll(Resources.getUrlAsProperties(url));
        }
        //　获取 configuration 对象中原来的配置信息
        Properties vars = configuration.getVariables();
        if (vars != null) {
            defaults.putAll(vars);
        }
        parser.setVariables(defaults);
        // 覆盖原来的配置信息
        configuration.setVariables(defaults);
    }
}

properties
从源码可以看出，首先是读取 properties 节点的所有子节点数据，并放置到一个 Properties 容器中 [Properties 继承自 HashTable]。然后再读取 resource 或 url 指向的文件数据，也放入 Properties。如果 properties 节点的子节点有属性与 resource/url 指向的文件的属性重名，那么子节点属性的值将被覆盖。所以，resource/url 属性中指定的配置文件的优先级高于 properties 属性中指定的属性。

最后，携带所有属性的 Properties 对象会被存储在 Configuration 对象中。

settings 节点的解析过程

settings 的解析过程和 properties　的解析过程比较相似，自己看下源码就明白了，这里不在赘述。最终
settings 的所有属性都会被存储在 Configuration 对象中。

typeAliases 和 typeHandlers 节点的解析过程

前者用于配置注册类型及其别名的映射关系，后者用于配置注册类型及其类型处理器之间的映射关系。二者在实现上基本相同，所以这里仅对 <typeAliases> 标签的解析过程进行分析，有兴趣的读者可以自己阅读 <typeHandlers> 的源码实现。

类型别名是为 Java 类型设置一个短的名字。主要是用在我们的 mapper 文件中定义的 sql 需要 parameterType 指定输入参数的类型、需要 resultType 指定输出结果的类型。

typeAliases 有两种定义方法

<!-- 每一个在包 com.doudou.mybatis.entity 中的 Java Bean，在没有注解的情况下，
会使用 Bean 的首字母小写类名来作为它的别名 -->
<typeAliases>
    <package name="com.doudou.mybatis.entity"/>
</typeAliases>

<!-- 对每一个单独的 class 文件指定别名 -->
<typeAliases>
    <typeAlias alias="user" type="com.doudou.mybatis.entity.User"/>
    <typeAlias alias="orders" type="com.doudou.mybatis.entity.Orders"/>
</typeAliases>

详细解析过程。分别对应以上的两种配置方式。

## XMLConfigBuilder.java

private void typeAliasesElement(XNode parent) {
    if (parent != null) {
        for (XNode child : parent.getChildren()) {
            if ("package".equals(child.getName())) {
                // 如果子节点是 package,　mybatis　会处理该包下的所有的　Java Bean
                String typeAliasPackage = child.getStringAttribute("name");
                configuration.getTypeAliasRegistry().registerAliases(typeAliasPackage);
            } else {
                // 获取对应的 alias 和 type
                String alias = child.getStringAttribute("alias");
                String type = child.getStringAttribute("type");
                try {
                    Class<?> clazz = Resources.classForName(type);
                    if (alias == null) {
                        // 如果没有配置别名，则获取 @Alias 注解，如果没有则使用类的简单名称
                        typeAliasRegistry.registerAlias(clazz);
                    } else {
                        // 使用指定的 alias 进行配置
                        typeAliasRegistry.registerAlias(alias, clazz);
                    }
                } catch (ClassNotFoundException e) {
                    throw new BuilderException("Error registering typeAlias for '" 
                    + alias + "'. Cause: " + e, e);
                }
            }
        }
    }
}

如果配置的是 package 方式，则会调用 TypeAliasRegistry#registerAliases 方法。

## TypeAliasRegistry.java

public void registerAliases(String packageName){
    registerAliases(packageName, Object.class);
}

public void registerAliases(String packageName, Class<?> superType){
    // 获取指定 package 下的所有 Java Bean
    ResolverUtil<Class<?>> resolverUtil = new ResolverUtil<Class<?>>();
    resolverUtil.find(new ResolverUtil.IsA(superType), packageName);
    Set<Class<? extends Class<?>>> typeSet = resolverUtil.getClasses();
    //　遍历扫描到的类
    for(Class<?> type : typeSet){
        // Ignore inner classes and interfaces (including package-info.java)
        // Skip also inner classes. See issue #6
        // 忽略内部类，接口
        if (!type.isAnonymousClass() && !type.isInterface() && !type.isMemberClass()) {
            // 优先尝试获取 @Alias 注解，如果没有则使用类的简单名称
            registerAlias(type);
        }
    }
}

mappers 节点的解析过程

mappers 标签用于指明映射文件所在的路径，我们可以通过 <mapper resource=""> 或 <mapper url=""> 子标签指定映射 XML 文件所在的位置，也可以通过 <mapper class=""> 子标签指定一个或多个具体的 Mapper 接口，甚至可以通过 <package name=""/> 子标签指定映射文件所在的包名，扫描注册。

## XMLConfigBuilder.java

private void mapperElement(XNode parent) throws Exception {
    if (parent != null) {
        for (XNode child : parent.getChildren()) {
            if ("package".equals(child.getName())) {
                // 配置了 package 属性，则从指定包下面扫描注册
                String mapperPackage = child.getStringAttribute("name");
                configuration.addMappers(mapperPackage);
            } else {
                String resource = child.getStringAttribute("resource");
                String url = child.getStringAttribute("url");
                String mapperClass = child.getStringAttribute("class");
                if (resource != null && url == null && mapperClass == null) {
                    // 配置了 resource
                    ErrorContext.instance().resource(resource);
                    InputStream inputStream = Resources.getResourceAsStream(resource);
                    XMLMapperBuilder mapperParser = new XMLMapperBuilder(inputStream,  
                            configuration, resource, configuration.getSqlFragments());
                    mapperParser.parse();
                } else if (resource == null && url != null && mapperClass == null) {
                    // 配置了 url
                    ErrorContext.instance().resource(url);
                    InputStream inputStream = Resources.getUrlAsStream(url);
                    XMLMapperBuilder mapperParser = new XMLMapperBuilder(inputStream, 
                            configuration, url, configuration.getSqlFragments());
                    mapperParser.parse();
                } else if (resource == null && url == null && mapperClass != null) {
                    // 配置了 class
                    Class<?> mapperInterface = Resources.classForName(mapperClass);
                    configuration.addMapper(mapperInterface);
                } else {
                    throw new BuilderException("A mapper element may only specify a url, " +
                            "resource or class, but not more than one.");
                }
            }
        }
    }
}

流程首先会判断当前是否是 package 配置，如果是的话则会获取配置的 package 名称，然后执行扫描注册逻辑。
如果是 resource 或 url 配置，则会先获取指定路径映射文件的输入流，然后构造 XMLMapperBuilder 对象对映射文件进行解析。
对于 class 配置而言，则会构建接口限定名对应的 Class 对象，并调用 MapperRegistry#addMapper 方法执行注册。

下一篇文章将介绍映射文件的解析！