作用
主要负责解析*Mpper.xml映射文件。
构造方法
XMLMapperBuilder 也是同样继承于BaseBuilder，它有以下四个构造方法，最终调用的还是最后一个构造方法来初始化XMLMapperBuilder 对象。
@Deprecated
public XMLMapperBuilder(Reader reader, Configuration configuration, String resource, Map<String, XNode> sqlFragments, String namespace) {
this(reader, configuration, resource, sqlFragments);
this.builderAssistant.setCurrentNamespace(namespace);
}
@Deprecated
public XMLMapperBuilder(Reader reader, Configuration configuration, String resource, Map<String, XNode> sqlFragments) {
this(new XPathParser(reader, true, configuration.getVariables(), new XMLMapperEntityResolver()),
configuration, resource, sqlFragments);
}
public XMLMapperBuilder(InputStream inputStream, Configuration configuration, String resource, Map<String, XNode> sqlFragments, String namespace) {
this(inputStream, configuration, resource, sqlFragments);
this.builderAssistant.setCurrentNamespace(namespace);
}
public XMLMapperBuilder(InputStream inputStream, Configuration configuration, String resource, Map<String, XNode> sqlFragments) {
this(new XPathParser(inputStream, true, configuration.getVariables(), new XMLMapperEntityResolver()),
configuration, resource, sqlFragments);
}
XMLMapperBuilder 对象的创建是在XMLConfigBuilder#mapperElement方法中
if (resource != null && url == null && mapperClass == null) {
ErrorContext.instance().resource(resource);
try(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);
try(InputStream inputStream = Resources.getUrlAsStream(url)){
XMLMapperBuilder mapperParser = new XMLMapperBuilder(inputStream, configuration, url, configuration.getSqlFragments());
mapperParser.parse();
}
}
方法
parse
parse方法是*Mapper.xml 解析的开始
public void parse() {
//判断是否已经加载该配置文件
if (!configuration.isResourceLoaded(resource)) {
//处理mapper节点
configurationElement(parser.evalNode("/mapper"));
//将mapper文件添加到configuration.loadedResources中
configuration.addLoadedResource(resource);
//注册mapper接口
bindMapperForNamespace();
}
//处理解析失败的ResultMap节点
parsePendingResultMaps();
//处理解析失败的CacheRef节点
parsePendingCacheRefs();
//处理解析失败的Sql语句节点
parsePendingStatements();
}
解析步骤分两种情况：
一、资源已加载
如果资源已加载就直接处理失败的节点，这一步比较简单。
二、资源未加载
如果资源未加载，分四个步骤：
1、解析mapper标签
2、资源加载到configuration对象的loadedResources的set集合中
3、注册mapper接口
4、处理解析失败的节点
configurationElement
1、解析mapper标签
mapper的解析在configurationElement方法中，在该方法中会对*Mapper.xml内的节点进行解析并将解析到的结果填充到configuration对象中。
/**
* 解析*mapper.xml文件
* @param context
*/
private void configurationElement(XNode context) {
try {
String namespace = context.getStringAttribute("namespace");
if (namespace == null || namespace.isEmpty()) {
throw new BuilderException("Mapper's namespace cannot be empty");
}
// 设置当前命名空间
builderAssistant.setCurrentNamespace(namespace);
// 缓存解析
cacheRefElement(context.evalNode("cache-ref"));
cacheElement(context.evalNode("cache"));
// parameterMap 标签已过时
parameterMapElement(context.evalNodes("/mapper/parameterMap"));
// 解析resultMap
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. The XML location is '" + resource + "'. Cause: " + e, e);
}
}
标签
映射文件各个标签具体介绍可看官网XML 映射器，这里只关注几个重要的节点
resultMap
resultMap节点的解析是在resultMapElements方法中进行的，经过层层调用最终调用
ResultMap resultMapElement(XNode resultMapNode, List additionalResultMappings, Class<?> enclosingType) 方法，重点要看的就是这个方法
resultMapElements
private void resultMapElements(List<XNode> list) {
for (XNode resultMapNode : list) {
try {
resultMapElement(resultMapNode);
} catch (IncompleteElementException e) {
// ignore, it will be retried
}
}
}
resultMapElement
private ResultMap resultMapElement(XNode resultMapNode, List<ResultMapping> additionalResultMappings, Class<?> enclosingType) {
ErrorContext.instance().activity("processing " + resultMapNode.getValueBasedIdentifier());
/**
* 获取resultMap 映射的类
* javaType、resultType、ofType、type 优先级顺序是
* type > ofType > resultType >javaType,
* 解析的时候按先从优先级最低的javaType属性开始，type的优先级最高，只要type属性存在，不管其他三个有没有最终都会用type，
* 如果type属性没有获取到才会按照顺序依次往下获取并使用结果
*/
String javaType = resultMapNode.getStringAttribute("javaType");
String resultType = resultMapNode.getStringAttribute("resultType", javaType);
String ofType = resultMapNode.getStringAttribute("ofType", resultType);
String type = resultMapNode.getStringAttribute("type", ofType);
// 从别名注册表中获取entity 的class对象
Class<?> typeClass = resolveClass(type);
if (typeClass == null) {
// 别名注册中如果没找到entity的class对象，
typeClass = inheritEnclosingType(resultMapNode, enclosingType);
}
Discriminator discriminator = null;
List<ResultMapping> resultMappings = new ArrayList<>(additionalResultMappings);
List<XNode> resultChildren = resultMapNode.getChildren();
for (XNode resultChild : resultChildren) {
if ("constructor".equals(resultChild.getName())) {
//constructor 节点解析
processConstructorElement(resultChild, typeClass, resultMappings);
} else if ("discriminator".equals(resultChild.getName())) {
//discriminator 节点解析
discriminator = processDiscriminatorElement(resultChild, typeClass, resultMappings);
} else {
List<ResultFlag> flags = new ArrayList<>();
if ("id".equals(resultChild.getName())) {
// 将id节点添加到ResultFlag 集合中
flags.add(ResultFlag.ID);
}
// 创建resultMapping对象并加入到resultMappings 集合中
resultMappings.add(buildResultMappingFromContext(resultChild, typeClass, flags));
}
}
//获取基于值的标识符 拼接成mapper_resultMap[BaseResultMap] 这样的字段，mapper 代表文件夹名, [ ]中间是resultMap节点的id属性值，这里id=BaseResultMap
String valueBasedIdentifier = resultMapNode.getValueBasedIdentifier();
String id = resultMapNode.getStringAttribute("id", valueBasedIdentifier);
String extend = resultMapNode.getStringAttribute("extends");
Boolean autoMapping = resultMapNode.getBooleanAttribute("autoMapping");
// resultMap解析器
ResultMapResolver resultMapResolver = new ResultMapResolver(builderAssistant, id, typeClass, extend, discriminator, resultMappings, autoMapping);
try {
// 返回resultMap对象
return resultMapResolver.resolve();
} catch (IncompleteElementException e) {
configuration.addIncompleteResultMap(resultMapResolver);
throw e;
}
}
解析步骤：
1、解析resultMap节点的属性找到映射类并从typeAliasRegistry类型别名注册表中找到对应的映射类的class对象。
2、循环解析resultMap的子节点。
2.1 解析constructor节点，解析步骤在processConstructorElement方法中。解析调用ResultMapping buildResultMappingFromContext(XNode context, Class<?> resultType, List flags)方法。
/**
* constructor节点解析
* @param resultChild 节点
* @param resultType 映射类
* @param resultMappings ResultMapping结果映射集合
*/
private void processConstructorElement(XNode resultChild, Class<?> resultType, List<ResultMapping> resultMappings) {
List<XNode> argChildren = resultChild.getChildren();
for (XNode argChild : argChildren) {
List<ResultFlag> flags = new ArrayList<>();
flags.add(ResultFlag.CONSTRUCTOR);
// idArg 类的id属性
if ("idArg".equals(argChild.getName())) {
flags.add(ResultFlag.ID);
}
resultMappings.add(buildResultMappingFromContext(argChild, resultType, flags));
}
}
2.2 解析discriminator节点，解析步骤在processDiscriminatorElement方法中。discriminator鉴别器会根据value的结果值来决定最终调用哪个resultMap。
private Discriminator processDiscriminatorElement(XNode context, Class<?> resultType, List<ResultMapping> resultMappings) {
String column = context.getStringAttribute("column");
String javaType = context.getStringAttribute("javaType");
String jdbcType = context.getStringAttribute("jdbcType");
String typeHandler = context.getStringAttribute("typeHandler");
Class<?> javaTypeClass = resolveClass(javaType);
Class<? extends TypeHandler<?>> typeHandlerClass = resolveClass(typeHandler);
JdbcType jdbcTypeEnum = resolveJdbcType(jdbcType);
Map<String, String> discriminatorMap = new HashMap<>();
for (XNode caseChild : context.getChildren()) {
// 取值
String value = caseChild.getStringAttribute("value");
// 获取嵌套的resultMap节点 id属性
String resultMap = caseChild.getStringAttribute("resultMap", processNestedResultMappings(caseChild, resultMappings, resultType));
// 根据结果获取对应的resultMap
discriminatorMap.put(value, resultMap);
}
// 构建一个Discriminator 对象返回
return builderAssistant.buildDiscriminator(resultType, column, javaTypeClass, jdbcTypeEnum, typeHandlerClass, discriminatorMap);
}
2.3 解析其他节点，其他节点的解析步骤在buildResultMappingFromContext方法中
/**
* 解析 result 节点 并封装为ResultMapping 返回
* @param context
* @param resultType
* @param flags
* @return
*/
private ResultMapping buildResultMappingFromContext(XNode context, Class<?> resultType, List<ResultFlag> flags) {
String property;
// 如果是构造方法节点
if (flags.contains(ResultFlag.CONSTRUCTOR)) {
property = context.getStringAttribute("name");
} else {
property = context.getStringAttribute("property");
}
String column = context.getStringAttribute("column");
String javaType = context.getStringAttribute("javaType");
String jdbcType = context.getStringAttribute("jdbcType");
String nestedSelect = context.getStringAttribute("select");
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"));
Class<?> javaTypeClass = resolveClass(javaType);
// 类型处理器
Class<? extends TypeHandler<?>> typeHandlerClass = resolveClass(typeHandler);
//jdbcType 枚举类型获取
JdbcType jdbcTypeEnum = resolveJdbcType(jdbcType);
// 创建resultMapping对象
return builderAssistant.buildResultMapping(resultType, property, column, javaTypeClass, jdbcTypeEnum, nestedSelect, nestedResultMap, notNullColumn, columnPrefix, typeHandlerClass, flags, resultSet, foreignColumn, lazy);
}
3、解析resultMap节点的id、extends、autoMapping等属性，然后构建一个ResultMapResolver
4、调用ResultMapResolver对象的resolve方法，解析并返回一个resultMap对象。resolve方法会调用MapperBuilderAssistant#addResultMap方法把解析到各种参数设值到resultMap对象中并返回，实际设值的方法是ResultMap#build方法，build方法中就是对ResultMap属性的各种赋值。
MapperBuilderAssistant#addResultMap
public ResultMap addResultMap(String id, Class<?> type,String extend, Discriminator discriminator, List<ResultMapping> resultMappings, Boolean autoMapping) {
id = applyCurrentNamespace(id, false);
extend = applyCurrentNamespace(extend, true);
// 如果resultMap有继承一个resultMap，解析继承的resultMap
if (extend != null) {
if (!configuration.hasResultMap(extend)) {
throw new IncompleteElementException("Could not find a parent resultmap with id '" + extend + "'");
}
ResultMap resultMap = configuration.getResultMap(extend);
List<ResultMapping> extendedResultMappings = new ArrayList<>(resultMap.getResultMappings());
extendedResultMappings.removeAll(resultMappings);
// Remove parent constructor if this resultMap declares a constructor.
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));
}
// 继承的resultMap也添加到resultMappings中
resultMappings.addAll(extendedResultMappings);
}
// 构建一个resultMap对象
ResultMap resultMap = new ResultMap.Builder(configuration, id, type, resultMappings, autoMapping)
.discriminator(discriminator).build();
// 把resultMap添加到configuration对象的resultMaps中
configuration.addResultMap(resultMap);
return resultMap;
}
sql
sql节点可以用来定义可重用的 SQL 代码片段，以便在其它语句中使用。 参数可以静态地（在加载的时候）确定下来，并且可以在不同的 include 元素中定义不同的参数值.
解析是在sqlElement(List list, String requiredDatabaseId)方法中,最终会把sql节点对象放到configuration#sqlFragments对象中的
private void sqlElement(List<XNode> list, String requiredDatabaseId) {
for (XNode context : list) {
String databaseId = context.getStringAttribute("databaseId");
String id = context.getStringAttribute("id");
id = builderAssistant.applyCurrentNamespace(id, false);
if (databaseIdMatchesCurrent(id, databaseId, requiredDatabaseId)) {
sqlFragments.put(id, context);
}
}
}
select|insert|update|delete
select|insert|update|delete节点解析是在buildStatementFromContext(List list, String requiredDatabaseId)，在buildStatementFromContext中会引出配置解析节点的第三个重要的类XMLStatementBuilder，在XMLStatementBuilder#parseStatementNode方法中。
private void buildStatementFromContext(List<XNode> list, String requiredDatabaseId) {
for (XNode context : list) {
final XMLStatementBuilder statementParser = new XMLStatementBuilder(configuration, builderAssistant, context, requiredDatabaseId);
try {
statementParser.parseStatementNode();
} catch (IncompleteElementException e) {
configuration.addIncompleteStatement(statementParser);
}
}
}
能力有限，水平一般，如有错误，请多指出。
本文标题：mybatis配置加载阶段源码之XMLMapperBuilder
本文链接：https://blog.quwenai.cn/post/5840.html
版权声明：本文不使用任何协议授权，您可以任何形式自由转载或使用。
还没有评论，来说两句吧...