【文章较长，建议收藏】本文解析MyBatis 工作流程源码，以及
Mybatis系列文章:
【深度好文】谈谈你对MyBatis的理解：MyBatis整体架构
【源码解析】谈谈你对 MyBatis动态SQL 的理解：Mybatis动态sql源码解析及动态sql的执行原理
【源码解析】谈谈你对 MyBatis结果集映射和参数绑定 的理解：MyBatis结果集映射源码解析，详细分析了 handleRowValuesForSimpleResultMap() 等方法实现映射的核心步骤
目录：
MyBatis 工作原理（运行流程）
【总】可以把 MyBatis 的运行流程分为三大阶段：
1. 初始化阶段：读取 XML 配置文件和注解中的配置信息，创建配置对象，并完成各个模块的初始化的工作；
2. 代理封装阶段：封装 iBatis 的编程模型，使用 mapper 接口开发的初始化工作；
3. 数据访问阶段：通过 SqlSession 完成 SQL 的解析，参数的映射、SQL 的执行、结果的解析过程；
MyBatis 工作流程简述
编辑
（1）读取 MyBatis 配置文件：mybatis-config.xml 为 MyBatis 的全局配置文件，配置了 MyBatis 的运行环境等信息，例如数据库连接信息。
（2）加载映射文件。映射文件即 SQL 映射文件，该文件中配置了操作数据库的 SQL 语句，需要在 MyBatis 配置文件 mybatis-config.xml 中加载。mybatis-config.xml 文件可以加载多个映射文件，每个文件对应数据库中的一张表。
（3）构造会话工厂：通过 MyBatis 的环境等配置信息构建会话工厂 SqlSessionFactory。
（4）创建会话对象：由会话工厂创建 SqlSession 对象，该对象中包含了执行 SQL 语句的所有方法。
（5）Executor 执行器：MyBatis 底层定义了一个 Executor 接口来操作数据库，它将根据 SqlSession 传递的参数动态地生成需要执行的 SQL 语句，同时负责查询缓存的维护。
（6）MappedStatement 对象：在 Executor 接口的执行方法中有一个 MappedStatement 类型的参数，该参数是对映射信息的封装，用于存储要映射的 SQL 语句的 id、参数等信息。
（7）输入参数映射：输入参数类型可以是 Map、List 等集合类型，也可以是基本数据类型和 POJO 类型。输入参数映射过程类似于 JDBC 对 preparedStatement 对象设置参数的过程。
（8）输出结果映射：输出结果类型可以是 Map、 List 等集合类型，也可以是基本数据类型和 POJO 类型。输出结果映射过程类似于 JDBC 对结果集的解析过程。
MyBatis 工作流程源码分析
这部分我们要知道 MyBatis 初始化流程源码，MyBatis是如何加载配置文件的？ Mapper.xml 映射文件是如何解析的？ SQL 语句是如何解析（<select>、<insert>、<delete>、<update> 等 SQL 语句标签）？
在初始化的过程中，MyBatis 会读取 mybatis-config.xml 这个全局配置文件以及所有的 Mapper 映射.xml 配置文件，同时还会加载这两个配置文件中指定的类，解析类中的相关注解，最终将解析得到的信息转换成配置对象。完成配置加载之后，MyBatis 就会根据得到的配置对象初始化各个模块。
1、mybatis-config.xml 解析全流程
下面我们正式开始介绍 MyBatis 的初始化过程（工作过程、工作原理）。
MyBatis 初始化的第一个步骤就是加载和解析 mybatis-config.xml 这个全局配置文件，入口是 XMLConfigBuilder 这个 Builder 对象，它由 SqlSessionFactoryBuilder.build() 方法创建。XMLConfigBuilder 会解析 mybatis-config.xml 配置文件得到对应的 Configuration 全局配置对象，然后 SqlSessionFactoryBuilder 会根据得到的 Configuration 全局配置对象创建一个 DefaultSqlSessionFactory 对象返回给上层使用。
在 SqlSessionFactoryBuilder.build() 方法中也可以看到，XMLConfigBuilder.parse() 方法触发了 mybatis-config.xml 配置文件的解析，其中的 parseConfiguration() 方法定义了解析 mybatis-config.xml 配置文件的完整流程，核心步骤如下：
解析 <properties> 标签；
解析 <settings> 标签；
处理日志相关组件；
解析 <typeAliases> 标签；
解析 <plugins> 标签；
解析 <objectFactory> 标签；
解析 <objectWrapperFactory> 标签；
解析 <reflectorFactory> 标签；
解析 <environments> 标签；
解析 <databaseIdProvider> 标签；
解析 <typeHandlers> 标签；
解析 <mappers> 标签。
public SqlSessionFactory build(Reader reader, String environment, Properties properties) { try { XMLConfigBuilder parser = new XMLConfigBuilder(reader, environment, properties); // 触发了 mybatis-config.xml 配置文件的解析 return build(parser.parse()); } catch (Exception e) { throw ExceptionFactory.wrapException("Error building SqlSession.", e); } finally { ErrorContext.instance().reset(); try { reader.close(); } catch (IOException e) { // Intentionally ignore. Prefer previous error. } } }
这里创建的 XMLConfigBuilder 对象的核心功能就是解析 mybatis-config.xml 配置文件。XMLConfigBuilder 有一部分能力继承自 BaseBuilder 抽象类，具体继承关系如下图所示：
编辑
configuration（Configuration 类型）：MyBatis 的初始化过程就是围绕 Configuration 对象展开的，我们可以认为 Configuration 是一个单例对象，MyBatis 初始化解析到的全部配置信息都会记录到 Configuration 对象中。
typeAliasRegistry（TypeAliasRegistry 类型）：别名注册中心。
typeHandlerRegistry（TypeHandlerRegistry 类型）：TypeHandler 注册中心。除了定义别名之外，我们在 mybatis-config.xml 配置文件中，还可以使用 <typeHandlers> 标签添加自定义 TypeHandler 实现，实现数据库类型与 Java 类型的自定义转换，这些自定义的 TypeHandler 都会记录在这个 TypeHandlerRegistry 对象中。
resolveAlias() 方法 ：解析别名，核心逻辑是在中实现的，主要依赖于 TypeAliasRegistry 对象
resolveTypeHandler() 方法：解析 TypeHandler，主要依赖于 TypeHandlerRegistry 对象。
public abstract class BaseBuilder { protected final Configuration configuration; protected final TypeAliasRegistry typeAliasRegistry; protected final TypeHandlerRegistry typeHandlerRegistry; protected Class<?> resolveAlias(String alias) { return typeAliasRegistry.resolveAlias(alias); } protected TypeHandler<?> resolveTypeHandler(Class<?> javaType, String typeHandlerAlias) { if (typeHandlerAlias == null) { return null; } Class<?> type = resolveClass(typeHandlerAlias); if (type != null && !TypeHandler.class.isAssignableFrom(type)) { throw new BuilderException("Type " + type.getName() + " is not a valid TypeHandler because it does not implement TypeHandler interface"); } @SuppressWarnings( "unchecked" ) // already verified it is a TypeHandler Class<? extends TypeHandler<?>> typeHandlerType = (Class<? extends TypeHandler<?>>) type; return resolveTypeHandler(javaType, typeHandlerType); } protected TypeHandler<?> resolveTypeHandler(Class<?> javaType, Class<? extends TypeHandler<?>> typeHandlerType) { if (typeHandlerType == null) { return null; } // javaType ignored for injected handlers see issue #746 for full detail TypeHandler<?> handler = typeHandlerRegistry.getMappingTypeHandler(typeHandlerType); if (handler == null) { // not in registry, create a new one handler = typeHandlerRegistry.getInstance(javaType, typeHandlerType); } return handler; } }
我们回来看 XMLConfigBuilder 这个 Builder 实现类，看看它是如何解析 mybatis-config.xml 配置文件的。
parsed（boolean 类型）：状态标识字段，记录当前 XMLConfigBuilder 对象是否已经成功解析完 mybatis-config.xml 配置文件。
parser（XPathParser 类型）：XPathParser 对象是一个 XML 解析器，这里的 parser 对象就是用来解析 mybatis-config.xml 配置文件的。
environment（String 类型）： 标签定义的环境名称。
localReflectorFactory（ReflectorFactory 类型）：ReflectorFactory 接口的核心功能是实现对 Reflector 对象的创建和缓存。
public class XMLConfigBuilder extends BaseBuilder { private boolean parsed; private final XPathParser parser; private String environment; 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 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); } } }
我们可以看到 parseConfiguration(XNode root) 就硬核处理，简单介绍几个常用的
处理<properties>标签：从 <properties> 标签中解析出来的 KV 信息会被记录到一个 Properties 对象（也就是 Configuration 全局配置对象的 variables 字段），在后续解析其他标签的时候，MyBatis 会使用这个 Properties 对象中记录的 KV 信息替换匹配的占位符。
处理<settings>标签：是否使用二级缓存、是否开启懒加载功能等，这些都是通过 mybatis-config.xml 配置文件中的 <settings> 标签进行配置的。XMLConfigBuilder.settingsAsProperties() 方法的核心逻辑就是解析 <settings> 标签，并将解析得到的配置信息记录到 Configuration 这个全局配置对象的同名属性中。
处理<mappers>标签：<mappers> 标签中会指定 Mapper.xml 映射文件的位置，通过解析 <mappers> 标签，MyBatis 就能够知道去哪里加载这些 Mapper.xml 文件了。mapperElement() 方法就是 XMLConfigBuilder 处理 <mappers> 标签的具体实现，其中会初始化 XMLMapperBuilder 对象来加载各个 Mapper.xml 映射文件。同时，还会扫描 Mapper 映射文件相应的 Mapper 接口，处理其中的注解并将 Mapper 接口注册到 MapperRegistry 中。
2、Mapper.xml 映射文件解析全流程
在 mybatis-config.xml 配置文件中可以定义多个 <mapper> 标签指定 Mapper 配置文件的地址，MyBatis 会为每个 Mapper.xml 映射文件创建一个 XMLMapperBuilder 实例完成解析。
与 XMLConfigBuilder 类似，XMLMapperBuilder也是具体构造者的角色，继承了 BaseBuilder 这个抽象类，解析 Mapper.xml 映射文件的入口是 XMLMapperBuilder.parse() 方法，其核心步骤如下：
1、执行 configurationElement() 方法解析整个Mapper.xml 映射文件的内容；
2、获取当前 Mapper.xml 映射文件指定的 Mapper 接口，并进行注册；
3、处理 configurationElement() 方法中解析失败的 <resultMap> 标签；
4、处理 configurationElement() 方法中解析失败的 <cache-ref> 标签；
5、处理 configurationElement() 方法中解析失败的SQL 语句标签。
public void parse() { if (!configuration.isResourceLoaded(resource)) { configurationElement(parser.evalNode("/mapper")); configuration.addLoadedResource(resource); bindMapperForNamespace(); } parsePendingResultMaps(); parsePendingCacheRefs(); parsePendingStatements(); } private void configurationElement(XNode context) { try { String namespace = context.getStringAttribute("namespace"); if (namespace == null || namespace.equals("")) { throw new BuilderException("Mapper's namespace cannot be empty"); } builderAssistant.setCurrentNamespace(namespace); cacheRefElement(context.evalNode("cache-ref")); cacheElement(context.evalNode("cache")); parameterMapElement(context.evalNodes("/mapper/parameterMap")); resultMapElements(context.evalNodes("/mapper/resultMap")); sqlElement(context.evalNodes("/mapper/sql")); buildStatementFromContext(context.evalNodes("select|insert|update|delete")); } catch (Exception e) { throw new BuilderException("Error parsing Mapper XML. Cause: " + e, e); } }
configurationElement() 方法才是真正解析 Mapper.xml 映射文件的地方，其中定义了处理 Mapper.xml 映射文件的核心流程：
获取 <mapper> 标签中的 namespace 属性，同时会进行多种边界检查；
解析 <cache> 标签；
解析 <cache-ref> 标签；
解析 <resultMap> 标签；
解析 <sql> 标签；
解析 <select>、<insert>、<update>、<delete> 等 SQL 标签。
我们详细讲解下<cache> 标签和<resultMap> 标签
1、处理 <cache> 标签
一级缓存是默认开启的，而二级缓存默认情况下并没有开启，如有需要，可以通过<cache>标签为指定的namespace 开启二级缓存。
XMLMapperBuilder 中解析 <cache> 标签的核心逻辑位于 cacheElement() 方法之中，其具体步骤如下：
（1）获取 <cache> 标签中的各项属性（type、flushInterval、size 等属性）；
（2）读取 <cache> 标签下的子标签信息，这些信息将用于初始化二级缓存；
（3）MapperBuilderAssistant 会根据上述配置信息，创建一个全新的Cache 对象并添加到 Configuration.caches 集合中保存。
CacheBuilder 是 Cache 的构造者，CacheBuilder 中最核心的方法是build() 方法，其中会根据传入的配置信息创建底层存储数据的 Cache 对象以及相关的 Cache 装饰器，具体实现如下：
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; }
2、处理<resultMap> 标签
MyBatis 提供了 <resultMap> 标签来定义结果集与 Java 对象之间的映射规则。
编辑
1、获取 <resultMap> 标签的type 属性值，这个值表示结果集将被映射成 type 指定类型的对象。如果没有指定 type 属性的话，会找其他属性值，优先级依次是：type、ofType、resultType、javaType。在这一步中会确定映射得到的对象类型，这里支持别名转换。
2、解析<resultMap>标签下的各个子标签，每个子标签都会生成一个ResultMapping 对象，这个 ResultMapping 对象会被添加到resultMappings 集合（List<ResultMapping> 类型）中暂存。这里会涉及 <id>、<result>、<association>、<collection>、<discriminator> 等子标签的解析。
3、获取 <resultMap> 标签的id 属性，默认值会拼装所有父标签的id、value 或 property 属性值。
4、获取 <resultMap> 标签的extends、autoMapping 等属性。
5、创建 ResultMapResolver 对象，ResultMapResolver 会根据上面解析到的ResultMappings 集合以及 <resultMap> 标签的属性构造 ResultMap 对象，并将其添加到 Configuration.resultMaps 集合（StrictMap 类型）中。
private ResultMap resultMapElement(XNode resultMapNode, List<ResultMapping> additionalResultMappings) throws Exception { ErrorContext.instance().activity("processing " + resultMapNode.getValueBasedIdentifier()); String id = resultMapNode.getStringAttribute("id", resultMapNode.getValueBasedIdentifier()); 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 = resolveClass(type); Discriminator discriminator = null; List<ResultMapping> resultMappings = new ArrayList<ResultMapping>(); resultMappings.addAll(additionalResultMappings); List<XNode> resultChildren = resultMapNode.getChildren(); for (XNode resultChild : resultChildren) { if ("constructor".equals(resultChild.getName())) { processConstructorElement(resultChild, typeClass, resultMappings); } else if ("discriminator".equals(resultChild.getName())) { discriminator = processDiscriminatorElement(resultChild, typeClass, resultMappings); } else { List<ResultFlag> flags = new ArrayList<ResultFlag>(); if ("id".equals(resultChild.getName())) { flags.add(ResultFlag.ID); } resultMappings.add(buildResultMappingFromContext(resultChild, typeClass, flags)); } } // 创建 ResultMapResolver 对象 // ResultMapResolver会根据上面解析到的ResultMappings集合以及<resultMap>标签的属性构造 ResultMap 对象 // 并将其添加到 Configuration.resultMaps 集合（StrictMap 类型）中 ResultMapResolver resultMapResolver = new ResultMapResolver(builderAssistant, id, typeClass, extend, discriminator, resultMappings, autoMapping); try { return resultMapResolver.resolve(); } catch (IncompleteElementException e) { configuration.addIncompleteResultMap(resultMapResolver); throw e; } }
3、SQL 语句解析全流程
在 Mapper.xml 映射文件中，除了上面介绍的标签之外，还有一类比较重要的标签，那就是<select>、<insert>、<delete>、<update>等 SQL 语句标签。虽然定义在 Mapper.xml 映射文件中，但是这些标签是由 XMLStatementBuilder 进行解析的，而不再由 XMLMapperBuilder 来完成解析。
XMLStatementBuilder 解析 SQL 标签的入口方法 parseStatementNode() 方法，在该方法中首先会根据 id 属性和 databaseId 属性决定加载匹配的 SQL 标签，然后解析其中的<include> 标签和 <selectKey> 标签，相关的代码片段如下：
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); // 前面是解析<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); } }
使用的设计模式
MyBatis 在加载配置文件、创建配置对象的时候，会使用到经典设计模式中的建造者模式（Builder Pattern），正文部分（谈谈你对MyBatis的理解【建议收藏】）也有提到，在这里我们详细聊一下
编辑
构造者模式的四个核心组件。
Product 接口：复杂对象的接口，定义了要创建的目标对象的行为。
ProductImpl 类：Product 接口的实现，它真正要创建的复杂对象，其中实现了我们需要的复杂业务逻辑。
Builder 接口：定义了构造 Product 对象的每一步行为。
BuilderImpl 类：Builder 接口的具体实现，其中具体实现了构造一个 Product 的每一个步骤，例如上图中的 setPart1()、setPart2() 等方法，都是用来构造 ProductImpl 对象的各个部分。在完成整个 Product 对象的构造之后，我们会通过 build() 方法返回这个构造好的 Product 对象。
使用构造者模式一般有两个目的。
第一个目的是将使用方与复杂对象的内部细节隔离，从而实现解耦的效果。使用方提供的所有信息，都是由 Builder 这个“中间商”接收的，然后由 Builder 消化这些信息并构造出一个完整可用的 Product 对象。
第二个目的是简化复杂对象的构造过程。在很多场景中，复杂对象可能有很多默认属性，这时我们就可以将这些默认属性封装到 Builder 中，这样就可以简化创建复杂对象所需的信息。
通过构建者模式的类图我们还可以看出，每个 BuilderImpl 实现都是能够独立创建出对应的 ProductImpl 对象，那么在程序需要扩展的时候，我们只需要添加新的 BuilderImpl 和 ProductImpl，就能实现功能的扩展，这完全符合“开放-封闭原则”
