SpringBoot——启动类的原理

优质博文：IT-BLOG-CN

SpringBoot

启动类上使用

@SpringBootApplication

注解，该注解是一个组合注解，包含多个其它注解。和类定义

SpringApplication.run

要揭开

SpringBoot

的神秘面纱，我们要从这两位开始就可以了。

@SpringBootApplicationpublicclassMySpringbootApplication{publicstaticvoidmain(String[] args){SpringApplication.run(MySpringbootApplication.class, args);}}

一、@SpringBootApplication

@Target({ElementType.TYPE})@Retention(RetentionPolicy.RUNTIME)@Documented@Inherited@SpringBootConfiguration@EnableAutoConfiguration@ComponentScan(
    excludeFilters ={@Filter(
    type =FilterType.CUSTOM,
    classes ={TypeExcludeFilter.class}),@Filter(
    type =FilterType.CUSTOM,
    classes ={AutoConfigurationExcludeFilter.class})})public@interfaceSpringBootApplication{

@SpringBootApplication

注解上标有三个注解

@SpringBootConfiguration

、

@EnableAutoConfiguration

、

@ComponentScan

。其它四个注解用来声明

SpringBootAppliction

为一个注解。

@SpringBootConfiguration

@Target({ElementType.TYPE})@Retention(RetentionPolicy.RUNTIME)@Documented@Configurationpublic@interfaceSpringBootConfiguration{

@SpringBootConfiguration

注解中没有定义任何属性信息，而该注解上有一个注解

@Configuration

，用于标识配置类。所以

@SpringBootConfiguration

注解的功能和

@Configuration

注解的功能相同，用于标识配置类，与

@Bean

搭配使用，一个带有

@Bean

的注解方法将返回一个对象，该对象应该被注册为在

Spring

应用程序上下文中的

bean

。如下案例：

@ConfigurationpublicclassConf{@BeanpublicCarcar(){returnnewCar();}}

@ComponentScan

@ComponentScan

这个注解在

Spring

中很重要，它对应

XML

配置中的元素，

@ComponentScan

的功能其实就是自动扫描并加载符合条件的组件（比如

@Component

和

@Repository

等）或者

bean

定义，最终将这些

bean

定义加载到

IoC

容器中。我们可以通过

basePackages

等属性来细粒度的定制

@ComponentScan

自动扫描的范围，如果不指定，则默认

Spring

框架实现会从声明

@ComponentScan

所在类的

package

进行扫描。注：所以

SpringBoot

的启动类最好是放在

root package

下，因为默认不指定

basePackages

。

@EnableAutoConfiguration

@Target({ElementType.TYPE})@Retention(RetentionPolicy.RUNTIME)@Documented@Inherited@AutoConfigurationPackage@Import({AutoConfigurationImportSelector.class})public@interfaceEnableAutoConfiguration{

个人感觉

@EnableAutoConfiguration

这个

Annotation

最为重要，

Spring

框架提供的各种名字为

@Enable

开头的

Annotation

，借助

@Import

的支持，收集和注册特定场景相关的

bean

定义。

@EnableAutoConfiguration

也是借助

@Import

的帮助，将所有符合自动配置条件的

bean

定义加载到

IoC

容器。

@EnableAutoConfiguration

注解上标注了两个注解，

@AutoConfigurationPackage

、

@Import

。

@Import

注解在

SpringIOC

一些注解的源码中比较常见，主要用来给容器导入目标

bean

。这里

@Import

注解给容器导入的组件用于自动配置：

AutoConfigurationImportSelector

而

@AutoConfigurationPackage

注解是

Spring

自定义的注解，用于将主配置类所在的包作为自动配置的包进行管理。

@AutoConfigurationPackage

packageorg.springframework.boot.autoconfigure;@Target({ElementType.TYPE})@Retention(RetentionPolicy.RUNTIME)@Documented@Inherited@Import({Registrar.class})public@interfaceAutoConfigurationPackage{String[]basePackages()default{};Class<?>[]basePackageClasses()default{};}

@AutoConfigurationPackage

注解上的

@Import

注解，给容器导入了

Registrar

组件

Registrar

staticclassRegistrarimplementsImportBeanDefinitionRegistrar,DeterminableImports{Registrar(){}publicvoidregisterBeanDefinitions(AnnotationMetadata metadata,BeanDefinitionRegistry registry){AutoConfigurationPackages.register(registry,(String[])(newAutoConfigurationPackages.PackageImports(metadata)).getPackageNames().toArray(newString[0]));}publicSet<Object>determineImports(AnnotationMetadata metadata){returnCollections.singleton(newAutoConfigurationPackages.PackageImports(metadata));}}

Registrar

是抽象类

AutoConfigurationPackages

的内部静态类，

Registrar

内的

registerBeanDefinitions()

方法负责将注解所在的包及其子包下的所有组件注册进容器。这也是为什么

SpringBoot

的启动类要在其他类的父包或在同一个包中。

AutoConfigurationImportSelector

publicclassAutoConfigurationImportSelectorimplementsDeferredImportSelector,BeanClassLoaderAware,ResourceLoaderAware,BeanFactoryAware,EnvironmentAware,Ordered{

借助

AutoConfigurationImportSelector

，

@EnableAutoConfiguration

可以帮助

SpringBoot

应用将所有符合条件的

@Configuration

配置都加载到当前

SpringBoot

创建的

IoC

容器中。借助于

Spring

框架原有的一个工具类：

SpringFactoriesLoader

，

@EnableAutoConfiguration

的自动配置功能才得以大功告成！

SpringFactoriesLoader

属于

Spring

框架私有的一种扩展方案，其主要功能就是**从指定的配置文件

META-INF/spring.factories

** 加载配置。

publicabstractclassSpringFactoriesLoader{publicstatic<T>List<T>loadFactories(Class<T> factoryClass,ClassLoader classLoader){......}publicstaticList<String>loadFactoryNames(Class<?> factoryClass,ClassLoader classLoader){......}}

配合

@EnableAutoConfiguration

使用的话，它更多是提供一种配置查找的功能支持，即根据

@EnableAutoConfiguration

的完整类名

org.springframework.boot.autoconfigure.EnableAutoConfiguration

作为查找的

Key

，获取对应的一组

@Configuration

类。

上图就是从

SpringBoot

的

autoconfigure

依赖包中的

META-INF/spring.factories

配置文件中摘录的一段内容，可以很好地说明问题。

所以，

@EnableAutoConfiguration

自动配置的魔法骑士就变成了：从

classpath

中搜寻所有的

META-INF/spring.factories

配置文件，并将其中

org.springframework.boot.autoconfigure.EnableutoConfiguration

对应的配置项通过反射

Java Refletion

实例化，为标注了

@Configuration

的配置类加载到

IoC

容器中。

AutoConfigurationImportSelector

类实现了很多

Aware

接口，而

Aware

接口的功能是使用一些

Spring

内置的实例获取一些想要的信息，如容器信息、环境信息、容器中注册的

bean

信息等。而

AutoConfigurationImportSelector

类的作用是将

Spring

中已经定义好的自动配置类注入容器中，而实现该功能的方法是

selectImports

方法：

selectImports

注册

Spring

中定义好的配置类

publicString[]selectImports(AnnotationMetadata annotationMetadata){if(!this.isEnabled(annotationMetadata)){returnNO_IMPORTS;}else{AutoConfigurationMetadata autoConfigurationMetadata =AutoConfigurationMetadataLoader.loadMetadata(this.beanClassLoader);AutoConfigurationImportSelector.AutoConfigurationEntry autoConfigurationEntry =this.getAutoConfigurationEntry(autoConfigurationMetadata, annotationMetadata);returnStringUtils.toStringArray(autoConfigurationEntry.getConfigurations());}}

@EnableAutoConfiguration

：

SpringBoot

根据应用所声明的依赖来对

Spring

框架进行自动配置。

@SpringBootConfiguration

(内部为@Configuration)：被标注的类等于在

Spring

的

XML

配置文件中(applicationContext.xml)，装配所有

Bean

事务，提供了一个

Spring

的上下文环境。

@ComponentScan

：组件扫描，可自动发现和装配

Bean

，默认扫描

SpringApplication

的

run

方法里的

Booter.class

所在的包路径下文件，所以最好将该启动类放到根包路径下。

二、SpringApplication.run(x.class, args)

SpringApplication

的

run

方法的实现是

SpringApplication

执行流程的主要线路，该方法的主要流程大体可以归纳如下：

【1】如果我们使用的是

SpringApplication

的静态

run

方法，那么，这个方法里面首先要创建一个

SpringApplication

对象实例，然后调用这个创建好的

SpringApplication

的实例方法。在

SpringApplication

实例初始化的时候，它会提前做几件事情：
 ● 根据

classpath

里面是否存在某个特征类

org.springframework.web.context.ConfigurableWebApplicationContext

来决定是否应该创建一个为

Web

应用使用的

ApplicationContext

类型。
 ● 使用

SpringFactoriesLoader

在应用的

classpath

中查找并加载所有可用的

ApplicationContextInitializer

。
 ● 使用

SpringFactoriesLoader

在应用的

classpath

中查找并加载所有可用的

ApplicationListener

。
 ● 推断并设置

main

方法的定义类。

【2】

SpringApplication

完成实例初始化并且完成设置后，就开始执行

run

方法的逻辑，首先遍历执行所有通过

SpringFactoriesLoader

可以查找到并加载的

SpringApplicationRunListener

[接口]。调用它们的

started()

方法，告诉这些

SpringApplicationRunListener

，“嘿，

SpringBoot

应用要开始执行咯！”。

publicinterfaceSpringApplicationRunListener{defaultvoidstarting(){}defaultvoidenvironmentPrepared(ConfigurableEnvironment environment){}defaultvoidcontextPrepared(ConfigurableApplicationContext context){}defaultvoidcontextLoaded(ConfigurableApplicationContext context){}defaultvoidstarted(ConfigurableApplicationContext context){}defaultvoidrunning(ConfigurableApplicationContext context){}defaultvoidfailed(ConfigurableApplicationContext context,Throwable exception){}}

【3】创建并配置当前

Spring Boot

应用将要使用的

Environment

（包括配置要使用的

PropertySource

以及

Profile

）。
【4】遍历调用所有

SpringApplicationRunListener

的

environmentPrepared()

的方法，告诉他们：“当前

SpringBoot

应用使用的

Environment

准备好了咯！”。
【5】如果

SpringApplication

的

showBanner

属性被设置为

true

，则打印

banner

。
【6】根据用户是否明确设置了

applicationContextClass

类型以及初始化阶段的推断结果，决定该为当前

SpringBoot

应用创建什么类型的

ApplicationContext

并创建完成，然后根据条件决定是否添加

ShutdownHook

，决定是否使用自定义的

BeanNameGenerator

，决定是否使用自定义的

ResourceLoader

，当然，最重要的，将之前准备好的

Environment

设置给创建好的

ApplicationContext

使用。
【7】

ApplicationContext

创建好之后，

SpringApplication

会再次借助

SpringFactoriesLoader

，查找并加载

classpath

中所有可用的

ApplicationContextInitializer

，然后遍历调用这些

ApplicationContextInitializer

的

initialize（applicationContext）

方法来对已经创建好的

ApplicationContext

进行进一步的处理。
【8】遍历调用所有

SpringApplicationRunListener

的

contextPrepared()

方法。
【9】最核心的一步，将之前通过

@EnableAutoConfiguration

获取的所有配置以及其他形式的 IoC容器配置加载到已经准备完毕的

ApplicationContext

。
【10】遍历调用所有

SpringApplicationRunListener

的

contextLoaded()

方法。
【11】调用

ApplicationContext

的

refresh()

方法，完成

IoC

容器可用的最后一道工序。
【12】查找当前

ApplicationContext

中是否注册有

CommandLineRunner

，如果有，则遍历执行它们。
【13】正常情况下，遍历执行

SpringApplicationRunListener

的

finished()

方法、（如果整个过程出现异常，则依然调用所有

SpringApplicationRunListener

的

finished()

方法，只不过这种情况下会将异常信息一并传入处理）

去除事件通知点后，整个流程如下：

调试一个

SpringBoot

启动程序为例，参考流程中主要类类图，来分析其启动逻辑和自动化配置原理。

上图为

SpringBoot

启动结构图，我们发现启动流程主要分为三个部分:
第一部分进行

SpringApplication

的初始化模块，配置一些基本的环境变量、资源、构造器、监听器
第二部分实现了应用具体的启动方案，包括启动流程的监听模块、加载配置环境模块、及核心的创建上下文环境模块
第三部分是自动化配置模块，该模块作为

SpringBoot

自动配置核心，在后面的分析中会详细讨论。在下面的启动程序中我们会串联起结构中的主要功能

SpringBoot启动类

进入

run()

方法，

run()

方法创建了一个

SpringApplication

实例并调用其

run()

方法。

publicstaticConfigurableApplicationContextrun(Class<?>[] primarySources,String[] args){return(newSpringApplication(primarySources)).run(args);}

SpringApplication

构造器主要为

SpringApplication

对象赋一些初值。构造函数执行完毕后，回到

run()

方法

publicConfigurableApplicationContextrun(String... args){StopWatch stopWatch =newStopWatch();
    stopWatch.start();ConfigurableApplicationContext context =null;Collection<SpringBootExceptionReporter> exceptionReporters =newArrayList();this.configureHeadlessProperty();SpringApplicationRunListeners listeners =this.getRunListeners(args);
    listeners.starting();Collection exceptionReporters;try{ApplicationArguments applicationArguments =newDefaultApplicationArguments(args);ConfigurableEnvironment environment =this.prepareEnvironment(listeners, applicationArguments);this.configureIgnoreBeanInfo(environment);Banner printedBanner =this.printBanner(environment);
        context =this.createApplicationContext();
        exceptionReporters =this.getSpringFactoriesInstances(SpringBootExceptionReporter.class,newClass[]{ConfigurableApplicationContext.class}, context);this.prepareContext(context, environment, listeners, applicationArguments, printedBanner);this.refreshContext(context);this.afterRefresh(context, applicationArguments);
        stopWatch.stop();if(this.logStartupInfo){(newStartupInfoLogger(this.mainApplicationClass)).logStarted(this.getApplicationLog(), stopWatch);}

        listeners.started(context);this.callRunners(context, applicationArguments);}catch(Throwable var10){this.handleRunFailure(context, var10, exceptionReporters, listeners);thrownewIllegalStateException(var10);}try{
        listeners.running(context);return context;}catch(Throwable var9){this.handleRunFailure(context, var9, exceptionReporters,(SpringApplicationRunListeners)null);thrownewIllegalStateException(var9);}}

该方法中实现了如下几个关键步骤：
【1】创建了应用的监听器

SpringApplicationRunListeners

并开始监听；
【2】加载

SpringBoot

配置环境

ConfigurableEnvironment

，如果是通过

web

容器发布，会加载

StandardEnvironment

，其最终也是继承了

ConfigurableEnvironment

，类图如下：

可以看出，

*Environment

最终都实现了

PropertyResolver

接口，我们平时通过

environment

对象获取配置文件中指定

Key

对应的

value

方法时，就是调用了

propertyResolver

接口的

getProperty

方法；
【3】配置环境

Environment

加入到监听器对象中

SpringApplicationRunListeners

；
【4】创建

run

方法的返回对象：

ConfigurableApplicationContext

(应用配置上下文)，我们可以看一下创建方法：

protectedConfigurableApplicationContextcreateApplicationContext(){Class<?> contextClass =this.applicationContextClass;if(contextClass ==null){try{switch(this.webApplicationType){caseSERVLET:
                contextClass =Class.forName("org.springframework.boot.web.servlet.context.AnnotationConfigServletWebServerApplicationContext");break;caseREACTIVE:
                contextClass =Class.forName("org.springframework.boot.web.reactive.context.AnnotationConfigReactiveWebServerApplicationContext");break;default:
                contextClass =Class.forName("org.springframework.context.annotation.AnnotationConfigApplicationContext");}}catch(ClassNotFoundException var3){thrownewIllegalStateException("Unable create a default ApplicationContext, please specify an ApplicationContextClass", var3);}}return(ConfigurableApplicationContext)BeanUtils.instantiateClass(contextClass);}

会先获取显式设置的应用上下文

applicationContextClass

，如果不存在，再加载默认的环境配置（通过是否是

web environment

判断），默认选择

AnnotationConfigApplicationContext

注解上下文（通过扫描所有注解类来加载bean），最后通过

BeanUtils

实例化上下文对象，并返回。

ConfigurableApplicationContext

类图如下：

主要看其继承的两个方向：
**

LifeCycle

：** 生命周期类，定义了

start

启动、

stop

结束、

isRunning

是否运行中等生命周期空值方法；

**

ApplicationContext

：** 应用上下文类，其主要继承了

beanFactory

(bean的工厂类)；
【5】回到

run

方法内，

prepareContext

方法将

listeners

、

environment

、

applicationArguments

、

banner

等重要组件与上下文对象关联；
【6】接下来的

refreshContext(context)

方法(初始化方法如下)将是实现

spring-boot-starter-*

(

mybatis

、

redis

等)自动化配置的关键，包括

spring.factories

的加载，

bean

的实例化等核心工作。

SpringIOC

源码

refresh

方法链接 有兴趣的可以看下。

privatevoidrefreshContext(ConfigurableApplicationContext context){this.refresh((ApplicationContext)context);}//进入 refresh 方法，IOC容器着重分析的方法publicvoidrefresh()throwsBeansException,IllegalStateException{synchronized(this.startupShutdownMonitor){this.prepareRefresh();ConfigurableListableBeanFactory beanFactory =this.obtainFreshBeanFactory();this.prepareBeanFactory(beanFactory);try{this.postProcessBeanFactory(beanFactory);this.invokeBeanFactoryPostProcessors(beanFactory);this.registerBeanPostProcessors(beanFactory);this.initMessageSource();this.initApplicationEventMulticaster();this.onRefresh();this.registerListeners();this.finishBeanFactoryInitialization(beanFactory);this.finishRefresh();}catch(BeansException var9){if(this.logger.isWarnEnabled()){this.logger.warn("Exception encountered during context initialization - cancelling refresh attempt: "+ var9);}this.destroyBeans();this.cancelRefresh(var9);throw var9;}finally{this.resetCommonCaches();}}}

配置结束后，

SpringBoot

做了一些基本的收尾工作，返回了应用环境上下文。回顾整体流程，

SpringBoot

的启动，主要创建了配置环境

environment

、事件监听

listeners

、应用上下文

applicationContext

，并基于以上条件，在容器中开始实例化我们需要的

Bean

，至此，通过

SpringBoot

启动的程序已经构造完成，接下来我们来探讨自动化配置是如何实现。

自动化配置

之前的启动结构图中，我们注意到无论是应用初始化还是具体的执行过程，都调用了

SpringBoot

自动配置模块。

**

SpringBoot

自动配置模块：** 该配置模块的主要使用到了

SpringFactoriesLoader

，即

Spring

工厂加载器，该对象提供了

loadFactoryNames

方法，入参为

factoryClass

和

classLoader

，即需要传入上图中的工厂类名称和对应的类加载器，方法会根据指定的

classLoader

，加载该类加器搜索路径下的指定文件，即

spring.factories

文件，传入的工厂类为接口，而文件中对应的类则是接口的实现类，或最终作为实现类，所以文件中一般为如下图这种一对多的类名集合，获取到这些实现类的类名后，

loadFactoryNames

方法返回类名集合，方法调用方得到这些集合后，再通过反射获取这些类的类对象、构造方法，最终生成实例。

# PropertySource Loaders
org.springframework.boot.env.PropertySourceLoader=\
org.springframework.boot.env.PropertiesPropertySourceLoader,\
org.springframework.boot.env.YamlPropertySourceLoader

# Run Listeners
org.springframework.boot.SpringApplicationRunListener=\
org.springframework.boot.context.event.EventPublishingRunListener

# Error Reporters
org.springframework.boot.SpringBootExceptionReporter=\
org.springframework.boot.diagnostics.FailureAnalyzers

# Application Context Initializers
org.springframework.context.ApplicationContextInitializer=\
org.springframework.boot.context.ConfigurationWarningsApplicationContextInitializer,\

下图有助于我们形象理解自动配置流程。

mybatis-spring-boot-starter

starter详细内容链接、

spring-boot-starter-web

等组件的

META-INF

文件下均含有

spring.factories

文件，自动配置模块中，

SpringFactoriesLoader

收集到文件中的类全名并返回一个类全名的数组，返回的类全名通过反射被实例化，就形成了具体的工厂实例，工厂实例来生成组件具体需要的

bean

。之前我们提到了

EnableAutoConfiguration

注解，其类图如下：

可以发现其最终实现了

ImportSelector

(选择器)和

BeanClassLoaderAware

(bean类加载器中间件)，重点关注一下

AutoConfigurationImportSelector

的

selectImports

方法。

publicString[]selectImports(AnnotationMetadata annotationMetadata){if(!this.isEnabled(annotationMetadata)){returnNO_IMPORTS;}else{AutoConfigurationImportSelector.AutoConfigurationEntry autoConfigurationEntry =this.getAutoConfigurationEntry(annotationMetadata);returnStringUtils.toStringArray(autoConfigurationEntry.getConfigurations());}}protectedAutoConfigurationImportSelector.AutoConfigurationEntrygetAutoConfigurationEntry(AnnotationMetadata annotationMetadata){if(!this.isEnabled(annotationMetadata)){returnEMPTY_ENTRY;}else{AnnotationAttributes attributes =this.getAttributes(annotationMetadata);List<String> configurations =this.getCandidateConfigurations(annotationMetadata, attributes);
        configurations =this.removeDuplicates(configurations);Set<String> exclusions =this.getExclusions(annotationMetadata, attributes);this.checkExcludedClasses(configurations, exclusions);
        configurations.removeAll(exclusions);
        configurations =this.getConfigurationClassFilter().filter(configurations);this.fireAutoConfigurationImportEvents(configurations, exclusions);returnnewAutoConfigurationImportSelector.AutoConfigurationEntry(configurations, exclusions);}}

该方法在

SpringBoot

启动流程

Bean

实例化前被执行，返回要实例化的类信息列表。如果获取到类信息，

Spring

自然可以通过类加载器将类加载到

jvm

中，现在我们已经通过

SpringBoot

的

starter

依赖方式依赖了我们需要的组件，那么这些组建的类信息在

select

方法中也是可以被获取到的。

protectedList<String>getCandidateConfigurations(AnnotationMetadata metadata,AnnotationAttributes attributes){List<String> configurations =SpringFactoriesLoader.loadFactoryNames(this.getSpringFactoriesLoaderFactoryClass(),this.getBeanClassLoader());Assert.notEmpty(configurations,"No auto configuration classes found in META-INF/spring.factories. If you are using a custom packaging, make sure that file is correct.");return configurations;}

该方法中的

getCandidateConfigurations

方法，其返回一个自动配置类的类名列表，方法调用了

loadFactoryNames

方法，查看该方法：

publicstaticList<String>loadFactoryNames(Class<?> factoryType,@NullableClassLoader classLoader){String factoryTypeName = factoryType.getName();return(List)loadSpringFactories(classLoader).getOrDefault(factoryTypeName,Collections.emptyList());}

在上面的代码可以看到自动配置器会根据传入的

factoryType.getName()

到项目系统路径下所有的

spring.factories

文件中找到相应的

key

，从而加载里面的类。我们就选取这个

mybatis-spring-boot-autoconfigure

下的

spring.factories

文件

# Auto Configure
org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
org.mybatis.spring.boot.autoconfigure.MybatisAutoConfiguration

进入

org.mybatis.spring.boot.autoconfigure.MybatisAutoConfiguration

中，主要看一下类头：

@Configuration@ConditionalOnClass({SqlSessionFactory.class,SqlSessionFactoryBean.class})@ConditionalOnBean({DataSource.class})@EnableConfigurationProperties({MybatisProperties.class})@AutoConfigureAfter({DataSourceAutoConfiguration.class})publicclassMybatisAutoConfiguration{

@Configuration

，俨然是一个通过注解标注的

SpringBean

；

@ConditionalOnClass({ SqlSessionFactory.class, SqlSessionFactoryBean.class})

这个注解的意思是：当存在

SqlSessionFactory.class

,

SqlSessionFactoryBean.class

这两个类时才解析

MybatisAutoConfiguration

配置类，否则不解析这一个配置类，

make sence

，我们需要

mybatis

为我们返回会话对象，就必须有会话工厂相关类；

@CondtionalOnBean(DataSource.class)

：只有处理已经被声明为

bean

的

dataSource

；

@ConditionalOnMissingBean(MapperFactoryBean.class)

这个注解的意思是如果容器中不存在

name

指定的

bean

则创建

bean

注入，否则不执行（该类源码较长，篇幅限制不全粘贴）；

以上配置可以保证

sqlSessionFactory

、

sqlSessionTemplate

、

dataSource

等

mybatis

所需的组件均可被自动配置，

@Configuration

注解已经提供了

Spring

的上下文环境，所以以上组件的配置方式与

Spring

启动时通过

mybatis.xml

文件进行配置起到一个效果。通过分析我们可以发现，只要一个基于

SpringBoot

项目的类路径下存在

SqlSessionFactory.class

,

SqlSessionFactoryBean.class

，并且容器中已经注册了

dataSourceBean

，就可以触发自动化配置，意思说我们只要在

maven

的项目中加入了

mybatis

所需要的若干依赖，就可以触发自动配置，但引入

mybatis

原生依赖的话，每集成一个功能都要去修改其自动化配置类，那就得不到开箱即用的效果了。所以

SpringBoot

为我们提供了统一的 starter可以直接配置好相关的类，触发自动配置所需的依赖(mybatis)如下：

<dependency><groupId>com.alibaba.cloud</groupId><artifactId>spring-cloud-alibaba-sentinel-gateway</artifactId><version>2.1.0.RELEASE</version></dependency>

这里是截取的

mybatis-spring-boot-starter

的源码中

pom.xml

文件中所有依赖：

<dependencies><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter</artifactId></dependency><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-jdbc</artifactId></dependency><dependency><groupId>org.mybatis.spring.boot</groupId><artifactId>mybatis-spring-boot-autoconfigure</artifactId></dependency><dependency><groupId>org.mybatis</groupId><artifactId>mybatis</artifactId></dependency><dependency><groupId>org.mybatis</groupId><artifactId>mybatis-spring</artifactId></dependency></dependencies>

因为

maven

依赖的传递性，我们只要依赖

starter

就可以依赖到所有需要自动配置的类，实现开箱即用的功能。也体现出

SpringBoot

简化了

Spring

框架带来的大量

XML

配置以及复杂的依赖管理，让开发人员可以更加关注业务逻辑的开发。

三、总结

配置文件定义属性[

@Configuration

]，自动装配到所属的配置类中，然后通过动态代理进入

spring

容器中。