2. 程式人生 > >mybatis-spring容器初始化

mybatis-spring容器初始化

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

1 引言

使用 MyBatis-Spring 模組，我們可以在Spring中使用mybatis，讓Spring容器來管理sqlSessionFactory單例的建立。如以下程式碼

<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
  <!--指定資料來源，不用再在mybatis的XML配置檔案中指定environment了-->
  <property name="dataSource" ref="dataSource" />
  <!--指定configuration物件，它是建立sqlSessionFactory的核心，包含mybatis幾乎全部的配置資訊-->
 

  <property name="configuration">
    <bean class="org.apache.ibatis.session.Configuration">
      <property name="mapUnderscoreToCamelCase" value="true"/>
    </bean>
  </property>
  <!--資料庫對映mapper檔案的位置-->
  <property  name="mapperLocations"  value="classpath*:com/xxt/ibatis/dbcp/**/*.xml"
 
/>
  <!--或指定指定sqlMapConfig總配置檔案位置configLocation，建議採用這種mybatis配置單獨放在另一個XML中的方式-->
  <property  name="configLocation"  value="classpath:sqlMapConfig.xml"/> 
</bean>

我們只需要指定兩個屬性即可，一是dataSource資料庫源，二是configuration物件或configLocation配置檔案所在位置。那麼有這兩個屬性是如何建立sqlSessionFactory物件的呢，這一節我們詳細分析。

2 sqlSessionFactory物件注入的流程

建立sqlSessionFactory bean時，指定的實現類是SqlSessionFactoryBean類，它是一個FactoryBean。我們知道，對於FactoryBean，Spring為我們建立的不是FactoryBean本身的物件，二是它的getObject()方法返回的物件。故我們從SqlSessionFactoryBean的getObject()方法來分析。

// 工廠bean，它返回的不是FactoryBean本身，而是它的getObject方法返回的bean
public SqlSessionFactory getObject() throws Exception {
  if (this.sqlSessionFactory == null) {
    afterPropertiesSet();
  }

  // getObject最終返回的還是一個SqlSessionFactory物件
  return this.sqlSessionFactory;
}

上面是典型的單例模式，我們到afterPropertiesSet()方法中去看。

public void afterPropertiesSet() throws Exception {
  // 各種報錯
  notNull(dataSource, "Property 'dataSource' is required");
  notNull(sqlSessionFactoryBuilder, "Property 'sqlSessionFactoryBuilder' is required");
  state((configuration == null && configLocation == null) || !(configuration != null && configLocation != null),
            "Property 'configuration' and 'configLocation' can not specified with together");

  // 建立sqlSessionFactory
  this.sqlSessionFactory = buildSqlSessionFactory();
}

afterPropertiesSet先做dataSource等屬性值的校驗，注入sqlSessionFactory的時候，必須傳入dataSource屬性的。然後呼叫buildSqlSessionFactory()方法來建立sqlSessionFactory，它是一個關鍵方法，我們詳細分析。

// 建立SqlSessionFactory例項
protected SqlSessionFactory buildSqlSessionFactory() throws IOException {
  // 包含了幾乎所有mybatis配置資訊，建立sqlSessionFactory最重要的變數，之前分析mybatis初始化的時候講到過
  Configuration configuration;

  // 先讀取sqlSessionFactory bean注入時，用來設定mybatis配置資訊Configuration的屬性
  // 有configuration屬性或者configLocation屬性兩種。
  XMLConfigBuilder xmlConfigBuilder = null;

  if (this.configuration != null) {
    // 注入的是configuration屬性時，它是一個bean
    configuration = this.configuration;
    // 合併configurationProperties變數到configuration的variables成員中。mybatis初始化的章節講到過這個合併
    // configurationProperties包含的是一些動態化常量，比如資料庫的username和password等資訊
    // configurationProperties屬性同樣在sqlSessionFactory bean注入時設定進來
    if (configuration.getVariables() == null) {
      configuration.setVariables(this.configurationProperties);
    } else if (this.configurationProperties != null) {
      configuration.getVariables().putAll(this.configurationProperties);
    }

  } else if (this.configLocation != null) {
    // 注入的是configLocation屬性時，它是一個String，描述了mybatis xml配置檔案的位置
    // 此時使用mybatis的配置檔案來配置其他屬性，利用配置檔案生成Configuration物件
    // 和原生mybatis一樣，也是先建立XMLConfigBuilder物件，然後利用它來解析mybatis配置檔案，然後將配置檔案中的屬性設定到configuration的相關成員變數中去
    // 此處只是建立XMLConfigBuilder和configuration物件，還沒有做解析
    xmlConfigBuilder = new XMLConfigBuilder(this.configLocation.getInputStream(), null, this.configurationProperties);
    configuration = xmlConfigBuilder.getConfiguration();

  } else {
    // configuration屬性和configLocation屬性都沒有注入時，只能直接構造mybatis預設的Configuration物件了
    LOGGER.debug(() -> "Property 'configuration' or 'configLocation' not specified, using default MyBatis Configuration");
    configuration = new Configuration();
    // 同樣合併configurationProperties屬性到configuration變數的variables變數中
    if (this.configurationProperties != null) {
      configuration.setVariables(this.configurationProperties);
    }
  }

  // 注入了objectFactory屬性時，一般不建議在sqlSessionFactory中注入，而是放到mybatis配置檔案中。
  if (this.objectFactory != null) {
    configuration.setObjectFactory(this.objectFactory);
  }

  // 注入了objectWrapperFactory屬性時，一般不建議在sqlSessionFactory中注入，而是放到mybatis配置檔案中。
  if (this.objectWrapperFactory != null) {
    configuration.setObjectWrapperFactory(this.objectWrapperFactory);
  }

  // 注入了vfs屬性時，一般不建議在sqlSessionFactory中注入，而是放到mybatis配置檔案中。
  if (this.vfs != null) {
    configuration.setVfsImpl(this.vfs);
  }

  // 注入了typeAliasesPackage屬性時，一般不建議在sqlSessionFactory中注入，而是放到mybatis配置檔案中。
  if (hasLength(this.typeAliasesPackage)) {
    String[] typeAliasPackageArray = tokenizeToStringArray(this.typeAliasesPackage,
        ConfigurableApplicationContext.CONFIG_LOCATION_DELIMITERS);
    for (String packageToScan : typeAliasPackageArray) {
      configuration.getTypeAliasRegistry().registerAliases(packageToScan,
              typeAliasesSuperType == null ? Object.class : typeAliasesSuperType);
      LOGGER.debug(() -> "Scanned package: '" + packageToScan + "' for aliases");
    }
  }

  // 注入了typeAliases屬性時，一般不建議在sqlSessionFactory中注入，而是放到mybatis配置檔案中。
  if (!isEmpty(this.typeAliases)) {
    for (Class<?> typeAlias : this.typeAliases) {
      configuration.getTypeAliasRegistry().registerAlias(typeAlias);
      LOGGER.debug(() -> "Registered type alias: '" + typeAlias + "'");
    }
  }

  // 注入了plugins屬性時，一般不建議在sqlSessionFactory中注入，而是放到mybatis配置檔案中。
  if (!isEmpty(this.plugins)) {
    for (Interceptor plugin : this.plugins) {
      configuration.addInterceptor(plugin);
      LOGGER.debug(() -> "Registered plugin: '" + plugin + "'");
    }
  }

  // 注入了typeHandlersPackage屬性時，一般不建議在sqlSessionFactory中注入，而是放到mybatis配置檔案中。
  if (hasLength(this.typeHandlersPackage)) {
    String[] typeHandlersPackageArray = tokenizeToStringArray(this.typeHandlersPackage,
        ConfigurableApplicationContext.CONFIG_LOCATION_DELIMITERS);
    for (String packageToScan : typeHandlersPackageArray) {
      configuration.getTypeHandlerRegistry().register(packageToScan);
      LOGGER.debug(() -> "Scanned package: '" + packageToScan + "' for type handlers");
    }
  }

  // 注入了typeHandlers屬性時，一般不建議在sqlSessionFactory中注入，而是放到mybatis配置檔案中。
  if (!isEmpty(this.typeHandlers)) {
    for (TypeHandler<?> typeHandler : this.typeHandlers) {
      configuration.getTypeHandlerRegistry().register(typeHandler);
      LOGGER.debug(() -> "Registered type handler: '" + typeHandler + "'");
    }
  }

  // 注入了databaseIdProvider屬性時，一般不建議在sqlSessionFactory中注入，而是放到mybatis配置檔案中。
  if (this.databaseIdProvider != null) {//fix #64 set databaseId before parse mapper xmls
    try {
      configuration.setDatabaseId(this.databaseIdProvider.getDatabaseId(this.dataSource));
    } catch (SQLException e) {
      throw new NestedIOException("Failed getting a databaseId", e);
    }
  }

  // 注入了cache屬性時，新增到configuration變數的cache map中
  if (this.cache != null) {
    configuration.addCache(this.cache);
  }

  // 使用configLocation屬性時，解析mybatis xml配置檔案，和直接使用原生mybatis的new SqlSessionFactoryBuild().build()方式幾乎相同
  if (xmlConfigBuilder != null) {
    try {
      // 利用前面建立的xmlConfigBuilder來解析XML配置檔案，並將解析後的鍵值對設定到configuration變數中
      xmlConfigBuilder.parse();
      LOGGER.debug(() -> "Parsed configuration file: '" + this.configLocation + "'");
    } catch (Exception ex) {
      throw new NestedIOException("Failed to parse config resource: " + this.configLocation, ex);
    } finally {
      ErrorContext.instance().reset();
    }
  }

  // 建立transactionFactory，用來建立transaction事務，Spring使用AOP來建立事務
  if (this.transactionFactory == null) {
    this.transactionFactory = new SpringManagedTransactionFactory();
  }

  // 設定configuration的environment變數，
  // 採用Spring注入方式時，直接指定了sqlSessionFactory下的dataSource資料庫源，一般不需要在mybaits配置檔案中設定environments了
  configuration.setEnvironment(new Environment(this.environment, this.transactionFactory, this.dataSource));

  // 注入了mapperLocations屬性時，一般不建議在sqlSessionFactory中注入，而是放到mybatis配置檔案中。
  if (!isEmpty(this.mapperLocations)) {
    for (Resource mapperLocation : this.mapperLocations) {
      if (mapperLocation == null) {
        continue;
      }

      try {
        // 讀取mapper配置檔案，並解析
        XMLMapperBuilder xmlMapperBuilder = new XMLMapperBuilder(mapperLocation.getInputStream(),
            configuration, mapperLocation.toString(), configuration.getSqlFragments());
        xmlMapperBuilder.parse();
      } catch (Exception e) {
        throw new NestedIOException("Failed to parse mapping resource: '" + mapperLocation + "'", e);
      } finally {
        ErrorContext.instance().reset();
      }
      LOGGER.debug(() -> "Parsed mapper file: '" + mapperLocation + "'");
    }
  } else {
    LOGGER.debug(() -> "Property 'mapperLocations' was not specified or no matching resources found");
  }

  // configuration變數建立並初始化好之後，就可以建立sqlSessionFactory物件了
  // sqlSessionFactoryBuilder的build建立DefaultSqlSessionFactory物件，預設的SqlSessionFactory
  // 這個過程之前講解mybatis初始化的章節時，講過了的
  return this.sqlSessionFactoryBuilder.build(configuration);
}

這個方法比較長，詳細內容讀者可以逐行看上面程式碼和註釋，註釋應該已經十分詳盡了。我們總結下這個方法的流程。

  1. 先讀取mybatis配置資訊，它通過sqlSessionFactory注入時，傳入的configuration物件或者configLocation String來分析配置資訊。

    1）傳入的是configuration屬性時，合併configurationProperties屬性到configuration物件中去即可。

    2）傳入的是configLocation屬性時，它是一個String，描述了mybatis xml配置檔案的位置。先建立XMLConfigBuilder物件和configuration物件，後面幾步會解析mybatis配置檔案，然後將配置檔案中的屬性設定到configuration的相關成員變數中去（這個過程和原生mybatis相同）

    3）configuration屬性和configLocation屬性都沒有注入時，只能直接構造mybatis預設的Configuration物件了

  2. 再讀取建立sqlSessionFactory bean時，傳入的其他屬性，如objectFactory objectWrapperFactory vfs typeAliasesPackage typeAliases plugins typeHandlersPackage typeHandlers databaseIdProvider等。如果我們使用配置檔案位置資訊configLocation來解析mybatis配置資訊的話，這些屬性均不需要傳入。如果採用configuration物件的方式，或者configLocation和configuration都沒有傳入的話，則需要這些屬性了。一般建議採用configLocation的方式，將mybatis的配置資訊和Spring配置資訊相分離。

  3. 使用configLocation屬性時，解析mybatis xml配置檔案，和直接使用原生mybatis的new SqlSessionFactoryBuild().build()方式幾乎相同。

  4. 建立transactionFactory，用來建立transaction事務，Spring使用AOP來建立事務

  5. 設定configuration的environment變數，利用傳入的dataSource屬性

  6. 讀取建立sqlSessionFactory bean時，傳入的mapperLocations屬性。如果採用configLocation指定mybatis配置檔案位置的方式，則一般不需要在Spring中配置mapperLocations

  7. sqlSessionFactoryBuilder的build建立DefaultSqlSessionFactory物件

這個方法很關鍵，且流程很長。大家最重要的是要知道，建立sqlSessionFactory時指定mybatis配置資訊，有三種方式。一是直接configuration物件，包含了配置資訊各項引數。二是configLocation字串，指定了配置檔案的位置。三是configuration和configLocation均沒有配置，完全依靠Spring配置檔案中指定objectFactory typeHandlers 等屬性。明白了這一點，上面的程式碼就會比較清晰了。

為了將Spring配置資訊和mybatis配置資訊相分離，從而讓各個XML各司其職，也避免Spring配置檔案過於膨脹，我們一般採用configLocation的方式。這種方式和原生mybatis建立sqlSessionFactory的過程極其類似，都是通過XMLConfigBuilder解析XML配置檔案，並將解析到的鍵值對設定到Configuration物件的相關變數中去。這一過程我們在前面講解mybatis初始化的章節中已經詳細介紹了，故此處不詳細講解了。最後我們看sqlSessionFactoryBuilder.build()方法。

public SqlSessionFactory build(Configuration config) {
    return new DefaultSqlSessionFactory(config);
}

這個方法十分簡單，構造sqlSessionFactory的預設實現類DefaultSqlSessionFactory，並傳入前面建立並解析好的configuration物件即可。configuration包含了幾乎所有的mybatis配置資訊，十分重要。

3 總結

Spring容器中sqlSessionFactory的建立其實是十分簡單的，特別是採用了configLocation方式的時候。建立過程基本是依賴原生mybatis的執行流程的。從這兒也可以看出程式碼分層有利於程式碼適配。這也是我們平時自己設計框架時要要注意的地方，儘量讓層次分明，模組解耦，這樣才能簡易的適配不同的環境，從而提高可移植性。

下一節我們分析mybatis-spring中，sqlSession是如何操作資料庫的

相關文章

相關推薦

mybatis-spring容器初始化

1 引言 使用 MyBatis-Spring 模組，我們可以在Spring中使用mybatis，讓Spring容器來管理sqlSessionFactory單例的建立。如以下程式碼 <bean id="sqlSessionFactory" class

spring容器初始化bean之後或銷燬bean之前，能做的操作

通過 <bean> 標籤 init-method  初始化bean之後呼叫的方法 destroy-method  銷燬bean之前呼叫的操作方法 <bean id="initQuartzJob" class="com.upinc

Spring容器初始化過程

https://blog.csdn.net/xingxing513234072/article/details/78247480 一、Spring 容器高層檢視   Spring 啟動時讀取應用程式提供的Bean配置資訊，並在Spring容器中生成一份相應的Bean配置登錄檔，

Spring容器初始化後執行某個指定的方法

1.配置springmvc.xml <?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://ww

spring容器初始化之後執行某些系統初始化動作

最近自己所在的專案中出現此種情形：專案啟動後，需要做一些初始化動作，如，讀取配置檔案、查詢資料庫資料存入快取等。參考前人寫的程式碼的實現方式如下： 思路：編寫一個系統初始化類，該類實現ServletContextListenner介面，並實現contextInitializ

spring 容器初始化完成後執行某個方法

一下內容來自internet，後面會整理在做web專案開發中，尤其是企業級應用開發的時候，往往會在工程啟動的時候做許多的前置檢查。比如檢查是否使用了我們組禁止使用的MySQL的group_concat函式，如果使用了專案就不能啟動，，在Spring容器將所有的Bean都初始化

【Spring原始碼閱讀】 Spring容器初始化流程

文章目錄 refresh方法原始碼 prepareRefresh實現 obtainFreshBeanFactory實現 refreshBeanFactory方法實現 prepareBeanFactory方法實現 invokeBeanFa

Spring容器初始化過程都做了哪些事兒

1.ClassPathXmlApplicationContext為入口構造方法中有個refresh()方法用來初始化Spring refresh執行的大致流程： Configurab

Spring容器初始化完之後執行某個方法

initializingBean介面是spring提供的，子類要實現afterPropertiesSet()方法，init-method是使用者可以通過屬性檔案配置的。從這裡可以看出實現initializingBean介面是要和spring耦合的，而init-method則不會。但afterProperti

最佳實踐--Spring容器初始化完成之後執行某個方法

在做javaweb專案的時候，當用戶訪問的時候需要從資料庫載入資料，現在要在容器初始化完成之後直接把資料放入快取，當用戶訪問的時候提高速度。 查閱相關spring文件，找到了一個最佳實踐（best p

spring容器初始化時候遇到的死鎖問題

最近啟動spring專案的時候遇到一個死鎖問題，使用jstack獲取執行緒堆疊的時候，可以看到2個執行緒出現了死鎖： DefaultSingletonBeanRegistry.getSinglet

Spring核心探索與總結（二）：Spring容器初始化原始碼探索

Spring容器概述 容器是spring的核心，Spring容器使用DI管理構成應用的元件，它會建立相互協作的元件之間的關聯，負責建立物件，裝配它們，配置它們並管理它們的生命週期，從生存到死亡（在這裡，可能就是new 到 finalize()）。 Sprin

spring容器初始化bean的過程中的時間週期

知識點介紹 1、 init-method方法，初始化bean的時候執行，可以針對某個具體的bean進行配置。init-method需要在 applicationContext.xml配置文件中bean的定義裡頭寫明。例如：<bean id="TestBean" cla

當spring 容器初始化完成後執行某個方法

在做web專案開發中，尤其是企業級應用開發的時候，往往會在工程啟動的時候做許多的前置檢查。 比如檢查是否使用了我們組禁止使用的Mysql的group_concat函式，如果使用了專案就不能啟動， 並指出哪個檔案的xml檔案使用了這個函式。而在Spring的

Spring源碼分析總結(一)-IOC容器初始化

Spring源碼分析總結一、IOC容器的初始化過程 IOC容器的初始化是由refresh()方法啟動。經常使用的ApplicationContext 有:ClassPathXmlApplicationContext和FileSystemXmlApplicationContext、XmlWebApp

03.Spring IoC 容器 - 初始化

itl ret num servlet fontsize eat 圖片 number sources 基本概念 Spring IoC 容器的初始化過程在監聽器 ContextLoaderListener 類中定義。 具體由該類的的 configureAndRefreshWe

spring原始碼學習之路---IOC容器初始化要義之bean定義載入（四）

上章說到要帶各位去看看bean定義載入的要義，其實就是loadBeanDefinitions這個方法的具體實現步驟，下面我們跟隨這個方法去看下它到底是如何載入bean定義的。 上面是我擷取的實現了loadBeanDefinitions的類級別截圖，loadBeanDefinit

spring原始碼學習之路---深度分析IOC容器初始化過程（三）

分析FileSystemXmlApplicationContext的建構函式，到底都做了什麼，導致IOC容器初始化成功。 public FileSystemXmlApplicationContext(String[] configLocations, boolean ref

【spring原始碼分析】IOC容器初始化（二）

前言：在【spring原始碼分析】IOC容器初始化（一）中已經分析了匯入bean階段，本篇接著分析bean解析階段。 1.解析bean程式呼叫鏈 同樣，先給出解析bean的程式呼叫鏈： 根據程式呼叫鏈，整理出在解析bean過程中主要涉及的類和相關方法。 2.解析bean原始碼分

Spring系列(五) 容器初始化過程原始碼

IoC/DI 的概念 容器是Spring的核心之一(另一個核心是AOP). 有了容器, IOC才可能實現. 什麼使IoC? IoC就是將類自身管理的與其由依賴關係的物件的建立/關聯和管理交予容器實現, 容器按照配置(比如xml檔案)來組織應用物件的建立和關聯. 什麼使DI? DI是IoC的實現方式, 由容器