2. 程式人生 > ># Mybatis原始碼解析之配置載入(二)

# Mybatis原始碼解析之配置載入(二)

阿新 • • 發佈：2019-01-02

Mybatis原始碼解析之配置載入(二)

這一篇是承接上一篇文章Mybatis原始碼解析之配置載入(一),上一篇原本是想把整個配置載入都分析完全，然後發現內容還是比較多，所以決定分成兩篇來說好了，現在就開始剩下的配置分析。

配置載入

繼續回到parseConfiguration方法中，**parseConfiguration()**方法如下：

private void parseConfiguration(XNode root) {
    try {
      //issue #117 read properties first
      propertiesElement
 
(root.evalNode("properties"));
      Properties settings = settingsAsProperties(root.evalNode("settings"));
      loadCustomVfs(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);
    }
  }

properties載入

我們首先看properties的載入:

private void propertiesElement(XNode context) throws Exception {
    if (context != null) {
      Properties defaults = context.getChildrenAsProperties();
      String resource = context.getStringAttribute("resource");
      String url = context.getStringAttribute("url");
      if (resource != null && url != null) {
        throw new BuilderException("The properties element cannot specify both a URL and a resource based property file reference.  Please specify one or the other.");
      }
      if (resource != null) {
        defaults.putAll(Resources.getResourceAsProperties(resource));
      } else if (url != null) {
        defaults.putAll(Resources.getUrlAsProperties(url));
      }
      Properties vars = configuration.getVariables();
      if (vars != null) {
        defaults.putAll(vars);
      }
      parser.setVariables(defaults);
      configuration.setVariables(defaults);
    }
  }

這裡properties其實到沒有多少好說的，其實就是我們一般在配置db連線的時候往往都是使用單獨的一個db.properties這種，不是直接配置到xml中，當然我們上一篇文章就簡便起見都配置都conf.xml檔案中了，一般配置都是如下：

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/db
jdbc.username=root
jdbc.password=root

<!-- 載入資料庫屬性檔案 -->
<properties resource="db.properties">

然後上述解析properties檔案就是解析resource節點，得到資料庫配置資訊。

解析typeAliases

接下來我們看typeAliases，settings的解析與載入與properties差不多，解析typeAliases原始碼如下：

private void typeAliasesElement(XNode parent) {
    if (parent != null) {
      for (XNode child : parent.getChildren()) {
        if ("package".equals(child.getName())) {
          String typeAliasPackage = child.getStringAttribute("name");
          configuration.getTypeAliasRegistry().registerAliases(typeAliasPackage);
        } else {
          String alias = child.getStringAttribute("alias");
          String type = child.getStringAttribute("type");
          try {
            Class<?> clazz = Resources.classForName(type);
            if (alias == null) {
              typeAliasRegistry.registerAlias(clazz);
            } else {
              typeAliasRegistry.registerAlias(alias, clazz);
            }
          } catch (ClassNotFoundException e) {
            throw new BuilderException("Error registering typeAlias for '" + alias + "'. Cause: " + e, e);
          }
        }
      }
    }
  }

這裡對alias進行了註冊，轉到registerAlias，

public void registerAlias(String alias, Class<?> value) {
    if (alias == null) {
      throw new TypeException("The parameter alias cannot be null");
    }
    // issue #748
    String key = alias.toLowerCase(Locale.ENGLISH);
    if (TYPE_ALIASES.containsKey(key) && TYPE_ALIASES.get(key) != null && !TYPE_ALIASES.get(key).equals(value)) {
      throw new TypeException("The alias '" + alias + "' is already mapped to the value '" + TYPE_ALIASES.get(key).getName() + "'.");
    }
    TYPE_ALIASES.put(key, value);
  }

實質上就是將對應的alias名與class儲存進map中，最後在使用的時候再從map中取出來，這個在後面使用的時候再來講這段。

解析外掛

解析plugin的過程：

private void pluginElement(XNode parent) throws Exception {
    if (parent != null) {
      for (XNode child : parent.getChildren()) {
        String interceptor = child.getStringAttribute("interceptor");
        Properties properties = child.getChildrenAsProperties();
        Interceptor interceptorInstance = (Interceptor) resolveClass(interceptor).newInstance();
        interceptorInstance.setProperties(properties);
        configuration.addInterceptor(interceptorInstance);
      }
    }
  }

這裡的plugin都是作為單獨的一個個功能增強來使用，所以攔截器是最好的表現形式，這裡的**configuration.addInterceptor()**裡面就是一個InterceptorChain，這個InterceptorChain在初始化的時候會將每一個plugin加入到chain中，然後在查詢的時候一個個過濾，看是否需要使用外掛，這個在後面也會說到。

解析mapper

前面幾種解析原理都差不多，就不再詳述了，最重要的還是mapper的載入，我們轉到

mapperElement(root.evalNode("mappers"))

mapperElement方法如下：

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 {
          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.");
          }
        }
      }
    }
  }

這就是解析mapper的具體過程，但在我們上一篇文章中的對應配置為:

<mappers>
        <mapper resource="cn/com/mapper/userMapper.xml"/>
</mappers>

所以對應的解析條件為else中的第二個if條件，如下：

InputStream inputStream = Resources.getResourceAsStream(resource);
            XMLMapperBuilder mapperParser = new XMLMapperBuilder(inputStream, configuration, resource, configuration.getSqlFragments());
            mapperParser.parse();

在載入xml檔案後，對xml進行了解析，進入到parse()方法中。

public void parse() {
    if (!configuration.isResourceLoaded(resource)) {
      configurationElement(parser.evalNode("/mapper"));
      configuration.addLoadedResource(resource);
      bindMapperForNamespace();
    }

    parsePendingResultMaps();
    parsePendingCacheRefs();
    parsePendingStatements();
  }

我們轉到**configurationElement()**方法中

private void configurationElement(XNode context) {
    try {
      String namespace = context.getStringAttribute("namespace");
      if (namespace == null || namespace.equals("")) {
        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);
    }
  }

重點都是在這個方法了，首先確定當前mapper屬於哪一個namespace。

String namespace = context.getStringAttribute("namespace");
builderAssistant.setCurrentNamespace(namespace);

接下來這兩行:

cacheRefElement(context.evalNode("cache-ref"));
cacheElement(context.evalNode("cache"));

是對快取的處理，這個就留到講快取的時候再說吧，暫且跳過。

最重要的是對resultMap的載入：

resultMapElements(context.evalNodes("/mapper/resultMap"));

private void resultMapElements(List<XNode> list) throws Exception {
    for (XNode resultMapNode : list) {
      try {
        resultMapElement(resultMapNode);
      } catch (IncompleteElementException e) {
        // ignore, it will be retried
      }
    }
  }
  private ResultMap resultMapElement(XNode resultMapNode, List<ResultMapping> additionalResultMappings) throws Exception {
    ErrorContext.instance().activity("processing " + resultMapNode.getValueBasedIdentifier());
    String id = resultMapNode.getStringAttribute("id",
        resultMapNode.getValueBasedIdentifier());
    String type = resultMapNode.getStringAttribute("type",
        resultMapNode.getStringAttribute("ofType",
            resultMapNode.getStringAttribute("resultType",
                resultMapNode.getStringAttribute("javaType"))));
    String extend = resultMapNode.getStringAttribute("extends");
    Boolean autoMapping = resultMapNode.getBooleanAttribute("autoMapping");
    Class<?> typeClass = resolveClass(type);
    Discriminator discriminator = null;
    List<ResultMapping> resultMappings = new ArrayList<ResultMapping>();
    resultMappings.addAll(additionalResultMappings);
    List<XNode> resultChildren = resultMapNode.getChildren();
    for (XNode resultChild : resultChildren) {
      if ("constructor".equals(resultChild.getName())) {
        processConstructorElement(resultChild, typeClass, resultMappings);
      } else if ("discriminator".equals(resultChild.getName())) {
        discriminator = processDiscriminatorElement(resultChild, typeClass, resultMappings);
      } else {
        List<ResultFlag> flags = new ArrayList<ResultFlag>();
        if ("id".equals(resultChild.getName())) {
          flags.add(ResultFlag.ID);
        }
        resultMappings.add(buildResultMappingFromContext(resultChild, typeClass, flags));
      }
    }
    ResultMapResolver resultMapResolver = new ResultMapResolver(builderAssistant, id, typeClass, extend, discriminator, resultMappings, autoMapping);
    try {
      return resultMapResolver.resolve();
    } catch (IncompleteElementException  e) {
      configuration.addIncompleteResultMap(resultMapResolver);
      throw e;
    }
  }

這些裡面其實最重要的就是**return resultMapResolver.resolve();**這行了，這一行對resultMap進行了最終的解析，這裡面就不再講述了，有興趣的可以看下。

接下來看Mapper中的sql的解析：

sqlElement(context.evalNodes("/mapper/sql"));
private void sqlElement(List<XNode> list) throws Exception {
    if (configuration.getDatabaseId() != null) {
      sqlElement(list, configuration.getDatabaseId());
    }
    sqlElement(list, null);
  }

  private void sqlElement(List<XNode> list, String requiredDatabaseId) throws Exception {
    for (XNode context : list) {
      String databaseId = context.getStringAttribute("databaseId");
      String id = context.getStringAttribute("id");
      id = builderAssistant.applyCurrentNamespace(id, false);
      if (databaseIdMatchesCurrent(id, databaseId, requiredDatabaseId)) {
        sqlFragments.put(id, context);
      }
    }
  }

這裡面做的就是將解析出的id與node節點一起儲存進map中，在sql具體使用時，我們後面如果使用到再講。

下面就是具體select、update、insert這些業務sql的解析了，如下：

buildStatementFromContext(context.evalNodes("select|insert|update|delete"));

轉到b

相關推薦

# Mybatis原始碼解析之配置載入(二)

Mybatis原始碼解析之配置載入(二) 這一篇是承接上一篇文章Mybatis原始碼解析之配置載入(一),上一篇原本是想把整個配置載入都分析完全，然後發現內容還是比較多，所以決定分成兩篇來說好了，現在就開始剩下的配置分析。 配置載入 繼續回到parseConfigura

Mybatis原始碼解析之配置載入(一)

Mybatis原始碼解析之配置載入(一) 用了好幾年的mybatis了，但是很少來鑽研mybatis原理所在，最近抽出空來，就把這一整套原始碼都研究了下，然後發現就是這些東西，mybatis沒啥難度，於是決定把研究的這一整套寫一個mybatis系列，記錄一下，在這些完了以後，順便寫一

mybatis原始碼解析之Configuration載入（二）

概述 上一篇我們講了configuation.xml中幾個標籤的解析，例如<properties>,<typeAlises>,<settings>等，今天我們來介紹剩下的兩個比較重要的標籤之一，<environments>，這個標籤主要用於我們訪問資料庫的配置

mybatis原始碼解析之Configuration載入（一）

概要 上一篇，我們主要搭建了一個簡單的環境，這邊我們主要來分析下mybatis是如何來載入它的配置檔案Configuration.xml的。 分析 1 public class App { 2 public static void main(String[] args) { 3

MyBatis原始碼解析之日誌記錄

一 .概述 MyBatis沒有提供日誌的實現類，需要接入第三方的日誌元件，但第三方日誌元件都有各自的Log級別，且各不相同，但MyBatis統一提供了trace、debug、warn、error四個級別； 自動掃描日誌實現，並且第三方日誌外掛載入優先順序如下：slf4J → commonsLoging →

MyBatis原始碼解析之資料來源（含資料庫連線池簡析）

一.概述： 常見的資料來源元件都實現了javax.sql.DataSource介面； MyBatis不但要能整合第三方的資料來源元件，自身也提供了資料來源的實現； 一般情況下，資料來源的初始化過程引數較多，比較複雜； 二.設計模式： 為什麼要使用工廠模式     資料來

Mybatis原始碼解析之Mybatis初始化過程

一、搭建一個簡單的Mybatis工程 為了瞭解Mybatis的初始化過程，這裡需要搭建一個簡單的Mybatis工程操作資料庫，工程結構如下： 一個UserBean.java private int id; private String user

mybatis 原始碼解析之 session

介紹 該部分程式碼位於 org.apache.ibatis.session 包。覆蓋了由讀取配置之後，到建立一個 SqlSession 的過程。 簡化流程 SqlSessionManager 根據 Reader、InputStream 用 SqlSessionFactoryB

Mybatis原始碼解析之寫流程

閱讀須知 Mybatis原始碼版本：3.4.4 註釋規則： //單行註釋做普通註釋 /**/多行註釋做深入分析 建議配合Mybatis原始碼閱讀 正文 承接上文，我們繼續來分析寫操作： DefaultSqlSession： public i

Spring原始碼解析之BeanFactoryPostProcessor（二）

上一章，我們介紹了在AnnotationConfigApplicationContext初始化的時候，會建立AnnotatedBeanDefinitionReader和ClassPathBeanDefinitionScanner兩個物件： public class AnnotationConfigAppli

mybatis原始碼-解析配置檔案（二）之解析的流程

1. 簡介 在之前的文章《mybatis 初步使用（IDEA的Maven專案, 超詳細）》中， 講解了mybatis的初步使用， 並總結了以下mybatis的執行流程： 通過 Resources 工具類讀取 mybatis-config.xml，

mybatis原始碼-解析配置檔案（三）之配置檔案Configuration解析(超詳細， 值得收藏)

1. 簡介 1.1 系列內容 本系列文章講解的是mybatis解析配置檔案內部的邏輯， 即 Reader reader = Resources.getResourceAsReader("mybatis-config.xml"); SqlSessionFact

mybatis原始碼-解析配置檔案（四）之配置檔案Mapper解析

其中， mappers作為configuration節點的一部分配置， 在本文章中， 我們講解解析mappers節點， 即 xxxMapper.xml 檔案的解析。 1 解析入口 在解析 mybatis-config.xml 時， 會進行解析 xxxMapper.xml 的檔案。 在圖示流程的 XMLCo

mybatis原始碼-解析配置檔案（四-1）之配置檔案Mapper解析(cache)

1. 簡介 本文章主要講解的是， xxxMapper.xml 檔案中， cache 節點的原始碼。 2. 解析 XMLMapperBuilder.cacheElement() 方法主要負責解析 <cache> private void cacheElement(XNode context)

mybatis原始碼學習之執行過程分析（2）——config.xml配置檔案和mapper.xml對映檔案解析過程

在上一篇中跟蹤了SqlSessionFactory及SqlSession的建立過程。這一篇，主要跟蹤Mapper介面和XML檔案對映及獲取。 1.xml檔案的解析 1.1Mybatis-config.xml的解析 在SqlSessionFactor

spring原始碼解析之IOC容器（二）------載入和註冊

　　上一篇跟蹤了IOC容器對配置檔案的定位，現在我們繼續跟蹤程式碼，看看IOC容器是怎麼載入和註冊配置檔案中的資訊的。開始之前，首先我們先來了解一下IOC容器所使用的資料結構-------BeanDefinition，它是一個上層介面，有很多實現類，分別對應不同的資料載體。我們平時開發的時候，也會定義很多po

Android框架原始碼解析之（二）OKhttp

原始碼在：https://github.com/square/okhttp 包實在是太多了，OKhttp核心在這塊https://github.com/square/okhttp/tree/master/okhttp 直接匯入Android Studio中即可。 基本使用：

Spring原始碼解析之四（bean載入）

1、概述 已經分析了spring對於xml配置檔案的解析，接下來就是對bean的載入。 getBean的實現 public <T> T getBean(String name, Class<T> requiredType, Object... args) thro

Spring原始碼解析之二（預設標籤的解析）

預設標籤解析 概述：本節重點詳細分析預設標籤的解析過程。接上一篇文章講到parseBeanDefinitions(root, delegate); /** * Parse the elements at the root level in the document: * "impor

Java原始碼解析之可重入鎖ReentrantLock（二）

上文接Java原始碼解析之可重入鎖ReentrantLock（一）。 接下來是tryLock方法。程式碼如下。從註釋中我們可以理解到，只有當呼叫tryLock時鎖沒有被別的執行緒佔用，tryLock才會獲取鎖。如果鎖沒有被另一個執行緒佔用，那麼就獲取鎖，並立刻返回true，並把鎖計數設定為1.