本篇文章主要讲解映射文件的解析过程
Mapper映射文件有哪几种配置方式呢？看下面的代码：
<!-- 映射文件 -->
<mappers>
<!-- 通过resource指定Mapper文件 --> 方式一
<mapper resource="com/yht/mybatisTest/dao/goods.xml" /> <!-- 通过class指定接口，但需要将接口与Mapper文件同名,从而将两者建立起关系，此处接口是GoodsDao，那么Mapper映射文件就需要是GoodsDao.xml --> 方式二
<mapper class="com.yht.mybatisTest.dao.GoodsDao" /> <!-- 扫描指定包中的接口，需要将接口名与Mapper文件同名 --> 方式三
<package name="com.yht.mybatisTest.dao"/> <!-- 通过url指定Mapper文件位置 --> 方式四
<mapper url="file://........" />
</mappers>
源码部分如下：
private void mapperElement(XNode parent) throws Exception {
if (parent != null) {
// 循环处理mappers节点下所有的子节点
for (XNode child : parent.getChildren()) {
if ("package".equals(child.getName())) {
// 获的package节点的name属性值
String mapperPackage = child.getStringAttribute("name");
// 针对 方式三 的解析方法
configuration.addMappers(mapperPackage);
} else {
// 获取mapper节点的resource属性值
String resource = child.getStringAttribute("resource");
// 获取mapper节点的url属性值
String url = child.getStringAttribute("url");
// 获取mapper节点的class属性值
String mapperClass = child.getStringAttribute("class");
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) {
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 void parse() {
// 检测Mapper映射文件是否被解析过
if (!configuration.isResourceLoaded(resource)) {
// 解析mapper节点
configurationElement(parser.evalNode("/mapper"));
// 将资源文件添加到 已解析资源集合 中
configuration.addLoadedResource(resource);
// 注册Mapper接口
bindMapperForNamespace();
}
// 处理 configurationElement方法中解析失败的<ResultMap />节点
parsePendingResultMaps();
// 处理 configurationElement方法中解析失败的<cache-ref />节点
parsePendingChacheRefs();
// 处理 configurationElement方法中解析失败的SQL语句节点
parsePendingStatements();
}
一 解析Mapper节点
进入XMLMapperBuilder类的configurationElement方法中：
private void configurationElement(XNode context) {
try {
String namespace = context.getStringAttribute("namespace");
if (namespace.equals("")) {
throw new BuilderException("Mapper's namespace cannot be empty");
}
// 设置当前的namespace
builderAssistant.setCurrentNamespace(namespace);
// 解析<cache-ref/>节点
cacheRefElement(context.evalNode("cache-ref"));
// 解析<cache/>节点
cacheElement(context.evalNode("cache"));
// 解析parameterMap节点
parameterMapElement(context.evalNodes("/mapper/parameterMap"));
// 解析resultMap节点
resultMapElements(context.evalNodes("/mapper/resultMap"));
// <sql/>节点
sqlElement(context.evalNodes("/mapper/sql"));
// 解析<insert>等节点
buildStatementFromContext(context.evalNodes("select|insert|update|delete"));
} catch (Exception e) {
throw new BuilderException("Error parsing Mapper XML. Cause: " + e, e);
}
}
XMLMapperBuilder类主要是用于解析映射配置文件，它继承了BaseBuilder抽象类，所有对映射配置文件的解析方法都在这个类中，接下来就分别对这些节点的解析过程进行分析。
1.<cache-ref />的解析
1.1 使用方法：
<!-- 表示使用以下namespace中的cache对象，也就是说和下面namespace共用一个cache对象 -->
<cache-ref namespace="com.yht.mybatisTest.dao.GoodsDao"/>
1.2 源码分析：
private void cacheRefElement(XNode context) {
if (context != null) {
// 这个方法是把当前节点的namespace作为key，<cache-ref>节点指定的namespace属性值作为value，存放到HashMap中；前者共用后者的cache对象
configuration.addCacheRef(builderAssistant.getCurrentNamespace(), context.getStringAttribute("namespace"));
//cacheRefResolver是一个cache引用解析器，封装了当前XMLMapperBuilder对应的MapperBuilderAssistant对象，和被引用的namespace
CacheRefResolver cacheRefResolver = new CacheRefResolver(builderAssistant, context.getStringAttribute("namespace"));
try {
// 这个方法主要是指定当前mapper文件使用的cache对象，也就是设置MapperBuilderAssistant的currentCache和unresolvedCacheRef字段
cacheRefResolver.resolveCacheRef();
} catch (IncompleteElementException e) {
configuration.addIncompleteCacheRef(cacheRefResolver);
}
}
}
进入 cacheRefResolver.resolveCacheRef();方法：
public Cache resolveCacheRef() {
// 进入此方法
return assistant.useCacheRef(cacheRefNamespace);
}
进入MapperBuilderAssistant类的userCacheRef方法，这个类是XMLMapperBuilder的一个辅助类，用于保存当前mapper文件的namespace，以及使用的cache对象
public Cache useCacheRef(String namespace) {
if (namespace == null) {
throw new BuilderException("cache-ref element requires a namespace attribute.");
}
try {
unresolvedCacheRef = true;
// 根据被引用的namespace，获取对应的cache对象
Cache cache = configuration.getCache(namespace);
if (cache == null) {
throw new IncompleteElementException("No cache for namespace '" + namespace + "' could be found.");
}
// 使当前mapper文件的cache对象currentCache指向cache，也就是共用一个cache对象
currentCache = cache;
unresolvedCacheRef = false;
return cache;
} catch (IllegalArgumentException e) {
throw new IncompleteElementException("No cache for namespace '" + namespace + "' could be found.", e);
}
}
1.3 总结：对于<cahce-ref>节点的解析，就是找到被引用namespace对应的cache对象，然后是当前namespace中的currentCache执向那个cache对象，也就是两者共用一个cache对象。在这个过程中，MapperBuilderAssistant这个辅助类保存了当前mapper文件中的namespace的值，cache对象以及其他属性。
2.<cache />的解析
2.1 使用方法：
<cache
eviction="FIFO"
flushInterval="60000"
size="512"
readOnly="true"/>
cache节点有这几个标签：
(a) eviction：缓存的回收策略
(b) flushInterval：刷新间隔
(c) size：要缓存的元素数目
(d) readOnly：如果为true表示只读，不能修改
(e) type：指定自定义的缓存的全类名
2.2 源码分析：
进入XMLMapperBuilder类的cacheElement方法：
private void cacheElement(XNode context) throws Exception {
if (context != null) {
// 获取<cache>节点的type属性，默认值是PERPETUAL
String type = context.getStringAttribute("type", "PERPETUAL");
// 获取type属性对应的Cache接口实现
Class<? extends Cache> typeClass = typeAliasRegistry.resolveAlias(type);
// 获取<cache>节点的eviction属性
String eviction = context.getStringAttribute("eviction", "LRU");
// 根据eviction属性获取对应的类
Class<? extends Cache> evictionClass = typeAliasRegistry.resolveAlias(eviction);
// 获取<cache>节点的flushInterval属性
Long flushInterval = context.getLongAttribute("flushInterval");
// 获取size熟悉和readOnly属性
Integer size = context.getIntAttribute("size");
boolean readWrite = !context.getBooleanAttribute("readOnly", false);
Properties props = context.getChildrenAsProperties();
// 以上从<cache>节点配置中获取的属性和对应的class，都是为生成cache对象做准备的，此处cache对象的生成使用了构造者模式
builderAssistant.useNewCache(typeClass, evictionClass, flushInterval, size, readWrite, props);
}
}
通过上面的代码可知：Cache对象是由MapperBuilderAssistant类生成的，进入useNewCache方法：
public Cache useNewCache(Class<? extends Cache> typeClass,
Class<? extends Cache> evictionClass,
Long flushInterval,
Integer size,
boolean readWrite,
Properties props) {
typeClass = valueOrDefault(typeClass, PerpetualCache.class);
evictionClass = valueOrDefault(evictionClass, LruCache.class);
// 这里使用到了构造者模式，CacheBuilder是建造者的角色，Cache是生成的产品，产品类的角色
Cache cache = new CacheBuilder(currentNamespace)
.implementation(typeClass)
.addDecorator(evictionClass)
.clearInterval(flushInterval)
.size(size)
.readWrite(readWrite)
.properties(props)
.build();
// 将cache对象放到configuration对象的StrctMap中，cache的id作为key，cache对象作为value。此处的cache对象使用了装饰器模式，最底层的对象是PerpetualCache
configuration.addCache(cache);
// 记录当前命名空间使用的cache对象
currentCache = cache;
return cache;
}
CacheBuilder是Cache的建造者，接下来分析CacheBuilder这个类：
// 这个类是建造者角色，根据<cache>节点中配置的各种属性来生成不同的Cache对象，<cache>节点中配置的属性都被赋予了这个类中的下面这些属性，然后又为这些属性提供了不同的赋值方法，可以灵活的生成任意组合的Cache对象；这是典型的建造者模式
public class CacheBuilder {
private String id; // Cache对象的唯一表示，一般情况下对应Mapper映射文件的namespace
private Class<? extends Cache> implementation; // Cache接口的真正实现类，默认是PerpetualCache
private List<Class<? extends Cache>> decorators; // 装饰器集合，默认只包含LRUCache.class
private Integer size; // Cache的大小
private Long clearInterval; //清理时间周期
private boolean readWrite; // 是否可读写
private Properties properties;// 其它配置信息
public CacheBuilder(String id) {
this.id = id;
this.decorators = new ArrayList<Class<? extends Cache>>();
}
// 这几个方法就是为生成的Cache对象使用到的方法
public CacheBuilder implementation(Class<? extends Cache> implementation) {
this.implementation = implementation;
return this;
} public CacheBuilder addDecorator(Class<? extends Cache> decorator) {
if (decorator != null) {
this.decorators.add(decorator);
}
return this;
} public CacheBuilder size(Integer size) {
this.size = size;
return this;
} public CacheBuilder clearInterval(Long clearInterval) {
this.clearInterval = clearInterval;
return this;
} // 生成Cache对象，cache对象是产品角色
public Cache build() {
//implement为null，decorators为空，则给予默认值
setDefaultImplementations();
// 根据implement指定的类型，创建Cache对象
Cache cache = newBaseCacheInstance(implementation, id);
// 根据<cache>节点下配置的<properties>信息，初始化Cache对象
setCacheProperties(cache);
// 如果cache对象的类型是PerpetualCahce类型，那么为其添加decorators集合中的装饰器，cache对象本身使用了装饰器模式
if (PerpetualCache.class.equals(cache.getClass())) { // issue #352, do not apply decorators to custom caches
for (Class<? extends Cache> decorator : decorators) {
// 为Cache对象添加装饰器
cache = newCacheDecoratorInstance(decorator, cache);
setCacheProperties(cache);// 为cache对象配置属性
}
// 添加mybatis中提供的标准装饰器
cache = setStandardDecorators(cache);
}
return cache;
}
}
3.<resultMap/>解析
3.1 使用方法：
<resultMap id="goodsMap" type="goods">
<id column="id" property="id"/>
<result column="name" property="name"/>
</resultMap>
3.2 源码解析
<resultMap>节点定义了数据库的结果集和javaBean对象之间的映射关系，在解析<resultMap>节点之前，先看两个类ResultMapping和ResultMap。
每个ResultMapping对象记录了结果集中的一列与javaBean中一个属性之间的映射关系，看它的属性字段：
private Configuration configuration; //Configuration对象
private String property; // 对应节点的property属性，表示的是javaBean中对应的属性
private String column; // 对应节点的column属性，表示的是从数据库中得到的列名或者列名的别名
private Class<?> javaType; //对应节点的javaType属性，表示的是一个javaBean的完全限定名，或者一个类型别名
private JdbcType jdbcType;// 对应节点的jdbcType属性，表示的是进行映射的列的JDBC类型
private TypeHandler<?> typeHandler;// 对应节点的typeHandler属性，表示的是类型处理器
private String nestedResultMapId; // 对应节点的resultMap属性 嵌套的结果映射时有用到
private String nestedQueryId; //对应节点的select属性 嵌套查询时有用到
private Set<String> notNullColumns;
private String columnPrefix;
private List<ResultFlag> flags;
private List<ResultMapping> composites;
private String resultSet; //对应节点的resultSet属性
private String foreignColumn;// 对应节点的foreignColumn属性
private boolean lazy; //是否延迟加载，对应节点的fetchType属性
对于ResultMap类，每个<resultMap>节点都会被解析成一个ResutltMap对象，看它的属性：
private String id; //<resultMap>节点id的属性
private Class<?> type; // <resultMap>节点type的属性
private List<ResultMapping> resultMappings; //ResutlMapping的集合
private List<ResultMapping> idResultMappings; //记录了映射关系中带有ID标志的映射关系 例如<id>节点和<constructor>节点的<idArg>子节点
private List<ResultMapping> constructorResultMappings; //记录映射关系中带有Constructor标志的映射关系，例如<constructor>所有子元素
private List<ResultMapping> propertyResultMappings; // 记录映射关系中不带有Constructor标志的映射关系
private Set<String> mappedColumns; // 记录所有映射关系中涉及的column熟悉的集合
private Discriminator discriminator;// 鉴别器 对应<discriminator>节点
private boolean hasNestedResultMaps; // 是否含有嵌套的结果映射，如果有，则为true
private boolean hasNestedQueries; // 是否含有嵌套查询，如果有，则为true
private Boolean autoMapping; //是否开启自动映射
现在我们进入<resultMap>节点的源码解析部分，进入XMLMapperBuilder的resultMapElement方法：
private ResultMap resultMapElement(XNode resultMapNode, List<ResultMapping> additionalResultMappings) throws Exception {
ErrorContext.instance().activity("processing " + resultMapNode.getValueBasedIdentifier());
// 获取<resutlMap>节点的id属性
String id = resultMapNode.getStringAttribute("id",
resultMapNode.getValueBasedIdentifier());
// 获取<resultMap>节点的type属性
String type = resultMapNode.getStringAttribute("type",
resultMapNode.getStringAttribute("ofType",
resultMapNode.getStringAttribute("resultType",
resultMapNode.getStringAttribute("javaType"))));
// 获取<resultMap>节点的extends属性，该属性指定了<resultMap>节点的继承关系
String extend = resultMapNode.getStringAttribute("extends");
// 读取resultMap节点的autoMapping属性
Boolean autoMapping = resultMapNode.getBooleanAttribute("autoMapping");
// 解析type类型
Class<?> typeClass = resolveClass(type);
Discriminator discriminator = null;
List<ResultMapping> resultMappings = new ArrayList<ResultMapping>();
resultMappings.addAll(additionalResultMappings);
List<XNode> resultChildren = resultMapNode.getChildren();
// 处理<resultMap>的所有子节点
for (XNode resultChild : resultChildren) {
// 处理<constructor>节点
if ("constructor".equals(resultChild.getName())) {
processConstructorElement(resultChild, typeClass, resultMappings);
} else if ("discriminator".equals(resultChild.getName())) {
// 处理<discriminator>节点
discriminator = processDiscriminatorElement(resultChild, typeClass, resultMappings);
} else {
// 处理<id>,<result>,<association>,<collection>等节点
ArrayList<ResultFlag> flags = new ArrayList<ResultFlag>();
if ("id".equals(resultChild.getName())) {
flags.add(ResultFlag.ID);
}
// 创建ResultMapping对象，并添加到集合中
resultMappings.add(buildResultMappingFromContext(resultChild, typeClass, flags));
}
}
ResultMapResolver resultMapResolver = new ResultMapResolver(builderAssistant, id, typeClass, extend, discriminator, resultMappings, autoMapping);
try {
// 创建ResultMap对象，并添加到Configuration.resultMaps集合中
return resultMapResolver.resolve();
} catch (IncompleteElementException e) {
configuration.addIncompleteResultMap(resultMapResolver);
throw e;
}
}
接下来，我们分析上面红色字体的方法首先是buildResultMappingFromContext方法，根据字面意思也可以知道，该方法是从上下文环境中获取到的属性信息创建ResultMapping对象，进入该方法：
private ResultMapping buildResultMappingFromContext(XNode context, Class<?> resultType, ArrayList<ResultFlag> flags) throws Exception {
// 获取每一个映射关系中 property，column,....的属性值
String 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.<ResultMapping> emptyList()));
String notNullColumn = context.getStringAttribute("notNullColumn");
String columnPrefix = context.getStringAttribute("columnPrefix");
String typeHandler = context.getStringAttribute("typeHandler");
String resulSet = context.getStringAttribute("resultSet");
String foreignColumn = context.getStringAttribute("foreignColumn");
boolean lazy = "lazy".equals(context.getStringAttribute("fetchType", configuration.isLazyLoadingEnabled() ? "lazy" : "eager"));
// 解析javaType，jdbcType和TypeHandler
Class<?> javaTypeClass = resolveClass(javaType);
@SuppressWarnings("unchecked")
Class<? extends TypeHandler<?>> typeHandlerClass = (Class<? extends TypeHandler<?>>) resolveClass(typeHandler);
JdbcType jdbcTypeEnum = resolveJdbcType(jdbcType);
// 创建ResultMapping对象
return builderAssistant.buildResultMapping(resultType, property, column, javaTypeClass, jdbcTypeEnum, nestedSelect, nestedResultMap, notNullColumn, columnPrefix, typeHandlerClass, flags, resulSet, foreignColumn, lazy);
}
4.<sql/>的解析
4.1 使用用法
<sql id="sql_where_key">
id = #{id}
</sql>
4.2 源码解析
private void sqlElement(List<XNode> list, String requiredDatabaseId) throws Exception {
// 遍历<sql>节点
for (XNode context : list) {
// 获取databaseId属性
String databaseId = context.getStringAttribute("databaseId");
// 获取id属性
String id = context.getStringAttribute("id");
// 为id添加命名空间
id = builderAssistant.applyCurrentNamespace(id, false);
// 以id为key，context为value存放到Map中
if (databaseIdMatchesCurrent(id, databaseId, requiredDatabaseId)) sqlFragments.put(id, context);
}
}
5.<select>,<insert>等sql节点的解析
5.1 使用方法：
<select id="selectGoodsById" resultMap="goodsMap">
select * from goods
<where>
<include refid="sql_where_key" />
</where>
</select>
5.2 源码解析
在源码解析前，先了解SQLSource接口和MappedStatement类
SqlSource接口表示映射文件或者注解中描述的sql语句，但是它并不是数据库可执行的sql语句，因为它还可能包含有动态sql语句相关的节点或者占位符等需要解析的元素。
public interface SqlSource {
// 根据映射文件或者注解描述的sql语句，以及传入的参数，返回可执行的sql
BoundSql getBoundSql(Object parameterObject);
}
MappedStatement表示映射文件中定义的sql节点，它的部分属性如下：
private String resource; //节点中id的属性
private Configuration configuration;
private String id;
private Integer fetchSize;
private Integer timeout;
private StatementType statementType;
private ResultSetType resultSetType;
private SqlSource sqlSource; //sqlSource对象，对应一条sql语句
private Cache cache;
private SqlCommandType sqlCommandType; // SQL的类型，INSERT,SELECT 等
SQL节点的解析是XMLStatementBuilder类来解析的，进入解析方法的入口：
public void parseStatementNode() {
String id = context.getStringAttribute("id");
String databaseId = context.getStringAttribute("databaseId");
if (!databaseIdMatchesCurrent(id, databaseId, this.requiredDatabaseId)) return;
Integer fetchSize = context.getIntAttribute("fetchSize");
Integer timeout = context.getIntAttribute("timeout");
String parameterMap = context.getStringAttribute("parameterMap");
String parameterType = context.getStringAttribute("parameterType");
Class<?> parameterTypeClass = resolveClass(parameterType);
String resultMap = context.getStringAttribute("resultMap");
String resultType = context.getStringAttribute("resultType");
String lang = context.getStringAttribute("lang");
LanguageDriver langDriver = getLanguageDriver(lang);
Class<?> resultTypeClass = resolveClass(resultType);
String resultSetType = context.getStringAttribute("resultSetType");
StatementType statementType = StatementType.valueOf(context.getStringAttribute("statementType", StatementType.PREPARED.toString()));
ResultSetType resultSetTypeEnum = resolveResultSetType(resultSetType);
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节点中的各种属性值，如 useCache,resultMap,resultType,paramterMap,timeout等
// Include Fragments before parsing 解析SQL语句前，先处理<sql>节点中的<include/>节点
XMLIncludeTransformer includeParser = new XMLIncludeTransformer(configuration, builderAssistant);
includeParser.applyIncludes(context.getNode());
// 处理selectKey节点
// Parse selectKey after includes and remove them.
processSelectKeyNodes(id, parameterTypeClass, langDriver);
// 解析SQL语句
// Parse the SQL (pre: <selectKey> and <include> were parsed and removed)
SqlSource sqlSource = langDriver.createSqlSource(configuration, context, parameterTypeClass);
String resultSets = context.getStringAttribute("resultSets");
String keyProperty = context.getStringAttribute("keyProperty");
String keyColumn = context.getStringAttribute("keyColumn");
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))
? new Jdbc3KeyGenerator() : new NoKeyGenerator();
}
// 将SQL节点解析为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);
}
到这里，映射配置文件的整个解析过程就结束了，在下一篇文章中，我们介绍SQL的执行过程。