目录
????????1、@SpringBootConfiguration
????????3、@EnableAutoConfiguration
????????4、@AutoConfigurationPackage
????????5、@Import(AutoConfigurationImportSelector.class)
视频是看的
视频，非常好评建议2到3刷，能有很多收获
一、SpringBoot的简介？
1、为什么要使用SpringBoot？
Spring Boot makes it easy to create stand-alone, production-grade Spring based Applications that you can "just run".
SpringBoot能快速创建出生产级别的Spring应用
即SpringBoot给我们提供了很多的启动类，包含了该技术所用到的jar包和一些死的xml配置（让我们无需操心配置，只需要关心业务逻辑即可），我们只需要单独配置一些不能提前配置的配置即可快速的创建一个生产级别的Spring应用
SpringBoot的出现也是将 Spring全注解开发得到了完全使用。
2、SpringBoot的优缺点
优点：
- Create stand-alone Spring applications
- 创建独立Spring应用
- Embed Tomcat, Jetty or Undertow directly (no need to deploy WAR files)
- 内嵌web服务器（嵌入Tomcat、jetty或Undertow，无需部署WAR；）
- Provide opinionated 'starter' dependencies to simplify your build configuration
- 自动starter依赖，简化构建配置
- Automatically configure Spring and 3rd party libraries whenever possible
- 自动配置Spring以及第三方功能
- Provide production-ready features such as metrics, health checks, and externalized configuration
- 提供生产级别的监控、健康检查及外部化配置
- Absolutely no code generation and no requirement for XML configuration
- 无代码生成、无需编写XML（通过内部的XXXAutoConfiguration实现）
?缺点：
入门容易，精通难。因为SpringBoot封装的太深，如果对Spring了解的不深，那么SpringBoot的底层也是很难理解的
总结 ：
SpringBoot不是用于替代spring框架的，通过starter简化了Spring框架的配置
常常说SpringBoot采用约定大于配置
二、了解配置原理
1、SpringBoot的特点
1.1 依赖管理
- 通过父项目做依赖管理
依赖管理 ? ? <parent> ? ? ? ? <groupId>org.springframework.boot</groupId> ? ? ? ? <artifactId>spring-boot-starter-parent</artifactId> ? ? ? ? <version>2.3.4.RELEASE</version> </parent> 他的父项目 ?<parent> ? ? <groupId>org.springframework.boot</groupId> ? ? <artifactId>spring-boot-dependencies</artifactId> ? ? <version>2.3.4.RELEASE</version> ? </parent> 几乎声明了所有开发中常用的依赖的版本号,自动版本仲裁机制
- 开发导入starter场景启动器
1、见到很多 spring-boot-starter-* ： *就某种场景? ?这种是SpringBoot本身提供的
2、只要引入starter，这个场景的所有常规需要的依赖我们都自动引入
3、SpringBoot所有支持的场景? ：Developing with Spring Boot
4、见到的 ?*-spring-boot-starter： 第三方为我们提供的简化开发的场景启动器。
5、所有场景启动器最底层的依赖
<dependency>
? <groupId>org.springframework.boot</groupId>
? <artifactId>spring-boot-starter</artifactId>
? <version>2.3.4.RELEASE</version>
? <scope>compile</scope>
</dependency>
- 无需关注版本号，自动版本仲裁
?SpringBoot中提供了版本管理，我们就无须进行写版本号
?SpringBoot没有提供版本，我们就需要自己写版本号了
- 可以修改默认版本号
?如果自己写了版本，SpringBoot就会使用你设置的版本
1.2 自动配置
- 自动配好Tomcat
????????引入Tomcat依赖。配置Tomcat
- 自动配好SpringMVC
????????引入SpringMVC全套组件、自动配好SpringMVC常用组件（功能）
- 自动配好Web常见功能，如：字符编码问题
SpringBoot帮我们配置好了所有web开发的常见场景
- 默认的包结构
????????主程序（@SpringBootApplication的类）所在包及其下面的所有子包里面的组件都会被默认? ? ?????????扫描进来
????????无需以前的包扫描配置
????????想要改变扫描路径，@SpringBootApplication(scanBasePackages="com.atguigu")
????????或者@ComponentScan 指定扫描路径
@SpringBootApplication
等同于
@SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan("com.sofwin.boot")- 各种配置拥有默认值
????????默认配置最终都是映射到某个类上
????????配置文件的值最终会绑定每个类上，这个类会在容器中创建对象
????????这也是为什么说是规定大于配置
- 按需加载所有自动配置项
????????非常多的starter
????????引入了哪些场景这个场景的自动配置才会开启（）
????????SpringBoot所有的自动配置功能都在 spring-boot-autoconfigure 包里面
2、容器功能
2.1、组件添加
1、@Configuration
- 基本使用
- Full模式与Lite模式
????????示例
#############################Configuration使用示例######################################################
/**
* 1、配置类里面使用@Bean标注在方法上给容器注册组件，默认也是单实例的
* 2、配置类本身也是组件
* 3、proxyBeanMethods：代理bean的方法
* Full(proxyBeanMethods = true)、【保证每个@Bean方法被调用多少次返回的组件都是单实例的】
* Lite(proxyBeanMethods = false)【每个@Bean方法被调用多少次返回的组件都是新创建的】
* 组件依赖必须使用Full模式默认。其他默认是否Lite模式
*
*
*
*/
@Configuration(proxyBeanMethods = false) //告诉SpringBoot这是一个配置类 == 配置文件
public class MyConfig {
/**
* Full:外部无论对配置类中的这个组件注册方法调用多少次获取的都是之前注册容器中的单实例对象
* @return
*/
@Bean //给容器中添加组件。以方法名作为组件的id。返回类型就是组件类型。返回的值，就是组件在容器中的实例
public User user01(){
User zhangsan = new User("zhangsan", 18);
//user组件依赖了Pet组件
zhangsan.setPet(tomcatPet());
return zhangsan;
}
@Bean("tom")
public Pet tomcatPet(){
return new Pet("tomcat");
}
}
################################@Configuration测试代码如下########################################
@SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan("com.sofwin.boot")
public class MainApplication {
public static void main(String[] args) {
//1、返回我们IOC容器
ConfigurableApplicationContext run = SpringApplication.run(MainApplication.class, args);
//2、查看容器里面的组件
String[] names = run.getBeanDefinitionNames();
for (String name : names) {
System.out.println(name);
}
//3、从容器中获取组件
Pet tom01 = run.getBean("tom", Pet.class);
Pet tom02 = run.getBean("tom", Pet.class);
System.out.println("组件："+(tom01 == tom02)); //false
//4、com.atguigu.boot.config.MyConfig$$EnhancerBySpringCGLIB$$51f1e1ca@1654a892
MyConfig bean = run.getBean(MyConfig.class);
System.out.println(bean);
//如果@Configuration(proxyBeanMethods = true)代理对象调用方法。SpringBoot总会检查这个组件是否在容器中有。
//保持组件单实例
User user = bean.user01();
User user1 = bean.user01();
System.out.println(user == user1); //true
User user01 = run.getBean("user01", User.class);
Pet tom = run.getBean("tom", Pet.class);
System.out.println("用户的宠物："+(user01.getPet() == tom)); //true
}
}
????????最佳实战
????????????????配置 类组件之间无依赖关系用Lite模式加速容器启动过程，减少判断
????????????????配置类组件之间有依赖关系，方法会被调用得到之前单实例组件，用Full模式
?4、@Import({User.class, DBHelper.class})
?* ? ? ?给容器中自动创建出这两个类型的组件、默认组件的名字就是全类名
?*
?*
?*
?*/
@Import({User.class, DBHelper.class})
@Configuration(proxyBeanMethods = false) //告诉SpringBoot这是一个配置类 == 配置文件
public class MyConfig {
}
?2、@Bean、@Component、@Controller、@Service、@Repository
@Component的三个衍生注解
@Controller? ?控制层
@Service? ? ? ?service层
@Repository? dao层
3、@ComponentScan、@Import?
?/*? ? ?@Import({User.class, DBHelper.class})
?* ? ? ?给容器中自动创建出这两个类型的组件、默认组件的名字就是全类名
?*/@Import({User.class, DBHelper.class})
@Configuration(proxyBeanMethods = false) //告诉SpringBoot这是一个配置类 == 配置文件
public class MyConfig {
}
4、@Conditional?
条件装配：满足Conditional指定的条件，则进行组件注入(非常重要)
?引入了哪些场景这个场景的自动配置才会开启的关键注解
=====================测试条件装配==========================
@Configuration(proxyBeanMethods = false) //告诉SpringBoot这是一个配置类 == 配置文件
//@ConditionalOnBean(name = "tom")
//当有tom的Bean实例的时候这个类才会进行注入
@ConditionalOnMissingBean(name = "tom")
public class MyConfig {
/**
* Full:外部无论对配置类中的这个组件注册方法调用多少次获取的都是之前注册容器中的单实例对象
* @return
*/
@Bean //给容器中添加组件。以方法名作为组件的id。返回类型就是组件类型。返回的值，就是组件在容器中的实例
public User user01(){
User zhangsan = new User("zhangsan", 18);
//user组件依赖了Pet组件
zhangsan.setPet(tomcatPet());
return zhangsan;
}
@Bean("tom22")
public Pet tomcatPet(){
return new Pet("tomcat");
}
}
public static void main(String[] args) {
//1、返回我们IOC容器
ConfigurableApplicationContext run = SpringApplication.run(MainApplication.class, args);
//2、查看容器里面的组件
String[] names = run.getBeanDefinitionNames();
for (String name : names) {
System.out.println(name);
}
boolean tom = run.containsBean("tom");
System.out.println("容器中Tom组件："+tom);
boolean user01 = run.containsBean("user01");
System.out.println("容器中user01组件："+user01);
boolean tom22 = run.containsBean("tom22");
System.out.println("容器中tom22组件："+tom22);
}2.2、原生配置文件引入
1、@ImportResource?
======================beans.xml=========================
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">
<bean id="haha" class="com.atguigu.boot.bean.User">
<property name="name" value="zhangsan"></property>
<property name="age" value="18"></property>
</bean>
<bean id="hehe" class="com.atguigu.boot.bean.Pet">
<property name="name" value="tomcat"></property>
</bean>
</beans>@ImportResource("classpath:beans.xml")
public class MyConfig {}
======================测试=================
boolean haha = run.containsBean("haha");
boolean hehe = run.containsBean("hehe");
System.out.println("haha："+haha);//true
System.out.println("hehe："+hehe);//true2.3、配置绑定
如何使用Java读取到properties文件中的内容，以供随时使用；?
Properties properties = new Properties();
2 // 使用ClassLoader加载properties配置文件生成对应的输入流
3 InputStream in = PropertiesMain.class.getClassLoader().getResourceAsStream("config/config.properties");
4 // 使用properties对象加载输入流
5 properties.load(in);
6 //获取key对应的value值
7 properties.getProperty(String key);?1、@ConfigurationProperties
/**
* 只有在容器中的组件，才会拥有SpringBoot提供的强大功能（如@ConfigurationProperties）
*/
@Component
@ConfigurationProperties(prefix = "mycar")
public class Car {
private String brand;
private Integer price;
public String getBrand() {
return brand;
}
public void setBrand(String brand) {
this.brand = brand;
}
public Integer getPrice() {
return price;
}
public void setPrice(Integer price) {
this.price = price;
}
@Override
public String toString() {
return "Car{" +
"brand='" + brand + '\'' +
", price=" + price +
'}';
}
}?2、@EnableConfigurationProperties + @ConfigurationProperties
@EnableConfigurationProperties(Car.class)
//1、开启Car配置绑定功能
//2、把这个Car这个组件自动注册到容器中
public class MyConfig {
}3、自动配置原理入门
3.1、引导加载自动配置类
@SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan(excludeFilters = { @Filter(type = FilterType.CUSTOM, classes = TypeExcludeFilter.class),
@Filter(type = FilterType.CUSTOM, classes = AutoConfigurationExcludeFilter.class) })
public @interface SpringBootApplication{}1、@SpringBootConfiguration
@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Configuration
@Indexed
public @interface SpringBootConfiguration {
@AliasFor(
annotation = Configuration.class
)
boolean proxyBeanMethods() default true;
}@Configuration。代表当前是一个配置类
2、@ComponentScan
指定扫描哪些，Spring注解；
3、@EnableAutoConfiguration
@AutoConfigurationPackage
@Import(AutoConfigurationImportSelector.class)
public @interface EnableAutoConfiguration {}主要目的是加载一些默认配置和组件?
4、@AutoConfigurationPackage
自动配置包？指定了默认的包规则
@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@Import({Registrar.class})
public @interface AutoConfigurationPackage {
String[] basePackages() default {};
Class<?>[] basePackageClasses() default {};
}
static class Registrar implements ImportBeanDefinitionRegistrar, DeterminableImports {
Registrar() {
}
public void registerBeanDefinitions(AnnotationMetadata metadata, BeanDefinitionRegistry registry) {
AutoConfigurationPackages.register(registry, (String[])(new AutoConfigurationPackages.PackageImports(metadata)).getPackageNames().toArray(new String[0]));
}
public Set<Object> determineImports(AnnotationMetadata metadata) {
return Collections.singleton(new AutoConfigurationPackages.PackageImports(metadata));
}
}
利用Registrar给容器中导入一系列组件
//将指定的一个包下的所有组件导入进来？MainApplication 所在包下5、@Import(AutoConfigurationImportSelector.class)
1、利用getAutoConfigurationEntry(annotationMetadata);给容器中批量导入一些组件
2、调用List<String> configurations = getCandidateConfigurations(annotationMetadata, attributes)获取到所有需要导入到容器中的配置类
3、利用工厂加载 Map<String, List<String>> loadSpringFactories(@Nullable ClassLoader classLoader)；得到所有的组件
4、从META-INF/spring.factories位置来加载一个文件。
?? ?默认扫描我们当前系统里面所有META-INF/spring.factories位置的文件
? ? spring-boot-autoconfigure-2.3.4.RELEASE.jar包里面也有META-INF/spring.factories
? ??
# Initializers
org.springframework.context.ApplicationContextInitializer=\
org.springframework.boot.autoconfigure.SharedMetadataReaderFactoryContextInitializer,\
org.springframework.boot.autoconfigure.logging.ConditionEvaluationReportLoggingListener
# Application Listeners
org.springframework.context.ApplicationListener=\
org.springframework.boot.autoconfigure.BackgroundPreinitializer
# Environment Post Processors
org.springframework.boot.env.EnvironmentPostProcessor=\
org.springframework.boot.autoconfigure.integration.IntegrationPropertiesEnvironmentPostProcessor
# Auto Configuration Import Listeners
org.springframework.boot.autoconfigure.AutoConfigurationImportListener=\
org.springframework.boot.autoconfigure.condition.ConditionEvaluationReportAutoConfigurationImportListener
# Auto Configuration Import Filters
org.springframework.boot.autoconfigure.AutoConfigurationImportFilter=\
org.springframework.boot.autoconfigure.condition.OnBeanCondition,\
org.springframework.boot.autoconfigure.condition.OnClassCondition,\
org.springframework.boot.autoconfigure.condition.OnWebApplicationCondition
# Failure analyzers
org.springframework.boot.diagnostics.FailureAnalyzer=\
org.springframework.boot.autoconfigure.data.redis.RedisUrlSyntaxFailureAnalyzer,\
org.springframework.boot.autoconfigure.diagnostics.analyzer.NoSuchBeanDefinitionFailureAnalyzer,\
org.springframework.boot.autoconfigure.flyway.FlywayMigrationScriptMissingFailureAnalyzer,\
org.springframework.boot.autoconfigure.jdbc.DataSourceBeanCreationFailureAnalyzer,\
org.springframework.boot.autoconfigure.jdbc.HikariDriverConfigurationFailureAnalyzer,\
org.springframework.boot.autoconfigure.jooq.NoDslContextBeanFailureAnalyzer,\
org.springframework.boot.autoconfigure.r2dbc.ConnectionFactoryBeanCreationFailureAnalyzer,\
org.springframework.boot.autoconfigure.r2dbc.MissingR2dbcPoolDependencyFailureAnalyzer,\
org.springframework.boot.autoconfigure.r2dbc.MultipleConnectionPoolConfigurationsFailureAnalzyer,\
org.springframework.boot.autoconfigure.r2dbc.NoConnectionFactoryBeanFailureAnalyzer,\
org.springframework.boot.autoconfigure.session.NonUniqueSessionRepositoryFailureAnalyzer
# Template availability providers
org.springframework.boot.autoconfigure.template.TemplateAvailabilityProvider=\
org.springframework.boot.autoconfigure.freemarker.FreeMarkerTemplateAvailabilityProvider,\
org.springframework.boot.autoconfigure.mustache.MustacheTemplateAvailabilityProvider,\
org.springframework.boot.autoconfigure.groovy.template.GroovyTemplateAvailabilityProvider,\
org.springframework.boot.autoconfigure.thymeleaf.ThymeleafTemplateAvailabilityProvider,\
org.springframework.boot.autoconfigure.web.servlet.JspTemplateAvailabilityProvider
# DataSource initializer detectors
org.springframework.boot.sql.init.dependency.DatabaseInitializerDetector=\
org.springframework.boot.autoconfigure.flyway.FlywayMigrationInitializerDatabaseInitializerDetector
# Depends on database initialization detectors
org.springframework.boot.sql.init.dependency.DependsOnDatabaseInitializationDetector=\
org.springframework.boot.autoconfigure.batch.JobRepositoryDependsOnDatabaseInitializationDetector,\
org.springframework.boot.autoconfigure.quartz.SchedulerDependsOnDatabaseInitializationDetector,\
org.springframework.boot.autoconfigure.session.JdbcIndexedSessionRepositoryDependsOnDatabaseInitializationDetector
?3.2、按需开启自动配置项
虽然我们127个场景的所有自动配置启动的时候默认全部加载。xxxxAutoConfiguration
按照条件装配规则（@Conditional），最终会按需配置。
? @Bean
?? ??? ?@ConditionalOnBean(MultipartResolver.class) ?//容器中有这个类型组件
?? ??? ?@ConditionalOnMissingBean(name = DispatcherServlet.MULTIPART_RESOLVER_BEAN_NAME) //容器中没有这个名字 multipartResolver 的组件
?? ??? ?public MultipartResolver multipartResolver(MultipartResolver resolver) {
? ? ? ? ? ? //给@Bean标注的方法传入了对象参数，这个参数的值就会从容器中找。
? ? ? ? ? ? //SpringMVC multipartResolver。防止有些用户配置的文件上传解析器不符合规范
?? ??? ??? ?// Detect if the user has created a MultipartResolver but named it incorrectly
?? ??? ??? ?return resolver;
?? ??? ?}
给容器中加入了文件上传解析器；SpringBoot默认会在底层配好所有的组件。但是如果用户自己配置了以用户的优先?
总结
- SpringBoot先加载所有的自动配置类 xxxxxAutoConfiguration
- 每个自动配置类按照条件进行生效，默认都会绑定配置文件指定的值。xxxxProperties里面拿。xxxProperties和配置文件进行了绑定
- 生效的配置类就会给容器中装配很多组件
- 只要容器中有这些组件，相当于这些功能就有了
- 定制化配置
- 用户直接自己@Bean替换底层的组件
- 用户去看这个组件是获取的配置文件什么值就去修改。
xxxxxAutoConfiguration ---> 组件 ---> xxxxProperties里面拿值 ----> application.properties