源碼分析Mybatis MappedStatement的建立流程

時間 2020-12-07

標籤 java node sql 緩存微信 mybatis app 運維 ide 源碼分析欄目 MyBatis 简体版

原文原文鏈接

上文重點闡述源碼分析MapperProxy初始化，但並無介紹.Mapper.java(UserMapper.java)是如何與Mapper.xml文件中的SQL語句是如何創建關聯的。本文將重點接開這個謎團。java

接下來重點從源碼的角度分析Mybatis MappedStatement的建立流程。node

上節回顧

咱們注意到這裏有兩三個與Mapper相關的配置：sql

SqlSessionFactory#mapperLocations，指定xml文件的配置路徑。
SqlSessionFactory#configLocation，指定mybaits的配置文件，該配置文件也能夠配置mapper.xml的配置路徑信息。
MapperScannerConfigurer，掃描Mapper的java類(DAO)。
咱們已經詳細介紹了Mybatis Mapper對象的掃描與構建，那接下來咱們將重點介紹MaperProxy與mapper.xml文件是如何創建關聯關係的。

根據上面的羅列以及上文的講述xml映射文件與Mapper創建聯繫的入口有三：緩存

MapperScannerConfigurer掃描Bean流程中，在調用MapperReigistry#addMapper時若是Mapper對應的映射文件(Mapper.xml)未加載到內存，會觸發加載。
實例化SqlSessionFactory時，若是配置了mapperLocations。
示例化SqlSessionFactory時，若是配置了configLocation。
本節的行文思路：從SqlSessionFacotry的初始化開始講起，由於mapperLocations、configLocation都是SqlSessionFactory的屬性。

舒適提示：下面開始從源碼的角度對其進行介紹，你們能夠先跳到文末看看其調用序列圖。微信

SqlSessionFacotry

buildSqlSessionFactory

1if (xmlConfigBuilder != null) {  // XMLConfigBuilder   // @1
 2      try {
 3        xmlConfigBuilder.parse();
 4
 5        if (logger.isDebugEnabled()) {
 6          logger.debug("Parsed configuration file: '" + this.configLocation + "'");
 7        }
 8      } catch (Exception ex) {
 9        throw new NestedIOException("Failed to parse config resource: " + this.configLocation, ex);
10      } finally {
11        ErrorContext.instance().reset();
12      }
13    }
14
15if (!isEmpty(this.mapperLocations)) {   // @2
16      for (Resource mapperLocation : this.mapperLocations) {
17        if (mapperLocation == null) {
18          continue;
19        }
20
21        try {
22          XMLMapperBuilder xmlMapperBuilder = new XMLMapperBuilder(mapperLocation.getInputStream(),
23              configuration, mapperLocation.toString(), configuration.getSqlFragments());
24          xmlMapperBuilder.parse();
25        } catch (Exception e) {
26          throw new NestedIOException("Failed to parse mapping resource: '" + mapperLocation + "'", e);
27        } finally {
28          ErrorContext.instance().reset();
29        }
30
31        if (logger.isDebugEnabled()) {
32          logger.debug("Parsed mapper file: '" + mapperLocation + "'");
33        }
34      }
35    } else {
36      if (logger.isDebugEnabled()) {
37        logger.debug("Property 'mapperLocations' was not specified or no matching resources found");
38      }
39    }

上文有兩個入口：
代碼@1：處理configLocation屬性。mybatis

代碼@2：處理mapperLocations屬性。app

咱們先從XMLConfigBuilder#parse開始進行追蹤。該方法主要是解析configLocation指定的配置路徑，對其進行解析，具體調用parseConfiguration方法。運維

XMLConfigBuilder

咱們直接查看其parseConfiguration方法。ide

1private void parseConfiguration(XNode root) {
 2    try {
 3      propertiesElement(root.evalNode("properties")); //issue #117 read properties first
 4      typeAliasesElement(root.evalNode("typeAliases"));
 5      pluginElement(root.evalNode("plugins"));
 6      objectFactoryElement(root.evalNode("objectFactory"));
 7      objectWrapperFactoryElement(root.evalNode("objectWrapperFactory"));
 8      settingsElement(root.evalNode("settings"));
 9      environmentsElement(root.evalNode("environments")); // read it after objectFactory and objectWrapperFactory issue #631
10      databaseIdProviderElement(root.evalNode("databaseIdProvider"));
11      typeHandlerElement(root.evalNode("typeHandlers"));
12      mapperElement(root.evalNode("mappers"));   // @1
13    } catch (Exception e) {
14      throw new BuilderException("Error parsing SQL Mapper Configuration. Cause: " + e, e);
15    }
16  }

重點關注mapperElement，從名稱與參數便可以看出，該方法主要是處理中mappers的定義，即mapper sql語句的解析與處理。若是使用過Mapper的人應該不難知道，咱們使用mapper節點，經過resource標籤訂義具體xml文件的位置。源碼分析

XMLConfigBuilder#mapperElement

1private void mapperElement(XNode parent) throws Exception {
 2    if (parent != null) {
 3      for (XNode child : parent.getChildren()) {
 4        if ("package".equals(child.getName())) {
 5          String mapperPackage = child.getStringAttribute("name");
 6          configuration.addMappers(mapperPackage);
 7        } else {
 8          String resource = child.getStringAttribute("resource");
 9          String url = child.getStringAttribute("url");
10          String mapperClass = child.getStringAttribute("class");
11          if (resource != null && url == null && mapperClass == null) {
12            ErrorContext.instance().resource(resource);
13            InputStream inputStream = Resources.getResourceAsStream(resource);
14            XMLMapperBuilder mapperParser = new XMLMapperBuilder(inputStream, configuration, resource, configuration.getSqlFragments());    // @1
15            mapperParser.parse();
16          } else if (resource == null && url != null && mapperClass == null) {
17            ErrorContext.instance().resource(url);
18            InputStream inputStream = Resources.getUrlAsStream(url);
19            XMLMapperBuilder mapperParser = new XMLMapperBuilder(inputStream, configuration, url, configuration.getSqlFragments());
20            mapperParser.parse();
21          } else if (resource == null && url == null && mapperClass != null) {
22            Class<?> mapperInterface = Resources.classForName(mapperClass);
23            configuration.addMapper(mapperInterface);
24          } else {
25            throw new BuilderException("A mapper element may only specify a url, resource or class, but not more than one.");
26          }
27        }
28      }
29    }
30  }

上面的代碼比較簡單，不難看出，解析出Mapper標籤，解析出resource標籤的屬性，建立對應的文件流，經過構建XMLMapperBuilder來解析對應的mapper.xml文件。此時你們會驚訝的發現，在SqlSessionFacotry的初始化代碼中，處理mapperLocations時就是經過構建XMLMapperBuilder來解析mapper文件，其實也不難理解，由於這是mybatis支持的兩個地方可使用mapper標籤來定義mapper映射文件，具體解析代碼固然是同樣的邏輯。那咱們解析來重點把目光投向XMLMapperBuilder。

XMLMapperBuilder

1XMLMapperBuilder#parse
 2public void parse() {
 3    if (!configuration.isResourceLoaded(resource)) {     // @1
 4      configurationElement(parser.evalNode("/mapper"));
 5      configuration.addLoadedResource(resource);
 6      bindMapperForNamespace();
 7    }
 8
 9    parsePendingResultMaps();                                    // @2
10    parsePendingChacheRefs();                                   // @3
11    parsePendingStatements();                                     // @4
12  }

代碼@1：若是該映射文件(*.Mapper.xml)文件未加載，則首先先加載，完成xml文件的解析，提取xml中與mybatis相關的數據，例如sql、resultMap等等。

代碼@2：處理mybatis xml中ResultMap。

代碼@3：處理mybatis緩存相關的配置。

代碼@4：處理mybatis statment相關配置，這裏就是本篇關注的，Sql語句如何與Mapper進行關聯的核心實現。

接下來咱們重點探討parsePendingStatements()方法，解析statement(對應SQL語句)。

XMLMapperBuilder

1private void parsePendingStatements() {
 2      Collection<XMLStatementBuilder> incompleteStatements = configuration.getIncompleteStatements();
 3      synchronized (incompleteStatements) {
 4          Iterator<XMLStatementBuilder> iter = incompleteStatements.iterator();    // @1
 5          while (iter.hasNext()) {
 6              try {
 7                  iter.next().parseStatementNode();   // @2
 8                  iter.remove();
 9              } catch (IncompleteElementException e) {
10                  // Statement is still missing a resource...
11              }
12          }
13      }
14  }

代碼@1：遍歷解析出來的全部SQL語句，用的是XMLStatementBuilder對象封裝的，故接下來重點看一下代碼@2，若是解析statmentNode。

XMLStatementBuilder

1public void parseStatementNode() {
 2    String id = context.getStringAttribute("id");                                                                  // @1 start
 3    String databaseId = context.getStringAttribute("databaseId");
 4
 5    if (!databaseIdMatchesCurrent(id, databaseId, this.requiredDatabaseId)) return;
 6
 7    Integer fetchSize = context.getIntAttribute("fetchSize");
 8    Integer timeout = context.getIntAttribute("timeout");
 9    String parameterMap = context.getStringAttribute("parameterMap");
10    String parameterType = context.getStringAttribute("parameterType");
11    Class<?> parameterTypeClass = resolveClass(parameterType);
12    String resultMap = context.getStringAttribute("resultMap");
13    String resultType = context.getStringAttribute("resultType");
14    String lang = context.getStringAttribute("lang");
15    LanguageDriver langDriver = getLanguageDriver(lang);
16
17    Class<?> resultTypeClass = resolveClass(resultType);
18    String resultSetType = context.getStringAttribute("resultSetType");
19    StatementType statementType = StatementType.valueOf(context.getStringAttribute("statementType", StatementType.PREPARED.toString()));
20    ResultSetType resultSetTypeEnum = resolveResultSetType(resultSetType);
21
22    String nodeName = context.getNode().getNodeName();
23    SqlCommandType sqlCommandType = SqlCommandType.valueOf(nodeName.toUpperCase(Locale.ENGLISH));
24    boolean isSelect = sqlCommandType == SqlCommandType.SELECT;
25    boolean flushCache = context.getBooleanAttribute("flushCache", !isSelect);
26    boolean useCache = context.getBooleanAttribute("useCache", isSelect);
27    boolean resultOrdered = context.getBooleanAttribute("resultOrdered", false);
28
29    // Include Fragments before parsing
30    XMLIncludeTransformer includeParser = new XMLIncludeTransformer(configuration, builderAssistant);
31    includeParser.applyIncludes(context.getNode());
32
33    // Parse selectKey after includes and remove them.
34    processSelectKeyNodes(id, parameterTypeClass, langDriver);             // @1 end
35
36    // Parse the SQL (pre: <selectKey> and <include> were parsed and removed)
37    SqlSource sqlSource = langDriver.createSqlSource(configuration, context, parameterTypeClass);                // @2
38    String resultSets = context.getStringAttribute("resultSets");
39    String keyProperty = context.getStringAttribute("keyProperty");
40    String keyColumn = context.getStringAttribute("keyColumn");
41    KeyGenerator keyGenerator;
42    String keyStatementId = id + SelectKeyGenerator.SELECT_KEY_SUFFIX;
43    keyStatementId = builderAssistant.applyCurrentNamespace(keyStatementId, true);
44    if (configuration.hasKeyGenerator(keyStatementId)) {
45      keyGenerator = configuration.getKeyGenerator(keyStatementId);
46    } else {
47      keyGenerator = context.getBooleanAttribute("useGeneratedKeys",
48          configuration.isUseGeneratedKeys() && SqlCommandType.INSERT.equals(sqlCommandType))
49          ? new Jdbc3KeyGenerator() : new NoKeyGenerator();
50    }
51
52    builderAssistant.addMappedStatement(id, sqlSource, statementType, sqlCommandType,                             // @3
53        fetchSize, timeout, parameterMap, parameterTypeClass, resultMap, resultTypeClass,
54        resultSetTypeEnum, flushCache, useCache, resultOrdered, 
55        keyGenerator, keyProperty, keyColumn, databaseId, langDriver, resultSets);
56  }

這個方法有點長，其關注點主要有3個：

代碼@1：構建基本屬性，其實就是構建MappedStatement的屬性，由於MappedStatement對象就是用來描述Mapper-SQL映射的對象。

代碼@2：根據xml配置的內容，解析出實際的SQL語句，使用SqlSource對象來表示。

代碼@3：使用MapperBuilderAssistant對象，根據準備好的屬性，構建MappedStatement對象，最終將其存儲在Configuration中。

Configuration#addMappedStatement

1public void addMappedStatement(MappedStatement ms) {
2   mappedStatements.put(ms.getId(), ms);
3}

MappedStatement的id爲：mapperInterface + methodName，例如com.demo.dao.UserMapper.findUser。

即上述流程完成了xml的解析與初始化，對終極目標是建立MappedStatement對象，上一篇文章介紹了mapperInterface的初始化，最終會初始化爲MapperProxy對象，那這兩個對象如何關聯起來呢？

從下文可知，MapperProxy與MappedStatement是在調用具Mapper方法時，能夠根據mapperInterface.getName + methodName構建出MappedStatement的id，而後就能夠從Configuration的mappedStatements容器中根據id獲取到對應的MappedStatement對象，這樣就創建起聯繫了。

其對應的代碼：

1// MapperMethod 構造器
 2public MapperMethod(Class<?> mapperInterface, Method method, Configuration config) {
 3    this.command = new SqlCommand(config, mapperInterface, method);
 4    this.method = new MethodSignature(config, method);
 5}
 6
 7// SqlCommand 構造器
 8public SqlCommand(Configuration configuration, Class<?> mapperInterface, Method method) throws BindingException {
 9      String statementName = mapperInterface.getName() + "." + method.getName();
10      MappedStatement ms = null;
11      if (configuration.hasStatement(statementName)) {
12        ms = configuration.getMappedStatement(statementName);
13      } else if (!mapperInterface.equals(method.getDeclaringClass().getName())) { // issue #35
14        String parentStatementName = method.getDeclaringClass().getName() + "." + method.getName();
15        if (configuration.hasStatement(parentStatementName)) {
16          ms = configuration.getMappedStatement(parentStatementName);
17        }
18      }
19      if (ms == null) {
20        throw new BindingException("Invalid bound statement (not found): " + statementName);
21      }
22      name = ms.getId();
23      type = ms.getSqlCommandType();
24      if (type == SqlCommandType.UNKNOWN) {
25        throw new BindingException("Unknown execution method for: " + name);
26      }
27    }

怎麼樣，從上面的源碼分析中，你們是否已經瞭解MapperProxy與Xml中的SQL語句是怎樣創建的關係了嗎？爲了讓你們更清晰的瞭解上述過程，現給出其調用時序圖：

本文的講解就到此結束了，下文將介紹Mybaits與Sharding-Jdbc整合時，SQL語句的執行過程。

更多文章請關注微信公衆號：

一波廣告來襲，做者新書《RocketMQ技術內幕》已出版上市：

《RocketMQ技術內幕》已出版上市，目前可在主流購物平臺（京東、天貓等）購買，本書從源碼角度深度分析了RocketMQ NameServer、消息發送、消息存儲、消息消費、消息過濾、主從同步HA、事務消息；在實戰篇重點介紹了RocketMQ運維管理界面與當前支持的39個運維命令；並在附錄部分羅列了RocketMQ幾乎全部的配置參數。本書獲得了RocketMQ創始人、阿里巴巴Messaging開源技術負責人、Linux OpenMessaging 主席的高度承認並做序推薦。目前是國內第一本成體系剖析RocketMQ的書籍。