Mybatis加载解析Mapper（xml）文件第二讲： http://donald-draper.iteye.com/blog/2333191
在上篇 SqlSessionFactory初始化中，解析全局配置文件mybatisConfig.xml文件时，讲到，properties,typeAliases,plugins,objectFactory,objectWrapperFactory
，settings,environments,databaseIdProvider,typeHandlers的初始化，而mappers的初始化较复杂，
我们放在这一篇来讲。
首先从下面这个方法来看
//加载Mapper xml文件，并解析
private void mapperElement(XNode parent)
throws Exception
{
if(parent != null)
{
for(Iterator i$ = parent.getChildren().iterator(); i$.hasNext();)
{
XNode child = (XNode)i$.next();
if("package".equals(child.getName()))
{
String mapperPackage = child.getStringAttribute("name");
configuration.addMappers(mapperPackage);
} else
{
String resource = child.getStringAttribute("resource");
String url = child.getStringAttribute("url");
String mapperClass = child.getStringAttribute("class");
//根据配置的resource，解析Mapper
if(resource != null && url == null && mapperClass == null)
{
ErrorContext.instance().resource(resource);
//加载Mapper的resource文件
InputStream inputStream = Resources.getResourceAsStream(resource);
构建XMLMapperBuilder
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
//这一部分放到下一篇讲
//根据配置的class，解析Mapper
if(resource == null && url == null && mapperClass != null)
{
Class mapperInterface = Resources.classForName(mapperClass);
//mapperInterface信息添加到configuration
configuration.addMapper(mapperInterface);
} else
{
throw new BuilderException("A mapper element may only specify a url, resource or class, but not more than one.");
}
}
}
}
}
//XMLMapperBuilder
public class XMLMapperBuilder extends BaseBuilder
{
private XPathParser parser;
private MapperBuilderAssistant builderAssistant;
private Map sqlFragments;
private String resource;
//构造XMLMapperBuilder
public XMLMapperBuilder(InputStream inputStream, Configuration configuration, String resource, Map sqlFragments)
{
this(new XPathParser(inputStream, true, configuration.getVariables(), new XMLMapperEntityResolver()), configuration, resource, sqlFragments);
}
private XMLMapperBuilder(XPathParser parser, Configuration configuration, String resource, Map sqlFragments)
{
super(configuration);
//构建MapperBuilderAssistant
builderAssistant = new MapperBuilderAssistant(configuration, resource);
this.parser = parser;
this.sqlFragments = sqlFragments;
this.resource = resource;
}
public void parse()
{
if(!configuration.isResourceLoaded(resource))
{
//如果configuration没有加载文件，则解析Mapper xml文件，
<mapper namespace="test.Dao.UserMapper">
configurationElement(parser.evalNode("/mapper"));
//将资源添加到configuration的Set<class.name> resource
configuration.addLoadedResource(resource);
//绑定Mapper的命名空间
bindMapperForNamespace();
}
//从configuration中移除未完成的ResultMaps
parsePendingResultMaps();
//从configuration中移除未完成的ChacheRefs
parsePendingChacheRefs();
//从configuration中移除未完成的Statements
parsePendingStatements();
}
//根据mapper Xnode 配置，namespace，cache，cache-ref，parameterMap，resultMap，
//sql，及select|insert|update|delete子节点
private void configurationElement(XNode context)
{
try
{
//这部分我们在下面分别去分析
String namespace = context.getStringAttribute("namespace");
builderAssistant.setCurrentNamespace(namespace);
cacheRefElement(context.evalNode("cache-ref"));
cacheElement(context.evalNode("cache"));
parameterMapElement(context.evalNodes("/mapper/parameterMap"));
resultMapElements(context.evalNodes("/mapper/resultMap"));
sqlElement(context.evalNodes("/mapper/sql"));
buildStatementFromContext(context.evalNodes("select|insert|update|delete"));
}
catch(Exception e)
{
throw new RuntimeException((new StringBuilder()).append("Error parsing Mapper XML. Cause: ").append(e).toString(), e);
}
}
}
//Configuration,添加Mapper xml文件名到Set<String> loadedResources;
//其中key为class完整名，com.mapper.UserMapper
public void addLoadedResource(String resource)
{
loadedResources.add(resource);
}
//XPathParser
public class XPathParser
{
private Document document;
private boolean validation;
private EntityResolver entityResolver;
private Properties variables;
private XPath xpath;
//构造XPathParser
public XPathParser(InputStream inputStream, boolean validation, Properties variables, EntityResolver entityResolver)
{
commonConstructor(validation, variables, entityResolver);
document = createDocument(new InputSource(inputStream));
}
//初始化属性
private void commonConstructor(boolean validation, Properties variables, EntityResolver entityResolver)
{
this.validation = validation;
this.entityResolver = entityResolver;
this.variables = variables;
XPathFactory factory = XPathFactory.newInstance();
xpath = factory.newXPath();
}
//创建createDocument
private Document createDocument(InputSource inputSource)
{
DocumentBuilder builder;
DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
factory.setValidating(validation);
factory.setNamespaceAware(false);
factory.setIgnoringComments(true);
factory.setIgnoringElementContentWhitespace(false);
factory.setCoalescing(false);
factory.setExpandEntityReferences(true);
builder = factory.newDocumentBuilder();
builder.setEntityResolver(entityResolver);
builder.setErrorHandler(new ErrorHandler() {
public void error(SAXParseException exception)
throws SAXException
{
throw exception;
}
public void fatalError(SAXParseException exception)
throws SAXException
{
throw exception;
}
public void warning(SAXParseException saxparseexception)
throws SAXException
{
}
final XPathParser this$0;
{
this$0 = XPathParser.this;
super();
}
});
return builder.parse(inputSource);
Exception e;
e;
throw new BuilderException((new StringBuilder()).append("Error creating document instance. Cause: ").append(e).toString(), e);
}
public XNode evalNode(String expression)
{
return evalNode(document, expression);
}
public Integer evalInteger(String expression)
{
return evalInteger(document, expression);
}
}
下面分别来看根据mapper Xnode 配置，namespace，cache，cacheref，parameterMap，resultMap，sql，及select|insert|update|delete子节点
//配置namespace
String namespace = context.getStringAttribute("namespace");
builderAssistant.setCurrentNamespace(namespace);
public class MapperBuilderAssistant extends BaseBuilder
{
private String currentNamespace;//命名空间
private String resource;//Mapper xml的url
private Cache currentCache;
private boolean unresolvedCacheRef;
public MapperBuilderAssistant(Configuration configuration, String resource)
{
super(configuration);
ErrorContext.instance().resource(resource);
this.resource = resource;
}
//设置命名空间
public void setCurrentNamespace(String currentNamespace)
{
if(currentNamespace == null)
throw new BuilderException("The mapper element requires a namespace attribute to be specified.");
if(this.currentNamespace != null && !this.currentNamespace.equals(currentNamespace))
{
throw new BuilderException((new StringBuilder()).append("Wrong namespace. Expected '").append(this.currentNamespace).append("' but found '").append(currentNamespace).append("'.").toString());
} else
{
this.currentNamespace = currentNamespace;
return;
}
}
}
从上面的方法可以看出，命名空间实际上是配置Mapper对应的MapperBuilderAssistantcurrentNamespace属性
//配置cache-ref
cacheRefElement(context.evalNode("cache-ref"));
private void cacheRefElement(XNode context)
{
if(context != null)
{
//添加cacheRef的命名空间映射关系
configuration.addCacheRef(builderAssistant.getCurrentNamespace(), context.getStringAttribute("namespace"));
CacheRefResolver cacheRefResolver = new CacheRefResolver(builderAssistant, context.getStringAttribute("namespace"));
try
{
//确定configuration中是否存在参考缓存
cacheRefResolver.resolveCacheRef();
}
catch(IncompleteElementException e)
{
//如果参考缓存不存在，则将cacheRefResolver，添加到configuration
//IncompleteCacheRef集合中Linklist<CacheRefResolver>
configuration.addIncompleteCacheRef(cacheRefResolver);
}
}
}
//configuration
public void addCacheRef(String namespace, String referencedNamespace)
{
//将CacheRef的namespace引用的referencedNamespace的映射关系，添加到
//configuration的缓存参考引用中cacheRefMap
cacheRefMap.put(namespace, referencedNamespace);
}
//CacheRefResolver,缓存参考处理器
public class CacheRefResolver
{
public CacheRefResolver(MapperBuilderAssistant assistant, String cacheRefNamespace)
{
this.assistant = assistant;
this.cacheRefNamespace = cacheRefNamespace;
}
public Cache resolveCacheRef()
{
return assistant.useCacheRef(cacheRefNamespace);
}
private final MapperBuilderAssistant assistant;
private final String cacheRefNamespace;//参考缓存命名空间
}
//MapperBuilderAssistant,
public Cache useCacheRef(String namespace)
{
if(namespace == null)
throw new BuilderException("cache-ref element requires a namespace attribute.");
Cache cache;
unresolvedCacheRef = true;
//根据命名空间，从configuration而级缓存中，获取缓存
cache = configuration.getCache(namespace);
if(cache == null)
throw new IncompleteElementException((new StringBuilder()).append("No cache for namespace '").append(namespace).append("' could be found.").toString());
//从这里可以看出，参考命名的缓存必须存在，否则抛出异常
currentCache = cache;
unresolvedCacheRef = false;
return cache;
IllegalArgumentException e;
e;
throw new IncompleteElementException((new StringBuilder()).append("No cache for namespace '").append(namespace).append("' could be found.").toString(), e);
}
从分析配置cache-ref，实际上，将cache和cache-ref的命名空间的映射关系添加到configuration中，并从configuration的获取cacheRefNamespace对应的Cache，如果cache-ref的cacheRefNamespace对应的缓存，不存在，则抛出IncompleteElementException，并将对应的CacheRefResolver添加到configuration的IncompleteCacheRef集合中Linklist<CacheRefResolver>；
//配置cache
cacheElement(context.evalNode("cache"));
配置实例
<!-- <cache eviction="LRU" flushInterval="60000" size="1024" readOnly="true" /> eviction是缓存的淘汰算法，可选值有"LRU"、"FIFO"、"SOFT"、"WEAK"，缺省值是LRU flashInterval指缓存过期时间，单位为毫秒，60000即为60秒，缺省值为空，即只要容量足够，永不过期 size指缓存多少个对象，默认值为1024 readOnly是否只读，如果为true，则所有相同的sql语句返回的是同一个对象 （有助于提高性能，但并发操作同一条数据时，可能不安全）， 如果设置为false，则相同的sql，后面访问的是cache的clone副本。 -->
private void cacheElement(XNode context)
throws Exception
{
if(context != null)
{
//返回cache节点的type属性，不存在，则返回PERPETUAL
String type = context.getStringAttribute("type", "PERPETUAL");
//根据type，从TypeAliasRegistry的TYPE_ALIASES中获取对应的Class
Class typeClass = typeAliasRegistry.resolveAlias(type);
//返回cache节点的eviction属性，不存在，则返回LRU，
//eviction是缓存的淘汰算法，可选值有"LRU"、"FIFO"、"SOFT"、"WEAK"，缺省值是LRU
String eviction = context.getStringAttribute("eviction", "LRU");
//根据eviction，从TypeAliasRegistry的TYPE_ALIASES中获取对应的Class
Class evictionClass = typeAliasRegistry.resolveAlias(eviction);
Long flushInterval = context.getLongAttribute("flushInterval");
Integer size = context.getIntAttribute("size");
//返回cache节点的readOnly属性，不存在，则返回false，
boolean readWrite = !context.getBooleanAttribute("readOnly", Boolean.valueOf(false)).booleanValue();
//获取缓存的child属性配置
java.util.Properties props = context.getChildrenAsProperties();
//
builderAssistant.useNewCache(typeClass, evictionClass, flushInterval, size, readWrite, props);
}
}
//XNode
//返回Xnode的name属性值，不存在返回默认值
public String getStringAttribute(String name, String def)
{
String value = attributes.getProperty(name);
if(value == null)
return def;
else
return value;
}
//TypeAliasRegistry 根据type，从TypeAliasRegistry的TYPE_ALIASES中获取对应的Class
// private final HashMap TYPE_ALIASES = new HashMap();
//HashMap<alias,Class> key为Class对应的别名alias
public Class resolveAlias(String string)
{
if(string == null)
return null;
Class value;
String key = string.toLowerCase(Locale.ENGLISH);
if(TYPE_ALIASES.containsKey(key))
value = (Class)TYPE_ALIASES.get(key);
else
value = Resources.classForName(string);
return value;
ClassNotFoundException e;
e;
throw new TypeException((new StringBuilder()).append("Could not resolve type alias '").append(string).append("'. Cause: ").append(e).toString(), e);
}
//MapperBuilderAssistant
//将缓存添加到Configuration的二级缓存中
public Cache useNewCache(Class typeClass, Class evictionClass, Long flushInterval, Integer size, boolean readWrite, Properties props)
{
//获取缓存类型
typeClass = (Class)valueOrDefault(typeClass, org/apache/ibatis/cache/impl/PerpetualCache);
//获取缓存算法类型
evictionClass = (Class)valueOrDefault(evictionClass, org/apache/ibatis/cache/decorators/LruCache);
//构建缓存
Cache cache = (new CacheBuilder(currentNamespace)).implementation(typeClass).addDecorator(evictionClass).clearInterval(flushInterval).size(size).readWrite(readWrite).properties(props).build();
//将缓存添加到Configuration的二级缓存中
configuration.addCache(cache);
currentCache = cache;
return cache;
}
//Configuration
//将缓存添加到Configuration的二级缓存中
//StrictMap<currentNamespace,CacheBuilder>
//caches = new StrictMap("Caches collection");
public void addCache(Cache cache)
{
caches.put(cache.getId(), cache);
}
public class MapperBuilderAssistant extends BaseBuilder
//BaseBuilder
public abstract class BaseBuilder
{
protected final Configuration configuration;
protected final TypeAliasRegistry typeAliasRegistry;
protected final TypeHandlerRegistry typeHandlerRegistry;
public BaseBuilder(Configuration configuration)
{
this.configuration = configuration;
typeAliasRegistry = this.configuration.getTypeAliasRegistry();
typeHandlerRegistry = this.configuration.getTypeHandlerRegistry();
}
//返回别名对应的Class类型
protected Class resolveAlias(String alias)
{
return typeAliasRegistry.resolveAlias(alias);
}
//返回别名对应的Class类型
protected Class resolveClass(String alias)
{
if(alias == null)
return null;
return resolveAlias(alias);
Exception e;
e;
throw new BuilderException((new StringBuilder()).append("Error resolving class. Cause: ").append(e).toString(), e);
}
//根据别名创建实例
protected Object createInstance(String alias)
{
Class clazz = resolveClass(alias);
if(clazz == null)
return null;
return resolveClass(alias).newInstance();
Exception e;
e;
throw new BuilderException((new StringBuilder()).append("Error creating instance. Cause: ").append(e).toString(), e);
}
protected Boolean booleanValueOf(String value, Boolean defaultValue)
{
return value != null ? Boolean.valueOf(value) : defaultValue;
}
protected Integer integerValueOf(String value, Integer defaultValue)
{
return value != null ? Integer.valueOf(value) : defaultValue;
}
protected Set stringSetValueOf(String value, String defaultValue)
{
value = value != null ? value : defaultValue;
return new HashSet(Arrays.asList(value.split(",")));
}
//获取别名对应的JdbcType
protected JdbcType resolveJdbcType(String alias)
{
if(alias == null)
return null;
return JdbcType.valueOf(alias);
IllegalArgumentException e;
e;
throw new BuilderException((new StringBuilder()).append("Error resolving JdbcType. Cause: ").append(e).toString(), e);
}
}
从上的分析可以看出Cache的节点的解析，实际上是，获取cache节点的type对应的Class，
cache节点的eviction对应的缓存算法Class，以及刷新间隔，读写属性，构造CacheBuilder
，并添加的configuration的二级缓存StrictMap<nameSpace,CacheBuilder>
//CacheBuilder
public class CacheBuilder
{
private String id;//缓存命名空间
private Class implementation;//缓存实现类
private List decorators;//缓存算法，缓存解决集合
private Integer size;
private Long clearInterval;//刷新间隔
private boolean readWrite;//读写属性
private Properties properties;
public CacheBuilder(String id)
{
this.id = id;
decorators = new ArrayList();
}
//设置缓存属性
private void setCacheProperties(Cache cache)
{
if(properties != null)
{
MetaObject metaCache = SystemMetaObject.forObject(cache);
Iterator i$ = properties.entrySet().iterator();
do
{
if(!i$.hasNext())
break;
java.util.Map.Entry entry = (java.util.Map.Entry)i$.next();
String name = (String)entry.getKey();
String value = (String)entry.getValue();
if(metaCache.hasSetter(name))
{
Class type = metaCache.getSetterType(name);
if(java/lang/String == type)
metaCache.setValue(name, value);
else
if(Integer.TYPE == type || java/lang/Integer == type)
metaCache.setValue(name, Integer.valueOf(value));
else
if(Long.TYPE == type || java/lang/Long == type)
metaCache.setValue(name, Long.valueOf(value));
else
if(Short.TYPE == type || java/lang/Short == type)
metaCache.setValue(name, Short.valueOf(value));
else
if(Byte.TYPE == type || java/lang/Byte == type)
metaCache.setValue(name, Byte.valueOf(value));
else
if(Float.TYPE == type || java/lang/Float == type)
metaCache.setValue(name, Float.valueOf(value));
else
if(Boolean.TYPE == type || java/lang/Boolean == type)
metaCache.setValue(name, Boolean.valueOf(value));
else
if(Double.TYPE == type || java/lang/Double == type)
metaCache.setValue(name, Double.valueOf(value));
else
throw new CacheException((new StringBuilder()).append("Unsupported property type for cache: '").append(name).append("' of type ").append(type).toString());
}
} while(true);
}
}
}
//MetaObject,设置Class实例属性
public class MetaObject
{
private Object originalObject;//原始Obeject
private ObjectWrapper objectWrapper;//包装后的Object
private ObjectFactory objectFactory;
private ObjectWrapperFactory objectWrapperFactory;
private MetaObject(Object object, ObjectFactory objectFactory, ObjectWrapperFactory objectWrapperFactory)
{
originalObject = object;
this.objectFactory = objectFactory;
this.objectWrapperFactory = objectWrapperFactory;
if(object instanceof ObjectWrapper)
objectWrapper = (ObjectWrapper)object;
else
//如果对应objectWrapperFactory中存在，则返回object
if(objectWrapperFactory.hasWrapperFor(object))
objectWrapper = objectWrapperFactory.getWrapperFor(this, object);
else
if(object instanceof Map)
//Map
objectWrapper = new MapWrapper(this, (Map)object);
else
if(object instanceof Collection)
//List
objectWrapper = new CollectionWrapper(this, (Collection)object);
else
//bean
objectWrapper = new BeanWrapper(this, object);
}
//构造MetaObject
public static MetaObject forObject(Object object, ObjectFactory objectFactory, ObjectWrapperFactory objectWrapperFactory)
{
if(object == null)
return SystemMetaObject.NULL_META_OBJECT;
else
return new MetaObject(object, objectFactory, objectWrapperFactory);
}
public String findProperty(String propName, boolean useCamelCaseMapping)
{
return objectWrapper.findProperty(propName, useCamelCaseMapping);
}
public String[] getGetterNames()
{
return objectWrapper.getGetterNames();
}
public String[] getSetterNames()
{
return objectWrapper.getSetterNames();
}
}
这个我们在后面单讲
//配置parameterMap
parameterMapElement(context.evalNodes("/mapper/parameterMap"));
parameterMap配置实例
<!-- <parameterMap id="course_param" type="java.util.Map"> <parameter property="subjectCode" javaType="java.lang.String"/> <parameter property="courseNumber" javaType="java.lang.String"/> <parameter property="termCode" javaType="java.lang.String"/> <parameter property="pidm" javaType="int"/> </parameterMap> -->
private void parameterMapElement(List list)
throws Exception
{
String id; //parameterMap的id
Class parameterClass;//parameterMap的type
List parameterMappings;
//遍历所有的，parameterMap，并解析构造parameterMappings，在添加到configuration的ParameterMap中
for(Iterator i$ = list.iterator(); i$.hasNext(); builderAssistant.addParameterMap(id, parameterClass, parameterMappings))
{
XNode parameterMapNode = (XNode)i$.next();
//获取parameterMap的id，type
id = parameterMapNode.getStringAttribute("id");
String type = parameterMapNode.getStringAttribute("type");
parameterClass = resolveClass(type);
//获取parameterMap的所有parameter子节点
List parameterNodes = parameterMapNode.evalNodes("parameter");
//parameterMappings，ArrayList<ParameterMapping>
parameterMappings = new ArrayList();
org.apache.ibatis.mapping.ParameterMapping parameterMapping;
//遍历所有的parameter节点,根据parameter节点属性构建ParameterMapping，并添加到parameterMappings
for(Iterator i$ = parameterNodes.iterator(); i$.hasNext(); parameterMappings.add(parameterMapping))
{
XNode parameterNode = (XNode)i$.next();
//获取parameter的property，javaType，jdbcType，resultMap，mode，typeHandler，numericScale属性
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", null);
// 获取mode的ParameterMode类型
org.apache.ibatis.mapping.ParameterMode modeEnum = resolveParameterMode(mode);
// 获取javaTypeClass类型
Class javaTypeClass = resolveClass(javaType);
// 获取jdbcType类型
JdbcType jdbcTypeEnum = resolveJdbcType(jdbcType);
// 获取typeHandler类型
Class typeHandlerClass = resolveClass(typeHandler);
//构建ParameterMapping
parameterMapping = builderAssistant.buildParameterMapping(parameterClass, property, javaTypeClass, jdbcTypeEnum, resultMap, modeEnum, typeHandlerClass, numericScale);
}
}
}
//MapperBuilderAssistant
public class MapperBuilderAssistant extends BaseBuilder
{
private String currentNamespace;
private String resource;
private Cache currentCache;
private boolean unresolvedCacheRef;
//ParameterMap添加到configuration中
public ParameterMap addParameterMap(String id, Class parameterClass, List parameterMappings)
{
//获取全局唯一的命名空间
id = applyCurrentNamespace(id, false);
org.apache.ibatis.mapping.ParameterMap.Builder parameterMapBuilder = new org.apache.ibatis.mapping.ParameterMap.Builder(configuration, id, parameterClass, parameterMappings);
ParameterMap parameterMap = parameterMapBuilder.build();
//ParameterMap添加到configuration中
configuration.addParameterMap(parameterMap);
return parameterMap;
}
//ParameterMapping构建
public ParameterMapping buildParameterMapping(Class parameterType, String property, Class javaType, JdbcType jdbcType, String resultMap, ParameterMode parameterMode, Class typeHandler,
Integer numericScale)
{
resultMap = applyCurrentNamespace(resultMap, true);
Class javaTypeClass = resolveParameterJavaType(parameterType, property, javaType, jdbcType);
TypeHandler typeHandlerInstance = resolveTypeHandler(javaTypeClass, typeHandler);
org.apache.ibatis.mapping.ParameterMapping.Builder builder = new org.apache.ibatis.mapping.ParameterMapping.Builder(configuration, property, javaTypeClass);
builder.jdbcType(jdbcType);
builder.resultMapId(resultMap);
builder.mode(parameterMode);
builder.numericScale(numericScale);
builder.typeHandler(typeHandlerInstance);
return builder.build();
}
}
//configuration
//ParameterMap的映射关系到configuration的parameterMaps中
//parameterMaps = new StrictMap("Parameter Maps collection");
//Map<nameSpace,ParameterMap>
public void addParameterMap(ParameterMap pm)
{
parameterMaps.put(pm.getId(), pm);
}
//ParameterMapping，ParameterMap的参数映射描述
public class ParameterMapping
{
private Configuration configuration;
private String property;
private ParameterMode mode;
private Class javaType;
private JdbcType jdbcType;
private Integer numericScale;
private TypeHandler typeHandler;
private String resultMapId;
private String jdbcTypeName;
private String expression;
public static class Builder
{
public Builder mode(ParameterMode mode)
{
parameterMapping.mode = mode;
return this;
}
public Builder javaType(Class javaType)
{
parameterMapping.javaType = javaType;
return this;
}
public Builder jdbcType(JdbcType jdbcType)
{
parameterMapping.jdbcType = jdbcType;
return this;
}
public Builder numericScale(Integer numericScale)
{
parameterMapping.numericScale = numericScale;
return this;
}
public Builder resultMapId(String resultMapId)
{
parameterMapping.resultMapId = resultMapId;
return this;
}
public Builder typeHandler(TypeHandler typeHandler)
{
parameterMapping.typeHandler = typeHandler;
return this;
}
public Builder jdbcTypeName(String jdbcTypeName)
{
parameterMapping.jdbcTypeName = jdbcTypeName;
return this;
}
public ParameterMapping build()
{
resolveTypeHandler();
return parameterMapping;
}
private void resolveTypeHandler()
{
if(parameterMapping.typeHandler == null && parameterMapping.javaType != null)
{
Configuration configuration = parameterMapping.configuration;
//从configuration的typeHandlerRegistry获取TypeHandler
TypeHandlerRegistry typeHandlerRegistry = configuration.getTypeHandlerRegistry();
parameterMapping.typeHandler = typeHandlerRegistry.getTypeHandler(parameterMapping.javaType, parameterMapping.jdbcType);
}
}
private ParameterMapping parameterMapping;
public Builder(Configuration configuration, String property, TypeHandler typeHandler)
{
parameterMapping = new ParameterMapping();
parameterMapping.configuration = configuration;
parameterMapping.property = property;
parameterMapping.typeHandler = typeHandler;
parameterMapping.mode = ParameterMode.IN;
}
public Builder(Configuration configuration, String property, Class javaType)
{
parameterMapping = new ParameterMapping();
parameterMapping.configuration = configuration;
parameterMapping.property = property;
parameterMapping.javaType = javaType;
parameterMapping.mode = ParameterMode.IN;
}
}
}
//ParameterMode
public final class ParameterMode extends Enum
{
public static ParameterMode[] values()
{
return (ParameterMode[])$VALUES.clone();
}
public static ParameterMode valueOf(String name)
{
return (ParameterMode)Enum.valueOf(org/apache/ibatis/mapping/ParameterMode, name);
}
private ParameterMode(String s, int i)
{
super(s, i);
}
public static final ParameterMode IN;
public static final ParameterMode OUT;
public static final ParameterMode INOUT;
private static final ParameterMode $VALUES[];
static
{
IN = new ParameterMode("IN", 0);
OUT = new ParameterMode("OUT", 1);
INOUT = new ParameterMode("INOUT", 2);
$VALUES = (new ParameterMode[] {
IN, OUT, INOUT
});
}
}
//ParameterMap
public class ParameterMap
{
private String id;
private Class type;
private List parameterMappings;
public static class Builder
{
public Class type()
{
return parameterMap.type;
}
public ParameterMap build()
{
parameterMap.parameterMappings = Collections.unmodifiableList(parameterMap.parameterMappings);
return parameterMap;
}
private ParameterMap parameterMap;
public Builder(Configuration configuration, String id, Class type, List parameterMappings)
{
parameterMap = new ParameterMap();
parameterMap.id = id;
parameterMap.type = type;
parameterMap.parameterMappings = parameterMappings;
}
}
}
//从configuration中移除未完成的ChacheRefs
parsePendingChacheRefs();
private void parsePendingChacheRefs()
{
Collection incompleteCacheRefs = configuration.getIncompleteCacheRefs();
synchronized(incompleteCacheRefs)
{
for(Iterator iter = incompleteCacheRefs.iterator(); iter.hasNext();)
try
{
//CacheRefResolver的参考缓存可以在configuration的缓存中找到，
//则从IncompleteCacheRefs,LinkedList<CacheRefResolver>中移除CacheRefResolver
((CacheRefResolver)iter.next()).resolveCacheRef();
iter.remove();
}
catch(IncompleteElementException e) { }
}
}
从上的分析可以看出ParameterMap的解析实际是解析ParameterMap的id，type属性和
parameter子节点；然后解析parameter的property，javaType，jdbcType，typeHalder，
resultMap的属性根据这些属性构建parameterMapping，并添加的parameterMappings（ArrayList<ParameterMapping>)集合中;然后再根据id，type属性和parameterMappings，构造ParameterMap，并添加到configuration的parameterMaps中
。
总结：
解析Mapper对应的xml文件，实际上是解析xml的mapper Xnode，具体到namespace属性，及cache，cache-ref，parameterMap，篇幅有限这一篇我们讲到namespace属性，及cache，cache-ref，parameterMap，这三部分的解析，我们都有小节，实际上就是将这些添加configuration的相应的cache，parameterMap的StrictMap中。
各小节的总结：
namespace：
从上面的方法可以看出，命名空间实际上是配置Mapper对应的MapperBuilderAssistantcurrentNamespace属性；
cache-ref：
从分析配置cache-ref，实际上，将cache和cache-ref的命名空间的映射关系添加到configuration中，并从configuration的获取cacheRefNamespace对应的Cache，如果cache-ref的cacheRefNamespace对应的缓存，不存在，则抛出IncompleteElementException，并将对应的CacheRefResolver添加到configuration的IncompleteCacheRef集合中Linklist<CacheRefResolver>；
cache：
从上的分析可以看出Cache的节点的解析，实际上是，获取cache节点的type对应的Class，
cache节点的eviction对应的缓存算法Class，以及刷新间隔，读写属性，构造CacheBuilder
，并添加的configuration的二级缓存StrictMap<nameSpace,CacheBuilder>；
parameterMap：
从上的分析可以看出ParameterMap的解析实际是解析ParameterMap的id，type属性和
parameter子节点；然后解析parameter的property，javaType，jdbcType，typeHalder，resultMap的属性，根据这些属性构建parameterMapping，并添加的parameterMappings（ArrayList<ParameterMapping>)集合中;
然后再根据id，type属性和parameterMappings，构造ParameterMap，并添加到configuration的parameterMaps中。
下面一片我们再讲resultMap，sql，及select|insert|update|delete子节点
//XMLMapperEntityResolver
public class XMLMapperEntityResolver
implements EntityResolver
{
public XMLMapperEntityResolver()
{
}
public InputSource resolveEntity(String publicId, String systemId)
throws SAXException
{
if(publicId != null)
publicId = publicId.toUpperCase(Locale.ENGLISH);
if(systemId != null)
systemId = systemId.toUpperCase(Locale.ENGLISH);
InputSource source = null;
try
{
String path = (String)doctypeMap.get(publicId);
source = getInputSource(path, source);
if(source == null)
{
path = (String)doctypeMap.get(systemId);
source = getInputSource(path, source);
}
}
catch(Exception e)
{
throw new SAXException(e.toString());
}
return source;
}
private InputSource getInputSource(String path, InputSource source)
{
if(path != null)
try
{
java.io.InputStream in = Resources.getResourceAsStream(path);
source = new InputSource(in);
}
catch(IOException e) { }
return source;
}
private static final Map doctypeMap;
private static final String IBATIS_CONFIG_DOCTYPE;
private static final String IBATIS_CONFIG_URL;
private static final String IBATIS_MAPPER_DOCTYPE;
private static final String IBATIS_MAPPER_URL;
private static final String MYBATIS_CONFIG_DOCTYPE;
private static final String MYBATIS_CONFIG_URL;
private static final String MYBATIS_MAPPER_DOCTYPE;
private static final String MYBATIS_MAPPER_URL;
private static final String IBATIS_CONFIG_DTD = "org/apache/ibatis/builder/xml/mybatis-3-config.dtd";
private static final String IBATIS_MAPPER_DTD = "org/apache/ibatis/builder/xml/mybatis-3-mapper.dtd";
static
{
doctypeMap = new HashMap();
IBATIS_CONFIG_DOCTYPE = "-//ibatis.apache.org//DTD Config 3.0//EN".toUpperCase(Locale.ENGLISH);
IBATIS_CONFIG_URL = "http://ibatis.apache.org/dtd/ibatis-3-config.dtd".toUpperCase(Locale.ENGLISH);
IBATIS_MAPPER_DOCTYPE = "-//ibatis.apache.org//DTD Mapper 3.0//EN".toUpperCase(Locale.ENGLISH);
IBATIS_MAPPER_URL = "http://ibatis.apache.org/dtd/ibatis-3-mapper.dtd".toUpperCase(Locale.ENGLISH);
MYBATIS_CONFIG_DOCTYPE = "-//mybatis.org//DTD Config 3.0//EN".toUpperCase(Locale.ENGLISH);
MYBATIS_CONFIG_URL = "http://mybatis.org/dtd/mybatis-3-config.dtd".toUpperCase(Locale.ENGLISH);
MYBATIS_MAPPER_DOCTYPE = "-//mybatis.org//DTD Mapper 3.0//EN".toUpperCase(Locale.ENGLISH);
MYBATIS_MAPPER_URL = "http://mybatis.org/dtd/mybatis-3-mapper.dtd".toUpperCase(Locale.ENGLISH);
doctypeMap.put(IBATIS_CONFIG_URL, "org/apache/ibatis/builder/xml/mybatis-3-config.dtd");
doctypeMap.put(IBATIS_CONFIG_DOCTYPE, "org/apache/ibatis/builder/xml/mybatis-3-config.dtd");
doctypeMap.put(IBATIS_MAPPER_URL, "org/apache/ibatis/builder/xml/mybatis-3-mapper.dtd");
doctypeMap.put(IBATIS_MAPPER_DOCTYPE, "org/apache/ibatis/builder/xml/mybatis-3-mapper.dtd");
doctypeMap.put(MYBATIS_CONFIG_URL, "org/apache/ibatis/builder/xml/mybatis-3-config.dtd");
doctypeMap.put(MYBATIS_CONFIG_DOCTYPE, "org/apache/ibatis/builder/xml/mybatis-3-config.dtd");
doctypeMap.put(MYBATIS_MAPPER_URL, "org/apache/ibatis/builder/xml/mybatis-3-mapper.dtd");
doctypeMap.put(MYBATIS_MAPPER_DOCTYPE, "org/apache/ibatis/builder/xml/mybatis-3-mapper.dtd");
}
}