本篇文章主要讲解映射文件的解析过程
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的执行过程。