1、Mapper配置方式
1、package方式
指定包路径：
<mappers> <package name="org.snails.mapper"/> </mappers>
2、resource方式
指定mapper.xml文件的相对路径：
<mappers> <mapper resource="org/snails/mapper/SnailsMapper.xml"/> </mappers>
3、url方式
指定mapper.xml文件的绝对路径：
<mappers> <mapper url="file:///opt/org/snails/mapper/SnailsMapper.xml"/> </mappers>
4、接口方式
指定mapper接口：
<mappers> <mapper class="org.snails.inter.SnailsMapper"/> </mappers>
2、Mapper解析源码
Mappers标签的解析，根据全局配置文件中不同的注册方式，有不同的扫描方式。最终都要做两件事，1、语句注册；2、接口注册。
Mappers标签的解析，XMLConfigBuilder#mapperElement() 核心代码：
1 // 映射器 mappers 标签解析
2 private void mapperElement(XNode parent) throws Exception {
3 if (parent != null) {
4 // 处理mapper子节点
5 for (XNode child : parent.getChildren()) {
6 // package子节点
7 if ("package".equals(child.getName())) {
8 // 自动扫描包下所有映射器
9 String mapperPackage = child.getStringAttribute("name");
10 // 扫描指定的包，并向mapperRegistry注册mapper接口
11 configuration.addMappers(mapperPackage);
12 } else {
13 // 获取mapper节点的resource、url、class属性，三个属性互斥
14 String resource = child.getStringAttribute("resource");
15 String url = child.getStringAttribute("url");
16 String mapperClass = child.getStringAttribute("class");
17 // 如果mapper节点指定了resource或者url属性，则创建XmlMapperBuilder对象，并通过该对象解析resource或者url属性指定的mapper配置文件
18 if (resource != null && url == null && mapperClass == null) {
19 // 使用类路径
20 ErrorContext.instance().resource(resource);
21 // 创建XMLMapperBuilder对象，解析映射配置文件
22 InputStream inputStream = Resources.getResourceAsStream(resource);
23 XMLMapperBuilder mapperParser = new XMLMapperBuilder(inputStream, configuration, resource, configuration.getSqlFragments());
24 // Mapper解析器解析
25 mapperParser.parse();
26 } else if (resource == null && url != null && mapperClass == null) {
27 // 使用绝对url路径
28 ErrorContext.instance().resource(url);
29 InputStream inputStream = Resources.getUrlAsStream(url);
30 // 创建XMLMapperBuilder对象，解析映射配置文件
31 XMLMapperBuilder mapperParser = new XMLMapperBuilder(inputStream, configuration, url, configuration.getSqlFragments());
32 mapperParser.parse();
33 } else if (resource == null && url == null && mapperClass != null) {
34 // 如果mapper节点指定了class属性，则向MapperRegistry注册该mapper接口
35 Class<?> mapperInterface = Resources.classForName(mapperClass);
36 // 直接把这个映射加入配置
37 configuration.addMapper(mapperInterface);
38 } else {
39 throw new BuilderException("A mapper element may only specify a url, resource or class, but not more than one.");
40 }
41 }
42 }
43 }
44 }
上述四种配置方式中，package方式与接口方式使用MapperAnnotationBuilder作为解析入口,；resource方式和url方式使用XMLMapperBuilder作为解析入口。
1、XMLMapperBuilder作为解析入口的解析
XMLMapperBuilder继承自BaseBuilder抽象类，在上面已经提到主要用于解析Mapper映射器。
XMLMapperBuilder#parse() 核心代码：
1 // 解析SQL的Mapper映射文件
2 public void parse() {
3 // 判断是否已经加载过该映射文件
4 if (!configuration.isResourceLoaded(resource)) {
5 // 1、语句注册，具体的增删改查接口标签解析<insert> <update> <delete> <select>。一个标签一个MappedStatement对象。
6 configurationElement(parser.evalNode("/mapper"));
7 // 2、接口注册，把namespace（接口类型）和工厂类绑定起来，放到一个map。一个namespace 一个 MapperProxyFactory
8 // 将resource添加到Configuration.loadedResources集合中保存，hashset类型的集合，其中记录了已经加载过的映射文件
9 configuration.addLoadedResource(resource);
10 // 绑定映射器到namespace
11 bindMapperForNamespace();
12 }
13
14 // 处理ConfigurationElement方法中解析失败的resultMap节点
15 parsePendingResultMaps();
16 // 处理ConfigurationElement方法中解析失败的cache-ref节点
17 parsePendingCacheRefs();
18 // 处理ConfigurationElement方法中解析失败的SQL语句节点
19 parsePendingStatements();
20 }
主要完成两件事情：
1、configurationElement()：解析Mapper.xml所有的子标签，最终获得MappedStatement对象，并注册到配置类configuration中。
2、bindMapperForNamespace()：把namespace（接口类型）和工厂类MapperProxyFactory绑定起来，将Mapper接口与接口代理工厂映射关系设置在configuration中mapperRegistry属性对象的knownMappers缓存属性中。
1.1、configurationElement()
解析Mapper.xml配置文件中的标签信息，比如namespace、cache、parameterMap、resultMap、sql和select|insert|update|delete等。
XMLMapperBuilder#configurationElement()，核心代码：
1 // 解析<Mapper标签>
2 private void configurationElement(XNode context) {
3 try {
4 // 获取mapper节点的namespace属性
5 String namespace = context.getStringAttribute("namespace");
6 if (namespace == null || namespace.equals("")) {
7 throw new BuilderException("Mapper's namespace cannot be empty");
8 }
9 // 设置MapperBuilderAssistant的currentNamespace字段，记录当前命名空间
10 builderAssistant.setCurrentNamespace(namespace);
11 // 解析cache-ref节点
12 cacheRefElement(context.evalNode("cache-ref"));
13 // 解析cache节点
14 cacheElement(context.evalNode("cache"));
15 // 解析parameterMap节点
16 parameterMapElement(context.evalNodes("/mapper/parameterMap"));
17 // 解析resultMap节点
18 resultMapElements(context.evalNodes("/mapper/resultMap"));
19 // 解析sql节点
20 sqlElement(context.evalNodes("/mapper/sql"));
21 // 解析select、update、insert、delete等SQL节点
22 buildStatementFromContext(context.evalNodes("select|insert|update|delete"));
23 } catch (Exception e) {
24 throw new BuilderException("Error parsing Mapper XML. The XML location is '" + resource + "'. Cause: " + e, e);
25 }
26 }
1、解析resultMap节点
resultMap的解析通过ResultMapResolver解析器中的assistant属性完成的。并将创建的ResultMap对象设置进配置类configuration的resultMaps属性中。
MapperBuilderAssistant#resultMapElement() 核心代码段:
1 // 创建 resultMap解析器 2 ResultMapResolver resultMapResolver = new ResultMapResolver(builderAssistant, id, typeClass, extend, discriminator, resultMappings, autoMapping); 3 // 创建ResultMap对象，并添加到resultMap集合中，该集合是StrictMap类型 4 return resultMapResolver.resolve();
MapperBuilderAssistant#addResultMap() 核心代码段:
1 // 创建ResultMap对象，并添加到configuration.resultMaps集合中保存 2 ResultMap resultMap = new ResultMap.Builder(configuration, id, type, resultMappings, autoMapping) 3 .discriminator(discriminator) 4 .build(); 5 // 将resultMap添加进配置类configuration的resultMap属性中 6 configuration.addResultMap(resultMap);
2、生成mappedStatement对象并添加至configuration中，解析select|insert|update|delete节点
XMLMapperBuilder#buildStatementFromContext() 的核心代码：
1 // 构建语句
2 private void buildStatementFromContext(List<XNode> list, String requiredDatabaseId) {
3 for (XNode context : list) {
4 // 构建所有语句,一个mapper下可以有很多select
5 // 语句比较复杂，核心都在这里面，所以调用XMLStatementBuilder
6 final XMLStatementBuilder statementParser = new XMLStatementBuilder(configuration, builderAssistant, context, requiredDatabaseId);
7 try {
8 // 核心XMLStatementBuilder.parseStatementNode
9 statementParser.parseStatementNode();
10 } catch (IncompleteElementException e) {
11 // 如果出现SQL语句不完整，把它记下来，塞到configuration去
12 configuration.addIncompleteStatement(statementParser);
13 }
14 }
15 }
在buildStatementFromContext()方法中，创建了用来解析增删改查标签的XMLStatementBuilder，并且把创建的MappedStatement添加到mappedStatements中。Mybatis通过MapperBuilderAssistant将MappedStatement对象设置到configuration配置类中。
MapperBuilderAssistant#addMappedStatement() 核心代码段:
1 // 创建MappedStatement对象 2 MappedStatement statement = statementBuilder.build(); 3 // 将MappedStatement对象添加进配置类configuration的mappedStatements属性中 4 configuration.addMappedStatement(statement);
注意：在addMappedStatement方法中，有个参数sqlCommandType，代表sql命令的类型，Mybtais通过sqlCommandType完成对SQL语句增删改查的判断，Mybatis解析Mapper.xml中的SQL的标签来获取sqlCommandType。
XMLStatementBuilder#parseStatementNode() 核心代码段：
// 根据SQL节点的名称决定其SqlCommandType String nodeName = context.getNode().getNodeName(); SqlCommandType sqlCommandType = SqlCommandType.valueOf(nodeName.toUpperCase(Locale.ENGLISH));
MappedStatement对象中的很多属性都是在XMLStatementBuilder#parseStatementNode()方法中创建的。
1.2、bindMapperForNamespace()
构建映射的SQL语句，XMLMapperBuilder#bindMapperForNamespace() 核心代码：
1 private void bindMapperForNamespace() {
2 // 获取映射配置文件的命名空间
3 String namespace = builderAssistant.getCurrentNamespace();
4 if (namespace != null) {
5 Class<?> boundType = null;
6 try {
7 // 解析命名空间对应的类型
8 boundType = Resources.classForName(namespace);
9 } catch (ClassNotFoundException e) {
10 //ignore, bound type is not required
11 }
12 if (boundType != null) {
13 // 是否已经加载了boundType接口
14 if (!configuration.hasMapper(boundType)) {
15 // 追加namespace前缀，并添加到loadedResources集合中保存
16 configuration.addLoadedResource("namespace:" + namespace);
17 // 调用MapperRegistry.addMapper方法，注册boundType接口
18 configuration.addMapper(boundType);
19 }
20 }
21 }
22 }
主要是调用了configuration#addMapper()。addMapper()方法中，把接口类型注册到MapperRegistry中：实际上是为接口创建一个对应的MapperProxyFactory（用于为这个type提供工厂类，创建MapperProxy）。
添加接口Class对象与MapperProxyFactory的映射，同时解析配置文件中SQL语句。
MapperRegistry#addMapper() 核心代码：
1 // 记录了Mapper接口与对应MapperProxyFactory之间的关系
2 private final Map<Class<?>, MapperProxyFactory<?>> knownMappers = new HashMap<>();
3
4 // 添加Mapper映射器
5 public <T> void addMapper(Class<T> type) {
6 // 检测type是否为接口
7 if (type.isInterface()) {
8 // knownMappers集合中，抛异常
9 if (hasMapper(type)) {
10 throw new BindingException("Type " + type + " is already known to the MapperRegistry.");
11 }
12 // 加载完成标识
13 boolean loadCompleted = false;
14 try {
15 // 将Mapper接口对应的Class对象和MapperProxyFactory对象添加到knownMappers集合
16 // Map<Class<?>, MapperProxyFactory<?>> 存放的是接口类型，和对应的工厂类的关系
17 knownMappers.put(type, new MapperProxyFactory<>(type));
18 // 创建MapperAnnotationBuilder对象用于解析
19 MapperAnnotationBuilder parser = new MapperAnnotationBuilder(config, type);
20 // 根据接口，开始解析所有方法上的注解，例如 @Select、@Insert...等注解
21 parser.parse();
22 loadCompleted = true;
23 } finally {
24 // 如果加载过程中出现异常需要再将这个mapper从mybatis中删除
25 if (!loadCompleted) {
26 knownMappers.remove(type);
27 }
28 }
29 }
30 }
Mapper接口对应的Class对象和MapperProxyFactory对象添加到knownMappers集合，MapperProxyFactory主要用于Mapper接口代理对象的创建，后续会详细介绍到。
解析SQL并获取MappedStatement对象并设置进configuration配置类中，MapperAnnotationBuilder#parse() 核心代码：
1 public void parse() {
2 String resource = type.toString();
3 // 检测是否已经加载过该接口
4 if (!configuration.isResourceLoaded(resource)) {
5 // 检测是否加载过对应的映射配置文件，如果未加载，则创建XMLMapperBuilder对象解析对应的映射文件
6 loadXmlResource();
7 configuration.addLoadedResource(resource);
8 assistant.setCurrentNamespace(type.getName());
9 // 解析@CacheNamespace注解
10 parseCache();
11 // 解析@CacheNamespaceRef注解
12 parseCacheRef();
13 Method[] methods = type.getMethods();
14 for (Method method : methods) {
15 try {
16 if (!method.isBridge()) {
17 // 解析@SelectKey,@ResultMap等注解，并创建MappedStatement对象，添加进configuration中的mappedStatements属性中
18 parseStatement(method);
19 }
20 } catch (IncompleteElementException e) {
21 // 如果解析过程出现IncompleteElementException异常，可能是引用了未解析的注解，此处将出现异常的方法添加到incompleteMethod集合中保存
22 configuration.addIncompleteMethod(new MethodResolver(this, method));
23 }
24 }
25 }
26 parsePendingMethods();
27 }
mappedStatement通过MapperBuilderAssistant对象完成MappedStatement对象添加进配置类configuration中的mappedStatements属性。
增加映射语句，MapperBuilderAssistant#addMappedStatement() 核心代码段：
// 创建MappedStatement对象 MappedStatement statement = statementBuilder.build(); // 将MappedStatement对象添加进配置类configuration的mappedStatements属性中 configuration.addMappedStatement(statement);
注意：在MapperBuilderAssistant#addMappedStatement()中创建MappedStatement的内部类Builder时，默认的将statementType设置为PREPARED，resultSetType设置为DEFAULT，该属性会在后续创建具体的StatementHandler对象是用到。
MappedStatement.Builder statementBuilder = new MappedStatement.Builder(configuration, id, sqlSource, sqlCommandType)
2、MapperAnnotationBuilder作为解析入口的解析
其实XMLMapperBuilder作为解析入口与MapperAnnotationBuilder作为解析入口核心流程是一样的，最终都是将MappedStatement对象添加进配置类configuration中的mappedStatements属性中。只不过代码执行的顺序不同。
MapperRegistry#addMapper() 核心代码：
1 // 记录了Mapper接口与对应MapperProxyFactory之间的关系
2 private final Map<Class<?>, MapperProxyFactory<?>> knownMappers = new HashMap<>();
3
4 // 添加Mapper映射器
5 public <T> void addMapper(Class<T> type) {
6 // 检测type是否为接口
7 if (type.isInterface()) {
8 // knownMappers集合中，抛异常
9 if (hasMapper(type)) {
10 throw new BindingException("Type " + type + " is already known to the MapperRegistry.");
11 }
12 // 加载完成表示
13 boolean loadCompleted = false;
14 try {
15 // 将Mapper接口对应的Class对象和MapperProxyFactory对象添加到knownMappers集合
16 knownMappers.put(type, new MapperProxyFactory<>(type));
17 // 创建MapperAnnotationBuilder对象用于解析
18 MapperAnnotationBuilder parser = new MapperAnnotationBuilder(config, type);
19 // 解析
20 parser.parse();
21 loadCompleted = true;
22 } finally {
23 // 如果加载过程中出现异常需要再将这个mapper从mybatis中删除
24 if (!loadCompleted) {
25 knownMappers.remove(type);
26 }
27 }
28 }
29 }
优先将接口的Class类型与映射代理工厂MapperProxyFactory的映射关系设置在MapperRegistry的knownMappers属性中,映射器代理工厂MapperProxyFactory在后续会详细介绍到，此处只需知道MapperProxyFactory使用来生成Mapper接口代理对象的。
通过MapperAnnotationBuilder完成解析，创建MappedStatement对象同时设置进configuration对象中。
MapperAnnotationBuilder#parse() 核心代码：
1 // 解析mapper
2 public void parse() {
3 String resource = type.toString();
4 // 检测是否已经加载过该接口
5 if (!configuration.isResourceLoaded(resource)) {
6 // 检测是否加载过对应的映射配置文件，如果未加载，则创建XMLMapperBuilder对象解析对应的映射文件
7 loadXmlResource();
8 configuration.addLoadedResource(resource);
9 assistant.setCurrentNamespace(type.getName());
10 // 解析@CacheNamespace注解
11 parseCache();
12 // 解析@CacheNamespaceRef注解
13 parseCacheRef();
14 Method[] methods = type.getMethods();
15 for (Method method : methods) {
16 try {
17 // issue #237
18 if (!method.isBridge()) {
19 // 解析@SelectKey,@ResultMap等注解，并创建MappedStatement对象
20 parseStatement(method);
21 }
22 } catch (IncompleteElementException e) {
23 // 如果解析过程出现IncompleteElementException异常，可能是引用了未解析的注解，此处将出现异常的方法添加到incompleteMethod集合中保存
24 configuration.addIncompleteMethod(new MethodResolver(this, method));
25 }
26 }
27 }
28 parsePendingMethods();
29 }
上述代码与xml配置文件中的解析方式相同，只不过是此处在loadXmlResource()中不会被过滤掉。
// 检测是否加载过对应的映射配置文件，如果未加载，则创建XMLMapperBuilder对象解析对应的映射文件 loadXmlResource()
loadXmlResource()最终会调用XMLMapperBuilder#parse()方法，加载Mapper.xml映射文件中的SQL映射语句，解析为MappedStatement对象并注册到配置类configuration中，然后将Mapper接口与映射代理工程MapperProxyFactory做绑定，将Mapper接口中被@Select等被注解修饰的方法也解析为MappedStatement对象并完成注册。
3、总结
对Mappers标签的解析工作，主要完成如下两件事情：
1、优先解析*Mapper.xml配置文件，将配置文件信息解析成MappedStatement对象。注册到configuration对象中的mappedStatements属性。
2、若Mapper接口未注册到配置类configuration中，把namespace（接口类型）和工厂类MapperProxyFactory绑定起来，将映射关系设置在configuration中mapperRegistry属性对象的knownMappers缓存属性中。同时将带有@Select等注解的方法解析成MappedStatement对象，注册到到configuration对象中的mappedStatements属性。
标签：Mapper,configuration,resource,MappedStatement,源码,Mybatis,解析,type From： https://www.cnblogs.com/RunningSnails/p/17237152.html