Spring Boot 自动配置原理

最新推荐文章于 2024-06-11 15:08:32 发布
最新推荐文章于 2024-06-11 15:08:32 发布
阅读量180 收藏
点赞数 1
分类专栏： Spring boot 文章标签： spring boot java
原文链接：https://www.yuque.com/atguigu/springboot/qb7hy2
版权

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>

 2.spring-boot-dependencies里几乎声明了所有开发中常用的依赖的版本号,自动版本仲裁机制

    开发导入starter场景启动器(starter会自动帮我们引入了某模块开发需要的相关jar包)

    见到很多 spring-boot-starter-* ： *就某种场景

     只要引入starter，这个场景的所有常规需要的依赖我们都自动引入

3、SpringBoot所支持的场景地址:

   https://docs.spring.io/spring-boot/docs/current/reference/html/using-spring-boot.html#using-boot-starter
4、见到的 *-spring-boot-starter： 第三方为我们提供的简化开发的场景启动器,,自己定义的starter不能以spring-boot命名。

5、所有场景启动器最底层的依赖             

<dependency>

 <groupId>org.springframework.boot</groupId>

 <artifactId>spring-boot-starter</artifactId>

 <version>2.3.4.RELEASE</version>

 <scope>compile</scope>

</dependency>

6.无需关注版本号，自动版本仲裁

  1. 、引入依赖默认都可以不写版本
  2. 、引入非版本仲裁的jar，要写版本号。

   7.可以修改默认版本号

  1. 查看spring-boot-dependencies里面规定当前依赖的版本 用的 key。
  2. 在当前项目里面重写配置

 <properties>

 <mysql.version>5.1.43</mysql.version>

 </properties>

 

 

1.2、自动配置

  • 自动配好Tomcat

  • 引入Tomcat依赖。

  • 配置Tomcat

<dependency>

 <groupId>org.springframework.boot</groupId>

 <artifactId>spring-boot-starter-tomcat</artifactId>

 <version>2.3.4.RELEASE</version>

 <scope>compile</scope>

 </dependency>

  • 自动配好SpringMVC

  • 引入SpringMVC全套组件

  • 自动配好SpringMVC常用组件（功能）

  • 自动配好Web常见功能，如:dispatcherServlet用来拦截所有请求,characterEncodingFilter用来解决乱码问题,multipartResolver用来上传文件,SpringBoot帮我们配置好了所有web开发的常见场景

 

 

    默认的包结构

  • 主程序所在包及其下面的所有子包里面的组件都会被默认扫描进来

  • 无需以前的包扫描配置

  • 想要改变扫描路径，@SpringBootApplication(scanBasePackages="com.atguigu")

  • 或者@ComponentScan 指定扫描路径

 @SpringBootApplication

等同于

@SpringBootConfiguration

@EnableAutoConfiguration

@ComponentScan("com.atguigu.boot")

 

  • 各种配置拥有默认值

    • 默认配置最终都是映射到某个类上，如：MultipartProperties

  • 配置文件的值最终会绑定每个类上，这个类会在容器中创建对象

  • 按需加载所有自动配置项

  • 非常多的starter

  • 引入了哪些场景这个场景的自动配置才会开启

  • SpringBoot所有的自动配置功能都在 spring-boot-autoconfigure 包里面

 

2、容器功能

2.1、组件添加

1、@Configuration

  • 基本使用

  • Full模式与Lite模式

  • 示例

  • 最佳实战

  • 配置 类组件之间无依赖关系用Lite模式加速容器启动过程，减少判断

  • 配置类组件之间有依赖关系，方法会被调用得到之前单实例组件，用Full模式

######################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.atguigu.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));

 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);

 User user01 = run.getBean("user01", User.class);

 Pet tom = run.getBean("tom", Pet.class);

 System.out.println("用户的宠物："+(user01.getPet() == tom));

 }

}

2、@ComponentScan、@Import

@Import({User.class,DBHelper.class})

//给容器中自动创建出这两个类型的组件、默认组件的名字就是全类名

@Import({User.class, DBHelper.class})

@Configuration(proxyBeanMethods = false) //告诉SpringBoot这是一个配置类 == 配置文件

public class MyConfig {}

 

@Import 高级用法： https://www.bilibili.com/video/BV1gW411W7wy?p=8

3、@Conditional

条件装配：满足Conditional指定的条件，则进行组件注入

 

===============测试条件装配==========================

@Configuration(proxyBeanMethods = false) //告诉SpringBoot这是一个配置类 == 配置文件

//@ConditionalOnBean(name = "tom")

@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);//true

 

2.3、配置绑定

如何使用Java读取到properties文件中的内容，并且把它封装到JavaBean中，以供随时使用；

public class getProperties {
 public static void main(String[] args) throws FileNotFoundException, IOException {
 Properties pps = new Properties();
 pps.load(new FileInputStream("a.properties"));
 Enumeration enum1 = pps.propertyNames();//得到配置文件的名字
 while(enum1.hasMoreElements()) {
 String strKey = (String) enum1.nextElement();
 String strValue = pps.getProperty(strKey);
 System.out.println(strKey + "=" + strValue);
 //封装到JavaBean。
 }
}
 }

1、@ConfigurationProperties

/*
 * 只有在容器中的组件，才会拥有SpringBoot提供的强大功能
 */
@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

3、@Component + @ConfigurationProperties

@EnableConfigurationProperties(Car.class)//开启属性绑定功能
//1、开启Car配置绑定功能
//2、把这个Car这个组件自动注册到容器中,这个的主要作用是引用第三方包的时候,你无法在代码里用ConfigurationProperties,就可以直接把类引进来标记
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

@Configuration。代表当前是一个配置类

 

2、@ComponentScan

指定扫描哪些包；

 

3、@EnableAutoConfiguration

@AutoConfigurationPackage

@Import(AutoConfigurationImportSelector.class)

public @interface EnableAutoConfiguration {}

 

1、@AutoConfigurationPackage

自动配置包？指定了默认的包规则

@Import(AutoConfigurationPackages.Registrar.class) //给容器中导入一个组件

public @interface AutoConfigurationPackage {}

//利用Registrar给容器中导入一系列组件,批量注册

//将指定的一个包下的所有组件导入进来？MainApplication 所在包下。

 

2、@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位置来加载一个文件。

5 默认扫描我们当前系统里面所有META-INF/spring.factories位置的文件

6 spring-boot-autoconfigure-2.3.4.RELEASE.jar包里面也有META-INF/spring.factories

 

 

3.2、按需开启自动配置项

1虽然我们127个场景的所有自动配置启动的时候默认全部加载。xxxxAutoConfiguration

2按照条件装配规则（@Conditional），最终会按需配置。

 

3.3、修改默认配置

@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默认会在底层配好所有的组件。但是如果用户自己配置了以用户的优先

@Bean

 @ConditionalOnMissingBean

 public CharacterEncodingFilter characterEncodingFilter() {

 }

 

总结：

  • SpringBoot先加载所有的自动配置类  xxxxxAutoConfiguration

  • 每个自动配置类按照条件进行生效，默认都会绑定配置文件指定的值。xxxxProperties里面拿。xxxProperties和配置文件进行了绑定

  • 生效的配置类就会给容器中装配很多组件

  • 只要容器中有这些组件，相当于这些功能就有了

  • 定制化配置

  • 用户直接自己@Bean替换底层的组件

  • 用户去看这个组件是获取的配置文件什么值就去修改。

      xxxxxAutoConfiguration ---> 组件  ---> xxxxProperties里面拿值  ----> application.properties

 

3.4、最佳实践

4、开发小技巧

4.1、Lombok

简化JavaBean开发

<dependency><groupId>org.projectlombok</groupId>

<artifactId>lombok</artifactId></dependency>

idea中搜索安装lombok插件

============================简化JavaBean开发============================

@NoArgsConstructor //无参构造器
//@AllArgsConstructor //全参构造器
@Data//lombok的方法,帮我们生成已有属性的get,set方法
@ToString //编译的时候给我们生成toString方法
@EqualsAndHashCode
public class User {
private String name;
private Integer age;
private Pet pet;
public User(String name,Integer age){//自定义构造器
this.name = name;
this.age = age;
}
}

================================简化日志开发===================================

@Slf4j //注入日志类
@RestController
public class HelloController {
@RequestMapping("/hello")
public String handle01(@RequestParam("name") String name){
log.info("请求进来了....");
return "Hello, Spring Boot 2!"+"你好："+name;
}
}

4.2、dev-tools

 <dependency>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-devtools</artifactId>
 <optional>true</optional>
 </dependency>

项目或者页面修改以后：Ctrl+F9可以实时生效

4.3、Spring Initailizr（项目初始化向导）

1、选择我们需要的开发场景

 

 

1、自动依赖引入

 

 

2、自动创建项目结构

 

 

3、自动编写好主配置类

 

 

黄四方
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Spring Boot面试杀手锏————自动配置原理
Morty的技术乐园
11-07 19万+
引言 不论在工作中，亦或是求职面试，Spring Boot已经成为我们必知必会的技能项。除了某些老旧的政府项目或金融项目持有观望态度外，如今的各行各业都在飞速的拥抱这个已经不是很新的Spring启动框架。 当然，作为Spring Boot的精髓，自动配置原理的工作过程往往只有在“面试”的时候才能用得上，但是如果在工作中你能够深入的理解Spring Boot的自动配置原理，将无往不利。 Spr...
Spring Boot自动配置原理
洛卡JAVA架构师每日分享Java架构师知识
05-31 2438
我们知道，Spring Boot 项目创建完成后，即使不进行任何的配置，也能够顺利地运行，这都要归功于 Spring Boot 的自动化配置。 Spring Boot 默认使用 application.properties 或 application.yml 作为其全局配置文件，我们可以在该配置文件中对各种自动配置属性（server.port、logging.level.* 、spring.config.active.no-profile 等等）进行修改，并使之生效，那么您有没有想过这些属性是否有据可依呢？
spring-boot-autoconfigure-2.0.6.RELEASE-API文档-中文版.zip
04-27
赠送jar包：spring-boot-autoconfigure-2.0.6.RELEASE.jar； 赠送原API文档：spring-boot-autoconfigure-2.0.6.RELEASE-javadoc.jar； 赠送源代码：spring-boot-autoconfigure-2.0.6.RELEASE-sources.jar； 赠送Maven依赖信息文件：spring-boot-autoconfigure-2.0.6.RELEASE.pom； 包含翻译后的API文档：spring-boot-autoconfigure-2.0.6.RELEASE-javadoc-API文档-中文(简体)版.zip； Maven坐标：org.springframework.boot:spring-boot-autoconfigure:2.0.6.RELEASE； 标签：spring、autoconfigure、springframework、boot、jar包、java、API文档、中文版； 使用方法：解压翻译后的API文档，用浏览器打开“index.html”文件，即可纵览文档内容。 人
03、了解自动配置原理笔记
狼魂之力
12-24 833
1、SpringBoot特点 1.1、依赖管理 父项目做依赖管理 依赖管理 <parent> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-parent</artifactId> <version>2.3.4.RELEASE</version> </par
springboot-自动配置
最新发布
qq_44895567的博客
06-11 1804
根据条件注解（如 @ConditionalOnClass、@ConditionalOnMissingBean 等），决定是否加载对应的配置类或 Bean。：在主类上添加 @SpringBootApplication 注解，该注解包含 @EnableAutoConfiguration，开启自动配置功能。@ConditionalOnProperty：当指定的配置属性存在并符合预期时，才会实例化相应的 Bean。@ConditionalOnClass：当类路径上存在指定的类时，才会实例化相应的 Bean。
Spring Boot#AutoConfigure
weixin_33907511的博客
04-09 220
2019独角兽企业重金招聘Python工程师标准>>> ...
03-SpringBoot 自动配置
鸣鼓ming的博客
06-08 341
SpringBoot通过场景启动器, 帮我们自动配置许多组件 自动配好Tomcat自动配好SpringMVC自动配好Web常见功能，如：字符编码问题我们在主类里打印我们的组件看看 MainApplication 如下图, HelloController在启动类MainApplication的子包下, 所以能被自动扫描 而TestController不在启动类MainApplication所在包及其下面的所有子包里面, 所以不能被自动扫描, 这时就需要手动填写配置改变扫描路径 SpringBoot所有的自动配
Spring Boot 入门 - 进阶篇（7）- 自动配置(AutoConfigure)
mark's technic world
10-12 4084
自动配置是Spring Boot的最大亮点，完美的展示了CoC约定由于配置。Spring Boot能自动配置Spring各种子项目（Spring MVC, Spring Security, Spring Data, Spring Cloud, Spring Integration, Spring Batch等）以及第三方开源框架所需要定义的各种Bean。  Spring Boot内部定义了各
spring boot 自动配置原理
03-16
Spring Boot自动配置原理是基于条件注解和Spring Boot Starter机制实现的。Spring Boot会根据classpath中的jar包、类、属性等信息，自动推断出应用程序所需的配置，并自动配置Spring应用程序上下文。同时，Spring ...
Spring Boot 中的自动配置（autoconfigure）
????
01-25 2293
详细的讲解了Spring Boot 自动配置的原理以及其中使用到的主要注解和类
SpringBoot autoconfigure
专注Java（全栈）应用开发，求知若渴，虚心若愚，talk is cheap, show me the code.
09-28 631
1、通过class标注@configuration，并基于@ConditionalOnClass和OnMissingBean等@Conditional注解的条件过滤，保证springboot满足一定条件下，才会将bean自动注入IOC容器。2、要使用自动配置，首先要添加@EnableAutoConfiguration注解，springboot通过该注解使用给@import注解完成导入配置的功能，配置在META-INFO/spring.factories中定义。消息队列有:jms，amqp，kafka。
SpringBoot学习笔记——尚硅谷
03-21
SpringBoot学习笔记 尚硅谷 SpringBoot学习笔记 尚硅谷
尚硅谷springboot核心笔记
07-19
尚硅谷springboot核心笔记发十分全面,讲解的也很清晰,提供给需要的开发人员
SpringBoot：模块探究之spring-boot-autoconfigure
栗筝i的博客
12-14 7374
顾名思义，Autoconfigure 就是自动配置的意思，SpringBoot 通过 spring-boot-autoconfigure 体现了 “约定优于配置” 这一设计原则！spring-boot-autoconfigure 也是 SpringBoot 最重要的模块之一！ SpringBoot 则可以依据 classpath 里面的依赖内容来自动配置 Bean 到 IOC 容器，Auto-configuration 会尝试推断哪些 Beans 是用户可能会需要的。比如如果HSQLDB 包在当前 cla
SpringBoot自动化配置之二：自动配置(AutoConfigure)原理、EnableAutoConfiguration、condition...
weixin_30451709的博客
03-20 354
　　自动配置绝对算得上是Spring Boot的最大亮点，完美的展示了CoC约定优于配置；Spring Boot能自动配置Spring各种子项目（Spring MVC, Spring Security, Spring Data, Spring Cloud, Spring Integration, Spring Batch等）以及第三方开源框架所需要定义的各种Bean。Spring Boot...
springboot
weixin_42592613的博客
10-29 237
换banner.txt 在resources下新建banner.txt，重启即可 热部署 在新建项目的时候 或者在pom文件中添加依赖 <dependency> //热部署 <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-devtools</artifactId> <scop
spring-boot-starter-data-redis 和 spring-boot-autoconfigure版本依赖冲突
qq_36746807的博客
06-02 862
需要更改spring-data-commons的版本。
SpringBoot2学习笔记
benben044的专栏
08-01 751
springboot学习的教程
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值