关于java:MyBatis-学习笔记MyBatis-启动流程

44次阅读

共计 41305 个字符，预计需要花费 104 分钟才能阅读完成。

MyBatis 通过应用 SqlSessionFactoryBuilder，以创立 SqlSessionFactory 对象来进行 MyBatis 的启动，无论是否集成 Spring 的模块。
SqlSessionFactoryBuilder 蕴含以下办法：

  • SqlSessionFactoryBuilder#build(java.io.Reader)
  • SqlSessionFactoryBuilder#build(java.io.Reader,java.lang.String)
  • SqlSessionFactoryBuilder#build(java.io.Reader,java.util.Properties)
  • SqlSessionFactoryBuilder#build(java.io.Reader,java.lang.String,java.util.Properties)
  • SqlSessionFactoryBuilder#build(java.io.InputStream)
  • SqlSessionFactoryBuilder#build(java.io.InputStream,java.lang.String)
  • SqlSessionFactoryBuilder#build(java.io.InputStream,java.util.Properties)
  • SqlSessionFactoryBuilder#build(java.io.InputStream,java.lang.String,java.util.Properties)
  • SqlSessionFactoryBuilder#build(org.apache.ibatis.session.Configuration)

除了最初了一个须要传入 Configuration 参数的办法外，其余底层都是通过 XMLConfigBuilder#parse() 办法来启动 MyBaits。
起因也很简略，除了须要传入 Configuration 参数的办法外，其余的办法都是要传入 Reader 或者 InputStream 文件流参数来进行文件读写。
而 XMLConfigBuilder 类是用来读取 mybatis-config.xml 文件的来进行 MyBatis 的全局配置和启动，那么它天然就须要通过文件流参数来读取配置文件。

SqlSessionFactoryBuilder 源码 

/**
 * 暗藏了局部源码，只保留次要局部
 */
public class SqlSessionFactoryBuilder {
    /**
     * 通过第一个参数的 Reader 对象读取 MyBatis-config.xml 文件，进行 MyBatis 的初始化，并返回 SqlSessionFactory 对象。* SqlSessionFactoryBuilder 除了该办法之外，还有另外一个办法反对 InputStream 文件流来读取 MyBatis-config.xml 文件。*/
    public SqlSessionFactory build(Reader reader, String environment, Properties properties) {
        try {
            // 创立 XMLConfigBuilder 对象
            XMLConfigBuilder parser = new XMLConfigBuilder(reader, environment, properties);
            // 调用 XMLConfigBuilder#parse() 办法，该办法进行 MyBatis 的初始化工作。// 最终失去了 Configuration 对象，并调用 build(Configuration) 办法，返回 SqlSessionFactory 的默认实现。return build(parser.parse());
        } catch (Exception e) {throw ExceptionFactory.wrapException("Error building SqlSession.", e);
        } finally {ErrorContext.instance().reset();
            try {reader.close();
            } catch (IOException e) {}}
    }

    public SqlSessionFactory build(Configuration config) {return new DefaultSqlSessionFactory(config);
    }

}

XMLConfigBuilder

在 SqlSessionFactoryBuilder#build(Reader, String, Properties) 办法中，咱们看到它实质上是通过 XMLConfigBuilder 对象来实现 MyBatis 的初始化，那么 XMLConfigBuilder#parse() 办法是咱们要关注的内容。
它次要干了以下几个事件：

  • 解析 <properties> 标签；
  • 解析 <settings> 标签；解析过程中如果蕴含了 vfsImpl 的属性，那么去设置自定义的 vfs 实现类。
  • 解决日志相干组件；
  • 解析 <typeAliases> 标签；
  • 解析 <plugins> 标签；
  • 解析 <objectFactory> 标签；
  • 解析 <objectWrapperFactory> 标签；
  • 解析 <reflectorFactory> 标签；
  • 解析 <environments> 标签；
  • 解析 <databaseIdProvider> 标签；
  • 解析 <typeHandlers> 标签；
  • 解析 <mappers> 标签。

源码如下：

public class XMLConfigBuilder extends BaseBuilder {
    // configuration、typeAliasRegistry、typeHandlerRegistry 都在父类 BaseBuilder 中
    /**
    * Mybatis 初始化解析到的配置信息，都会记录到 configuration 这里
    * Mybatis 的初始化过程，根本都是围绕这个对象的
    * 这个能够了解成是这个单例的对象
    */
    protected final Configuration configuration;
    /**
    * 别名注册核心，用于解析别名
    */
    protected final TypeAliasRegistry typeAliasRegistry;
    /**
    * TypeHandler 注册核心，用于解析 TypeHandler
    * TypeHandler 次要是做 Java 类型和数据库类型的转换映射
    * 而用户能够自定义 TypeHandler，自定义的 TypeHandler 都会记录在这里
    */
    protected final TypeHandlerRegistry typeHandlerRegistry;
    /**
    * 标识是否曾经齐全解析完 mybatis-config.xml 配置文件
    */
    private boolean parsed;
    /**
    * XML 解析器，用于解析 mybatis-config.xml 配置文件
    */
    private final XPathParser parser;
    /**
    * 标签定义的环境名称
    */
    private String environment;
    /**
    * 对 Reflector 对象的创立和缓存
    */
    private final ReflectorFactory localReflectorFactory = new DefaultReflectorFactory();

    public Configuration parse() {if (parsed) {throw new BuilderException("Each XMLConfigBuilder can only be used once.");
        }
        parsed = true;
        parseConfiguration(parser.evalNode("/configuration"));
        return configuration;
    }

    private void parseConfiguration(XNode root) {
        try {
            // issue #117 read properties first
            // 解析 <properties> 标签
            propertiesElement(root.evalNode("properties"));
            // 解析 <settings> 标签
            Properties settings = settingsAsProperties(root.evalNode("settings"));
            // 从 <settings> 标签中，查找并设置自定义的 vfs（虚构文件系统）实现类。loadCustomVfs(settings);
            // 解决日志相干组件
            loadCustomLogImpl(settings);
            // 解析 <typeAliases> 标签
            typeAliasesElement(root.evalNode("typeAliases"));
            // 解析 <plugins> 标签
            pluginElement(root.evalNode("plugins"));
            // 解析 <objectFactory> 标签
            objectFactoryElement(root.evalNode("objectFactory"));
            // 解析 <objectWrapperFactory> 标签
            objectWrapperFactoryElement(root.evalNode("objectWrapperFactory"));
            // 解析 <reflectorFactory> 标签
            reflectorFactoryElement(root.evalNode("reflectorFactory"));
            // 从 <settings> 标签中解析到的内容，设置到 Configuration 对象的字段上
            settingsElement(settings);
            // read it after objectFactory and objectWrapperFactory issue #631
            // 解析 <environments> 标签
            environmentsElement(root.evalNode("environments"));
            // 解析 <databaseIdProvider> 标签
            databaseIdProviderElement(root.evalNode("databaseIdProvider"));
            // 解析 <typeHandlers> 标签
            typeHandlerElement(root.evalNode("typeHandlers"));
            // 解析 <mappers> 标签
            mapperElement(root.evalNode("mappers"));
        } catch (Exception e) {throw new BuilderException("Error parsing SQL Mapper Configuration. Cause:" + e, e);
        }
    }
}

解析 properties 标签

通过调用 propertiesElement(XNode) 办法，读取 <properties> 标签以及它的属性值。
<properties> 标签读取属性的优先级如下：通过办法参数传递 > resource 或者 url 属性指定的配置文件 > properties 元素指定的属性。
从 <properties> 标签中解析进去的 KV 信息会被记录到一个 Properties 对象（也就是 Configuration 全局配置对象的 variables 字段），在后续解析其余标签的时候，MyBatis 会应用这个 Properties 对象中记录的 KV 信息替换匹配的占位符。

解析 settings 标签

MyBatis 在解析 <settings> 标签时，次要是这么做：

  1. 通过调用 settingsAsProperties(XNode) 办法来解析 <settings> 标签，并失去 Properties 对象
  2. 通过调用 loadCustomVfs(Properties) 办法来查找并设置自定义的 vfs 实现
  3. 通过调用 loadCustomLogImpl(Properties) 办法来查找并设置自定义的日志实现
  4. 通过调用 settingsElement(Properties) 办法，来设置 Configuration 对象的信息

解析 typeAliases 标签

将 <typeAliases> 标签扫描的类 class 和别名信息，保留到 TypeAliasRegistry.typeAliases 的字段中去。
源码如下：

private void typeAliasesElement(XNode parent) {if (parent != null) {for (XNode child : parent.getChildren()) {if ("package".equals(child.getName())) {
                // 如果是 <package> 标签，则通过 name 属性来扫描所有的 class
                // 而后查看每一个 class 是否蕴含 @Alias 注解。如果有，那么 class 的别名就是 @Alias 的值, 否则就是 class 的名字
                // 最初保留到 TypeAliasRegistry.typeAliases 的字段中去
                String typeAliasPackage = child.getStringAttribute("name");
                configuration.getTypeAliasRegistry().registerAliases(typeAliasPackage);
            } else {String alias = child.getStringAttribute("alias");
                String type = child.getStringAttribute("type");
                try {Class<?> clazz = Resources.classForName(type);
                    if (alias == null) {
                        // 如果 alias 属性为 null，就先从 type 属性指定的 class 中，查找是否有 @Alias 这个注解
                        // 如果注解存在，则拿注解的值，否则就间接拿 class 的名字
                        // 最初保留到 TypeAliasRegistry.typeAliases 的字段中去
                        typeAliasRegistry.registerAlias(clazz);
                    } else {
                        // 如果 alias 属性不为 null，就去将 alias 的值设置为 class 的别名
                        // 最初保留到 TypeAliasRegistry.typeAliases 的字段中去
                        typeAliasRegistry.registerAlias(alias, clazz);
                    }
                } catch (ClassNotFoundException e) {throw new BuilderException("Error registering typeAlias for'" + alias + "'. Cause:" + e, e);
                }
            }
        }
    }
}

解析 plugins 标签

扫描 <plugins> 下的 <plugin> 标签，并将这些 <plugin> 标签对应的 class，通过无参构造方法来创立进去。增加到 Configuration 对象的 interceptorChain 成员变量（外部保护了 List<Interceptor> 对象的链）下。

解决 typeHandlers 标签

源码如下：

private void typeHandlerElement(XNode parent) {if (parent != null) {
        // 解决所有 <typeHandler> 的标签
        for (XNode child : parent.getChildren()) {if ("package".equals(child.getName())) {
                // 如果指定了 package 属性，就扫描指定包中所有带有 @MappedTypes 注解的类，而后实现 TypeHandler 的注册
                String typeHandlerPackage = child.getStringAttribute("name");
                typeHandlerRegistry.register(typeHandlerPackage);
            } else {
                // 如果没有指定 package 属性，则尝试获取 javaType、jdbcType、handler 三个属性
                String javaTypeName = child.getStringAttribute("javaType");
                String jdbcTypeName = child.getStringAttribute("jdbcType");
                String handlerTypeName = child.getStringAttribute("handler");
                // 依据属性确定 TypeHandler 类型以及它可能解决的数据库类型和 Java 类型
                Class<?> javaTypeClass = resolveClass(javaTypeName);
                JdbcType jdbcType = resolveJdbcType(jdbcTypeName);
                Class<?> typeHandlerClass = resolveClass(handlerTypeName);
                // 调用 TypeHandlerRegistry 的 register 办法来注册 TypeHandler
                if (javaTypeClass != null) {if (jdbcType == null) {typeHandlerRegistry.register(javaTypeClass, typeHandlerClass);
                    } else {typeHandlerRegistry.register(javaTypeClass, jdbcType, typeHandlerClass);
                    }
                } else {typeHandlerRegistry.register(typeHandlerClass);
                }
            }
        }
    }
}

解析 mappers 标签

Mybatis 通过解析 <mappers> 标签，加载并增加 Mapper 到 Configuration 对象的 MapperRegistry 成员变量中去。
它的工作流程如下：

  1. 扫描 <mappers> 标签下的 <mapper> 标签，依据其 package、resource、url 或者 mapperClass 属性的值，创立出 XMLMapperBuilder。
  2. 调用 XMLMapperBuilder#parse() 办法，以实现 <mappers> 标签的解析。

源码如下：

// org.apache.ibatis.builder.xml.XMLConfigBuilder#mapperElement
private void mapperElement(XNode parent) throws Exception {if (parent != null) {
        // 遍历每个子标签
        for (XNode child : parent.getChildren()) {if ("package".equals(child.getName())) {
                // 如果指定了 <package> 标签，那么就去扫描指定包内的全副 class
                String mapperPackage = child.getStringAttribute("name");
                configuration.addMappers(mapperPackage);
            } else {
                // 解析 <mapper> 子标签，这里会获取 resource、url、class 三个属性，这三个属性互斥
                String resource = child.getStringAttribute("resource");
                String url = child.getStringAttribute("url");
                String mapperClass = child.getStringAttribute("class");
                /*
                如果 <mapper> 标签指定了 resource 或者 url 属性，就会创立 XMLMapperBuilder 对象
                而后应用这个 XMLMapperBuilder 实例解析指定的 Mapper.xml 配置文件
                Mybatis 会为每个 mapper.xml 文件创建一个 XMLMapperBuilder
                */
                if (resource != null && url == null && mapperClass == null) {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) {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) {
                    // 如果 <mapper> 标签指定了 class 属性，则向 MapperRegistry 注册 class 属性指定的 Mapper 接口
                    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.");
                }
            }
        }
    }
}

XMLMapperBuilder#parse() 办法

XMLMapperBuilder#parse() 办法的工作流程如下：

  1. 解析 <cache-ref> 跟 <cache> 标签的信息，来设置该 Mapper 的二级缓存
  2. 解析 <parameterMap> 标签
  3. 解析 <resultMap> 标签
  4. 解析 <sql> 标签
  5. 解析 <select>，<insert>，<update>，<delete> 标签

源码如下：

// org.apache.ibatis.builder.xml.XMLMapperBuilder#parse
public void parse() {
    // 这么做次要是避免屡次加载同一个 mapper 的配置信息（因为 Spring 早就曾经加过一次了）if (!configuration.isResourceLoaded(resource)) {
        // 真正解析 Mapper.xml 映射文件的中央
        configurationElement(parser.evalNode("/mapper"));
        // 将 resource 对象增加到 Configuration 中，示意曾经加载过该资源了
        configuration.addLoadedResource(resource);
        // 从 MapperBuilderAssistant 中获取以后加载 Mapper 的全限定名
        // 并通过全限定名找到该 Mapper 的 class 信息，而后增加到 Configuration.mapperRegistry 的 knownMappers 中去
        bindMapperForNamespace();}

    parsePendingResultMaps();
    parsePendingCacheRefs();
    parsePendingStatements();}

// org.apache.ibatis.builder.xml.XMLMapperBuilder#configurationElement
private void configurationElement(XNode context) {
    try {
        // 获取 mapper 的 namespace
        String namespace = context.getStringAttribute("namespace");
        if (namespace == null || namespace.isEmpty()) {throw new BuilderException("Mapper's namespace cannot be empty");
        }
        // 设置 mapper 的 namespace 到 builderAssistant 的 currentNamespace 字段上
        // 后续解析 <cache-ref> 标签会用到
        builderAssistant.setCurrentNamespace(namespace);
        // 解析 cache 和 cache-ref(二级缓存) 标签
        cacheRefElement(context.evalNode("cache-ref"));
        cacheElement(context.evalNode("cache"));
        // 解析 parameterMap 和 resultMap 标签
        parameterMapElement(context.evalNodes("/mapper/parameterMap"));
        resultMapElements(context.evalNodes("/mapper/resultMap"));
        // 解析 sql 标签
        sqlElement(context.evalNodes("/mapper/sql"));
        // 解析 select , insert , update , delete 的标签
        buildStatementFromContext(context.evalNodes("select|insert|update|delete"));
    } catch (Exception e) {throw new BuilderException("Error parsing Mapper XML. The XML location is'" + resource + "'. Cause:" + e, e);
    }
}

1 解析 cache-ref 和 cache 标签

解析 <cache-ref> 标签的流程如下：

  1. 将以后 mapper 的 namespace 与 <cache-ref> 的 namespace 属性关联到 configuration.cacheRef 中去
  2. 从 Configuration.caches 中查找 <cache-ref> 指定的缓存，并通过 MapperBuilderAssistant 将以后的 mapper 的缓存设置成 <cache-ref> 指定的缓存。
  3. 如果 <cache-ref> 指定的缓存没有加载进来的话，那么就会抛出 IncompleteElementException 的异样，
    并增加到 configuration 的 incompleteCacheRefs 列表中去，等到后续再增加

<cache> 标签的解析绝对 <cache-ref> 就简略很多了，流程如下：

  1. 读取 <cache> 标签下的 type，eviction，flushInterval 等属性的信息
  2. 依据读取到的属性，用于创立一个新的 Cache 缓存对象，而后增加到 Configuration.caches 中去

2 解析 parameterMap 标签

流程如下：

  1. 获取 <parameterMap> 标签的 id 跟 type 属性。
  2. 解析 <parameterMap> 标签内所有的 <parameter> 标签的属性，如 property , javaType , jdbcType , resultMap 等属性。
  3. 将 <parameter> 标签解析到的属性，通过 builderAssistant#buildParameterMapping() 办法创立 ParameterMapping 对象。
  4. 创立 ParameterMap 对象，并将 ParameterMapping 对象增加到 ParameterMap 外面。
  5. 将 ParameterMap 对象增加到 Configuration 对象的 parameterMap 中去。

源码如下：

private void parameterMapElement(List<XNode> list) {for (XNode parameterMapNode : list) {
        // 解析每个 <parameterMap> 标签的 id、type 属性
        String id = parameterMapNode.getStringAttribute("id");
        String type = parameterMapNode.getStringAttribute("type");
        Class<?> parameterClass = resolveClass(type);
        List<XNode> parameterNodes = parameterMapNode.evalNodes("parameter");
        List<ParameterMapping> parameterMappings = new ArrayList<>();
        for (XNode parameterNode : parameterNodes) {
            // 解析 <parameter> 的标签属性
            String property = parameterNode.getStringAttribute("property");
            String javaType = parameterNode.getStringAttribute("javaType");
            String jdbcType = parameterNode.getStringAttribute("jdbcType");
            String resultMap = parameterNode.getStringAttribute("resultMap");
            String mode = parameterNode.getStringAttribute("mode");
            String typeHandler = parameterNode.getStringAttribute("typeHandler");
            Integer numericScale = parameterNode.getIntAttribute("numericScale");
            ParameterMode modeEnum = resolveParameterMode(mode);
            Class<?> javaTypeClass = resolveClass(javaType);
            JdbcType jdbcTypeEnum = resolveJdbcType(jdbcType);
            Class<? extends TypeHandler<?>> typeHandlerClass = resolveClass(typeHandler);
            // 依据 <parameter> 标签的属性，创立 ParameterMapping 对象，并增加到 Configuration 的 parameterMap 中去
            ParameterMapping parameterMapping = 
                builderAssistant.buildParameterMapping(parameterClass, property, javaTypeClass, jdbcTypeEnum, resultMap, modeEnum, typeHandlerClass, numericScale);
            parameterMappings.add(parameterMapping);
        }
        builderAssistant.addParameterMap(id, parameterClass, parameterMappings);
    }
}

2.1 创立 ParameterMapping 对象流程

MyBatis 在解析 <parameter> 的过程中，会创立 ParameterMapping 对象进去，用来示意 <parameter> 标签的信息。
ParameterMapping 对象创立的流程如下：

  1. 生成 resultMap 的名字，名字是 mapper 的全限定名 + resultMap 的 id，用于示意该 PameterMapping 对象与 resultMap 的关联关系。

  2. 解析 <parameter> 标签对应 javaType，也就是参数的 class 信息，它的流程如下:

    1. 如果 javaType 参数不为空，那么 javaTypeClass 也就是 javaType
    2. 如果 jdbcType 参数的值为 JdbcType.CURSOR，那么 javaTypeClass 的值就是它
    3. 如果 parameterType 参数的值为 Map，那么 javaTypeClass 的值就是 Object.class
    4. 尝试通过 parameterType 参数来创立 MetaClass , 并通过 MetaClass 来获取 property 的 class 信息，那么 javaTypeClass 就是这个 class 信息。
      实质就是通过反射来获取 parameterType 参数的 property 参数的 class 信息
    5. 如果都获取不到，那返回 Object.class
  3. 依据 typeHandler 的 class 信息来获取 / 创立 typeHandler 对象
  4. 返回 ParameterMapping 对象

源码如下：

//org.apache.ibatis.builder.MapperBuilderAssistant#buildParameterMapping
public ParameterMapping buildParameterMapping(
    Class<?> parameterType,
    String property,
    Class<?> javaType,
    JdbcType jdbcType,
    String resultMap,
    ParameterMode parameterMode,
    Class<? extends TypeHandler<?>> typeHandler,
    Integer numericScale) {
    // 生成 resultMap 的名字
    resultMap = applyCurrentNamespace(resultMap, true);
    // 解析参数的 javaType，用于决定 <parameter> 的类型
    Class<?> javaTypeClass = resolveParameterJavaType(parameterType, property, javaType, jdbcType);
    // 依据 typeHandler 的 class 信息来获取 / 创立 typeHandler 对象
    TypeHandler<?> typeHandlerInstance = resolveTypeHandler(javaTypeClass, typeHandler);

    return new ParameterMapping.Builder(configuration, property, javaTypeClass)
        .jdbcType(jdbcType)
        .resultMapId(resultMap)
        .mode(parameterMode)
        .numericScale(numericScale)
        .typeHandler(typeHandlerInstance)
        .build();}

/**
* 解析参数的 javaType
* 如果 javaType 参数为空的话，则尝试通过 jdbcType 或者 resultType 去查找参数的类型
* @param resultType <parameterMap> 的 type 信息，也就是 parameterMap 映射的类
* @param property <parameter> 的 property 信息，也就是 parameterMap 映射的类的字段名
* @param javaType <parameter> 的 javaType，示意指定的字段名的类型
* @param jdbcType <parameter> 的 jdbcType，示意指定的字段名对应的 jdbcType
* @return
*/
//org.apache.ibatis.builder.MapperBuilderAssistant#resolveParameterJavaType
private Class<?> resolveParameterJavaType(Class<?> resultType, String property, Class<?> javaType, JdbcType jdbcType) {if (javaType == null) {
        // 如果没有指定 javaType 的话，则思考从 jdbcType 或者 resultType 外面获取
        if (JdbcType.CURSOR.equals(jdbcType)) {javaType = java.sql.ResultSet.class;} else if (Map.class.isAssignableFrom(resultType)) {javaType = Object.class;} else {
            // 如果 jdbcType 不是 CURSOR，resultType 也不是 Map 的话
            // 则须要依据 resultType 来创立 MetaClass，而后获取 property 对应的 class 信息
            MetaClass metaResultType = MetaClass.forClass(resultType, configuration.getReflectorFactory());
            // 失去了 MetaClass 后，调用 getGetterType 办法
            // 底层是调用 Reflector#getGetterType 来获取 resultType 的 property 的 class 信息
            javaType = metaResultType.getGetterType(property);
        }
    }
    if (javaType == null) {javaType = Object.class;}
    return javaType;
}

3 解析 resultMap 标签

在解析 <resultMap> 标签的过程中，会解析它的 id 跟 type 属性值，以确定 resultMap 的 id 跟 java 类型。
而后解析它的子标签，如：<constructor> , <discriminator> , <id> , <result> 等子标签，而后将这些子标签转换成 ResultMapping 对象来示意。
接着创立 ResultMapResolver 对象，并把下面失去的 id、type、ResultMapping 对象，传入到 ResultMapResolver 对象中去。
最初调用 ResultMapResolver#resolve() 办法，创立出 ResultMap 对象，并把该对象存入到 Configuration 的 resultMaps 中去。

3.1 解析 resultMap 外围源码 

// org.apache.ibatis.builder.xml.XMLMapperBuilder#resultMapElement
private ResultMap resultMapElement(XNode resultMapNode, List<ResultMapping> additionalResultMappings, Class<?> enclosingType) {ErrorContext.instance().activity("processing" + resultMapNode.getValueBasedIdentifier());
    /*
        解析 resultMap 的 type 属性，会顺次依照以下程序查找 type 属性
        type->ofType->resultType->javaType
    */
    String type = resultMapNode.getStringAttribute("type",
        resultMapNode.getStringAttribute("ofType",
            resultMapNode.getStringAttribute("resultType",
                resultMapNode.getStringAttribute("javaType"))));
    Class<?> typeClass = resolveClass(type);
    if (typeClass == null) {
        // 如果没有找到 resultMap 的类型，则尝试从参数 enclosingType 中获取
        typeClass = inheritEnclosingType(resultMapNode, enclosingType);
    }
    Discriminator discriminator = null;
    List<ResultMapping> resultMappings = new ArrayList<>(additionalResultMappings);
    List<XNode> resultChildren = resultMapNode.getChildren();
    /*
        解析 resultMap 下的各个子标签，每个子标签都会生成一个 ResultMapping 对象
        这些 resultMapping 对象会增加到 resultMappings 汇合中去
        这里波及到 <id> , <result> , <association> , <collection> , <discriminator> 标签
    */
    for (XNode resultChild : resultChildren) {if ("constructor".equals(resultChild.getName())) {
            // 解析 <constructor> 标签
            processConstructorElement(resultChild, typeClass, resultMappings);
        } else if ("discriminator".equals(resultChild.getName())) {discriminator = processDiscriminatorElement(resultChild, typeClass, resultMappings);
        } else {List<ResultFlag> flags = new ArrayList<>();
            if ("id".equals(resultChild.getName())) {flags.add(ResultFlag.ID);
            }
            // 解析 <id>、<result> 标签
            resultMappings.add(buildResultMappingFromContext(resultChild, typeClass, flags));
        }
    }
    // 获取 <resultMap> 标签的 id 属性，默认值会拼装所有父标签的 id、value、property 属性值
    String id = resultMapNode.getStringAttribute("id",resultMapNode.getValueBasedIdentifier());
    // 获取 resultMap 的 <extends> 和 <autoMapping> 属性
    String extend = resultMapNode.getStringAttribute("extends");
    Boolean autoMapping = resultMapNode.getBooleanAttribute("autoMapping");
    // 创立 ResultMapResolver 对象，ResultMapResolver 会依据下面解析到的 ResultMappings 汇合以及 <resultMap> 标签的属性
    ResultMapResolver resultMapResolver = 
        new ResultMapResolver(builderAssistant, id, typeClass, extend, discriminator, resultMappings, autoMapping);
    try {
        // 结构 resultMap 对象，并将其增加到 Configuration.resultMaps 汇合中去，而后返回 resultMap 对象
        return resultMapResolver.resolve();} catch (IncompleteElementException e) {configuration.addIncompleteResultMap(resultMapResolver);
        throw e;
    }
}

3.2 buildResultMappingFromContext 办法

该办法是解析 <resultMap> 下的 <constructor>、<id> 跟 <result> 标签的次要入口。

源码：

// org.apache.ibatis.builder.xml.XMLMapperBuilder#buildResultMappingFromContext
private ResultMapping buildResultMappingFromContext(XNode context, Class<?> resultType, List<ResultFlag> flags) {
    String property;
    // 如果是 <construct> 标签，则取 name 属性，否则取 property 属性
    if (flags.contains(ResultFlag.CONSTRUCTOR)) {property = context.getStringAttribute("name");
    } else {property = context.getStringAttribute("property");
    }
    // 获取 column、javaType、jdbcType、select 等一系列属性
    String column = context.getStringAttribute("column");
    String javaType = context.getStringAttribute("javaType");
    String jdbcType = context.getStringAttribute("jdbcType");
    String nestedSelect = context.getStringAttribute("select");
    // 如果是 <association> 和 <collection> 标签，则进行解析
    // 如果 resultMap 属性有值，则间接取 resultMap 的属性值，否则就要去获取 resultMap 的 id（如果标签的 select 属性不为空，那么 resultMap 的 id 就为 null）// processNestedResultMappings 其实就是递归调用 org.apache.ibatis.builder.xml.XMLMapperBuilder#resultMapElement() 办法
    String nestedResultMap = context.getStringAttribute("resultMap", () ->
        processNestedResultMappings(context, Collections.emptyList(), resultType));
    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"));
    // 依据下面失去的属性值，获取标签对应的 javaTypeClass , typeHandler , jdbcType 的类型
    Class<?> javaTypeClass = resolveClass(javaType);
    Class<? extends TypeHandler<?>> typeHandlerClass = resolveClass(typeHandler);
    JdbcType jdbcTypeEnum = resolveJdbcType(jdbcType);
    // 创立 ResultMapping 对象，源码在上面
    return builderAssistant.buildResultMapping(resultType, property, column, javaTypeClass, jdbcTypeEnum, nestedSelect, 
        nestedResultMap, notNullColumn, columnPrefix, typeHandlerClass, flags, resultSet, foreignColumn, lazy);
}

// org.apache.ibatis.builder.MapperBuilderAssistant#buildResultMapping
public ResultMapping buildResultMapping(
    Class<?> resultType,
    String property,
    String column,
    Class<?> javaType,
    JdbcType jdbcType,
    String nestedSelect,
    String nestedResultMap,
    String notNullColumn,
    String columnPrefix,
    Class<? extends TypeHandler<?>> typeHandler,
    List<ResultFlag> flags,
    String resultSet,
    String foreignColumn,
    boolean lazy) {
    // 如果 javaType 为 null 的话，间接拿 resultMap（resultType 参数）的 class 下的属性 /setter 办法（property 参数）的 class
    // 如果 javaType 不为 null 的话，则间接是拿 javaType 的 class
    Class<?> javaTypeClass = resolveResultJavaType(resultType, property, javaType);
    // 获取 typeHandler
    TypeHandler<?> typeHandlerInstance = resolveTypeHandler(javaTypeClass, typeHandler);
    List<ResultMapping> composites;
    if ((nestedSelect == null || nestedSelect.isEmpty()) && (foreignColumn == null || foreignColumn.isEmpty())) {composites = Collections.emptyList();
    } else {composites = parseCompositeColumnName(column);
    }
    return new ResultMapping.Builder(configuration, property, column, javaTypeClass)
        .jdbcType(jdbcType)
        .nestedQueryId(applyCurrentNamespace(nestedSelect, true))
        .nestedResultMapId(applyCurrentNamespace(nestedResultMap, true))
        .resultSet(resultSet)
        .typeHandler(typeHandlerInstance)
        .flags(flags == null ? new ArrayList<>() : flags)
        .composites(composites)
        .notNullColumns(parseMultipleColumnNames(notNullColumn))
        .columnPrefix(columnPrefix)
        .foreignColumn(foreignColumn)
        .lazy(lazy)
        .build();}

3.3 ResultMapResolver#resolve() 办法

失去了 ResultMapping 对象的列表后，则须要将 resultMap 的 id , type , resultMapping 等属性，通过 ResultMapResolver#resolve() 办法创立 ResultMap 对象进去，再增加到 Configuration.resultMaps 中去。

源码：

// org.apache.ibatis.builder.ResultMapResolver#resolve
public ResultMap resolve() {return assistant.addResultMap(this.id, this.type, this.extend, this.discriminator, this.resultMappings, this.autoMapping);
}

// org.apache.ibatis.builder.MapperBuilderAssistant#addResultMap
public ResultMap addResultMap(
    String id,
    Class<?> type,
    String extend,
    Discriminator discriminator,
    List<ResultMapping> resultMappings,
    Boolean autoMapping) {
    // ResultMap 的残缺 id 是 "namespace.id" 的格局，namespace 就是 mapper 的 namespace 
    id = applyCurrentNamespace(id, false);
    // 获取被继承的 ResultMap 的残缺 id，也就是父 ResultMap 对象的残缺 id
    extend = applyCurrentNamespace(extend, true);

    // 针对 extend 属性的解决
    if (extend != null) {
        // 针对 extend 检测 Configuration.resultMaps 汇合中是否存在被继承的 ResultMap 对象
        if (!configuration.hasResultMap(extend)) {throw new IncompleteElementException("Could not find a parent resultmap with id'" + extend + "'");
        }
        // 获取须要被继承的 resultMap 对象，也就是父 ResultMap 对象
        ResultMap resultMap = configuration.getResultMap(extend);
        // 获取父对 ResultMap 对象中记录的 ResultMapping 汇合
        List<ResultMapping> extendedResultMappings = new ArrayList<>(resultMap.getResultMappings());
        // 删除须要笼罩的 ResultMapping 汇合
        extendedResultMappings.removeAll(resultMappings);
        /*
        *  如果以后 <resultMap> 标签中定义了 <constructor> 标签，*  则不须要应用父 ResultMap 中记录的相应 <constructor> 标签，这里会将其对应的 resultMapping 对象删除
        */
        boolean declaresConstructor = false;
        for (ResultMapping resultMapping : resultMappings) {if (resultMapping.getFlags().contains(ResultFlag.CONSTRUCTOR)) {
                declaresConstructor = true;
                break;
            }
        }
        if (declaresConstructor) {extendedResultMappings.removeIf(resultMapping -> resultMapping.getFlags().contains(ResultFlag.CONSTRUCTOR));
        }
        // 增加须要被继承的 resultMapping 对象记录到 resultMappings 汇合中
        resultMappings.addAll(extendedResultMappings);
    }
    // 创立 resultMap 对象，并增加到 Configuration.resultMaps 汇合中
    ResultMap resultMap = new ResultMap.Builder(configuration, id, type, resultMappings, autoMapping)
        .discriminator(discriminator)
        .build();
    configuration.addResultMap(resultMap);
    return resultMap;
}

4 解析 sql 标签

解析 <sql> 标签的流程则比较简单，次要是扫描所有 <sql> 的标签，并把它们保留到 XMLMapperBuilder 的 sqlFragments Map 中去。其中 sqlFragments 的 key 为 <sql> 标签的 id 属性，value 为 <sql> 标签对应的 XNode 对象。
对应源码在 org.apache.ibatis.builder.xml.XMLMapperBuilder#sqlElement(java.util.List<org.apache.ibatis.parsing.XNode>) 办法上。

5 解析 select , insert , update , delete 的标签

工作流程如下：

  1. 依据标签的名字来决定 SQL 的类型，是 select , insert 还是其余 SQL 语句，并用 SqlCommandType 来示意。
  2. 如果标签内蕴含 <include> 的子标签，则将 <include> 的内容转换成 SQL 片段。
  3. 获取标签的 parameterType，确定标签的参数类型。
  4. 解决 <selectKey> 标签，并解析 <selectKey> 标签来失去 KeyGenerator 对象。
  5. 通过 LanguageDriver.createSqlSource() 办法来创立 SqlSource 对象，这个过程会解析标签内的 <if> , <where> 等子标签。
  6. 获取 SQL 标签中配置的 resultSets、keyProperty、keyColumn 等属性，以及后面解析 <selectKey> 标签失去的 KeyGenerator 对象等，这些信息将会填充到 MappedStatement 对象中。
  7. 根据上述属性信息创立 MappedStatement 对象，并增加到 Configuration.mappedStatements 汇合中保留

源码如下：

// org.apache.ibatis.builder.xml.XMLStatementBuilder#parseStatementNode
public void parseStatementNode() {
    // 获取 id 跟 databaseId
    String id = context.getStringAttribute("id");
    String databaseId = context.getStringAttribute("databaseId");
    /*
        1. 如果 databaseId 跟以后的不匹配，则不加载该 SQL 标签
        2. 如果存在雷同 id 且 databaseId 不为空的 SQL 标签，则不再加载该 SQL 标签
    */
    if (!databaseIdMatchesCurrent(id, databaseId, this.requiredDatabaseId)) {return;}
    // 依据 SQL 标签名来决定其 SqlCommandType, SqlCommandType 用来判断是以后的 SQL 标签是 select , insert , update , delete 还是 flush
    String nodeName = context.getNode().getNodeName();
    SqlCommandType sqlCommandType = SqlCommandType.valueOf(nodeName.toUpperCase(Locale.ENGLISH));
    boolean isSelect = sqlCommandType == SqlCommandType.SELECT;
    boolean flushCache = context.getBooleanAttribute("flushCache", !isSelect);
    boolean useCache = context.getBooleanAttribute("useCache", isSelect);
    boolean resultOrdered = context.getBooleanAttribute("resultOrdered", false);

    // 在解析 SQL 标签前，先解决 <include> 标签
    XMLIncludeTransformer includeParser = new XMLIncludeTransformer(configuration, builderAssistant);
    // 将 <include> 标签的内容转换成 SQL 片段
    includeParser.applyIncludes(context.getNode());

    // 获取 SQL 标签的 parameterType 和 lang 属性
    String parameterType = context.getStringAttribute("parameterType");
    Class<?> parameterTypeClass = resolveClass(parameterType);

    String lang = context.getStringAttribute("lang");
    LanguageDriver langDriver = getLanguageDriver(lang);

    // 解决 <selectKey> 标签
    processSelectKeyNodes(id, parameterTypeClass, langDriver);

    // 获取其余属性，而后持续解析这些属性
    // 获取 / 创立主键 id 生成器，如果是标签上的 useGeneratedKeys 的属性为 true
    // 或者是 useGeneratedKeys 没有值，mybatis-config.xml 上设置了 userGeneratedKey，并且是 Insert 语句
    KeyGenerator keyGenerator;
    String keyStatementId = id + SelectKeyGenerator.SELECT_KEY_SUFFIX;
    keyStatementId = builderAssistant.applyCurrentNamespace(keyStatementId, true);
    if (configuration.hasKeyGenerator(keyStatementId)) {keyGenerator = configuration.getKeyGenerator(keyStatementId);
    } else {
        keyGenerator = context.getBooleanAttribute("useGeneratedKeys",
            configuration.isUseGeneratedKeys() && SqlCommandType.INSERT.equals(sqlCommandType))
            ? Jdbc3KeyGenerator.INSTANCE : NoKeyGenerator.INSTANCE;
    }
    // 通过 LanguageDriver.createSqlSource() 办法来创立 SqlSource 对象
    // 这里会解析 if , where , case 等子标签
    SqlSource sqlSource = langDriver.createSqlSource(configuration, context, parameterTypeClass);
    /*
        获取 SQL 标签中配置的 resultSets、keyProperty、keyColumn 等属性，以及后面解析 <selectKey> 标签失去的 KeyGenerator 对象等，这些信息将会填充到 MappedStatement 对象中
    */
    StatementType statementType = StatementType.valueOf(context.getStringAttribute("statementType", StatementType.PREPARED.toString()));
    Integer fetchSize = context.getIntAttribute("fetchSize");
    Integer timeout = context.getIntAttribute("timeout");
    String parameterMap = context.getStringAttribute("parameterMap");
    String resultType = context.getStringAttribute("resultType");
    Class<?> resultTypeClass = resolveClass(resultType);
    String resultMap = context.getStringAttribute("resultMap");
    String resultSetType = context.getStringAttribute("resultSetType");
    ResultSetType resultSetTypeEnum = resolveResultSetType(resultSetType);
    if (resultSetTypeEnum == null) {resultSetTypeEnum = configuration.getDefaultResultSetType();
    }
    String keyProperty = context.getStringAttribute("keyProperty");
    String keyColumn = context.getStringAttribute("keyColumn");
    String resultSets = context.getStringAttribute("resultSets");
    // 根据上述属性信息创立 MappedStatement 对象，并增加到 Configuration.mappedStatements 汇合中保留
    builderAssistant.addMappedStatement(id, sqlSource, statementType, sqlCommandType,
        fetchSize, timeout, parameterMap, parameterTypeClass, resultMap, resultTypeClass,
        resultSetTypeEnum, flushCache, useCache, resultOrdered,
        keyGenerator, keyProperty, keyColumn, databaseId, langDriver, resultSets);
}

5.1 获取标签对应的 SQL 类型

MyBatis 依据 SqlCommandType 枚举类来决定该 SQL 的类型，该 SqlCommandType 会最初在 MapperBuilderAssistant#addMappedStatement() 办法中，作为其中一个参数增加进去。
源码如下：

// org.apache.ibatis.mapping.SqlCommandType
public enum SqlCommandType {UNKNOWN, INSERT, UPDATE, DELETE, SELECT, FLUSH}

5.2 解析 include 标签

MyBatis 通过创立 XMLIncludeTransformer 对象，并通过其 applyIncludes(XNode) 办法，来将 <include> 标签援用的 <sql> 标签，转换成 SQL 片段。
源码如下 

// org.apache.ibatis.builder.xml.XMLIncludeTransformer#applyIncludes(org.w3c.dom.Node)
public void applyIncludes(Node source) {Properties variablesContext = new Properties();
    Properties configurationVariables = configuration.getVariables();
    Optional.ofNullable(configurationVariables).ifPresent(variablesContext::putAll);
    applyIncludes(source, variablesContext, false);
}
// org.apache.ibatis.builder.xml.XMLIncludeTransformer#applyIncludes(org.w3c.dom.Node, java.util.Properties, boolean)
private void applyIncludes(Node source, final Properties variablesContext, boolean included) {if ("include".equals(source.getNodeName())) {
        // 通过 <include> 标签的 refid 字段，找到对应的 <sql> 标签，失去 Node 对象
        Node toInclude = findSqlFragment(getStringAttribute(source, "refid"), variablesContext);
        /*
            解析 <include> 标签下的 <property> 标签，将失去的键值增加到 variablesContext 汇合（Properties 类型）并造成新的 Properties 对象返回，用于替换占位符
        */
        Properties toIncludeContext = getVariablesContext(source, variablesContext);
        /*
            递归执行 applyIncludes() 办法，因为在 <sql> 标签的定义中可能会应用 <include> 援用其余 SQL 片段，在 applyIncludes() 办法递归的过程中，如果遇到“${}”占位符，则应用 variablesContext 汇合中的键值对进行替换；最初，将 <include> 标签替换成 <sql> 标签的内容。*/
        applyIncludes(toInclude, toIncludeContext, true);
        if (toInclude.getOwnerDocument() != source.getOwnerDocument()) {toInclude = source.getOwnerDocument().importNode(toInclude, true);
        }
        source.getParentNode().replaceChild(toInclude, source);
        while (toInclude.hasChildNodes()) {toInclude.getParentNode().insertBefore(toInclude.getFirstChild(), toInclude);
        }
        toInclude.getParentNode().removeChild(toInclude);
    } else if (source.getNodeType() == Node.ELEMENT_NODE) {if (included && !variablesContext.isEmpty()) {
        // replace variables in attribute values
        NamedNodeMap attributes = source.getAttributes();
        for (int i = 0; i < attributes.getLength(); i++) {Node attr = attributes.item(i);
            attr.setNodeValue(PropertyParser.parse(attr.getNodeValue(), variablesContext));
        }
        }
        NodeList children = source.getChildNodes();
        for (int i = 0; i < children.getLength(); i++) {applyIncludes(children.item(i), variablesContext, included);
        }
    } else if (included && (source.getNodeType() == Node.TEXT_NODE || source.getNodeType() == Node.CDATA_SECTION_NODE)
        && !variablesContext.isEmpty()) {
        // replace variables in text node
        source.setNodeValue(PropertyParser.parse(source.getNodeValue(), variablesContext));
    }
}

5.3 获取 SqlSource 对象

MyBatis 通过调用 getLanguageDriver() 办法，以获取 LanguageDriver 对象，并调用其 createSqlSource() 办法，以获取 SqlSource 对象。
LanguageDriver 的默认实现类是 XMLLanguageDriver，它的 createSqlSource() 会解析 <if> , <where> , <trim> 等其余标签。
具体逻辑在 org.apache.ibatis.scripting.xmltags.XMLScriptBuilder#parseScriptNode() 办法中。
而 XMLScriptBuilder 外部保护了 NodeHandler 接口以及其实现类，NodeHandler 负责解析动静 SQL 内的标签，生成相应的 SqlNode 对象。
以 <trim> 标签为例：

private interface NodeHandler {
    // 将 nodeToHandle 参数，转化成 SqlNode 对象，并增加到 targetContents 列表中去
    void handleNode(XNode nodeToHandle, List<SqlNode> targetContents);
}

private class TrimHandler implements NodeHandler {public TrimHandler() { }

    @Override
    public void handleNode(XNode nodeToHandle, List<SqlNode> targetContents) {
        // 通过 org.apache.ibatis.scripting.xmltags.XMLScriptBuilder#parseDynamicTags 办法失去 MixedSqlNode 
        MixedSqlNode mixedSqlNode = parseDynamicTags(nodeToHandle);
        // 解析 trim 标签的 prefix , prefixOverrides , suffix , suffixOverrides 属性
        String prefix = nodeToHandle.getStringAttribute("prefix");
        String prefixOverrides = nodeToHandle.getStringAttribute("prefixOverrides");
        String suffix = nodeToHandle.getStringAttribute("suffix");
        String suffixOverrides = nodeToHandle.getStringAttribute("suffixOverrides");
        // 将这些属性作为构造方法的参数，创立出 TrimSqlNode 对象进去
        TrimSqlNode trim = new TrimSqlNode(configuration, mixedSqlNode, prefix, prefixOverrides, suffix, suffixOverrides);
        targetContents.add(trim);
    }
}

集成了 Spring 模块的状况

在集成了 MyBatis/Spring 或者是 MyBatis/Spring-Boot-Starter 下，则是应用 SqlSessionFactoryBean 来实现 SqlSessionFactory 对象的创立。
次要办法在 org.mybatis.spring.SqlSessionFactoryBean#buildSqlSessionFactory 办法下：

public class SqlSessionFactoryBean
    implements FactoryBean<SqlSessionFactory>, InitializingBean, ApplicationListener<ApplicationEvent> {
    
    // 因为 SqlSessionFactoryBean 继承了 InitializingBean，实现了该办法
    // 故在 Spring 初始化该 Bean 时，会调用该办法，而后调用 buildSqlSessionFactory() 办法，来进行 MyBatis 的初始化和启动流程，并获取 SqlSessionFactory 对象
    @Override
    public void afterPropertiesSet() throws Exception {notNull(dataSource, "Property'dataSource'is required");
        notNull(sqlSessionFactoryBuilder, "Property'sqlSessionFactoryBuilder'is required");
        state((configuration == null && configLocation == null) || !(configuration != null && configLocation != null),
            "Property'configuration'and'configLocation'can not specified with together");

        this.sqlSessionFactory = buildSqlSessionFactory();}

    // 创立 SqlSessionFactory 
    // 与 XMLConfigBuilder#parseConfiguration 办法相似
    // 往 Configuration 对象设置全局配置信息
    // 最初再调用 SqlSessionFactoryBuilder#build(org.apache.ibatis.session.Configuration) 办法实现 MyBatis 的启动
    protected SqlSessionFactory buildSqlSessionFactory() throws Exception {
        
        final Configuration targetConfiguration;

        XMLConfigBuilder xmlConfigBuilder = null;
        if (this.configuration != null) {
            targetConfiguration = this.configuration;
        if (targetConfiguration.getVariables() == null) {targetConfiguration.setVariables(this.configurationProperties);
        } else if (this.configurationProperties != null) {targetConfiguration.getVariables().putAll(this.configurationProperties);
        }
        } else if (this.configLocation != null) {xmlConfigBuilder = new XMLConfigBuilder(this.configLocation.getInputStream(), null, this.configurationProperties);
            targetConfiguration = xmlConfigBuilder.getConfiguration();} else {
            LOGGER.debug(() -> "Property'configuration'or'configLocation'not specified, using default MyBatis Configuration");
            targetConfiguration = new Configuration();
            Optional.ofNullable(this.configurationProperties).ifPresent(targetConfiguration::setVariables);
        }

        Optional.ofNullable(this.objectFactory).ifPresent(targetConfiguration::setObjectFactory);
        Optional.ofNullable(this.objectWrapperFactory).ifPresent(targetConfiguration::setObjectWrapperFactory);
        Optional.ofNullable(this.vfs).ifPresent(targetConfiguration::setVfsImpl);

        if (hasLength(this.typeAliasesPackage)) {scanClasses(this.typeAliasesPackage, this.typeAliasesSuperType).stream()
                .filter(clazz -> !clazz.isAnonymousClass()).filter(clazz -> !clazz.isInterface())
                .filter(clazz -> !clazz.isMemberClass()).forEach(targetConfiguration.getTypeAliasRegistry()::registerAlias);
        }

        if (!isEmpty(this.typeAliases)) {Stream.of(this.typeAliases).forEach(typeAlias -> {targetConfiguration.getTypeAliasRegistry().registerAlias(typeAlias);
                LOGGER.debug(() -> "Registered type alias:'" + typeAlias + "'");
            });
        }

        if (!isEmpty(this.plugins)) {Stream.of(this.plugins).forEach(plugin -> {targetConfiguration.addInterceptor(plugin);
                LOGGER.debug(() -> "Registered plugin:'" + plugin + "'");
            });
        }

        if (hasLength(this.typeHandlersPackage)) {scanClasses(this.typeHandlersPackage, TypeHandler.class).stream().filter(clazz -> !clazz.isAnonymousClass())
                .filter(clazz -> !clazz.isInterface()).filter(clazz -> !Modifier.isAbstract(clazz.getModifiers()))
                .forEach(targetConfiguration.getTypeHandlerRegistry()::register);
        }

        if (!isEmpty(this.typeHandlers)) {Stream.of(this.typeHandlers).forEach(typeHandler -> {targetConfiguration.getTypeHandlerRegistry().register(typeHandler);
                LOGGER.debug(() -> "Registered type handler:'" + typeHandler + "'");
            });
        }

        targetConfiguration.setDefaultEnumTypeHandler(defaultEnumTypeHandler);

        if (!isEmpty(this.scriptingLanguageDrivers)) {Stream.of(this.scriptingLanguageDrivers).forEach(languageDriver -> {targetConfiguration.getLanguageRegistry().register(languageDriver);
                LOGGER.debug(() -> "Registered scripting language driver:'" + languageDriver + "'");
            });
        }
        Optional.ofNullable(this.defaultScriptingLanguageDriver)
            .ifPresent(targetConfiguration::setDefaultScriptingLanguage);

        if (this.databaseIdProvider != null) {// fix #64 set databaseId before parse mapper xmls
            try {targetConfiguration.setDatabaseId(this.databaseIdProvider.getDatabaseId(this.dataSource));
            } catch (SQLException e) {throw new IOException("Failed getting a databaseId", e);
            }
        }

        Optional.ofNullable(this.cache).ifPresent(targetConfiguration::addCache);

        if (xmlConfigBuilder != null) {
            try {xmlConfigBuilder.parse();
                LOGGER.debug(() -> "Parsed configuration file:'" + this.configLocation + "'");
            } catch (Exception ex) {throw new IOException("Failed to parse config resource:" + this.configLocation, ex);
            } finally {ErrorContext.instance().reset();}
        }

        targetConfiguration.setEnvironment(new Environment(this.environment,
            this.transactionFactory == null ? new SpringManagedTransactionFactory() : this.transactionFactory,
            this.dataSource)
        );

        if (this.mapperLocations != null) {if (this.mapperLocations.length == 0) {LOGGER.warn(() -> "Property'mapperLocations'was specified but matching resources are not found.");
            } else {for (Resource mapperLocation : this.mapperLocations) {if (mapperLocation == null) {continue;}
                    try {XMLMapperBuilder xmlMapperBuilder = new XMLMapperBuilder(mapperLocation.getInputStream(),
                            targetConfiguration, mapperLocation.toString(), targetConfiguration.getSqlFragments());
                        xmlMapperBuilder.parse();} catch (Exception e) {throw new IOException("Failed to parse mapping resource:'" + mapperLocation + "'", e);
                    } finally {ErrorContext.instance().reset();}
                    LOGGER.debug(() -> "Parsed mapper file:'" + mapperLocation + "'");
                }
            }
        } else {LOGGER.debug(() -> "Property'mapperLocations'was not specified.");
        }

        return this.sqlSessionFactoryBuilder.build(targetConfiguration);
    }

    @Override
    public SqlSessionFactory getObject() throws Exception {if (this.sqlSessionFactory == null) {afterPropertiesSet();
        }
        return this.sqlSessionFactory;
    }
}

集成 MyBatis/Spring-Boot-Starter 模块

MyBatis/Spring-Boot-Starter 通过 MybatisAutoConfiguration 的 sqlSessionFactory() 办法，来主动创立 SqlSessionFactory 对象。
该办法实际上就是创立一个 SqlSessionFactoryBean 的对象，并调用其 getObject() 办法，来实现 MyBatis 的启动流程。

源码如下：

@org.springframework.context.annotation.Configuration(proxyBeanMethods = false)
@ConditionalOnClass({SqlSessionFactory.class, SqlSessionFactoryBean.class})
@ConditionalOnSingleCandidate(DataSource.class)
@EnableConfigurationProperties(MybatisProperties.class)
@AutoConfigureAfter({DataSourceAutoConfiguration.class, MybatisLanguageDriverAutoConfiguration.class})
public class MybatisAutoConfiguration implements InitializingBean {private static final Logger logger = LoggerFactory.getLogger(MybatisAutoConfiguration.class);

    private final MybatisProperties properties;

    private final Interceptor[] interceptors;

    private final TypeHandler[] typeHandlers;

    private final LanguageDriver[] languageDrivers;

    private final ResourceLoader resourceLoader;

    private final DatabaseIdProvider databaseIdProvider;

    private final List<ConfigurationCustomizer> configurationCustomizers;

    private final List<SqlSessionFactoryBeanCustomizer> sqlSessionFactoryBeanCustomizers;

    public MybatisAutoConfiguration(MybatisProperties properties, ObjectProvider<Interceptor[]> interceptorsProvider,
                                    ObjectProvider<TypeHandler[]> typeHandlersProvider, ObjectProvider<LanguageDriver[]> languageDriversProvider,
                                    ResourceLoader resourceLoader, ObjectProvider<DatabaseIdProvider> databaseIdProvider,
                                    ObjectProvider<List<ConfigurationCustomizer>> configurationCustomizersProvider,
                                    ObjectProvider<List<SqlSessionFactoryBeanCustomizer>> sqlSessionFactoryBeanCustomizers) {
        this.properties = properties;
        this.interceptors = interceptorsProvider.getIfAvailable();
        this.typeHandlers = typeHandlersProvider.getIfAvailable();
        this.languageDrivers = languageDriversProvider.getIfAvailable();
        this.resourceLoader = resourceLoader;
        this.databaseIdProvider = databaseIdProvider.getIfAvailable();
        this.configurationCustomizers = configurationCustomizersProvider.getIfAvailable();
        this.sqlSessionFactoryBeanCustomizers = sqlSessionFactoryBeanCustomizers.getIfAvailable();}

    @Bean
    @ConditionalOnMissingBean
    public SqlSessionFactory sqlSessionFactory(DataSource dataSource) throws Exception {SqlSessionFactoryBean factory = new SqlSessionFactoryBean();
        factory.setDataSource(dataSource);
        if (properties.getConfiguration() == null || properties.getConfiguration().getVfsImpl() == null) {factory.setVfs(SpringBootVFS.class);
        }
        if (StringUtils.hasText(this.properties.getConfigLocation())) {factory.setConfigLocation(this.resourceLoader.getResource(this.properties.getConfigLocation()));
        }
        applyConfiguration(factory);
        if (this.properties.getConfigurationProperties() != null) {factory.setConfigurationProperties(this.properties.getConfigurationProperties());
        }
        if (!ObjectUtils.isEmpty(this.interceptors)) {factory.setPlugins(this.interceptors);
        }
        if (this.databaseIdProvider != null) {factory.setDatabaseIdProvider(this.databaseIdProvider);
        }
        if (StringUtils.hasLength(this.properties.getTypeAliasesPackage())) {factory.setTypeAliasesPackage(this.properties.getTypeAliasesPackage());
        }
        if (this.properties.getTypeAliasesSuperType() != null) {factory.setTypeAliasesSuperType(this.properties.getTypeAliasesSuperType());
        }
        if (StringUtils.hasLength(this.properties.getTypeHandlersPackage())) {factory.setTypeHandlersPackage(this.properties.getTypeHandlersPackage());
        }
        if (!ObjectUtils.isEmpty(this.typeHandlers)) {factory.setTypeHandlers(this.typeHandlers);
        }
        // 如果配置文件 application.yaml 的 mybatis.mapperLocations 信息不为空，那么就会设置 mapper.xml 的加载门路
        Resource[] mapperLocations = this.properties.resolveMapperLocations();
        if (!ObjectUtils.isEmpty(mapperLocations)) {factory.setMapperLocations(mapperLocations);
        }
        Set<String> factoryPropertyNames = Stream
                .of(new BeanWrapperImpl(SqlSessionFactoryBean.class).getPropertyDescriptors()).map(PropertyDescriptor::getName)
                .collect(Collectors.toSet());
        Class<? extends LanguageDriver> defaultLanguageDriver = this.properties.getDefaultScriptingLanguageDriver();
        if (factoryPropertyNames.contains("scriptingLanguageDrivers") && !ObjectUtils.isEmpty(this.languageDrivers)) {
            // Need to mybatis-spring 2.0.2+
            factory.setScriptingLanguageDrivers(this.languageDrivers);
            if (defaultLanguageDriver == null && this.languageDrivers.length == 1) {defaultLanguageDriver = this.languageDrivers[0].getClass();}
        }
        if (factoryPropertyNames.contains("defaultScriptingLanguageDriver")) {
            // Need to mybatis-spring 2.0.2+
            factory.setDefaultScriptingLanguageDriver(defaultLanguageDriver);
        }
        applySqlSessionFactoryBeanCustomizers(factory);
        // 这里实际上就是调用 SqlSessionFactoryBean 的 buildSqlSessionFactory() 办法
        return factory.getObject();}
}

正文完
java
发表至： java
2023-03-22
 0
关于java:Java初始化和清理
关于java:新蜂商城增强版来了完善秒杀功能添加秒杀单超期未支付任务支持万人秒杀
关于java:linux常用命令如何操作目录如何查看文件内容
RPC框架是啥之Apache-CXF一款WebService-RPC框架入门教程