目录
一、Bean的作用域
1、概念
2、Bean的作用域
（1）singleton
（2）prototype
（3）request
（4）session
（5）application
二、Bean的生命周期
1、代码演示
2、源码阅读
三、Spring Boot自动配置
1、Spring 加载 Bean
（1）问题描述
（2）原因分析
（3）解决方案
@ComponentScan
@Import
1、导入类
2、导入ImportSelector接口实现类
（4）问题
1、第三方依赖提供注解
2、在启动类上使用第三方提供的注解
2、SpringBoot原理分析
（1）源码阅读
1、元注解
2、@SpringBootConfiguration
3、@EnableAutoConfiguration（开启自动配置）
4、@ComponentScan（包扫描）
（2）EnableAutoConfiguration
1、Import({AutoConfigurationImportSelector.class})
2、@AutoConfigurationPackage
3、总结
四、总结
一、Bean的作用域
1、概念
在Spring IoC&DI阶段，学习了 Spring是如何帮助我们管理对象的
1、通过 @Controller，@Service，@Repository，@Component，@Configuration，@Bean 来声明Bean对象。
2、通过 ApplicationContext 或者 BeanFactory 来获取对象。
3、通过 @Autowired，Setter 方法或者构造方法等来为应用程序注入所依赖的Bean对象。
下面进行简单回顾一下：
1、通过@Bean声明bean，把bean存进Spring容器中
public class Dog {private String name;public String getName() {return name;}public void setName(String name) {this.name = name;}
}@Configuration
public class DogConfig {@Beanpublic Dog dog() {Dog dog = new Dog();dog.setName("huahua");return dog;}
}2、从Spring容器中获取bean
@SpringBootApplication
public class SpringPrincipleApplication {public static void main(String[] args) {ApplicationContext context = SpringApplication.run(SpringPrincipleApplication.class, args);Dog dog = context.getBean(Dog.class);System.out.println(dog);}}
通过注入的方式获取
@SpringBootTest
class SpringPrincipleApplicationTests {@Autowiredprivate ApplicationContext context;@Testvoid contextLoads() {Dog dog1 = context.getBean(Dog.class);dog1.setName("name1");System.out.println(dog1.getName());System.out.println(dog1);Dog dog2 = context.getBean(Dog.class);System.out.println(dog2.getName());System.out.println(dog2);}
} 观察运行结果：
发现输出bean的地址都是一样的，说明每次从Spring容器中拿出的对象都是同一个。
dog1 和 dog2 为同一个对象，dog2 拿到了 dog1 设置的值。
这也是“单例模式”。
单例模式：确保一个类只有一个实例，多次创建也不会创建出多个实例。
默认情况下，Spring容器中的bean都是单例的，这种行为模式，我们就称之为Bean的作用域。
Bean 的作用域是指Bean在Spring框架中的某种行为模式
比如单例作用域：表示Bean在整个Spring中只有一份，它是全局共享的。那么当其他人修改了这个值之后，那么另一个人读取到的就是被修改的值。
那能不能将bean对象设置为非单例的（每次获取的bean都是一个新的对象呢）？这就是Bean的不同作用域了。
2、Bean的作用域
在Spring中支持6中作用域，后4中在Spring MVC环境才生效
1、singleton：单例作用域
2、prototype：原型作用域（多例作用域）
3、request：请求作用域
4、session：会话作用域
5、Application：全局作用域
6、websocket：HTTP WebSocket 作用域
参考文档：Bean Scopes :: Spring Framework
| 作用域 | 说明 |
|---|---|
| singleton | 每个Spring IoC容器内同名称的bean只有一个实例（单例）（默认） |
| prototype | 每次使用该bean时会创建新的实例（非单例） |
| request | 每个HTTP 请求生命周期内，创建新的实例（web环境中，了解） |
| session | 每个HTTP Session 生命周期内，创建新的实例（web环境中，了解） |
| application | 每个ServletContext生命周期内，创建新的实例（web环境中，了解） |
| websocket | 每个WebSocket生命周期内，创建新的实例（web环境中，了解） |
（范围从小到大）
我们来简单看下代码实现，定义⼏个不同作⽤域的Bean
@Configuration
public class DogConfig {@Bean@Scope(ConfigurableBeanFactory.SCOPE_SINGLETON)public Dog singletonDog() {return new Dog();}@Bean@Scope(ConfigurableBeanFactory.SCOPE_PROTOTYPE)public Dog prototypeDog() {return new Dog();}@Bean@RequestScopepublic Dog requestDog() {return new Dog();}@Bean@SessionScopepublic Dog sessionDog() {return new Dog();}@Bean@ApplicationScopepublic Dog applicationDog() {return new Dog();}}测试不同作⽤域的Bean取到的对象是否⼀样：
（这里Autowired注入，从Spring中拿对象，先是根据类名查找，如果注入的类名在Spring容器中只有一个，那就直接获取，如果注入多个同名的类，则按变量名查找，如果根据变量名称查找不到，就会报错；因此可以使用@Qualifiy和@Source指定名称）
@RestController
public class DogController {@Autowiredprivate ApplicationContext context;@Autowiredprivate Dog singletonDog;@Autowiredprivate Dog prototypeDog;@Autowiredprivate Dog requestDog;@Autowiredprivate Dog sessionDog;@Autowiredprivate Dog applicationDog;@RequestMapping("/single")public String single() {//从context获取对象Dog dog = context.getBean("singletonDog", Dog.class);return "contextDog: " + dog + "</br>Autowired: " + singletonDog;}@RequestMapping("/prototype")public String prototype() {//从context获取对象Dog dog = context.getBean("prototypeDog", Dog.class);return "contextDog: " + dog + "</br>Autowired: " + prototypeDog;}@RequestMapping("/request")public String request() {//从context获取对象Dog dog = context.getBean("requestDog", Dog.class);return "contextDog: " + dog + "</br>Autowired: " + requestDog;}@RequestMapping("/session")public String session() {//从context获取对象Dog dog = context.getBean("sessionDog", Dog.class);return "contextDog: " + dog + "</br>Autowired: " + sessionDog;}@RequestMapping("/application")public String application() {//从context获取对象Dog dog = context.getBean("applicationDog", Dog.class);return "contextDog: " + dog + "</br>Autowired: " + applicationDog;}
}观察bean的作用域：
（1）singleton
多次访问，得到的都是同一个对象，并且 @Autowired 和 applicationContext.getBean() 也是同一个对象。(不同浏览器也是一样的)
（2）prototype
可以看到，每次使用context得到的对象都不同（程序运行时机是请求该接口）
但使用@Autowired注入进来的bean对象是一样的，这是因为依赖注入在Spring容器启动时，就已经注入了，所以多次请求也不会发生变化。（程序运行时机是项目启动的时候）
不同浏览器Autowired注入的对象是相同的
（3）request
可以看到，不同的请求，获取的对象不同。（在一次请求中，@Autowired 和applicationContext.getBean()也是同一个对象。但每次请求，都会重新创建对象）
（4）session
每次获取的对象都是一样的，因为是同一个浏览器，所以属于同一个会话。（如果换个浏览器就不是一样的了）
（5）application
每次访问的bean对象都是同一个，因为它是作用在全局的。
Application scope就是对于整个web容器来说，bean的作⽤域是ServletContext级别的。这个和singleton有点类似，区别在于：Application scope是ServletContext的单例，singleton是⼀个ApplicationContext的单例。在⼀个web容器中ApplicationContext可以有多个。(了解即可)
二、Bean的生命周期
生命周期指的是一个对象从诞生到销毁的整个生命过程，我们把这个过程就叫做一个对象的生命周期。
Bean 的生命周期分为以下5个部分：
1、实例化（为Bean分配内存空间）
2、属性赋值（Bean注入和装配，比如@Autowired）
3、初始化：
a、执行各种通知，如 BeanNameAware，BeanFactoryAware，ApplicationContextAware 的接口方法。
b、执行初始化方法
（1）xml 定义 init-method。
（2）使用注解的方式 @PostConstruct。
（3）执行初始化后置方法（BeanPostProcessor）。
4、使用 Bean
5、销毁 Bean
a、销毁容器的各种方法，如 @PreDestroy，DisposableBean 接口方法，destroy-method。
实例化 对应 构造方法，属性赋值 对应 setter方法 的注入。初始化 和 销毁 是用户自定义扩展的两个阶段，可以在实例化之后，类加载完成之前进行自定义“事件”处理。
Bean的生命周期类似下面：
买房的流程
（1）先买房（实例化，从无到有）
（2）装修（设置属性）
（3）买家电，如洗衣机、冰箱、电视、空调等（[各种]初始化，可以入住）
（4）入住（使用 Bean）
（5）买房（Bean 销毁）
执行流程如图：
1、代码演示
@Component
public class BeanLifeComponent implements BeanNameAware {private Dog singletonDog;//1、实例化（为bean分配空间）public BeanLifeComponent() {System.out.println("执行构造函数....");}//2、属性赋值(bean注入和装配，比如@Autowired）@Autowiredpublic void setSingletonDog(Dog singletonDog) {this.singletonDog = singletonDog;System.out.println("执行setSingletonDog...");}//3、初始化//执行通知@Overridepublic void setBeanName(String name) {System.out.println("setBeanName");}//执行初始化方法@PostConstruct//这个注解在对BeanLifeComponent对象初始化时就会执行public void init() {System.out.println("执行PostConstruct....");}//4、使用beanpublic void use() {System.out.println("执行use方法");}//5、销毁bean@PreDestroy//销毁前做的事情public void destroy() {System.out.println("执行destroy方法...");}
}
执行结果：
通过运⾏结果观察：
1. 先执⾏构造函数
2. 设置属性
3. Bean初始化
4. 使⽤Bean
5. 销毁Bean
2、源码阅读
上面步骤，在源码中均有体现
创建Bean的代码入口在 AbstractAutowireCapableBeanFactory#createBean
public abstract class AbstractAutowireCapableBeanFactory extendsAbstractBeanFactoryimplements AutowireCapableBeanFactory {protected Object createBean(String beanName, RootBeanDefinition mbd,@Nullable Object[] args)throws BeanCreationException {//...代码省略try {// Give BeanPostProcessors a chance to return a proxy instead of thetarget bean instance.//在实例化之前, 是否有快捷创建的Bean, 也就是通过PostProcessorsBeforeInstantiation返回的Bean//如果存在, 则会替代原来正常通过target bean⽣成的bean的流程Object bean = resolveBeforeInstantiation(beanName, mbdToUse);if (bean != null) {return bean;}}catch (Throwable ex) {throw new BeanCreationException(mbdToUse.getResourceDescription(),beanName,"BeanPostProcessor before instantiation of bean failed", ex);}try {//创建Bean//⽅法中包含了实例化、属性赋值、初始化过程Object beanInstance = doCreateBean(beanName, mbdToUse, args);if (logger.isTraceEnabled()) {logger.trace("Finished creating instance of bean '" + beanName +"'");}return beanInstance;}//...代码省略}
}点进去继续看源码：AbstractAutowireCapableBeanFactory#createBean
protected Object doCreateBean(String beanName, RootBeanDefinition mbd,@Nullable Object[] args)throws BeanCreationException {//...代码省略// Instantiate the bean.if (instanceWrapper == null) {//实例化BeaninstanceWrapper = createBeanInstance(beanName, mbd, args);}//...代码省略//初始化bean// Initialize the bean instance.Object exposedObject = bean;try {//依据bean definition 完成bean属性赋值populateBean(beanName, mbd, instanceWrapper);//执⾏bean初始化exposedObject = initializeBean(beanName, exposedObject, mbd);}catch (Throwable ex) {if (ex instanceof BeanCreationException &&beanName.equals(((BeanCreationException) ex).getBeanName())) {throw (BeanCreationException) ex;}else {throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Initialization of beanfailed", ex);}}//...代码省略return exposedObject;}这三个⽅法与三个⽣命周期阶段⼀⼀对应
1. createBeanInstance() -> 实例化
2. populateBean() -> 属性赋值
3. initializeBean() -> 初始化
继续点进去 initializeBean
//初始化Beanprotected Object initializeBean(String beanName, Object bean, @NullableRootBeanDefinition mbd) {if (System.getSecurityManager() != null) {AccessController.doPrivileged((PrivilegedAction<Object>) () -> {invokeAwareMethods(beanName, bean);return null;}, getAccessControlContext());}else {//调⽤的三个Bean开头的Aware⽅法invokeAwareMethods(beanName, bean);}Object wrappedBean = bean;if (mbd == null || !mbd.isSynthetic()) {wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean,beanName);}try {invokeInitMethods(beanName, wrappedBean, mbd);}catch (Throwable ex) {throw new BeanCreationException((mbd != null ? mbd.getResourceDescription() : null),beanName, "Invocation of init method failed", ex);}if (mbd == null || !mbd.isSynthetic()) {wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean,beanName);}return wrappedBean;}//调⽤的三个Bean开头的Aware⽅法private void invokeAwareMethods(String beanName, Object bean) {if (bean instanceof Aware) {if (bean instanceof BeanNameAware) {((BeanNameAware) bean).setBeanName(beanName);}if (bean instanceof BeanClassLoaderAware) {ClassLoader bcl = getBeanClassLoader();if (bcl != null) {((BeanClassLoaderAware) bean).setBeanClassLoader(bcl);}}if (bean instanceof BeanFactoryAware) {((BeanFactoryAware)bean).setBeanFactory(AbstractAutowireCapableBeanFactory.this);}}}三、Spring Boot自动配置
SpringBoot的自动配置就是当Spring容器启动后，一些配置类，bean对象等就自动存入到了IoC容器中，不需要我们手动去声明，从而简化了开发，省去了繁琐的配置操作。
SpringBoot自动配置，就是指SpringBoot是如何将依赖jar包中的配置类以及Bean加载到Spring IoC容器中的。
主要介绍以下两个方面：
1、Spring 是如何把对象加载到 Spring IoC容器中的。
2、SpringBoot 是如何实现的。
1、Spring 加载 Bean
（1）问题描述
需求：使用 Spring管理第三方的 jar 包的配置。
引入第三方的包，其实就是在该项目下，引入第三方代码，我们采用在该项目下创建不同的目录来模拟第三方的代码引入。
数据准备：
1、当前目录为：com.example.springprinciple，模拟第三方代码文件在autoconfig目录下
代码如下：
@Component
public class AutoConfig {public void study() {System.out.println("start study...");}
}2、获取AutoConfig这个Bean，代码如下：
@SpringBootTest
class SpringPrincipleApplicationTests {@Autowiredprivate ApplicationContext applicationContext;@Testvoid contextLoads() {AutoConfig autoConfig = applicationContext.getBean(AutoConfig.class, "autoConfig");System.out.println(autoConfig);}
}3、运行程序，观察结果：
观察日志：No qualifying bean of type 'autoconfig.AutoConfig' available
没有autoconfig.AutoConfig 这个类型的Bean
（2）原因分析
Spring通过五大注解和@Bean注解可以帮助我们把Bean加载到SpringIoC容器中，以上有个前提就是这些注解类需要和SpringBoot启动类在同一个目录下（@SpringBootApplication 标注的类 就是 SpringBoot项目的启动类）。
上面启动类所在目录为：com.example.springprinciple，而AutoConfig这个类在autoconfig下，所以SpringBoot并没有扫描到。
当我们引入第三方的Jar包时，第三方的Jar代码目录肯定不在启动类的目录下，如何告诉Spring帮我们管理这些Bean呢？
（3）解决方案
我们需要指定路径或者引入的文件，告诉Spring，让Spring进行扫描到。常见的解决方案有两种：
1、@ComponentScan 组件扫描
2、@Import 导入（使用 @Import导入的类，会被Spring加载到IoC容器中）
@ComponentScan
通过@ComponentScan指定扫描路径
@ComponentScan("autoconfig")
@SpringBootApplication
public class SpringPrincipleApplication {public static void main(String[] args) {SpringApplication.run(SpringPrincipleApplication.class, args);}}运行程序：
可以看到这次 autoConfig Bean获取到了
Spring 是否使用了这种方式呢？
非常明显，没有（引入我们引入第三方框架时，没有加扫描路径，比如 Mybatis）
如果Spring Boot采用这种方式，当我们引入大量的第三方依赖，比如 MyBatis、Jackson等时，就需要再启动类上配置不同。
加入依赖需要扫描包，这种方式会非常繁琐。
@Import
@Import 导入主要有以下几种形式：
1、导入类
2、导入 ImportSelector 接口实现类
1、导入类
@Import(AutoConfig.class)
@SpringBootApplication
public class SpringPrincipleApplication {public static void main(String[] args) {SpringApplication.run(SpringPrincipleApplication.class, args);}}运行程序：
可以看到，这种方式也可以告诉Spring加载autoConfig。
问题是如果多了一些配置项呢？
@Import({BiteConfig.class, BiteConfig2.class})
@SpringBootApplication
public class SpringAutoconfigApplication {public static void main(String[] args) {SpringApplication.run(SpringAutoconfigApplication.class, args);}
}
那是不是就要频繁写多个配置项的类，也非常繁琐，所以Spring Boot 也没有采用这种方式。
2、导入ImportSelector接口实现类
public class MyImportSelector implements ImportSelector {@Overridepublic String[] selectImports(AnnotationMetadata importingClassMetadata) {return new String[]{"autoconfig.AutoConfig", "autoconfig.AutoConfig2"};//需要导⼊的全限定类名}
}运行程序：
@Import(MyImportSelector .class)
@SpringBootApplication
public class SpringPrincipleApplication {public static void main(String[] args) {SpringApplication.run(SpringPrincipleApplication.class, args);}}
可以看到，我们采用这种方式也可以导入第三方依赖提供的Bean。
（4）问题
但是他们都有一个明显的问题，就是使用者需要知道第三方依赖中有哪些Bean对象或者配置类。如果漏掉一些Bean，很可能导致我们的项目出现大的事故。
这对程序员来说非常不友好。
依赖中有哪些Bean，使用时需要配置哪些bean，第三方依赖最清楚，那能否由第三方依赖来做这些事呢？
比较常见的方案就是第三方依赖给我们提供一个注解，这个注解一般都以@EnableXxxx开头的注解，注解中封装的就是@Import注解。
步骤如下：
1、第三方依赖提供注解
import org.springframework.context.annotation.Import;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
@Import(MyImportSelector.class)//指定要导⼊哪些类
public @interface EnableAutoConfig {
}注解中封装 @Import 注解，导入 MyImportSelector.class
2、在启动类上使用第三方提供的注解
@EnableAutoConfig
@SpringBootApplication
public class SpringPrincipleApplication {public static void main(String[] args) {SpringApplication.run(SpringPrincipleApplication.class, args);}}运行程序：
可以看到，这种方式也可以导入第三方依赖提供的Bean。并且这种方式更优雅一点。SpringBoot采用的也是这种方式。
2、SpringBoot原理分析
（1）源码阅读
SpringBoot是如何帮助我们做的呢？一切的来自起源SpringBoot启动类开始。（@SpringBootApplication 标注的类就是SpringBoot项目的启动类）
@SpringBootApplication
public class SpringPrincipleApplication {public static void main(String[] args) {//获取Spring上下文对象ApplicationContext context = SpringApplication.run(SpringPrincipleApplication.class, args);//从Spring上下文获取对象BeanLifeComponent beanLifeComponent = context.getBean(BeanLifeComponent.class);beanLifeComponent.use();}}
这个类和普通类唯一的区别就是 @SpringBootApplication 注解，这个注解也是SpringBoot实现自动配置的核心。
@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 @interface SpringBootApplication {
//代码省略...
}@SpringBootApplication 是一个组合注解，注解中包含了：
1、元注解
JDK中提供了4个标准的用来对注解类型进行注解的注解的注解类，我们称之为 meta-annotation（元注解），他们分别是：
@Target 描述注解的使用范围（即被修饰的注解可以用在什么地方）
@Retention 描述注解保留的时间范围
@Documented 描述在使用 javadoc工具为类生成帮助文档时要保留其注解信息
@Inherited 使被它修饰的注解具有继承性（如果某个类使用了被@Inherited修饰的注解，则其子类将自动具有该注解）
2、@SpringBootConfiguration
里面就是 @Configuration，标注当前类为配置类，其实只是做了一层封装，改了个名字而已（@Indexed注解，是用来加速应用启动的，不用关心）
@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Configuration
@Indexed
public @interface SpringBootConfiguration {@AliasFor(annotation = Configuration.class)boolean proxyBeanMethods() default true;
}3、@EnableAutoConfiguration（开启自动配置）
Spring 自动配置的核心注解。
4、@ComponentScan（包扫描）
可以通过 basePackageClasses 或 basePackages 来定义要扫描的特定包，如果没有定义特定的包，将从声明该注解的类的包开始扫描，这也是为什么 SpringBoot项目声明的注解类必须要在启动类的目录下。
excludeFilters 自定义过滤器，通常用于排除一些类、注解等。
（2）EnableAutoConfiguration
看下 @EnableAutoConfiguration 注解的实现：
@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@AutoConfigurationPackage
@Import({AutoConfigurationImportSelector.class})
public @interface EnableAutoConfiguration {String ENABLED_OVERRIDE_PROPERTY = "spring.boot.enableautoconfiguration";Class<?>[] exclude() default {};String[] excludeName() default {};
}这个注解包含两部分：
1、Import({AutoConfigurationImportSelector.class})
使用@Import注解，导入了实现ImportSelector接口的实现类。
public class AutoConfigurationImportSelector implements DeferredImportSelector, BeanClassLoaderAware, ResourceLoaderAware, BeanFactoryAware, EnvironmentAware, Ordered {public String[] selectImports(AnnotationMetadata annotationMetadata) {if (!this.isEnabled(annotationMetadata)) {return NO_IMPORTS;} else {//获取自动配置的配置类信息AutoConfigurationEntry autoConfigurationEntry = this.getAutoConfigurationEntry(annotationMetadata);return StringUtils.toStringArray(autoConfigurationEntry.getConfigurations());}}
}selectImports() 方法底层调用 getAutoConfigurationEntry() 方法，获取可自动配置的配置类信息集合。
点进去：
protected AutoConfigurationEntry getAutoConfigurationEntry(AnnotationMetadata annotationMetadata) {if (!this.isEnabled(annotationMetadata)) {return EMPTY_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);return new AutoConfigurationEntry(configurations, exclusions);}}getAutoConfigurationEntry() 方法通过调用getCandidateConfigurations(annotationMetadata, attributes)方法 获取在配置文件中配置的所有自动配置类的集合。
点击去：
//获取所有基于
//METAINF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports⽂件
//META-INF/spring.factories⽂件中配置类的集合protected List<String> getCandidateConfigurations(AnnotationMetadata metadata, AnnotationAttributes attributes) {List<String> configurations = ImportCandidates.load(AutoConfiguration.class, getBeanClassLoader()).getCandidates();Assert.notEmpty(configurations,"No auto configuration classes found in "+ "META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports. If you "+ "are using a custom packaging, make sure that file is correct.");return configurations;}getCandidateConfiguration 方法的功能：
获取所有基于 METAINF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports⽂件，META-INF/spring.factories⽂件中配置类的集合。
在引入的起步依赖中，通常都有包含以上两个文件。
这里面包含了很多第三方依赖的配置文件（连续按两下shift可以查看对应的源码）
1、在加载自动配置类的时候，并不是将所有的配置全部加载进来，而是通过@Conditional等注解的判断进行动态加载。
@Conditional是Spring底层的注解，意思就是根据不同的条件，来进行自己不同的条件判断，如果满足指定的条件，那么配置类里边的配置才会生效。
2、META-INF/spring.factories文件是Spring内部提供的一个约定俗成的加载方式，只需要在模块的META-INF/spring.factories文件中配置即可，Spring就会把相应的实现类注入到Spring容器中。
注意：会加载所有jar包下的classpath路径下的META-INF/spring.factories文件，这样的文件不止一个。
比如 Redis的配置: RedisAutoConfiguration
可以看到，配置文件中使用@Bean声明了一下对象，Spring就会自动调用配置类中使用@Bean标识的方法，并把对象注册到Spring IoC容器中。
在加载自动配置类的时候，并不是将所有的配置全部加载进来，而是通过@Conditional等注解的判断进行动态加载。
@Conditional是Spring底层注解，意思就是根据不同的条件，来进行自己不同的条件判断，如果满足指定条件，那么配置类里边的配置才会生效。
2、@AutoConfigurationPackage
源码如下：
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@Import(AutoConfigurationPackages.Registrar.class)
public @interface AutoConfigurationPackage {/*** Base packages that should be registered with {@link AutoConfigurationPackages}.* <p>* Use {@link #basePackageClasses} for a type-safe alternative to String-based package* names.* @return the back package names* @since 2.3.0*/String[] basePackages() default {};/*** Type-safe alternative to {@link #basePackages} for specifying the packages to be* registered with {@link AutoConfigurationPackages}.* <p>* Consider creating a special no-op marker class or interface in each package that* serves no purpose other than being referenced by this attribute.* @return the base package classes* @since 2.3.0*/Class<?>[] basePackageClasses() default {};}这个注解主要是导入一个配置文件：AutoConfigurationPackages.Registrar.class
static class Registrar implements ImportBeanDefinitionRegistrar, DeterminableImports {@Overridepublic void registerBeanDefinitions(AnnotationMetadata metadata, BeanDefinitionRegistry registry) {register(registry, new PackageImports(metadata).getPackageNames().toArray(new String[0]));}@Overridepublic Set<Object> determineImports(AnnotationMetadata metadata) {return Collections.singleton(new PackageImports(metadata));}}Registrar实现了 ImportBeanDefinitionRegistrar 类，就可以被注解@Import导入到Spring容器里。
(String[ ]) (new PackageImports(metadata)).getPackageNames().toArray(new String[0])：当前启动类所在的包名。
所以：@AutoConfigurationPackage 就是将启动类所在的包下面所有的组件都扫描注册到Spring 容器中。
3、总结
当SpringBoot程序启动时，会加载配置文件当中所定义的配置类，通过 @Import 注解将这些配置类全部加载到Spring的IoC容器中，交给IoC容器管理。
四、总结
1、Bean的作用域共分为6种：singleton、prototype、request、session、application、websocket
2、Bean的生命周期共分为5大部分：实例化、属性赋值、初始化、使用Bean、销毁Bean
3、SpringBoot的自动配置原理源码入口：@SpringBootApplication 注解，这个注解封装了3个注解：
（1）@SpringBootConfiguration：标志当前类为配置类。
（2）@ComponentScan：进行包扫描（默认扫描的是启动类所在的当前包及其子包）
（3）EnableAutoConfiguration
1、@Import注解：读取当前项目下所有依赖jar包中 META-INF/spring.factories、METAINF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports这两个⽂件 里面定义的配置类（配置类中定义了 @Bean 注解标识的方法）
2、@AutoConfigurationPackage：把启动类所在的包下面所有的组件都注入到 Spring 容器中。
