精盡MyBatis原始碼分析 - Spring-Boot-Starter 原始碼分析-有解無憂

該系列檔案是本人在學習 Mybatis 的原始碼程序中總結下來的，可能對讀者不太友好，請結合我的原始碼注釋（Mybatis原始碼分析 GitHub 地址、Mybatis-Spring 原始碼分析 GitHub 地址、Spring-Boot-Starter 原始碼分析 GitHub 地址）進行閱讀

MyBatis 版本：3.5.2

MyBatis-Spring 版本：2.0.3

MyBatis-Spring-Boot-Starter 版本：2.1.4

在《MyBatis-Spring原始碼分析》檔案中對 Spring 集成 MyBatis 的方案進行了分析，MyBatis-Spring 讓你能夠在 Spring 專案中方便地使用 MyBatis，隨著 Spring Boot 框架受到業界的廣泛關注，有越來越多企業使將它使用到正式的生產環境，它支持整合其他組件，讓你能夠在 Spring Boot 專案中更加方便地使用其他組件

當然，MyBatis 也提供了整合到 Spring Boot 的方案 Spring-Boot-Starter，能夠讓你快速的在 Spring Boot 上面使用 MyBatis，那么我們來看看這個 Spring-Boot-Starter 子專案是如何將 MyBatis 集成到 Spring 中的

在開始讀這篇檔案之前，需要對 Spring 有一定的了解，其中Spring-Boot-Starter 基于 MyBatis-Spring 來實作的，所以可以先查看我的另一篇《MyBatis-Spring原始碼分析》檔案來了解 MyBatis-Spring，本文可以結合我的原始碼注釋（Spring-Boot-Starter 原始碼分析 GitHub 地址）進行閱讀

簡述

MyBatis 的 Spring-Boot-Starter 子專案我們主要看到兩個模塊

mybatis-spring-boot-starter：定義了一個 pom 檔案，引入 MyBatis 相關依賴
mybatis-spring-boot-autoconfigure：MyBatis 整合到 Spring Boot 的具體實作

主要涉及到的幾個類：

org.mybatis.spring.boot.autoconfigure.MybatisProperties：MyBatis 的配置類，注入 Spring Boot 的組態檔中 MyBatis 的相關配置
org.mybatis.spring.boot.autoconfigure.MybatisAutoConfiguration：實作 InitializingBean 介面，MyBatis 自動配置類，用于初始化 MyBatis，核心類

大致邏輯如下：

通過 MybatisAutoConfiguration 這個自動配置類，再加上 MybatisProperties 的配置資訊，生成 SqlSessionFactory 和 SqlSessionTemplate 類，完成初始化，通過 @MapperScan 注解指定 Mapper 介面

配置示例

mybatis:
  type-aliases-package: tk.mybatis.simple.model
  mapper-locations: classpath:mapper/*.xml
  config-location: classpath:mybatis-config.xml

在application.yml中添加上面三個MyBatis的相關配置即可，然后在啟動類上面添加@MapperScan注解指定 Mapper 介面所在包路徑即可

注意：你還需要定義一個 DataSource 資料源，可選 Druid、HikariCP等資料庫連接池，這里就不講述如何使用了

MybatisProperties

org.mybatis.spring.boot.autoconfigure.MybatisProperties：MyBatis 的配置類，通過 Spring Boot 中的 @ConfigurationProperties 注解，注入 MyBatis 的相關配置，代碼如下：

@ConfigurationProperties(prefix = MybatisProperties.MYBATIS_PREFIX)
public class MybatisProperties {

  public static final String MYBATIS_PREFIX = "mybatis";

  private static final ResourcePatternResolver resourceResolver = new PathMatchingResourcePatternResolver();

  /**
   * Location of MyBatis xml config file.
   * mybatis-config.xml 組態檔的路徑
   */
  private String configLocation;

  /**
   * Locations of MyBatis mapper files.
   * XML 映射檔案的路徑
   */
  private String[] mapperLocations;

  /**
   * Packages to search type aliases. (Package delimiters are ",; \t\n")
   * 需要設定別名的包路徑
   */
  private String typeAliasesPackage;

  /**
   * The super class for filtering type alias. If this not specifies, the MyBatis deal as type alias all classes that
   * searched from typeAliasesPackage.
   */
  private Class<?> typeAliasesSuperType;

  /**
   * Packages to search for type handlers. (Package delimiters are ",; \t\n")
   */
  private String typeHandlersPackage;

  /**
   * Indicates whether perform presence check of the MyBatis xml config file.
   */
  private boolean checkConfigLocation = false;

  /**
   * Execution mode for {@link org.mybatis.spring.SqlSessionTemplate}.
   */
  private ExecutorType executorType;

  /**
   * The default scripting language driver class. (Available when use together with mybatis-spring 2.0.2+)
   */
  private Class<? extends LanguageDriver> defaultScriptingLanguageDriver;

  /**
   * Externalized properties for MyBatis configuration.
   */
  private Properties configurationProperties;

  /**
   * A Configuration object for customize default settings. If {@link #configLocation} is specified, this property is
   * not used.
   */
  @NestedConfigurationProperty
  private Configuration configuration;

  /**
   * 獲取 XML 映射檔案路徑下的資源物件
   *
   * @return Resource 資源陣列
   */
  public Resource[] resolveMapperLocations() {
    return Stream.of(Optional.ofNullable(this.mapperLocations).orElse(new String[0]))
        .flatMap(location -> Stream.of(getResources(location))).toArray(Resource[]::new);
  }

  /**
   * 獲取某個路徑下的資源
   *
   * @param location 路徑
   * @return Resource 資源陣列
   */
  private Resource[] getResources(String location) {
    try {
      return resourceResolver.getResources(location);
    } catch (IOException e) {
      return new Resource[0];
    }
  }

}

configLocation：mybatis-config.xml 組態檔的路徑
mapperLocations：XML 映射檔案的路徑
typeAliasesPackage：需要設定別名的包路徑，多個以, ; \t\n分隔
typeAliasesSuperType：需要設定別名的父 Class 型別
typeHandlersPackage：型別處理器的包路徑
checkConfigLocation：檢查 mybatis-config.xml 組態檔是否存在
executorType：Executor 執行器型別，默認 SIMPLE
defaultScriptingLanguageDriver：設定默認的 LanguageDriver 語言驅動類，默認為 XMLLanguageDriver

其中定義了前綴為mybatis，說明你可以在 Spring Boot 專案中的 application.yml 組態檔中，以該前綴定義 MyBatis 的相關屬性

我們通常添加前面三個配置就可以了

這里注意到僅添加了 @ConfigurationProperties 注解，在作為 Spring Bean 注入到 Spring 容器中時，會將相關配置注入到屬性中，但是這個注解不會將該類作為 Spring Bean 進行注入，需要結合 @Configuration 注解或者其他注解一起使用

SpringBootVFS

org.mybatis.spring.boot.autoconfigure.SpringBootVFS：MyBatis 需要使用到的虛擬檔案系統，用于替代 MyBatis 的 org.apache.ibatis.io.DefaultVFS 默認類

使用 Spring Boot 提供的 PathMatchingResourcePatternResolver 決議器，獲取到指定路徑下的 Resource 資源，代碼如下：

public class SpringBootVFS extends VFS {

  private final ResourcePatternResolver resourceResolver;

  public SpringBootVFS() {
    this.resourceResolver = new PathMatchingResourcePatternResolver(getClass().getClassLoader());
  }

  @Override
  public boolean isValid() {
    return true;
  }

  @Override
  protected List<String> list(URL url, String path) throws IOException {
    String urlString = url.toString();
    String baseUrlString = urlString.endsWith("/") ? urlString : urlString.concat("/");
    Resource[] resources = resourceResolver.getResources(baseUrlString + "**/*.class");
    return Stream.of(resources).map(resource -> preserveSubpackageName(baseUrlString, resource, path))
        .collect(Collectors.toList());
  }

  private static String preserveSubpackageName(final String baseUrlString, final Resource resource,
      final String rootPath) {
    try {
      return rootPath + (rootPath.endsWith("/") ? "" : "/")
          + resource.getURL().toString().substring(baseUrlString.length());
    } catch (IOException e) {
      throw new UncheckedIOException(e);
    }
  }

}

MybatisAutoConfiguration

org.mybatis.spring.boot.autoconfigure.MybatisAutoConfiguration：實作 InitializingBean 介面，MyBatis 自動配置類，用于初始化 MyBatis，核心類

構造方法

@org.springframework.context.annotation.Configuration
@ConditionalOnClass({ SqlSessionFactory.class, SqlSessionFactoryBean.class })
@ConditionalOnSingleCandidate(DataSource.class)
@EnableConfigurationProperties(MybatisProperties.class)
@AutoConfigureAfter({ DataSourceAutoConfiguration.class, MybatisLanguageDriverAutoConfiguration.class })
public class MybatisAutoConfiguration implements InitializingBean {

  private static final Logger logger = LoggerFactory.getLogger(MybatisAutoConfiguration.class);

  /**
   * MyBatis 配置資訊
   */
  private final MybatisProperties properties;

  private final Interceptor[] interceptors;

  private final TypeHandler[] typeHandlers;

  private final LanguageDriver[] languageDrivers;

  private final ResourceLoader resourceLoader;

  private final DatabaseIdProvider databaseIdProvider;

  private final List<ConfigurationCustomizer> configurationCustomizers;

  public MybatisAutoConfiguration(MybatisProperties properties, ObjectProvider<Interceptor[]> interceptorsProvider,
      ObjectProvider<TypeHandler[]> typeHandlersProvider, ObjectProvider<LanguageDriver[]> languageDriversProvider,
      ResourceLoader resourceLoader, ObjectProvider<DatabaseIdProvider> databaseIdProvider,
      ObjectProvider<List<ConfigurationCustomizer>> configurationCustomizersProvider) {
    this.properties = properties;
    this.interceptors = interceptorsProvider.getIfAvailable();
    this.typeHandlers = typeHandlersProvider.getIfAvailable();
    this.languageDrivers = languageDriversProvider.getIfAvailable();
    this.resourceLoader = resourceLoader;
    this.databaseIdProvider = databaseIdProvider.getIfAvailable();
    this.configurationCustomizers = configurationCustomizersProvider.getIfAvailable();
  }
}

我們主要來看到類上面定義的幾個注解：

@Configuration：可以當作一個 Spring Bean 注入到 Spring 背景關系中
@ConditionalOnClass({ SqlSessionFactory.class, SqlSessionFactoryBean.class })

保證存在 value 中所有的 Class 物件，以確保可以創建它們的實體物件，這里就保證 SqlSessionFactory 和 SqlSessionFactoryBean 都能夠被創建
@ConditionalOnSingleCandidate(DataSource.class)

保證存在 value 型別對應的 Bean，這里確保已經存在一個 DataSource 資料源物件
@EnableConfigurationProperties(MybatisProperties.class)

注入 value 中所有的型別的 Bean，這里會讓 MybatisProperties 作為 Spring Bean 注入到 Spring 背景關系中
@AutoConfigureAfter({ DataSourceAutoConfiguration.class, MybatisLanguageDriverAutoConfiguration.class })

在加載 value 中的所有類之后注入當前 Bean，會先注入 DataSourceAutoConfiguration 和 MybatisLanguageDriverAutoConfiguration 兩個類（感興趣的可以去看看，我沒搞懂這兩個類?? ?? ?? ）

我們可以看到是通過建構式注入 MybatisAutoConfiguration ，其中會注入 MybatisProperties 和 ResourceLoader 兩個 Bean，其他的物件都是通過 ObjectProvider 進行注入的（通過它的getIfAvailable()方法，如果存在對應的實體物件則設定）

afterPropertiesSet方法

afterPropertiesSet()方法，實作的 InitializingBean 介面的方法，在 Spring 容器初始化該 Bean 時會呼叫該方法

用于校驗 mybatis-config 組態檔是否存在，方法如下：

  @Override
  public void afterPropertiesSet() {
    checkConfigFileExists();
  }

  private void checkConfigFileExists() {
    if (this.properties.isCheckConfigLocation() && StringUtils.hasText(this.properties.getConfigLocation())) {
      Resource resource = this.resourceLoader.getResource(this.properties.getConfigLocation());
      Assert.state(resource.exists(),
          "Cannot find config location: " + resource + " (please add config file or check your Mybatis configuration)");
    }
  }

如果配置了 MybatisProperties 中配置checkConfigLocation需要檢查 mybatis-config.xml 組態檔，那么就會檢查該檔案是否有對應的 Resource 資源，檔案不存在則會拋出例外

sqlSessionFactory方法

sqlSessionFactory(DataSource dataSource)方法，注入一個 SqlSessionFactory 型別的 Spring Bean 到 Spring 背景關系，方法如下：

@Bean
@ConditionalOnMissingBean
public SqlSessionFactory sqlSessionFactory(DataSource dataSource) throws Exception {
    // <1> 創建一個 SqlSessionFactoryBean 物件，在 mybatis-spring 子專案中
    SqlSessionFactoryBean factory = new SqlSessionFactoryBean();
    // <2> 設定資料源
    factory.setDataSource(dataSource);
    // <3> 設定虛擬檔案系統為 SpringBootVFS 物件
    factory.setVfs(SpringBootVFS.class);
    /*
     * <4> 接下來設定一些屬性
     */
    // 如果配置了 mybatis-config.xml 組態檔
    if (StringUtils.hasText(this.properties.getConfigLocation())) {
      factory.setConfigLocation(this.resourceLoader.getResource(this.properties.getConfigLocation()));
    }
    // <5> 應用 Configuration 物件
    applyConfiguration(factory);
    if (this.properties.getConfigurationProperties() != null) {
      factory.setConfigurationProperties(this.properties.getConfigurationProperties());
    }
    if (!ObjectUtils.isEmpty(this.interceptors)) {
      factory.setPlugins(this.interceptors);
    }
    if (this.databaseIdProvider != null) {
      factory.setDatabaseIdProvider(this.databaseIdProvider);
    }
    // 如果配置了需要設定別名包路徑
    if (StringUtils.hasLength(this.properties.getTypeAliasesPackage())) {
      factory.setTypeAliasesPackage(this.properties.getTypeAliasesPackage());
    }
    if (this.properties.getTypeAliasesSuperType() != null) {
      factory.setTypeAliasesSuperType(this.properties.getTypeAliasesSuperType());
    }
    if (StringUtils.hasLength(this.properties.getTypeHandlersPackage())) {
      factory.setTypeHandlersPackage(this.properties.getTypeHandlersPackage());
    }
    if (!ObjectUtils.isEmpty(this.typeHandlers)) {
      factory.setTypeHandlers(this.typeHandlers);
    }
    // 如果配置了 XML 映射檔案路徑
    if (!ObjectUtils.isEmpty(this.properties.resolveMapperLocations())) {
      factory.setMapperLocations(this.properties.resolveMapperLocations());
    }
    // 獲取 SqlSessionFactoryBean 物件中屬性的名稱
    Set<String> factoryPropertyNames = Stream
            .of(new BeanWrapperImpl(SqlSessionFactoryBean.class).getPropertyDescriptors())
            .map(PropertyDescriptor::getName)
            .collect(Collectors.toSet());
    Class<? extends LanguageDriver> defaultLanguageDriver = this.properties.getDefaultScriptingLanguageDriver();
    // 如果包含了 scriptingLanguageDrivers 屬性，并且存在語言驅動類
    if (factoryPropertyNames.contains("scriptingLanguageDrivers") && !ObjectUtils.isEmpty(this.languageDrivers)) {
      // Need to mybatis-spring 2.0.2+
      // 設定語言驅動類
      factory.setScriptingLanguageDrivers(this.languageDrivers);
      if (defaultLanguageDriver == null && this.languageDrivers.length == 1) {
        defaultLanguageDriver = this.languageDrivers[0].getClass();
      }
    }
    // 如果包含了 defaultScriptingLanguageDriver 屬性
    if (factoryPropertyNames.contains("defaultScriptingLanguageDriver")) {
      // Need to mybatis-spring 2.0.2+
      // 設定默認的語言驅動類
      factory.setDefaultScriptingLanguageDriver(defaultLanguageDriver);
    }

    // <6> 這里會初始化（通過 afterPropertiesSet() 方法），回傳一個 DefaultSqlSessionFactory 物件
    return factory.getObject();
}

@ConditionalOnMissingBean注解：不存在同型別則注入當前 Bean（DefaultSqlSessionFactory），存在則不注入

創建一個 SqlSessionFactoryBean 物件，在《MyBatis-Spring原始碼分析》已經講到過
設定資料源 DataSource
設定 VFS 虛擬檔案系統為 SpringBootVFS 物件
接下來設定一些屬性，例如 configLocation、typeAliasesPackage、mapperLocation等屬性

應用 Configuration 物件

private void applyConfiguration(SqlSessionFactoryBean factory) {
  Configuration configuration = this.properties.getConfiguration();
  if (configuration == null && !StringUtils.hasText(this.properties.getConfigLocation())) {
    // 如果沒有自定義 Configuration 物件，也沒有定義 configLocation 組態檔，則直接創建
    configuration = new Configuration();
  }
  /*
   * 如果 Configuration 不為 null，并且 ConfigurationCustomizer 處理器不為空
   * 則對該 Configuration 物件進行自定義處理
   */
  if (configuration != null && !CollectionUtils.isEmpty(this.configurationCustomizers)) {
    for (ConfigurationCustomizer customizer : this.configurationCustomizers) {
      customizer.customize(configuration);
    }
  }
  factory.setConfiguration(configuration);
}

如果你在 MapperProperties 中定義了 Configuration 物件，或者你沒有配置 configLocation（會創建一個 Configuration）

那么會通過 ConfigurationCustomizer 處理器（需要自己去實作該介面），對該 Configuration 物件進行自定義處理

呼叫SqlSessionFactoryBean 的 getObject() 方法，回傳一個 DefaultSqlSessionFactory 物件，這里會呼叫其 afterPropertiesSet() 方法，完成 MyBatis 的初始化

sqlSessionTemplate方法

sqlSessionTemplate(SqlSessionFactory sqlSessionFactory)方法，注入一個 SqlSessionTemplate 型別的 Spring Bean 到 Spring 背景關系，方法如下：

@Bean
@ConditionalOnMissingBean
public SqlSessionTemplate sqlSessionTemplate(SqlSessionFactory sqlSessionFactory) {
    // 獲取執行器型別，默認 SIMPLE
    ExecutorType executorType = this.properties.getExecutorType();
    if (executorType != null) {
      return new SqlSessionTemplate(sqlSessionFactory, executorType);
    } else {
      return new SqlSessionTemplate(sqlSessionFactory);
    }
}

@ConditionalOnMissingBean注解：不存在同型別則注入當前 Bean（SqlSessionTemplate），存在則不注入

根據 SqlSessionFactory 創建一個 SqlSessionTemplate 物件

這里怎么才能被 MapperFactoryBean 注入 sqlSessionTemplate 屬性為當前 SqlSessionTemplate 物件呢？

在 org.mybatis.spring.mapper.ClassPathMapperScanner 的 processBeanDefinitions 方法中你會發現，如果沒有配置 sqlSession 相關配置，則 explicitFactoryUsed 為 false，那么就會設定該 MapperFactoryBean 的 AutowireMode 為 AUTOWIRE_BY_TYPE，也就是說通過屬性型別注入值，通過 set 方法來賦值，就會找到這個 SqlSessionTemplate 物件了

MapperScannerRegistrarNotFoundConfiguration

MybatisAutoConfiguration 的一個內部靜態類，實作了 InitializingBean 介面

用于注入一個 AutoConfiguredMapperScannerRegistrar 靜態類，代碼如下：

/**
 * If mapper registering configuration or mapper scanning configuration not present,
 * this configuration allow to scan mappers based on the same component-scanning path as Spring Boot itself.
 *
 */
@org.springframework.context.annotation.Configuration
@Import(AutoConfiguredMapperScannerRegistrar.class)
@ConditionalOnMissingBean({ MapperFactoryBean.class, MapperScannerConfigurer.class })
public static class MapperScannerRegistrarNotFoundConfiguration implements InitializingBean {

    @Override
    public void afterPropertiesSet() {
      logger.debug(
          "Not found configuration for registering mapper bean using @MapperScan, MapperFactoryBean and MapperScannerConfigurer.");
    }

}

如果 MapperFactoryBean 和 MapperScannerConfigurer 型別的 Bean 都不存在則注入該 Bean，則通過 @Import(AutoConfiguredMapperScannerRegistrar.class) 匯入的 AutoConfiguredMapperScannerRegistrar 類，會去掃描 Spring Boot 專案的基礎包路徑，帶有 @Mapper 注解的介面會被當成 Mapper介面進行決議

AutoConfiguredMapperScannerRegistrar

MybatisAutoConfiguration 的一個內部靜態類，實作了 BeanFactoryAware 和 ImportBeanDefinitionRegistrar 介面

用于往 BeanDefinitionRegistry 注冊表添加一個 MapperScannerConfigurer 型別的 BeanDefinition 物件，該物件在《MyBatis-Spring原始碼分析》已經講過，代碼如下：

/**
 * This will just scan the same base package as Spring Boot does. If you want more power, you can explicitly use
 * {@link org.mybatis.spring.annotation.MapperScan} but this will get typed mappers working correctly, out-of-the-box,
 * similar to using Spring Data JPA repositories.
 */
public static class AutoConfiguredMapperScannerRegistrar implements BeanFactoryAware, ImportBeanDefinitionRegistrar {

    private BeanFactory beanFactory;

    @Override
    public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {

      if (!AutoConfigurationPackages.has(this.beanFactory)) {
        logger.debug("Could not determine auto-configuration package, automatic mapper scanning disabled.");
        return;
      }

      logger.debug("Searching for mappers annotated with @Mapper");

      // <1> 獲取到 Spring Boot 的基礎包路徑
      List<String> packages = AutoConfigurationPackages.get(this.beanFactory);
      if (logger.isDebugEnabled()) {
        packages.forEach(pkg -> logger.debug("Using auto-configuration base package '{}'", pkg));
      }

      // <2> 生成一個 BeanDefinition 構建器，用于構建 MapperScannerConfigurer 的 BeanDefinition 物件
      BeanDefinitionBuilder builder = BeanDefinitionBuilder.genericBeanDefinition(MapperScannerConfigurer.class);
      builder.addPropertyValue("processPropertyPlaceHolders", true);
      // <3> 設定 @Mapper 注解的介面才會被當成 Mapper 介面
      builder.addPropertyValue("annotationClass", Mapper.class);
      builder.addPropertyValue("basePackage", StringUtils.collectionToCommaDelimitedString(packages));
      BeanWrapper beanWrapper = new BeanWrapperImpl(MapperScannerConfigurer.class);
      // 獲取 MapperScannerConfigurer 的屬性名稱
      Set<String> propertyNames = Stream.of(beanWrapper.getPropertyDescriptors()).map(PropertyDescriptor::getName)
          .collect(Collectors.toSet());
      if (propertyNames.contains("lazyInitialization")) {
        // Need to mybatis-spring 2.0.2+
        builder.addPropertyValue("lazyInitialization", "${mybatis.lazy-initialization:false}");
      }
      if (propertyNames.contains("defaultScope")) {
        // Need to mybatis-spring 2.0.6+
        builder.addPropertyValue("defaultScope", "${mybatis.mapper-default-scope:}");
      }
      // <4> 添加 一個 MapperScannerConfigurer 的 BeanDefinition 物件，也就是注入一個 MapperScannerConfigurer 物件到容器中
      registry.registerBeanDefinition(MapperScannerConfigurer.class.getName(), builder.getBeanDefinition());
    }

    @Override
    public void setBeanFactory(BeanFactory beanFactory) {
      this.beanFactory = beanFactory;
    }

}

獲取到 Spring Boot 的基礎包路徑
生成一個 BeanDefinition 構建器，用于構建 MapperScannerConfigurer 的 BeanDefinition 物件
設定 @Mapper 注解的介面才會被當成 Mapper 介面
添加一個 MapperScannerConfigurer 的 BeanDefinition 物件，也就是注入一個 MapperScannerConfigurer 物件到容器中

這個類和@MapperScan注解一樣的作用，如果你沒有通過下面三種配置方式掃描 Mapper 介面的包路徑

配置 MapperScannerConfigurer 掃描器型別的 Spring Bean
@MapperScan注解
<mybatis:scan />標簽）

那么這里就會通過AutoConfiguredMapperScannerRegistrar添加一個 MapperScannerConfigurer 掃描器物件，去掃描 Spring Boot 專案設定的基礎包路徑，如果配置了@Mapper注解，則會當成Mapper介面進行決議，和@MapperScan注解的作用一樣

spring.factories檔案

spring.factories 檔案位于resources/META-INF下面，內容如下：

# Auto Configure
org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
org.mybatis.spring.boot.autoconfigure.MybatisLanguageDriverAutoConfiguration,\
org.mybatis.spring.boot.autoconfigure.MybatisAutoConfiguion

上面講到的 MybatisAutoConfiguration 自定配置類作為初始化 MyBatis 的入口，需要被 Spring 容器管理，但是他人通過引入該組件后，這些類不一定能夠被 Spring 掃描到，所以需要通過 spring.factories 檔案來定義 org.springframework.boot.autoconfigure.EnableAutoConfiguration 的類名值，那么這些類名對應的類就會一定會被 Spring 管理了（SPI 機制）

同目錄中還有一個additional-spring-configuration-metadata.json檔案，該檔案定義的內容是在 Spring Boot 專案中的 application.yml 組態檔中 mybatis 相關配置的默認值以及提示等資訊

總結

通過 spring.factories 檔案，在你引入 MyBatis 的 mybatis-spring-boot-starter 依賴后，MybatisAutoConfiguion 自定配置類將會作為 Spring Bean 注入到 Spring 的背景關系中，從這個類中會初始化 SqlSessionFactory 和 SqlSessionTemplate 兩個物件，完成初始化，另外可以通過 @MapperScan 注解決議對應的 Mapper 介面

實際上就是在 MyBatis-Spring 的子專案上增加對 Spring Boot 組態檔以及注解的支持，不用在組態檔中定義相應的 Bean 了，相對來說比較簡單

到這里已經對 MyBatis 相關內容全部分析玩了，相信大家對 MyBatis 有了一個更加深入的了解，感謝大家的閱讀！！！??????

參考文章：芋道原始碼《精盡 MyBatis 原始碼分析》

轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/228061.html

標籤：其他

上一篇：精盡MyBatis原始碼分析 - Spring-Boot-Starter 原始碼分析

下一篇：Java基本概念：介面