流程原理分析系列：
MyBatis原理分析之获取SqlSessionFactory
MyBatis原理分析之获取SqlSession
MyBatis原理分析之获取Mapper接口的代理对象
MyBatis原理分析之查询单个对象
MyBatis的执行原理分为如下四步:
- ① 获取SqlSessionFactory
- ② 获取SqlSession
- ③ 获取mapper的代理对象
- ④ sqlsession进行具体CRUD过程
这里又分为三种场景：
- ① 无spring环境
自己手动根据mybatis配置文件获取SqlSessionFactory和SqlSession
- ② 传统ssm环境
通常在applicationContext.xml中注册了SqlSessionFactory和SqlSession
- ③ SpringBoot环境
SpringBoot做了自动化配置，当然你也可以自定义注册
这里咱们从第一种场景(无spring)进行分析。
【1】抽象类BaseBuilder与子类
BaseBuilder 有如下子类：
- XMLConfigBuilder
用来解析mybatis全局配置，初步获取Configuration实例
- XMLMapperBuilder
解析mapper.xml文件，每个XMLMapperBuilder实例有成员实例MapperBuilderAssistant
- MapperBuilderAssistant
- XMLStatementBuilder
解析mapper.xml中每个select|insert|update|delete结点
有成员属性MapperBuilderAssistant builderAssistant
- XMLScriptBuilder
XMLScriptBuilder和SqlSourceBuilder获取sqlsource片段
- SqlSourceBuilder
这里需要注意的是，上述子类在实例化时，会显示调用父类有参构造方法super(configuration);来为当前子类实例拥有的来自于父类的成员属性赋值。如下图所示：
① 抽象父类BaseBuilder
如下所示，有属性configuration、typeAliasRegistry、typeHandlerRegistry，上述子类都有这三个成员属性。在创建configuration实例时，会进行初始化。
public abstract class BaseBuilder {
protected final Configuration configuration;
protected final TypeAliasRegistry typeAliasRegistry;
protected final TypeHandlerRegistry typeHandlerRegistry;
public BaseBuilder(Configuration configuration) {
this.configuration = configuration;
this.typeAliasRegistry = this.configuration.getTypeAliasRegistry();
this.typeHandlerRegistry = this.configuration.getTypeHandlerRegistry();
}
//...
}typeAliasRegistry维护了一个mapprivate final Map<String, Class<?>> TYPE_ALIASES = new HashMap<>();，里面放了类型别名与class类型。如(string,class java.lang.String),参考其源码可发现在其实例化的时候就注册了值。
typeHandlerRegistry维护了了六个final Map，同样在实例化时就进行了Map初始化。
public final class TypeHandlerRegistry {
private final Map<JdbcType, TypeHandler<?>> JDBC_TYPE_HANDLER_MAP = new EnumMap<>(JdbcType.class);
private final Map<Type, Map<JdbcType, TypeHandler<?>>> TYPE_HANDLER_MAP = new ConcurrentHashMap<>();
private final TypeHandler<Object> UNKNOWN_TYPE_HANDLER = new UnknownTypeHandler(this);
private final Map<Class<?>, TypeHandler<?>> ALL_TYPE_HANDLERS_MAP = new HashMap<>();
private static final Map<JdbcType, TypeHandler<?>> NULL_TYPE_HANDLER_MAP = Collections.emptyMap();
private Class<? extends TypeHandler> defaultEnumTypeHandler = EnumTypeHandler.class;
public TypeHandlerRegistry() {
register(Boolean.class, new BooleanTypeHandler());
register(boolean.class, new BooleanTypeHandler());
register(JdbcType.BOOLEAN, new BooleanTypeHandler());
register(JdbcType.BIT, new BooleanTypeHandler());
register(Byte.class, new ByteTypeHandler());
register(byte.class, new ByteTypeHandler());
register(JdbcType.TINYINT, new ByteTypeHandler());
register(Short.class, new ShortTypeHandler());
register(short.class, new ShortTypeHandler());
register(JdbcType.SMALLINT, new ShortTypeHandler());
register(Integer.class, new IntegerTypeHandler());
register(int.class, new IntegerTypeHandler());
register(JdbcType.INTEGER, new IntegerTypeHandler());
register(Long.class, new LongTypeHandler());
register(long.class, new LongTypeHandler());
register(Float.class, new FloatTypeHandler());
register(float.class, new FloatTypeHandler());
register(JdbcType.FLOAT, new FloatTypeHandler());
register(Double.class, new DoubleTypeHandler());
register(double.class, new DoubleTypeHandler());
register(JdbcType.DOUBLE, new DoubleTypeHandler());
register(Reader.class, new ClobReaderTypeHandler());
register(String.class, new StringTypeHandler());
register(String.class, JdbcType.CHAR, new StringTypeHandler());
register(String.class, JdbcType.CLOB, new ClobTypeHandler());
register(String.class, JdbcType.VARCHAR, new StringTypeHandler());
register(String.class, JdbcType.LONGVARCHAR, new ClobTypeHandler());
register(String.class, JdbcType.NVARCHAR, new NStringTypeHandler());
register(String.class, JdbcType.NCHAR, new NStringTypeHandler());
register(String.class, JdbcType.NCLOB, new NClobTypeHandler());
register(JdbcType.CHAR, new StringTypeHandler());
register(JdbcType.VARCHAR, new StringTypeHandler());
register(JdbcType.CLOB, new ClobTypeHandler());
register(JdbcType.LONGVARCHAR, new ClobTypeHandler());
register(JdbcType.NVARCHAR, new NStringTypeHandler());
register(JdbcType.NCHAR, new NStringTypeHandler());
register(JdbcType.NCLOB, new NClobTypeHandler());
register(Object.class, JdbcType.ARRAY, new ArrayTypeHandler());
register(JdbcType.ARRAY, new ArrayTypeHandler());
register(BigInteger.class, new BigIntegerTypeHandler());
register(JdbcType.BIGINT, new LongTypeHandler());
register(BigDecimal.class, new BigDecimalTypeHandler());
register(JdbcType.REAL, new BigDecimalTypeHandler());
register(JdbcType.DECIMAL, new BigDecimalTypeHandler());
register(JdbcType.NUMERIC, new BigDecimalTypeHandler());
register(InputStream.class, new BlobInputStreamTypeHandler());
register(Byte[].class, new ByteObjectArrayTypeHandler());
register(Byte[].class, JdbcType.BLOB, new BlobByteObjectArrayTypeHandler());
register(Byte[].class, JdbcType.LONGVARBINARY, new BlobByteObjectArrayTypeHandler());
register(byte[].class, new ByteArrayTypeHandler());
register(byte[].class, JdbcType.BLOB, new BlobTypeHandler());
register(byte[].class, JdbcType.LONGVARBINARY, new BlobTypeHandler());
register(JdbcType.LONGVARBINARY, new BlobTypeHandler());
register(JdbcType.BLOB, new BlobTypeHandler());
register(Object.class, UNKNOWN_TYPE_HANDLER);
register(Object.class, JdbcType.OTHER, UNKNOWN_TYPE_HANDLER);
register(JdbcType.OTHER, UNKNOWN_TYPE_HANDLER);
register(Date.class, new DateTypeHandler());
register(Date.class, JdbcType.DATE, new DateOnlyTypeHandler());
register(Date.class, JdbcType.TIME, new TimeOnlyTypeHandler());
register(JdbcType.TIMESTAMP, new DateTypeHandler());
register(JdbcType.DATE, new DateOnlyTypeHandler());
register(JdbcType.TIME, new TimeOnlyTypeHandler());
register(java.sql.Date.class, new SqlDateTypeHandler());
register(java.sql.Time.class, new SqlTimeTypeHandler());
register(java.sql.Timestamp.class, new SqlTimestampTypeHandler());
register(String.class, JdbcType.SQLXML, new SqlxmlTypeHandler());
register(Instant.class, InstantTypeHandler.class);
register(LocalDateTime.class, LocalDateTimeTypeHandler.class);
register(LocalDate.class, LocalDateTypeHandler.class);
register(LocalTime.class, LocalTimeTypeHandler.class);
register(OffsetDateTime.class, OffsetDateTimeTypeHandler.class);
register(OffsetTime.class, OffsetTimeTypeHandler.class);
register(ZonedDateTime.class, ZonedDateTimeTypeHandler.class);
register(Month.class, MonthTypeHandler.class);
register(Year.class, YearTypeHandler.class);
register(YearMonth.class, YearMonthTypeHandler.class);
register(JapaneseDate.class, JapaneseDateTypeHandler.class);
// issue #273
register(Character.class, new CharacterTypeHandler());
register(char.class, new CharacterTypeHandler());
}
//...
}② final修饰符
为什么这里提到final修饰符呢？跟踪源码会看到上面提到的BaseBuilder的几个子类，包括configuration类中很多成员都是final。
final修饰符只能够作用在类、方法和变量上。它的作用是所有被final修饰的内容不能被改变。
- final类不能被继承。
- final变量一旦被赋值就不能被改变。
- final方法不能被重写(可以被重载)。
- final变量允许在构造函数中对其进行赋值
注意：如果一个final变量是对象的引用，这意味着该引用的值是一定不会改变的，但是对象的成员值可以改变。
【2】源码分析
源码分析时序图如下所示：
① SqlSessionFactoryBuilder
SqlSessionFactoryBuilder提供了诸多重载方法build来创建DefaultSqlSessionFactory。更多参考MyBatis中SqlSessionFactory和SqlSession简解
public SqlSessionFactory build(InputStream inputStream, String environment, Properties properties) {
try {
XMLConfigBuilder parser = new XMLConfigBuilder(inputStream, environment, properties);
return build(parser.parse());
} catch (Exception e) {
throw ExceptionFactory.wrapException("Error building SqlSession.", e);
} finally {
ErrorContext.instance().reset();
try {
inputStream.close();
} catch (IOException e) {
// Intentionally ignore. Prefer previous error.
}
}
}② XMLConfigBuilder
这个类主要作用如下：
- ① 创建configuration实例，进行初步初始化
- ② 解析mybatis全局配置，对configuration做进一步赋值
public Configuration parse() {
if (parsed) {
throw new BuilderException("Each XMLConfigBuilder can only be used once.");
}
parsed = true;
parseConfiguration(parser.evalNode("/configuration"));
return configuration;
}
private void parseConfiguration(XNode root) {
try {
// issue #117 read properties first
propertiesElement(root.evalNode("properties"));
Properties settings = settingsAsProperties(root.evalNode("settings"));
loadCustomVfs(settings);
loadCustomLogImpl(settings);
typeAliasesElement(root.evalNode("typeAliases"));
pluginElement(root.evalNode("plugins"));
objectFactoryElement(root.evalNode("objectFactory"));
objectWrapperFactoryElement(root.evalNode("objectWrapperFactory"));
reflectorFactoryElement(root.evalNode("reflectorFactory"));
settingsElement(settings);
// read it after objectFactory and objectWrapperFactory issue #631
environmentsElement(root.evalNode("environments"));
databaseIdProviderElement(root.evalNode("databaseIdProvider"));
typeHandlerElement(root.evalNode("typeHandlers"));
mapperElement(root.evalNode("mappers"));
} catch (Exception e) {
throw new BuilderException("Error parsing SQL Mapper Configuration. Cause: " + e, e);
}
}熟系mybatis全局配置的同学应该对上面代码很容易理解，解析mybatis的全局配置，为configuration实例属性赋值。
解释如下：
- 解析properties结点
- 解析settings结点
- 解析typeAliases结点
- 解析plugins结点
- 解析objectFactory结点
- 解析objectWrapperFactory结点
- 解析reflectorFactory结点
- 根据settings结点为configuration设置对应的成员变量
- 解析environments结点
- 解析databaseIdProvider结点
- 解析typeHandlers结点
- 解析mappers结点-这个也是我们着重关注的
从 mapperElement(root.evalNode(“mappers”))方法中会根据映射器mappers的配置类型进行不同的处理。代码如下所示：
private void mapperElement(XNode parent) throws Exception {
if (parent != null) {
for (XNode child : parent.getChildren()) {
//解析包
if ("package".equals(child.getName())) {
String mapperPackage = child.getStringAttribute("name");
configuration.addMappers(mapperPackage);
} else {
//获取resource url 或者完全限定类名
String resource = child.getStringAttribute("resource");
String url = child.getStringAttribute("url");
String mapperClass = child.getStringAttribute("class");
//解析resource
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();
//解析url
} 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.");
}
}
}
}
}③ XMLMapperBuilder
每一个mapper资源都会创建一个XMLMapperBuilder实例，而每一个XMLMapperBuilder实例都会有一个私有的成员实例MapperBuilderAssistant 。
这里从其构造函数即可看出：
private XMLMapperBuilder(XPathParser parser, Configuration configuration, String resource, Map<String, XNode> sqlFragments) {
super(configuration);
this.builderAssistant = new MapperBuilderAssistant(configuration, resource);
this.parser = parser;
this.sqlFragments = sqlFragments;
this.resource = resource;
}核心方法parse
源码如下：
public void parse() {
if (!configuration.isResourceLoaded(resource)) {
configurationElement(parser.evalNode("/mapper"));
configuration.addLoadedResource(resource);
bindMapperForNamespace();
}
//下面代码可以理解为mybatis"后手"，对前面不能确定的ResultMap、ChacheRef、Statement再次处理
parsePendingResultMaps();
//若是在某个地方看到了parsePendingChacheRefs()，也是正确的。这是mybatis框架开发工程师写错单词了；不过已经修正
parsePendingCacheRefs();
parsePendingStatements();
}代码解释如下
- ① 判断当前资源是否被加载。通过判断configuration实例的成员属性
Set<String> loadedResources = new HashSet<>()是否contains当前resource来判断 - ② 如果没有加载，执行以下步骤
- ③ 解析mapper结点
- ④ 将当前
resource放到configuration实例中Set<String> loadedResources = new HashSet<>()属性里 - ⑤ bindMapperForNamespace();
- 判断当前resource对应的namespace是否已经在configuration实例的MapperRegistry成员实例的knownMappers集合中。
Map<Class<?>, MapperProxyFactory<?>> knownMappers = new HashMap<>() - 如果不在，则执行以下步骤
- 将
"namespace:" + namespace添加到configuration实例的成员loadedResources中 -
configuration.addMapper(boundType);
-
knownMappers.put(type, new MapperProxyFactory<>(type)) - 创建MapperAnnotationBuilder实例，解析命名空间对应的mapper接口(也就是解析接口上面的注解)
- ⑥ 尝试处理待解决的ResultMaps
- ⑦ 尝试处理待解决的CacheRefs
- ⑧ 尝试处理待解决的Statements
核心方法configurationElement
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"));
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 BuilderException("Error parsing Mapper XML. The XML location is '" + resource + "'. Cause: " + e, e);
}
}代码解释如下：
- ① 获取namespace
- ② 为当前mapper的
builderAssistant(MapperBuilderAssistant实例，是XMLMapperBuilder成员变量)设置namespace - ③ 解析cache-ref结点，处理缓存引用
- ④ 解析cache结点，为当前namespace创建缓存实例
- ⑤ 解析parameterMap结点，参数映射
- ⑥ 解析resultMap结点，结果映射
- ⑦ 解析sql结点，SQL片段
- ⑧ 解析
select|insert|update|delete结点，这里最终会创建一个个MappedStatement放入configuration实例的Map<String, MappedStatement> mappedStatements中
关于缓存解析参考博文Mybatis二级缓存创建过程与使用详解。
核心方法parameterMapElement
参数映射解析
private void parameterMapElement(List<XNode> list) {
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<>();
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);
Class<? extends TypeHandler<?>> typeHandlerClass = resolveClass(typeHandler);
ParameterMapping parameterMapping = builderAssistant.buildParameterMapping(parameterClass, property, javaTypeClass, jdbcTypeEnum, resultMap, modeEnum, typeHandlerClass, numericScale);
parameterMappings.add(parameterMapping);
}
builderAssistant.addParameterMap(id, parameterClass, parameterMappings);
}
}一个parameterMap结点格式可能如下：
<parameterMap type="com.mybatis.bean.Employee" id="employeeParamMap">
<parameter property="id" javaType="java.lang.Long" jdbcType="BIGINT" typeHandler="org.apache.ibatis.type.LongTypeHandler" mode="IN" resultMap="" scale=""/>
<parameter property="lastName" javaType="java.lang.String" jdbcType="VARCHAR" typeHandler="org.apache.ibatis.type.StringTypeHandler" mode="IN" resultMap="" scale=""/>
</parameterMap>代码解释如下：
- ① 遍历循环每一个parameterMap结点
- ② 解析parameterMap结点的id 、type属性并遍历循环其子结点parameter
- ③ 解析每一个子结点parameter的属性，封装为一个
ParameterMapping 实例对象，放到list集合List<ParameterMapping> parameterMappings中 - ④ 当前调用parameterMap结点解析完，调用
builderAssistant.addParameterMap(id, parameterClass, parameterMappings);。
- ⑤
new ParameterMap.Builder(configuration, id, parameterClass, parameterMappings).build();获取parameterMap实例对象然后放入configuration实例的成员属性Map<String, ParameterMap> parameterMaps集合中。放入格式为：namespace+'.'+id=parameterMap
public ParameterMap addParameterMap(String id, Class<?> parameterClass, List<ParameterMapping> parameterMappings) {
id = applyCurrentNamespace(id, false);
ParameterMap parameterMap = new ParameterMap.Builder(configuration, id, parameterClass, parameterMappings).build();
configuration.addParameterMap(parameterMap);
return parameterMap;
}- ⑥ 重复执行①-⑤
这里引申看一下ParameterMap类。这个类比较有意思，其有三个成员属性以及一个静态嵌套类Builder (注意这里我们没有称之为内部类)。
//...
public class ParameterMap {
private String id;
private Class<?> type;
private List<ParameterMapping> parameterMappings;
private ParameterMap() {
}
public static class Builder {
private ParameterMap parameterMap = new ParameterMap();
//为parameterMap 实例属性赋值
public Builder(Configuration configuration, String id, Class<?> type, List<ParameterMapping> parameterMappings) {
parameterMap.id = id;
parameterMap.type = type;
parameterMap.parameterMappings = parameterMappings;
}
public Class<?> type() {
return parameterMap.type;
}
public ParameterMap build() {
//lock down collections
parameterMap.parameterMappings = Collections.unmodifiableList(parameterMap.parameterMappings);
return parameterMap;
}
}
//...
}
内部类的实例化对象需要绑定一个外围类的实例化对象，而静态嵌套类的实例化对象不能也无法绑定外围类的实例化对象。
此外MappedStatement、ResultMap也有各自的Builder来创建mappedStatement与resultMap实例对象。
核心方法buildStatementFromContext
private void buildStatementFromContext(List<XNode> list) {
if (configuration.getDatabaseId() != null) {
buildStatementFromContext(list, configuration.getDatabaseId());
}
buildStatementFromContext(list, null);
}代码解释如下：
- ① 判断是否配置了DatabaseId，如果配置了则执行②，否则执行③；
- ② 执行
buildStatementFromContext(list, configuration.getDatabaseId()); - ③ 执行
buildStatementFromContext(list, null);
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);
}
}
}代码解释如下：
- ①循环遍历
select|insert|update|delete结点 - ② 为每个结点创建XMLStatementBuilder 然后解析
- ③ 如果当前结点解析过程中报了异常，则将当前statementParser放入configuration实例的
Collection<XMLStatementBuilder> incompleteStatements = new LinkedList<>();属性中，然后留给mybatis的“后手”parsePendingResultMaps解决
④ XMLStatementBuilder
public void parseStatementNode() {
String id = context.getStringAttribute("id");
String databaseId = context.getStringAttribute("databaseId");
if (!databaseIdMatchesCurrent(id, databaseId, this.requiredDatabaseId)) {
return;
}
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);
// Include Fragments before parsing
XMLIncludeTransformer includeParser = new XMLIncludeTransformer(configuration, builderAssistant);
includeParser.applyIncludes(context.getNode());
String parameterType = context.getStringAttribute("parameterType");
Class<?> parameterTypeClass = resolveClass(parameterType);
String lang = context.getStringAttribute("lang");
LanguageDriver langDriver = getLanguageDriver(lang);
// Parse selectKey after includes and remove them.
processSelectKeyNodes(id, parameterTypeClass, langDriver);
// Parse the SQL (pre: <selectKey> and <include> were parsed and removed)
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))
? Jdbc3KeyGenerator.INSTANCE : NoKeyGenerator.INSTANCE;
}
SqlSource sqlSource = langDriver.createSqlSource(configuration, context, parameterTypeClass);
StatementType statementType = StatementType.valueOf(context.getStringAttribute("statementType", StatementType.PREPARED.toString()));
Integer fetchSize = context.getIntAttribute("fetchSize");
Integer timeout = context.getIntAttribute("timeout");
String parameterMap = context.getStringAttribute("parameterMap");
String resultType = context.getStringAttribute("resultType");
Class<?> resultTypeClass = resolveClass(resultType);
String resultMap = context.getStringAttribute("resultMap");
String resultSetType = context.getStringAttribute("resultSetType");
ResultSetType resultSetTypeEnum = resolveResultSetType(resultSetType);
if (resultSetTypeEnum == null) {
resultSetTypeEnum = configuration.getDefaultResultSetType();
}
String keyProperty = context.getStringAttribute("keyProperty");
String keyColumn = context.getStringAttribute("keyColumn");
String resultSets = context.getStringAttribute("resultSets");
builderAssistant.addMappedStatement(id, sqlSource, statementType, sqlCommandType,
fetchSize, timeout, parameterMap, parameterTypeClass, resultMap, resultTypeClass,
resultSetTypeEnum, flushCache, useCache, resultOrdered,
keyGenerator, keyProperty, keyColumn, databaseId, langDriver, resultSets);
}代码解释如下：
- ① 获取当前结点配置的 id和
databaseId属性 - ②
databaseIdMatchesCurrent(id, databaseId, this.requiredDatabaseId)根据全局配置的requiredDatabaseId和当前结点的databaseId判断是否解析当前结点
- ③ 如果configuration配置了
requiredDatabaseId且requiredDatabaseId.equals(databaseId)则进行解析否则不解析当前结点 - ④ 如果configuration没有配置requiredDatabaseId但是当前结点配置了databaseId，不解析当前结点直接返回
- ⑤ 如果configuration已经有了当前id对应的MappedStatement，则不解析当前结点直接返回
- ⑥ 解析SqlCommandType与isSelect、flushCache、useCache、resultOrdered
- ⑦ 解析
<include/>结点、parameterType、<selectKey/>、keyGenerator最后获取sqlSource - ⑧ 解析
StatementType，默认是PREPARED - ⑨ 解析
fetchSize、timeout、parameterMap、resultType、resultMap、resultSetType、keyProperty、keyColumn、resultSets - ⑩
builderAssistant.addMappedStatement获取MappedStatement并放入configuration的protected final Map<String, MappedStatement> mappedStatements = new StrictMap<MappedStatement>集合中
SqlSource有哪些信息？
顾名思义，包含了当前节点解析的SQL语句、参数映射以及全局配置实例configuration。
BoundSql
与SqlSource紧密相关的是BoundSql。与SqlSource不同的是,BoundSql多了参数值对象(可能是单个值，也可能是map)。
BoundSql主要属性和构造函数如下：
public class BoundSql {
private String sql;
private List<ParameterMapping> parameterMappings;
private Object parameterObject;
private Map<String, Object> additionalParameters;
private MetaObject metaParameters;
public BoundSql(Configuration configuration, String sql, List<ParameterMapping> parameterMappings, Object parameterObject) {
this.sql = sql;
this.parameterMappings = parameterMappings;
this.parameterObject = parameterObject;
this.additionalParameters = new HashMap<String, Object>();
this.metaParameters = configuration.newMetaObject(additionalParameters);
}
//...
}一个BoundSql实例可能如下：
关于结点属性配置详情说明更多参考MyBatis中XML映射器使用详解
⑤ MapperBuilderAssistant
public MappedStatement addMappedStatement(String id,SqlSource sqlSource,StatementType statementType,SqlCommandType sqlCommandType,Integer fetchSize,
Integer timeout,String parameterMap,Class<?> parameterType,String resultMap,Class<?> resultType,ResultSetType resultSetType,
boolean flushCache,boolean useCache,boolean resultOrdered,KeyGenerator keyGenerator,String keyProperty,
String keyColumn,String databaseId,LanguageDriver lang,String resultSets) {
if (unresolvedCacheRef) {
throw new IncompleteElementException("Cache-ref not yet resolved");
}
id = applyCurrentNamespace(id, false);
boolean isSelect = sqlCommandType == SqlCommandType.SELECT;
MappedStatement.Builder statementBuilder = new MappedStatement.Builder(configuration, id, sqlSource, sqlCommandType)
.resource(resource).fetchSize(fetchSize).timeout(timeout).statementType(statementType)
.keyGenerator(keyGenerator)
.keyProperty(keyProperty)
.keyColumn(keyColumn)
.databaseId(databaseId)
.lang(lang)
.resultOrdered(resultOrdered)
.resultSets(resultSets)
.resultMaps(getStatementResultMaps(resultMap, resultType, id))
.resultSetType(resultSetType)
.flushCacheRequired(valueOrDefault(flushCache, !isSelect))
.useCache(valueOrDefault(useCache, isSelect))
.cache(currentCache);
ParameterMap statementParameterMap = getStatementParameterMap(parameterMap, parameterType, id);
if (statementParameterMap != null) {
statementBuilder.parameterMap(statementParameterMap);
}
MappedStatement statement = statementBuilder.build();
configuration.addMappedStatement(statement);
return statement;
}代码解释如下：
- ①
applyCurrentNamespace给ID加上namespace - ②
new MappedStatement.Builder创建一个MappedStatement实例，先在构造方法中进行初步复制，然后使用方法参数给MappedStatement实例进行进一步赋值，注意哦，这里同样设置了结点的二级缓存引用cache(currentCache) - ③ 尝试获取ParameterMap ，如果不为null，则更新
MappedStatement实例的parameterMap属性值 - ④ 最后得到的MappedStatement 实例，放到configuration实例的
Map<String, MappedStatement> mappedStatements = new StrictMap<MappedStatement>，会放入两组对象，如下所示：
{com.mybatis.dao.EmployeeMapper.getEmpByIds=org.apache.ibatis.mapping.MappedStatement@279fedbd,
getEmpByIds=org.apache.ibatis.mapping.MappedStatement@279fedbd}如下图所示，MappedStatement 实例可能如下：
⑥ 解析完mapper结点后的动作
再回头看下方法：
public void parse() {
if (!configuration.isResourceLoaded(resource)) {
configurationElement(parser.evalNode("/mapper"));
configuration.addLoadedResource(resource);
bindMapperForNamespace();
}
parsePendingResultMaps();
parsePendingCacheRefs();
parsePendingStatements();
}核心方法bindMapperForNamespace
XMLMapperBuilder的bindMapperForNamespace如下：
private void bindMapperForNamespace() {
String namespace = builderAssistant.getCurrentNamespace();
if (namespace != null) {
Class<?> boundType = null;
try {
boundType = Resources.classForName(namespace);
} catch (ClassNotFoundException e) {
// ignore, bound type is not required
}
if (boundType != null && !configuration.hasMapper(boundType)) {
// Spring may not know the real resource name so we set a flag
// to prevent loading again this resource from the mapper interface
// look at MapperAnnotationBuilder#loadXmlResource
configuration.addLoadedResource("namespace:" + namespace);
configuration.addMapper(boundType);
}
}
}代码解释如下：
- ① 获取builderAssistant的namespace，如果为null直接结束；
- ② 解析namespace对应的Class类型boundType ；
- ③ 如果boundType 不为null并且configuration实例的
MapperRegistry mapperRegistry = new MapperRegistry(this);成员实例的private final Map<Class<?>, MapperProxyFactory<?>> knownMappers = new HashMap<>();中没有boundType，执行如下步骤：
- ④ 以
"namespace:"+namespace为值放入configuration实例的Set<String> loadedResources = new HashSet<>();成员属性中 - ⑤
mapperRegistry.addMapper(type);
核心方法MapperRegistry.addMapper(Class type)
方法源码如下：
public <T> void addMapper(Class<T> type) {
if (type.isInterface()) {
if (hasMapper(type)) {
throw new BindingException("Type " + type + " is already known to the MapperRegistry.");
}
boolean loadCompleted = false;
try {
knownMappers.put(type, new MapperProxyFactory<>(type));
// It's important that the type is added before the parser is run
// otherwise the binding may automatically be attempted by the
// mapper parser. If the type is already known, it won't try.
MapperAnnotationBuilder parser = new MapperAnnotationBuilder(config, type);
parser.parse();
loadCompleted = true;
} finally {
if (!loadCompleted) {
knownMappers.remove(type);
}
}
}
}代码解释如下：
- ① 判断当前type是否为接口，如果不是直接结束；
- ② 判断
Map<Class<?>, MapperProxyFactory<?>> knownMappers = new HashMap<>()是否已经有了type，如果是，则抛出异常； - ③ 为当前接口创建MapperProxyFactory实例，然后放入knownMappers 中-
knownMappers.put(type, new MapperProxyFactory<>(type));
{interface com.mybatis.dao.EmployeeMapper=org.apache.ibatis.binding.MapperProxyFactory@6913c1fb}
- ④ 为当前接口创建MapperAnnotationBuilder，然后进行解析(mapper接口上面是可以加注解的)
至于后面的parsePendingResultMaps(); parsePendingCacheRefs(); parsePendingStatements();，则是mybatis提供的后手|二次解析，获取configuration实例的如下属性，然后遍历进行二次处理。
protected final Collection<XMLStatementBuilder> incompleteStatements = new LinkedList<>();
protected final Collection<CacheRefResolver> incompleteCacheRefs = new LinkedList<>();
protected final Collection<ResultMapResolver> incompleteResultMaps = new LinkedList<>();参考博文：
MyBatis二级缓存创建过程与使用详解
MyBatis全局配置文件实例与详解
MyBatis中XML映射器使用详解
Mybatis中基于注解的增删改查实践
Mybatis中使用xml进行增删改查实践
