Mybatis 代码流程及实现原理解析(三)

接上篇， 这篇继续分析XMLMapperBuilder.parse()里的configurationElement() 这个方法。

private void configurationElement(XNode context) {
try {
//mapper可以加namespace来避免重复情况
String namespace = context.getStringAttribute("namespace");
builderAssistant.setCurrentNamespace(namespace);
//该节点表示从其他名目空间引用缓存配置
cacheRefElement(context.evalNode("cache-ref"));
cacheElement(context.evalNode("cache"));//解析cache子节点.
//解析parameterMap 子节点，因为有多个并列的parameterMap节点，所以要加上路径，解析返回的列表
parameterMapElement(context.evalNodes("/mapper/parameterMap"));
//解析resultMap子节点,因为有多个并列的resultMap节点，所以要加上路径，解析返回的列表
resultMapElements(context.evalNodes("/mapper/resultMap"));
//解析sql子节点,因为有多个并列的sql节点，所以要加上路径，解析返回的列表
sqlElement(context.evalNodes("/mapper/sql"));
//解析select，insert，update，delete子节点
buildStatementFromContext(context.evalNodes("select|insert|update|delete"));
} catch (Exception e) {
throw new RuntimeException("Error parsing Mapper XML. Cause: " + e, e);
}
}

此方法逐步解析<mapper>的子节点。

子节点<cache-ref>

xml配置片段：

<cache-ref namespace="com.Book"/>

java代码解析：

private void cacheRefElement(XNode context) {
if (context != null) {
//首先用该节点的namespace替换cacherefmap中mapper文件的。
configuration.addCacheRef(builderAssistant.getCurrentNamespace(), context.getStringAttribute("namespace"));
CacheRefResolver cacheRefResolver = new CacheRefResolver(builderAssistant, context.getStringAttribute("namespace"));
try {
//创建resolver，判断该namespace是否可用。
cacheRefResolver.resolveCacheRef();
} catch (IncompleteElementException e) {
//如果不可用，加入到为完成列表，在所有节点解析完成后，再统一做处理
configuration.addIncompleteCacheRef(cacheRefResolver);
}
}
}

CacheRefResolver.java的resolve方法

public Cache resolveCacheRef() {
return assistant.useCacheRef(cacheRefNamespace);
}

MapperBuilderAssistant.java的useCacheRef方法：

public Cache useCacheRef(String namespace) {
if (namespace == null) {
throw new BuilderException("cache-ref element requires a namespace attribute.");
}
try {
unresolvedCacheRef = true;
Cache cache = configuration.getCache(namespace);
//如果当前configuration对象没有持有该namespace的Cache， 则抛出异常。
if (cache == null) {
throw new IncompleteElementException("No cache for namespace '" + namespace + "' could be found.");
}
currentCache = cache;
unresolvedCacheRef = false;
return cache;
} catch (IllegalArgumentException e) {
throw new IncompleteElementException("No cache for namespace '" + namespace + "' could be found.", e);
}
}

子节点<cache>

xml配置如下：

<mapper namespace="com.skoyou.domain.UserDAO">
<cache type="com.domain.something.MyCustomCache"
eviction="FIFO"
flushInterval="60000"
size="512"
readOnly="tr">
<property name="cacheFile" value="/tmp/my-custom-cache.tmp"/>
</cache>

type：配置自定义缓存或为其他第三方缓存方案 创建适配器来完全覆盖缓存行为。如果未指定的话， 使用“PERPETFUL”类型（PerpetualCache.java）。

eviction：缓存回收策略，默认值是“LRU”， 有如下几种策略可以指定：

LRU：最近最少使用的:移除最长时间不被使用的对象。

FIFO：先进先出:按对象进入缓存的顺序来移除它们。

SOFT：软引用:移除基于垃圾回收器状态和软引用规则的对象。

WEAK:弱引用:更积极地移除基于垃圾收集器状态和弱引用规则的对象.

flushInterval：刷新间隔)可以被设置为任意的正整数,而且它们代表一个合理的毫秒 形式的时间段。默认情况是不设置,也就是没有刷新间隔,缓存仅仅调用语句时刷新。

size：(引用数目)可以被设置为任意正整数,要记住你缓存的对象数目和你运行环境的 可用内存资源数目。默认值是 1024。

readyOnly：(只读)属性可以被设置为 true 或 false。只读的缓存会给所有调用者返回缓 存对象的相同实例。因此这些对象不能被修改。这提供了很重要的性能优势。可读写的缓存 会返回缓存对象的拷贝(通过序列化) 。这会慢一些,但是安全,因此默认是 false。

cache可以有个子节点<property> 来加载.

java方法解析：

private void cacheElement(XNode context) throws Exception {
if (context != null) {
//获取cache type的值，没有的话，使用默认PERPETUAL
String type = context.getStringAttribute("type", "PERPETUAL");
// 得到type类, 默认是PERPETUAL 对应的PerpetualCache
Class<? extends Cache> typeClass = typeAliasRegistry.resolveAlias(type);
//获取eviction的值，没有的话，使用默认LRU得到eviction类, 即LruCache.class
String eviction = context.getStringAttribute("eviction", "LRU");
Class<? extends Cache> evictionClass = typeAliasRegistry.resolveAlias(eviction);
Long flushInterval = context.getLongAttribute("flushInterval");
Integer size = context.getIntAttribute("size");
boolean readWrite = !context.getBooleanAttribute("readOnly", false);
Properties props = context.getChildrenAsProperties();
//根据提供的参数， 建一个cache对象， 并将这个对象放入到Configuration 对象中.
builderAssistant.useNewCache(typeClass, evictionClass, flushInterval, size, readWrite, props);
}
}

子节点<parameterMap>

在Mybatis中，这个节点已经被废弃了!老式风格的参数映射。内联参数是首选,这个元素可能在将来被移除。其实解析还是比较简单的。取这个节点的所有属性，build出一个ParameterMapping对象，方法parametermappings列表里， 然后将这个列表更新到configuration对象中的ParameterMap中去。

for (XNode parameterMapNode : list) {
String id = parameterMapNode.getStringAttribute("id");
String type = parameterMapNode.getStringAttribute("type");
Class<?> parameterClass = resolveClass(type);
List<XNode> parameterNodes = parameterMapNode.evalNodes("parameter");
List<ParameterMapping> parameterMappings = new ArrayList<ParameterMapping>();
for (XNode parameterNode : parameterNodes) {
String property = parameterNode.getStringAttribute("property");
String javaType = parameterNode.getStringAttribute("javaType");
String jdbcType = parameterNode.getStringAttribute("jdbcType");
String resultMap = parameterNode.getStringAttribute("resultMap");
String mode = parameterNode.getStringAttribute("mode");
String typeHandler = parameterNode.getStringAttribute("typeHandler");
Integer numericScale = parameterNode.getIntAttribute("numericScale");
ParameterMode modeEnum = resolveParameterMode(mode);
Class<?> javaTypeClass = resolveClass(javaType);
JdbcType jdbcTypeEnum = resolveJdbcType(jdbcType);
@SuppressWarnings("unchecked")
Class<? extends TypeHandler<?>> typeHandlerClass = (Class<? extends TypeHandler<?>>) resolveClass(typeHandler);
ParameterMapping parameterMapping = builderAssistant.buildParameterMapping(parameterClass, property, javaTypeClass, jdbcTypeEnum, resultMap, modeEnum, typeHandlerClass, numericScale);
parameterMappings.add(parameterMapping);
}
builderAssistant.addParameterMap(id, parameterClass, parameterMappings);
}
}

子节点<resultMap>

这个节点的解析较复杂，会在下一遍中单独讲解。

子节点<sql>

<sql id="userColumns"> id,username,password </sql>

这个元素可以被用来定义可重用的 SQL 代码段,可以包含在其他语句中。

Java 代码

private void sqlElement(List<XNode> list) throws Exception {
if (configuration.getDatabaseId() != null) {  //传人configuration现有的database id。
sqlElement(list, configuration.getDatabaseId());
}
sqlElement(list, null);
}

sqlElement方法：

private void sqlElement(List<XNode> list, String requiredDatabaseId) throws Exception {
for (XNode context : list) { //由于有多个并列的sql节点，需求逐个解析。
//sql 也可以有自己的database id,但实际上这个id要与全局配置的一致
String databaseId = context.getStringAttribute("databaseId");
String id = context.getStringAttribute("id");
//判断id是否包含有当前的namespace，包含的话直接返回当前id。 没有的话，则以当前mapper的namespace.id值返回
id = builderAssistant.applyCurrentNamespace(id, false);
if (databaseIdMatchesCurrent(id, databaseId, requiredDatabaseId))
sqlFragments.put(id, context);
}
}

databaseIdMatchesCurrent 方法：

sql节点自己指定的database id要与configuration中的一致。

private boolean databaseIdMatchesCurrent(String id, String databaseId, String requiredDatabaseId) {
if (requiredDatabaseId != null) {
if (!requiredDatabaseId.equals(databaseId)) {
return false;
}
} else {
if (databaseId != null) {
return false;
}
// skip this fragment if there is a previous one with a not null databaseId
if (this.sqlFragments.containsKey(id)) {
XNode context = this.sqlFragments.get(id);
if (context.getStringAttribute("databaseId") != null) {
return false;
}
}
}
return true;
}

实际上这个sqlFragments map是在XMLMappBuilder初始化的时候，有configuration传入的， 所以configuration能得到最新的对这个map的修改。这个map会在build select等节点的时候被用到。

子节点<select>，<insert>,<update>,<delete>

节点配置，以select为例：

<select
id="selectPerson"
databaseId="test"
fetchSize="256"
timeout="10000"
parameterMap="deprecated"
parameterType="int"
resultMap="personResultMap"
resultType="hashmap"
lang="XML"
resultSetType="FORWARD_ONLY"
statementType="PREPARED"
flushCache="false"
useCache="true"
resultOrdered="false"
>

节点属性描述：

属性	描述
id	在命名空间中唯一的标识符,可以被用来引用这条语句。
databaseId	如果配置了databaseProvider，databaseId要与配置的一致。如果不匹配的话，后续代码不会继续解析
fetchSize	这是暗示驱动程序每次批量返回的结果行数。默认不设置(驱动 自行处理)。
timeout	这个设置驱动程序等待数据库返回请求结果,并抛出异常时间的 最大等待值。默认不设置(驱动自行处理)
parameterMap	这是引用外部 parameterMap 的已经被废弃的方法。使用内联参数 映射和 parameterType 属性。
parameterType	将会传入这条语句的参数类的完全限定名或别名。
resultMap	命名引用外部的 resultMap。 返回 map 是 MyBatis 最具力量的特性, 对其有一个很好的理解的话, 许多复杂映射的情形就 能被解决了。 使用 resultMap 或 resultType,但不能同时使用。
resultType	从这条语句中返回的期望类型的类的完全限定名或别名。注意集 合情形,那应该是集合可以包含的类型,而不能是集合本身。使 用 resultType 或 resultMap,但不能同时使用
lang	提供”XML“或”RAW“，不同的lang，可能会影响最终的sql语句的生成，默认是”XML“
resultSetType	FORWARD_ONLY|SCROLL_SENSITIVE|SCROLL_INSENSITIVE 中的一种。默认是不设置(驱动自行处理)。
statementType	STA TEMENT,PREPARED 或 CALLABLE 的一种。 这会让 MyBatis 使用选择使用 Statement,PreparedStatement 或 CallableStatement。 默认值:PREPARED
fhushCache	将其设置为 true,不论语句什么时候被调用,都会导致缓存被 清空。默认值:false
userCache	将其设置为 true, 将会导致本条语句的结果被缓存。 默认值: true
resultOrdered	这个属性值适用于有嵌套结果的select 语句。如果是true， 那么就认为包含了嵌套的结果， 或者嵌套的结果被分在一组。这样的话， 当一个新的主结果返回时， 就不会出现上一个结果行。 这能够更加内存友好地填充嵌套结果。默认是false。

另外还有3个是只对insert有效的属性：

useGeneratedKeys	这会告诉 MyBatis使用JDBC的getGeneratedKeys 方法来取出由数据(比如:像 MySQL 和 SQL Server 这样的数据库管理系统的自动递增字段)内部生成的主键。 默认值:false
keyProperty	标记一个属性, MyBatis 会通过 getGeneratedKeys 或者通过 insert 语句的 selectKey 子元素设置它的值。 默认: 不设置
keyColumn	标记一个属性, MyBatis 会通过 getGeneratedKeys 或者通过 insert 语句的 selectKey 子元素设置它的值。 默认: 不设置

sql语句的解析实际上是在 XMLStatementBuider的parseStatementNode方法中解析的。

private void buildStatementFromContext(List<XNode> list) {
if (configuration.getDatabaseId() != null) {
buildStatementFromContext(list, configuration.getDatabaseId());
}
buildStatementFromContext(list, null);
}

private void buildStatementFromContext(List<XNode> list, String requiredDatabaseId) {
for (XNode context : list) {
//构造statementBuilder。这几个sql语句相关的节点在这个类里解析
final XMLStatementBuilder statementParser = new XMLStatementBuilder(configuration, builderAssistant, context, requiredDatabaseId);
try {
statementParser.parseStatementNode();
} catch (IncompleteElementException e) {
configuration.addIncompleteStatement(statementParser);
}
}
}

XMLStatementBuilder.java的 parseStatementNode方法，如下。这个方法比较长，但主要是读取属性值，然后包装生成一个MappedStatement，并放入configuration对象中。

public void parseStatementNode() {
//读取id 属性
String id = context.getStringAttribute("id");
String databaseId = context.getStringAttribute("databaseId");
//读取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 默认是PreparedStatement
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;
//如果是select语句，则默认值是false。否则默认值是true。
boolean flushCache = context.getBooleanAttribute("flushCache", !isSelect);
//如果是select语句，则默认值是true。否则默认值是false。
boolean useCache = context.getBooleanAttribute("useCache", isSelect);
boolean resultOrdered = context.getBooleanAttribute("resultOrdered", false);

// 解析<include>子节点，其实是用引用替换<sql>节点的实际内容。
XMLIncludeTransformer includeParser = new XMLIncludeTransformer(configuration, builderAssistant);
includeParser.applyIncludes(context.getNode());

// 解析<selectKey>子节点，仅对<insert>有用。后面会讲解parseSelectKeyNodes方法
List<XNode> selectKeyNodes = context.evalNodes("selectKey");
if (configuration.getDatabaseId() != null) {
parseSelectKeyNodes(id, selectKeyNodes, parameterTypeClass, langDriver, configuration.getDatabaseId());
}
parseSelectKeyNodes(id, selectKeyNodes, parameterTypeClass, langDriver, null);

//默认是XMLLanguageDriver，parameterTypeClass用不上
//生成持有当前sql语句的sqlSource对象，后面会具体看这个sqlSource是怎么生成的
SqlSource sqlSource = langDriver.createSqlSource(configuration, context, parameterTypeClass);
//keyProperty和keyColumn使用于<insert>语句
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();
}
//通过解析出来的属性值，构造MappedStatement对象。并放入configuration对象中
builderAssistant.addMappedStatement(id, sqlSource, statementType, sqlCommandType,
fetchSize, timeout, parameterMap, parameterTypeClass, resultMap, resultTypeClass,
resultSetTypeEnum, flushCache, useCache, resultOrdered,
keyGenerator, keyProperty, keyColumn, databaseId, langDriver);
}

<insert>节点的子节点<selectKey>的解析

<selectKey>配置例子：

<selectKey
databaseId="mysql“
keyProperty="id"
resultType="int"
order="BEFORE"
statementType="PREPARED">
select CAST(RANDOM()*1000000 as INTEGER) a from SYSIBM.SYSDUMMY1
</selectKey>

keyProperty：selectKey 语句结果应该被设置的目标属性。就是给哪个字段生成主键值。

resultType：结果的类型。MyBatis 通常可以算出来,但是写上也没有问题。 MyBatis 允许任何简单类型用作主键的类型,包括字符串

statementType：MyBatis 支持 STA TEMENT ,PREPARED 和 CALLABLE 语句的映射类型,分别代表 PreparedStatement 和 CallableStatement 类型。

order:这可以被设置为 BEFORE 或 AFTER。如果设置为 BEFORE,那 么它会首先选择主键, 设置 keyProperty 然后执行插入语句。 如果 设置为 AFTER,那么先执行插入语句,然后是 selectKey 元素- 这和如 Oracle 数据库相似,可以在插入语句中嵌入序列调用.

java代码：

public void parseSelectKeyNodes(String parentId, List<XNode> list, Class<?> parameterTypeClass, LanguageDriver langDriver, String skRequiredDatabaseId) {
//可以有多个<selectKey>节点。
for (XNode nodeToHandle : list) {
String id = parentId + SelectKeyGenerator.SELECT_KEY_SUFFIX;
String databaseId = nodeToHandle.getStringAttribute("databaseId");
if (databaseIdMatchesCurrent(id, databaseId, skRequiredDatabaseId)) {
parseSelectKeyNode(id, nodeToHandle, parameterTypeClass, langDriver, databaseId);
}
}
}
//
public void parseSelectKeyNode(String id, XNode nodeToHandle, Class<?> parameterTypeClass, LanguageDriver langDriver, String databaseId) {
String resultType = nodeToHandle.getStringAttribute("resultType");
Class<?> resultTypeClass = resolveClass(resultType);
StatementType statementType = StatementType.valueOf(nodeToHandle.getStringAttribute("statementType", StatementType.PREPARED.toString()));
String keyProperty = nodeToHandle.getStringAttribute("keyProperty");
boolean executeBefore = "BEFORE".equals(nodeToHandle.getStringAttribute("order", "AFTER"));

//defaults
boolean useCache = false;
boolean resultOrdered = false;
KeyGenerator keyGenerator = new NoKeyGenerator();
Integer fetchSize = null;
Integer timeout = null;
boolean flushCache = false;
String parameterMap = null;
String resultMap = null;
ResultSetType resultSetTypeEnum = null;
//解析生成主键的sql语句
SqlSource sqlSource = langDriver.createSqlSource(configuration, nodeToHandle, parameterTypeClass);
SqlCommandType sqlCommandType = SqlCommandType.SELECT;
//生成MappedStatement 对象，放入configuration对象的mappedStatements map中
builderAssistant.addMappedStatement(id, sqlSource, statementType, sqlCommandType,
fetchSize, timeout, parameterMap, parameterTypeClass, resultMap, resultTypeClass,
resultSetTypeEnum, flushCache, useCache, resultOrdered,
keyGenerator, keyProperty, null, databaseId, langDriver);

id = builderAssistant.applyCurrentNamespace(id, false);

MappedStatement keyStatement = configuration.getMappedStatement(id, false);
//同时将这个MappedStatement 对象放入到configuration的 keyGenerator map中
configuration.addKeyGenerator(id, new SelectKeyGenerator(keyStatement, executeBefore));
nodeToHandle.getParent().getNode().removeChild(nodeToHandle.getNode());
}

下篇会主要看看<resultMap>的解析和sqlSource的生成。