初始化与配置解析

private Properties settingsAsProperties(XNode context) {
    if (context == null) {
        return new Properties();
    }
    // 处理<settings>标签的所有子标签，也就是<setting>标签，将其name属性和value属性
    // 整理到Properties对象中保存
    Properties props = context.getChildrenAsProperties();
    // 创建Configuration对应的MetaClass对象
    MetaClass metaConfig = MetaClass.forClass(Configuration.class, localReflectorFactory);
    // 检测Configuration对象中是否包含每个配置项的setter方法
    for (Object key : props.keySet()) {
        if (!metaConfig.hasSetter(String.valueOf(key))) {
            throw new BuilderException("The setting " + key + " is not known.  Make sure you spelled it correctly (case sensitive).");
        }
    }
    return props;
}

private void typeHandlerElement(XNode parent) {
    if (parent != null) {
        for (XNode child : parent.getChildren()) { // 处理全部<typeHandler>子标签
            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);
                }
            }
        }
    }
}

private void pluginElement(XNode parent) throws Exception {
    if (parent != null) {
        // 遍历全部的<plugin>子标签
        for (XNode child : parent.getChildren()) {
            // 获取每个<plugin>标签中的interceptor属性
            String interceptor = child.getStringAttribute("interceptor");
            // 获取<plugin>标签下的其他配置信息
            Properties properties = child.getChildrenAsProperties();
            // 初始化interceptor属性指定的自定义插件
            Interceptor interceptorInstance = (Interceptor) resolveClass(interceptor).getDeclaredConstructor().newInstance();
            // 初始化插件的配置
            interceptorInstance.setProperties(properties);
            // 将Interceptor对象添加到Configuration的插件链中保存，等待后续使用
            configuration.addInterceptor(interceptorInstance);
        }
    }
}

private void objectFactoryElement(XNode context) throws Exception {
if (context != null) {
    // 获取<objectFactory>标签的type属性
    String type = context.getStringAttribute("type");
    // 根据type属性值，初始化自定义的ObjectFactory实现
    ObjectFactory factory = (ObjectFactory) resolveClass(type).getDeclaredConstructor().newInstance();
    // 初始化ObjectFactory对象的配置
    Properties properties = context.getChildrenAsProperties();
    factory.setProperties(properties);
    // 将ObjectFactory对象记录到Configuration这个全局配置对象中
    configuration.setObjectFactory(factory);
}

private void environmentsElement(XNode context) throws Exception {
    if (context != null) {
        if (environment == null) { // 未指定使用的环境id，默认获取default值
            environment = context.getStringAttribute("default");
        }
        // 获取<environment>标签下的所有配置
        for (XNode child : context.getChildren()) {
            // 获取环境id
            String id = child.getStringAttribute("id");
            if (isSpecifiedEnvironment(id)) {
                // 获取<transactionManager>、<dataSource>等标签，并进行解析，其中会根据配置信息初始化相应的TransactionFactory对象和DataSource对象
                TransactionFactory txFactory = transactionManagerElement(child.evalNode("transactionManager"));
                DataSourceFactory dsFactory = dataSourceElement(child.evalNode("dataSource"));
                DataSource dataSource = dsFactory.getDataSource();
                // 创建Environment对象，并关联创建好的TransactionFactory和DataSource
                Environment.Builder environmentBuilder = new Environment.Builder(id)
                        .transactionFactory(txFactory)
                        .dataSource(dataSource);
                // 将Environment对象记录到Configuration中，等待后续使用
                configuration.setEnvironment(environmentBuilder.build());
            }
        }
    }
}

private void databaseIdProviderElement(XNode context) throws Exception {
    DatabaseIdProvider databaseIdProvider = null;
    if (context != null) {
        // 获取type属性值
        String type = context.getStringAttribute("type");
        if ("VENDOR".equals(type)) { // 兼容操作
            type = "DB_VENDOR";
        }
        // 初始化DatabaseIdProvider
        Properties properties = context.getChildrenAsProperties();
        databaseIdProvider = (DatabaseIdProvider) resolveClass(type).getDeclaredConstructor().newInstance();
        databaseIdProvider.setProperties(properties);
    }
    Environment environment = configuration.getEnvironment();
    if (environment != null && databaseIdProvider != null) {
        // 通过DataSource获取DatabaseId，并保存到Configuration中，等待后续使用
        String databaseId = databaseIdProvider.getDatabaseId(environment.getDataSource());
        configuration.setDatabaseId(databaseId);
    }
}

public String getDatabaseId(DataSource dataSource) {
    // 省略边界检查和异常处理
    return getDatabaseName(dataSource);
}
private String getDatabaseName(DataSource dataSource) throws SQLException {
    // 从数据库连接中，获取数据库名称
    String productName = getDatabaseProductName(dataSource);
    if (this.properties != null) {
        // 根据<databaseIdProvider>标签配置，查找自定义数据库名称
        for (Map.Entry<Object, Object> property : properties.entrySet()) {
            if (productName.contains((String) property.getKey())) {
                return (String) property.getValue(); // 返回配置的value
            }
        }
        return null;
    }
    return productName;
}

private void mapperElement(XNode parent) throws Exception {
    if (parent != null) {
        for (XNode child : parent.getChildren()) { // 遍历每个子标签
            if ("package".equals(child.getName())) {
                // 如果指定了<package>子标签，则会扫描指定包内全部Java类型
                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配置文件
                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.");
                }
            }
        }
    }
}

public Cache build() {
    // 将implementation默认值设置为PerpetualCache，在decorators集合中默认添加LruCache装饰器，
    // 都是在setDefaultImplementations()方法中完成的
    setDefaultImplementations();
    // 通过反射，初始化implementation指定类型的对象
    Cache cache = newBaseCacheInstance(implementation, id);
    // 创建Cache关联的MetaObject对象，并根据properties设置Cache中的各个字段
    setCacheProperties(cache);
    // 根据上面创建的Cache对象类型，决定是否添加装饰器
    if (PerpetualCache.class.equals(cache.getClass())) {
        // 如果是PerpetualCache类型，则为其添加decorators集合中指定的装饰器
        for (Class<? extends Cache> decorator : decorators) {
            // 通过反射创建Cache装饰器
            cache = newCacheDecoratorInstance(decorator, cache);
            // 依赖MetaObject将properties中配置信息设置到Cache的各个属性中，同时调用Cache的initialize()方法完成初始化
            setCacheProperties(cache);
        }
        // 根据readWrite、blocking、clearInterval等配置，
        // 添加SerializedCache、ScheduledCache等装饰器
        cache = setStandardDecorators(cache);
    } else if (!LoggingCache.class.isAssignableFrom(cache.getClass())) {
        // 如果不是PerpetualCache类型，就是其他自定义类型的Cache，则添加一个LoggingCache装饰器
        cache = new LoggingCache(cache);
    }
    return cache;
}

public ResultMap addResultMap(
        String id,
        Class<?> type,
        String extend,
        Discriminator discriminator,
        List<ResultMapping> resultMappings,
        Boolean autoMapping) {
    // ResultMap的完整id是"namespace.id"的格式
    id = applyCurrentNamespace(id, false);
    // 获取被继承的ResultMap的完整id，也就是父ResultMap对象的完整id
    extend = applyCurrentNamespace(extend, true);
    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;
}

private ResultMapping buildResultMappingFromContext(XNode context, Class<?> resultType, List<ResultFlag> flags) {
    ... // <association>标签中其他属性的解析与<result>、<id>标签类似，这里不再展开
    // 如果<association>标签没有指定resultMap属性，那么就是匿名嵌套映射，需要通过
    //  processNestedResultMappings()方法解析该匿名的嵌套映射
    String nestedResultMap = context.getStringAttribute("resultMap", () ->
            processNestedResultMappings(context, Collections.emptyList(), resultType));
    ... // <association>标签中其他属性的解析与<result>、<id>标签类似，这里不再展开
    // 根据上面解析到的属性值，创建ResultMapping对象
    return builderAssistant.buildResultMapping(resultType, property, column, javaTypeClass, jdbcTypeEnum, nestedSelect, nestedResultMap, notNullColumn, columnPrefix, typeHandlerClass, flags, resultSet, foreignColumn, lazy);
}

private Discriminator processDiscriminatorElement(XNode context, Class<?> resultType, List<ResultMapping> resultMappings) {
    // 从<discriminator>标签中解析column、javaType、jdbcType、typeHandler四个属性的逻辑非常简单，这里将这部分代码省略
    Map<String, String> discriminatorMap = new HashMap<>();
    // 解析<discriminator>标签的<case>子标签
    for (XNode caseChild : context.getChildren()) {
        String value = caseChild.getStringAttribute("value");
        // 通过前面介绍的processNestedResultMappings()方法，解析<case>标签，
        // 创建相应的嵌套ResultMap对象
        String resultMap = caseChild.getStringAttribute("resultMap",
                processNestedResultMappings(caseChild, resultMappings, resultType));
        // 记录该列值与对应选择的ResultMap的Id
        discriminatorMap.put(value, resultMap);
    }
    // 创建Discriminator对象
    return builderAssistant.buildDiscriminator(resultType, column, javaTypeClass, jdbcTypeEnum, typeHandlerClass, discriminatorMap);
}

public interface SqlSource {
    // 根据Mapper文件或注解描述的SQL语句，以及传入的实参，返回可执行的SQL
    BoundSql getBoundSql(Object parameterObject);
}

public void parseStatementNode() {
    // 获取SQL标签的id以及databaseId属性
    String id = context.getStringAttribute("id");
    String databaseId = context.getStringAttribute("databaseId");
    // 若databaseId属性值与当前使用的数据库不匹配，则不加载该SQL标签
    // 若存在相同id且databaseId不为空的SQL标签，则不再加载该SQL标签
    if (!databaseIdMatchesCurrent(id, databaseId, this.requiredDatabaseId)) {
        return;
    }
    // 根据SQL标签的名称决定其SqlCommandType
    String nodeName = context.getNode().getNodeName();
    SqlCommandType sqlCommandType = SqlCommandType.valueOf(nodeName.toUpperCase(Locale.ENGLISH));
    // 获取SQL标签的属性值，例如，fetchSize、timeout、parameterType、parameterMap、
    // resultMap、resultType、lang、resultSetType、flushCache、useCache等。
    // 这些属性的具体含义在MyBatis官方文档中已经有比较详细的介绍了，这里不再赘述
    ... ...
    // 在解析SQL语句之前，先处理其中的<include>标签
    XMLIncludeTransformer includeParser = new XMLIncludeTransformer(configuration, builderAssistant);
    includeParser.applyIncludes(context.getNode());
    // 获取SQL标签的parameterType、lang两个属性
    ... ...
    // 解析<selectKey>标签
    processSelectKeyNodes(id, parameterTypeClass, langDriver);

// 暂时省略后面的逻辑
    ...
}

private void parseSelectKeyNode(String id, XNode nodeToHandle, Class<?> parameterTypeClass, LanguageDriver langDriver, String databaseId) {
    ... // 解析<selectKey>标签的resultType、statementType、keyProperty等属性

// 通过LanguageDriver解析<selectKey>标签中的SQL语句，得到对应的SqlSource对象
    SqlSource sqlSource = langDriver.createSqlSource(configuration, nodeToHandle, parameterTypeClass);
    SqlCommandType sqlCommandType = SqlCommandType.SELECT;
    // 创建MappedStatement对象
    builderAssistant.addMappedStatement(id, sqlSource, statementType, sqlCommandType,
            fetchSize, timeout, parameterMap, parameterTypeClass, resultMap, resultTypeClass,
            resultSetTypeEnum, flushCache, useCache, resultOrdered,
            keyGenerator, keyProperty, keyColumn, databaseId, langDriver, null);
    id = builderAssistant.applyCurrentNamespace(id, false);
    // 创建<selectKey>标签对应的KeyGenerator对象，这个KeyGenerator对象会添加到Configuration.keyGenerators集合中
    MappedStatement keyStatement = configuration.getMappedStatement(id, false);
    configuration.addKeyGenerator(id, new SelectKeyGenerator(keyStatement, executeBefore));
}

public void parseStatementNode() {
    // 前面是解析<selectKey>和<include>标签的逻辑，这里不再展示
    // 当执行到这里的时候，<selectKey>和<include>标签已经被解析完毕，并删除掉了
    // 下面是解析SQL语句的逻辑，也是parseStatementNode()方法的核心
    // 通过LanguageDriver.createSqlSource()方法创建SqlSource对象
    SqlSource sqlSource = langDriver.createSqlSource(configuration, context, parameterTypeClass);

// 获取SQL标签中配置的resultSets、keyProperty、keyColumn等属性，以及前面解析<selectKey>标签得到的KeyGenerator对象等，
    // 这些信息将会填充到MappedStatement对象中

// 根据上述属性信息创建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);
}

protected MixedSqlNode parseDynamicTags(XNode node) {
    List<SqlNode> contents = new ArrayList<>(); // 解析后的SqlNode结果集合
    NodeList children = node.getNode().getChildNodes();
    // 获取SQL标签下的所有节点，包括标签节点和文本节点
    for (int i = 0; i < children.getLength(); i++) {
        XNode child = node.newXNode(children.item(i));
        if (child.getNode().getNodeType() == Node.CDATA_SECTION_NODE ||
                child.getNode().getNodeType() == Node.TEXT_NODE) {
            // 处理文本节点，也就是SQL语句
            String data = child.getStringBody("");
            TextSqlNode textSqlNode = new TextSqlNode(data);
            // 解析SQL语句，如果含有未解析的"${}"占位符，则为动态SQL
            if (textSqlNode.isDynamic()) {
                contents.add(textSqlNode);
                isDynamic = true; // 标记为动态SQL语句
            } else {
                contents.add(new StaticTextSqlNode(data));
            }
        } else if (child.getNode().getNodeType() == Node.ELEMENT_NODE) {
            // 如果解析到一个子标签，那么一定是动态SQL
            // 这里会根据不同的标签，获取不同的NodeHandler，然后由NodeHandler进行后续解析
            String nodeName = child.getNode().getNodeName();
            NodeHandler handler = nodeHandlerMap.get(nodeName);
            if (handler == null) {
                throw new BuilderException("Unknown element <" + nodeName + "> in SQL statement.");
            }
            // 处理动态SQL语句，并将解析得到的SqlNode对象记录到contents集合中
            handler.handleNode(child, contents);
            isDynamic = true;
        }
    }
    // 解析后的SqlNode集合将会被封装成MixedSqlNode返回
    return new MixedSqlNode(contents);
}

private class IfHandler implements NodeHandler {
    public void handleNode(XNode nodeToHandle, List<SqlNode> targetContents) {
        // 通过parseDynamicTags()方法，解析<if>标签下嵌套的动态SQL
        MixedSqlNode mixedSqlNode = parseDynamicTags(nodeToHandle);
        // 获取<if>标签判断分支的条件
        String test = nodeToHandle.getStringAttribute("test");
        // 创建IfNode对象(也是SqlNode接口的实现)，并将其保存下来
        IfSqlNode ifSqlNode = new IfSqlNode(mixedSqlNode, test);
        targetContents.add(ifSqlNode);
    }
}

public SqlSource parseScriptNode() {
    // 对SQL语句进行解析
    MixedSqlNode rootSqlNode = parseDynamicTags(context);
    SqlSource sqlSource;
    if (isDynamic) { // 根据该SQL是否为动态SQL，创建不同的SqlSource实现
        sqlSource = new DynamicSqlSource(configuration, rootSqlNode);
    } else {
        sqlSource = new RawSqlSource(configuration, rootSqlNode, parameterType);
    }
    return sqlSource;
}