mybatis 源码分析（二）mapper 初始化
mybatis 的初始化还是相对比较复杂，但是作者在初始化过程中使用了多种设计模式，包括建造者、动态代理、策略、外观等，使得代码的逻辑仍然非常清晰，这一点非常值得我们学习；
一、mapper 初始化主要流程
mybatis 初始化的过程中，主要是 XML 配置的解析，不同的部分又分别委托给了不同的解析器；
解析流程为：
XMLConfigBuilder -> XMLMapperBuilder -> XMLStatementBuilder -> XMLScriptBuilder -> SqlSourceBuilder
- XMLConfigBuilder：负责全局的 mybatis-conf.xml 配置解析；
- XMLMapperBuilder：负责 sql 配置的 mapper 配置解析；
- XMLStatementBuilder：负责 mapper 配置文件中 select|insert|update|delete 节点解析；
- XMLScriptBuilder：负责各 sql 节点解析，主要是动态 sql 解析；
- SqlSourceBuilder：负责构建 SqlSource；
源码分析：
首先在 XMLConfigBuilder 确定了主要的解析流程：
private void parseConfiguration(XNode root) { // 解析的代码和xml的配置一一对应
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);
}
}
private void mapperElement(XNode parent) throws Exception {
if (parent != null) {
for (XNode child : parent.getChildren()) {
if ("package".equals(child.getName())) { // package 方式，mapper 必须和 xml 配置文件在同一目录下
String mapperPackage = child.getStringAttribute("name");
configuration.addMappers(mapperPackage);
} else {
String resource = child.getStringAttribute("resource");
String url = child.getStringAttribute("url");
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.");
}
}
}
}
}
然后在 XMLMapperBuilder 中解析 mapper
public void parse() {
if (!configuration.isResourceLoaded(resource)) {
configurationElement(parser.evalNode("/mapper"));
configuration.addLoadedResource(resource);
bindMapperForNamespace(); // 绑定 mapper 和 xml 配置
}
// 下面的三个方式是继续之前未完成的节点解析；比如在 cache-ref 解析的时候，依赖的 cache namespace 还未创建的时候，就需要暂停
parsePendingResultMaps();
parsePendingCacheRefs();
parsePendingStatements();
}
private void cacheRefElement(XNode context) {
if (context != null) {
configuration.addCacheRef(builderAssistant.getCurrentNamespace(), context.getStringAttribute("namespace"));
CacheRefResolver cacheRefResolver = new CacheRefResolver(builderAssistant, context.getStringAttribute("namespace"));
try {
cacheRefResolver.resolveCacheRef(); // 未找到依赖的 cache 时，暂停解析
} catch (IncompleteElementException e) {
configuration.addIncompleteCacheRef(cacheRefResolver);
}
}
}
二、动态 sql 解析
此外在 mapper 各节点的解析过程中 resultMap 和 sql 节点的解析最为复杂，resultMap 解析主要是 xml 和 反射的处理，有一点繁琐有兴趣可以自己看一下；这里主要讲一下 sql 节点的解析要点；
buildStatementFromContext(context.evalNodes("select|insert|update|delete"));
private void buildStatementFromContext(List<XNode> list, String requiredDatabaseId) {
for (XNode context : list) {
final XMLStatementBuilder statementParser = new XMLStatementBuilder(configuration, builderAssistant, context, requiredDatabaseId);
try {
statementParser.parseStatementNode(); // 主要的解析过程放到了XMLStatementBuilder中
} catch (IncompleteElementException e) {
configuration.addIncompleteStatement(statementParser);
}
}
}
// XMLStatementBuilder
public void parseStatementNode() {
...
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);
...
builderAssistant.addMappedStatement(id, sqlSource, statementType, sqlCommandType,
fetchSize, timeout, parameterMap, parameterTypeClass, resultMap, resultTypeClass,
resultSetTypeEnum, flushCache, useCache, resultOrdered,
keyGenerator, keyProperty, keyColumn, databaseId, langDriver, resultSets);
}
代码中的 LanguageDriver 就封装了动态 sql 的解析规则，通过这个接口也可以使用其他的模版引擎或者解析规则（可以通过配置或者注解指定）；
其中 XMLLanguageDriver 主要处理动态 sql，RawLanguageDriver 主要处理静态 sql；
从代码中可以看到最后 LanguageDriver 将 xml 配置解析成了 SqlSource，其结构如下：
其中：
- RawSqlSource：处理静态sql，去掉xml标签；
- DynamicSqlSource：处理动态sql，去掉xml标签；
- ProviderSqlSource：处理注解形式的sql；
- StaticSqlSource：最终将上面 SqlSource 处理结果中的占位符，替换为 "?"，构成真正可执行的sql；
其解析的整体流程如下：
从图中可以看到 sql 节点的主要解析逻辑就在于 parseDynamicTags，MixedSqlNode rootSqlNode = parseDynamicTags(context);
在看源码之前先看一下 SqlNode 的结构；
这里的每个 node 和 sql 节点下的子节点一一对应；
protected MixedSqlNode parseDynamicTags(XNode node) {
List<SqlNode> contents = new ArrayList<>();
NodeList children = node.getNode().getChildNodes();
for (int i = 0; i < children.getLength(); i++) {
XNode child = node.newXNode(children.item(i));
if (child.getNode().getNodeType() == Node.CDATA_SECTION_NODE || child.getNode().getNodeType() == Node.TEXT_NODE) {
String data = child.getStringBody("");
TextSqlNode textSqlNode = new TextSqlNode(data);
if (textSqlNode.isDynamic()) {
contents.add(textSqlNode);
isDynamic = true;
} else {
contents.add(new StaticTextSqlNode(data));
}
} else if (child.getNode().getNodeType() == Node.ELEMENT_NODE) { // issue #628
String nodeName = child.getNode().getNodeName();
NodeHandler handler = nodeHandlerMap.get(nodeName);
if (handler == null) {
throw new BuilderException("Unknown element <" + nodeName + "> in SQL statement.");
}
handler.handleNode(child, contents);
isDynamic = true;
}
}
return new MixedSqlNode(contents);
}
这里主要逻辑是首先通过子标签的名字，获取对应的处理器，然后将所有的子标签生成的 SqlNode 合成 MixedSqlNode；
private void initNodeHandlerMap() {
nodeHandlerMap.put("trim", new TrimHandler());
nodeHandlerMap.put("where", new WhereHandler());
nodeHandlerMap.put("set", new SetHandler());
nodeHandlerMap.put("foreach", new ForEachHandler());
nodeHandlerMap.put("if", new IfHandler());
nodeHandlerMap.put("choose", new ChooseHandler());
nodeHandlerMap.put("when", new IfHandler());
nodeHandlerMap.put("otherwise", new OtherwiseHandler());
nodeHandlerMap.put("bind", new BindHandler());
}
到这里就已经比较清楚了，这个 sql 节点的解析过程使用的是策略模式，整个 sql 节点被封装成 SqlSource，其子节点封装为 SqlNode，每个 Node 的解析行为又封装到 NodeHandler 中；整个流程虽然比较长，但是每个模块都非常的清晰，这里非常值得我们学习；
三、mapper 动态代理
首先简单看一个动态代理的 demo
interface Car { void run(String name); }
@Test
public void testDynamic() {
Car car = (Car) Proxy.newProxyInstance(
Car.class.getClassLoader(), // 代理目标的类加载器
new Class[]{Car.class}, // 代理的接口数组，因为可以实现多个接口
new InvocationHandler() { // 动态代理的逻辑代码
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("----动态代理开始----");
// 目标逻辑代码
System.out.println("----动态代理结束----");
return null;
}
});
car.run("sdf");
}
从上面的代码可以看到，我们只定义一个接口并没有实现类，但是通过动态代理就可以动态生成实现类；在使用 mapper 的时候也是一样的，每次调用mapper方法的时候，都会动态生成一个实现类；
初始化：
// MapperRegistry
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)); // 为每一个接口添加一个动态代理工厂
MapperAnnotationBuilder parser = new MapperAnnotationBuilder(config, type); // 解析注解配置
parser.parse();
loadCompleted = true;
} finally {
if (!loadCompleted) {
knownMappers.remove(type);
}
}
}
}
使用：
public <T> T getMapper(Class<T> type, SqlSession sqlSession) {
final MapperProxyFactory<T> mapperProxyFactory = (MapperProxyFactory<T>) knownMappers.get(type);
if (mapperProxyFactory == null) {
throw new BindingException("Type " + type + " is not known to the MapperRegistry.");
}
try {
return mapperProxyFactory.newInstance(sqlSession);
} catch (Exception e) {
throw new BindingException("Error getting mapper instance. Cause: " + e, e);
}
}
其主要流程大致如下：
