文章目录
1. SpingBoot原理
- 配置优先级:Springboot项目当中属性配置的常见方式以及配置的优先级
- Bean的管理
- 剖析Springboot的底层原理
1. 1 配置优先级
SpringBoot项目当中支持的三类配置文件:
- application.properties
- application.yml
- application.yaml
在SpringBoot项目当中,要想配置一个属性,可以通过这三种方式当中的任意一种来配置都可以,那么如果项目中同时存在这三种配置文件,且都配置了同一个属性,如:Tomcat端口号,到底哪一份配置文件生效呢?
- application.properties
server.port=8081
- application.yml
server: port: 8083
- application.yaml
server: port: 8082
启动SpringBoot程序,测试下三个配置文件中哪个Tomcat端口号生效:
- properties、yaml、yml三种配置文件同时存在
properties、yaml、yml三种配置文件,优先级最高的是properties
- yaml、yml两种配置文件同时存在
配置文件优先级排名(从高到低):
- properties配置文件
- yml配置文件
- yaml配置文件
注意事项:虽然springboot支持多种格式配置文件,但是在项目开发时,推荐统一使用一种格式的配置。(yml是主流)
在SpringBoot项目当中除了以上3种配置文件外,SpringBoot为了增强程序的扩展性,除了支持配置文件的配置方式以外,还支持另外两种常见的配置方式:
Java系统属性配置 (格式: -Dkey=value)
-Dserver.port=9000
命令行参数 (格式:–key=value)
--server.port=10010
idea当中运行程序时,编辑启动程序的配置信息来指定Java系统属性和命令行参数。
重启服务,同时配置Tomcat端口(三种配置文件、系统属性、命令行参数),测试哪个Tomcat端口号生效:
删除命令行参数配置,重启SpringBoot服务:
优先级: 命令行参数 > 系统属性参数 > properties参数 > yml参数 > yaml参数
思考:如果项目已经打包上线了,这个时候如何来设置Java系统属性和命令行参数?
java -Dserver.port=9000 -jar XXXXX.jar --server.port=10010
下面演示打包程序运行时指定Java系统属性和命令行参数:
- 执行maven打包指令package,把项目打成jar文件
- 使用命令:java -jar 方式运行jar文件程序
项目打包:
运行jar程序:
同时设置Java系统属性和命令行参数
仅设置Java系统属性
注意事项:
- Springboot项目进行打包时,需要引入插件 spring-boot-maven-plugin (基于官网骨架创建项目,会自动添加该插件)
在SpringBoot项目当中,常见的属性配置方式有5种, 3种配置文件,加上2种外部属性的配置(Java系统属性、命令行参数)。通过以上的测试,可得出优先级(从低到高):
- application.yaml(忽略)
- application.yml
- application.properties
- java系统属性(-Dxxx=xxx)
- 命令行参数(–xxx=xxx)
1.2 Bean管理
通过Spring当中提供的注解@Component以及它的三个衍生注解(@Controller、@Service、@Repository)来声明IOC容器中的bean对象,为应用程序注入运行时所需要依赖的bean对象,也就是依赖注入DI。
IOC容器中Bean的其他使用细节,主要有以下三方面:
- 如何从IOC容器中手动的获取到bean对象
- bean的作用域配置
- 管理第三方的bean对象
1.2.1 获取Bean
默认情况下,SpringBoot项目在启动的时候会自动的创建IOC容器(也称为Spring容器),并且在启动的过程当中会自动的将bean对象都创建好,存放在IOC容器当中。应用程序在运行时需要依赖什么bean对象,就直接进行依赖注入就可以了。
而在Spring容器中提供了一些方法,可以主动从IOC容器中获取到bean对象,下面介绍3种常用方式:
根据name获取bean
Object getBean(String name)
根据类型获取bean
<T> T getBean(Class<T> requiredType)
根据name获取bean(带类型转换)
<T> T getBean(String name, Class<T> requiredType)
思考:要从IOC容器当中来获取到bean对象,需要先拿到IOC容器对象,怎么样才能拿到IOC容器呢?
- 想获取到IOC容器,直接将IOC容器对象注入进来就可以了
控制器:DeptController
@RestController @RequestMapping("/depts") public class DeptController { @Autowired private DeptService deptService; public DeptController(){ System.out.println("DeptController constructor ...."); } @GetMapping public Result list(){ List<Dept> deptList = deptService.list(); return Result.success(deptList); } @DeleteMapping("/{id}") public Result delete(@PathVariable Integer id) { deptService.delete(id); return Result.success(); } @PostMapping public Result save(@RequestBody Dept dept){ deptService.save(dept); return Result.success(); } }
业务实现类:DeptServiceImpl
@Slf4j @Service public class DeptServiceImpl implements DeptService { @Autowired private DeptMapper deptMapper; @Override public List<Dept> list() { List<Dept> deptList = deptMapper.list(); return deptList; } @Override public void delete(Integer id) { deptMapper.delete(id); } @Override public void save(Dept dept) { dept.setCreateTime(LocalDateTime.now()); dept.setUpdateTime(LocalDateTime.now()); deptMapper.save(dept); } }
Mapper接口:
@Mapper public interface DeptMapper { //查询全部部门数据 @Select("select * from dept") List<Dept> list(); //删除部门 @Delete("delete from dept where id = #{id}") void delete(Integer id); //新增部门 @Insert("insert into dept(name, create_time, update_time) values (#{name},#{createTime},#{updateTime})") void save(Dept dept); }
测试类:
@SpringBootTest class SpringbootWebConfig2ApplicationTests { @Autowired private ApplicationContext applicationContext; //IOC容器对象 //获取bean对象 @Test public void testGetBean(){ //根据bean的名称获取 DeptController bean1 = (DeptController) applicationContext.getBean("deptController"); System.out.println(bean1); //根据bean的类型获取 DeptController bean2 = applicationContext.getBean(DeptController.class); System.out.println(bean2); //根据bean的名称 及 类型获取 DeptController bean3 = applicationContext.getBean("deptController", DeptController.class); System.out.println(bean3); } }
程序运行后控制台日志:
输出的bean对象地址值是一样的,说明IOC容器当中的bean对象只有一个。(默认情况下,IOC中的bean对象是单例)
注意事项:
- 上述所说的 【Spring项目启动时,会把其中的bean都创建好】还会受到作用域及延迟初始化影响,这里主要针对于默认的单例非延迟加载的bean而言。
1.2.2 Bean作用域
如何设置bean对象为非单例呢?需要设置bean的作用域。
在Spring中支持五种作用域,后三种在web环境才生效:
作用域 说明 singleton 容器内同名称的bean只有一个实例(单例)(默认) prototype 每次使用该bean时会创建新的实例(非单例) request 每个请求范围内会创建新的实例(web环境中,了解) session 每个会话范围内会创建新的实例(web环境中,了解) application 每个应用范围内会创建新的实例(web环境中,了解)
- 可以借助Spring中的@Scope注解来进行配置bean的作用域
1). 测试一
- 控制器
//默认bean的作用域为:singleton (单例) @Lazy //延迟加载(第一次使用bean对象时,才会创建bean对象并交给ioc容器管理) @RestController @RequestMapping("/depts") public class DeptController { @Autowired private DeptService deptService; public DeptController(){ System.out.println("DeptController constructor ...."); } //省略其他代码... }
- 测试类
@SpringBootTest class SpringbootWebConfig2ApplicationTests { @Autowired private ApplicationContext applicationContext; //IOC容器对象 //bean的作用域 @Test public void testScope(){ for (int i = 0; i < 10; i++) { DeptController deptController = applicationContext.getBean(DeptController.class); System.out.println(deptController); } } }
重启SpringBoot服务,运行测试方法,查看控制台打印的日志:
注意事项:
- IOC容器中的bean默认使用的作用域:singleton (单例)
- 默认singleton的bean,在容器启动时被创建,可以使用@Lazy注解来延迟初始化(延迟到第一次使用时)
2). 测试二
修改控制器DeptController代码:
@Scope("prototype") //bean作用域为非单例 @Lazy //延迟加载 @RestController @RequestMapping("/depts") public class DeptController { @Autowired private DeptService deptService; public DeptController(){ System.out.println("DeptController constructor ...."); } //省略其他代码... }
重启SpringBoot服务,再次执行测试方法,查看控制台打印的日志:
注意事项:
- prototype的bean,每一次使用该bean的时候都会创建一个新的实例
- 实际开发当中,绝大部分的Bean是单例的,也就是说绝大部分Bean不需要配置scope属性
1.2.3 第三方Bean
在pom.xml文件中,引入dom4j:
<!--Dom4j--> <dependency> <groupId>org.dom4j</groupId> <artifactId>dom4j</artifactId> <version>2.1.3</version> </dependency>
dom4j就是第三方组织提供的。 dom4j中的SAXReader类就是第三方编写的。
当需要使用到SAXReader对象时,直接进行依赖注入是不是就可以了呢?
- 按照我们之前的做法,需要在SAXReader类上添加一个注解@Component(将当前类交给IOC容器管理)
结论:第三方提供的类是只读的。无法在第三方类上添加@Component注解或衍生注解。
如果要管理的bean对象来自于第三方(不是自定义的),是无法用@Component 及衍生注解声明bean的,就需要用到**@Bean**注解。
解决方案1:在启动类上添加@Bean标识的方法
@SpringBootApplication public class SpringbootWebConfig2Application { public static void main(String[] args) { SpringApplication.run(SpringbootWebConfig2Application.class, args); } //声明第三方bean @Bean //将当前方法的返回值对象交给IOC容器管理, 成为IOC容器bean public SAXReader saxReader(){ return new SAXReader(); } }
xml文件:
<?xml version="1.0" encoding="UTF-8"?> <emp> <name>Tom</name> <age>18</age> </emp>
测试类:
@SpringBootTest class SpringbootWebConfig2ApplicationTests { @Autowired private SAXReader saxReader; //第三方bean的管理 @Test public void testThirdBean() throws Exception { Document document = saxReader.read(this.getClass().getClassLoader().getResource("1.xml")); Element rootElement = document.getRootElement(); String name = rootElement.element("name").getText(); String age = rootElement.element("age").getText(); System.out.println(name + " : " + age); } //省略其他代码... }
重启SpringBoot服务,执行测试方法后,控制台输出日志:
Tom : 18
说明:以上在启动类中声明第三方Bean的作法,不建议使用(项目中要保证启动类的纯粹性)
解决方案2:在配置类中定义@Bean标识的方法
- 如果需要定义第三方Bean时, 通常会单独定义一个配置类
@Configuration //配置类 (在配置类当中对第三方bean进行集中的配置管理) public class CommonConfig { //声明第三方bean @Bean //将当前方法的返回值对象交给IOC容器管理, 成为IOC容器bean //通过@Bean注解的name/value属性指定bean名称, 如果未指定, 默认是方法名 public SAXReader reader(DeptService deptService){ System.out.println(deptService); return new SAXReader(); } }
注释掉SpringBoot启动类中创建第三方bean对象的代码,重启服务,执行测试方法,查看控制台日志:
Tom : 18
在方法上加上一个@Bean注解,Spring 容器在启动的时候,它会自动的调用这个方法,并将方法的返回值声明为Spring容器当中的Bean对象。
注意事项 :
通过@Bean注解的name或value属性可以声明bean的名称,如果不指定,默认bean的名称就是方法名。
如果第三方bean需要依赖其它bean对象,直接在bean定义方法中设置形参即可,容器会根据类型自动装配。
关于Bean只需要保持一个原则:
- 如果是在项目当中自己定义的类,想将这些类交给IOC容器管理,直接使用@Component以及它的衍生注解来声明就可以。
- 如果这个类它不是自己定义的,而是引入的第三方依赖当中提供的类,还想将这个类交给IOC容器管理。此时就需要在配置类中定义一个方法,在方法上加上一个@Bean注解,通过这种方式来声明第三方的bean对象。
1.3 SpringBoot原理
Spring是目前世界上最流行的Java框架,它可以帮助我们更加快速、更加容易的来构建Java项目。而在Spring家族当中提供了很多优秀的框架,而所有的框架都是基于一个基础框架的SpringFramework(也就是Spring框架)。如果直接基于Spring框架进行项目的开发,会比较繁琐。
这个繁琐主要体现在两个地方:
- 在pom.xml中依赖配置比较繁琐,在项目开发时,需要自己去找到对应的依赖,还需要找到依赖它所配套的依赖以及对应版本,否则就会出现版本冲突问题。
- 在使用Spring框架进行项目开发时,需要在Spring的配置文件中做大量的配置,这就造成Spring框架入门难度较大,学习成本较高。
基于Spring存在的问题,官方在Spring框架4.0版本之后,又推出了一个全新的框架:SpringBoot。
通过 SpringBoot来简化Spring框架的开发(是简化不是替代)。直接基于SpringBoot来构建Java项目,会让项目开发更加简单,更加快捷。
SpringBoot框架之所以使用起来更简单更快捷,是因为SpringBoot框架底层提供了两个非常重要的功能:一个是起步依赖,一个是自动配置。
通过SpringBoot所提供的起步依赖,就可以大大的简化pom文件当中依赖的配置,从而解决了Spring框架当中依赖配置繁琐的问题。
通过自动配置的功能就可以大大的简化框架在使用时bean的声明以及bean的配置。只需要引入程序开发时所需要的起步依赖,项目开发时所用到常见的配置都已经有了,直接使用就可以了。
1.3.1 起步依赖
假如没有使用SpringBoot,用的是Spring框架进行web程序的开发,此时就需要引入web程序开发所需要的一些依赖。
spring-webmvc依赖:这是Spring框架进行web程序开发所需要的依赖
servlet-api依赖:Servlet基础依赖
jackson-databind依赖:JSON处理工具包
如果要使用AOP,还需要引入aop依赖、aspect依赖
项目中所引入的这些依赖,还需要保证版本匹配,否则就可能会出现版本冲突问题。
如果使用了SpringBoot,就不需要像上面这么繁琐的引入依赖了。只需要引入一个依赖就可以了,那就是web开发的起步依赖:springboot-starter-web。
只需要引入一个web开发的起步依赖,web开发所需要的所有的依赖都有了,是因为Maven的依赖传递。
- 在SpringBoot提供的这些起步依赖当中,已提供了当前程序开发所需要的所有的常见依赖(官网地址:https://docs.spring.io/spring-boot/docs/2.7.7/reference/htmlsingle/#using.build-systems.starters)。
- 比如:springboot-starter-web,这是web开发的起步依赖,在web开发的起步依赖当中,就集成了web开发中常见的依赖:json、web、webmvc、tomcat等。只需要引入这一个起步依赖,其他的依赖都会自动的通过Maven的依赖传递进来。
结论:起步依赖的原理就是Maven的依赖传递。
1.3.2 自动配置
1.3.2.1 概述
SpringBoot的自动配置就是当Spring容器启动后,一些配置类、bean对象就自动存入到了IOC容器中,不需要手动去声明,从而简化了开发,省去了繁琐的配置操作。
比如:要进行事务管理、要进行AOP程序的开发,此时就不需要再去手动的声明这些bean对象了,直接使用就可以从而大大的简化程序的开发,省去了繁琐的配置操作。
下面打开idea,一起来看下自动配置的效果:
运行SpringBoot启动类
大家会看到有两个CommonConfig,在第一个CommonConfig类中定义了一个bean对象,bean对象的名字叫reader。
在第二个CommonConfig中它的bean名字叫commonConfig,为什么还会有这样一个bean对象呢?原因是在CommonConfig配置类上添加了一个注解@Configuration,而@Configuration底层就是@Component
所以配置类最终也是SpringIOC容器当中的一个bean对象
在IOC容器中除了自己定义的bean以外,还有很多配置类,这些配置类都是SpringBoot在启动的时候加载进来的配置类。这些配置类加载进来之后,它也会生成很多的bean对象。
比如:配置类GsonAutoConfiguration里面有一个bean,bean的名字叫gson,它的类型是Gson。
com.google.gson.Gson是谷歌包中提供的用来处理JSON格式数据的。
当想要使用这些配置类中生成的bean对象时,可以使用@Autowired就自动注入了:
import com.google.gson.Gson; import com.itheima.pojo.Result; import org.junit.jupiter.api.Test; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.boot.test.context.SpringBootTest; @SpringBootTest public class AutoConfigurationTests { @Autowired private Gson gson; @Test public void testJson(){ String json = gson.toJson(Result.success()); System.out.println(json); } }
添加断点,使用debug模式运行测试类程序:
问题:在当前项目中并没有声明谷歌提供的Gson这么一个bean对象,却可以通过@Autowired从Spring容器中注入bean对象,是因为SpringBoot项目在启动时通过自动配置完成了bean对象的创建。
1.3.2.2 常见方案
1.3.2.2.1 概述
其实分析自动配置原理就是来解析在SpringBoot项目中,在引入依赖之后是如何将依赖jar包当中所定义的配置类以及bean加载到SpringIOC容器中的。
1、在SpringBoot项目 spring-boot-web-config2 工程中,通过坐标引入yishooo-utils依赖
@Component public class TokenParser { public void parse(){ System.out.println("TokenParser ... parse ..."); } }
2、在测试类中,添加测试方法
@SpringBootTest public class AutoConfigurationTests { @Autowired private ApplicationContext applicationContext; @Test public void testTokenParse(){ System.out.println(applicationContext.getBean(TokenParser.class)); } //省略其他代码... }
3、执行测试方法
异常信息描述: 没有com.example.TokenParse类型的bean
说明:在Spring容器中没有找到com.example.TokenParse类型的bean对象
思考:引入进来的第三方依赖当中的bean以及配置类为什么没有生效?
- 原因:在类上添加@Component注解来声明bean对象时,还需要保证@Component注解能被Spring的组件扫描到。
- SpringBoot项目中的@SpringBootApplication注解,具有包扫描的作用,但是它只会扫描启动类所在的当前包以及子包。
- 当前包:com.yishooo, 第三方依赖中提供的包:com.example(扫描不到)
何解上述问题的2种办法:
- 方案1:@ComponentScan 组件扫描
- 方案2:@Import 导入(使用@Import导入的类会被Spring加载到IOC容器中)
1.3.2.2.2 方案一
@ComponentScan组件扫描
@SpringBootApplication @ComponentScan({"com.yishooo","com.example"}) //指定要扫描的包 public class SpringbootWebConfig2Application { public static void main(String[] args) { SpringApplication.run(SpringbootWebConfig2Application.class, args); } }
重新执行测试方法,控制台日志输出:
如果采用以上这种方式来完成自动配置,在进行项目开发时,当需要引入大量的第三方的依赖,就需要在启动类上配置N多要扫描的包,这种方式会很繁琐。而且这种大面积的扫描性能也比较低。
缺点:
- 使用繁琐
- 性能低
结论:SpringBoot中并没有采用以上这种方案。
1.3.2.2.3 方案二
@Import导入
- 导入形式主要有以下几种:
- 导入普通类
- 导入配置类
- 导入ImportSelector接口实现类
1). 使用@Import导入普通类:
@Import(TokenParser.class) //导入的类会被Spring加载到IOC容器中 @SpringBootApplication public class SpringbootWebConfig2Application { public static void main(String[] args) { SpringApplication.run(SpringbootWebConfig2Application.class, args); } }
重新执行测试方法,控制台日志输出:
2). 使用@Import导入配置类:
- 配置类
@Configuration public class HeaderConfig { @Bean public HeaderParser headerParser(){ return new HeaderParser(); } @Bean public HeaderGenerator headerGenerator(){ return new HeaderGenerator(); } }
- 启动类
@Import(HeaderConfig.class) //导入配置类 @SpringBootApplication public class SpringbootWebConfig2Application { public static void main(String[] args) { SpringApplication.run(SpringbootWebConfig2Application.class, args); } }
- 测试类
@SpringBootTest public class AutoConfigurationTests { @Autowired private ApplicationContext applicationContext; @Test public void testHeaderParser(){ System.out.println(applicationContext.getBean(HeaderParser.class)); } @Test public void testHeaderGenerator(){ System.out.println(applicationContext.getBean(HeaderGenerator.class)); } //省略其他代码... }
执行测试方法:
3). 使用@Import导入ImportSelector接口实现类:
- ImportSelector接口实现类
public class MyImportSelector implements ImportSelector { public String[] selectImports(AnnotationMetadata importingClassMetadata) { //返回值字符串数组(数组中封装了全限定名称的类) return new String[]{"com.example.HeaderConfig"}; } }
- 启动类
@Import(MyImportSelector.class) //导入ImportSelector接口实现类 @SpringBootApplication public class SpringbootWebConfig2Application { public static void main(String[] args) { SpringApplication.run(SpringbootWebConfig2Application.class, args); } }
执行测试方法:
使用@Import注解通过这三种方式都可以导入第三方依赖中所提供的bean或者是配置类。
如果基于以上方式完成自动配置,当要引入一个第三方依赖时,还要知道第三方依赖中有哪些配置类和哪些Bean对象。
要使用第三方依赖,依赖中到底有哪些bean和配置类,第三方依赖开发者自身最清楚。
结论:不用自己指定要导入哪些bean对象和配置类,让第三方依赖它自己来指定。
怎么让第三方依赖自己指定bean对象和配置类?
- 比较常见的方案就是第三方依赖给我们提供一个注解,这个注解一般都以@EnableXxxx开头的注解,注解中封装的就是@Import注解
4). 使用第三方依赖提供的 @EnableXxxxx注解
- 第三方依赖中提供的注解
@Retention(RetentionPolicy.RUNTIME) @Target(ElementType.TYPE) @Import(MyImportSelector.class)//指定要导入哪些bean对象或配置类 public @interface EnableHeaderConfig { }
- 在使用时只需在启动类上加上@EnableXxxxx注解即可
@EnableHeaderConfig //使用第三方依赖提供的Enable开头的注解 @SpringBootApplication public class SpringbootWebConfig2Application { public static void main(String[] args) { SpringApplication.run(SpringbootWebConfig2Application.class, args); } }
执行测试方法:
以上四种方式都可以完成导入操作,但是第4种方式会更方便更优雅,而这种方式也是SpringBoot当中所采用的方式。
1.3.2.3 原理分析
1.3.2.3.1 源码跟踪
源码跟踪技巧:
在跟踪框架源码的时候,一定要抓住关键点,找到核心流程。一定不要从头到尾一行代码去看,一个方法的去研究,一定要找到关键流程,抓住关键点,先在宏观上对整个流程或者整个原理有一个认识,有精力再去研究其中的细节。
要搞清楚SpringBoot的自动配置原理,要从SpringBoot启动类上使用的核心注解@SpringBootApplication开始分析:
在@SpringBootApplication注解中包含了:
- 元注解(不再解释)
- @SpringBootConfiguration
- @EnableAutoConfiguration
- @ComponentScan
@SpringBootConfiguration注解:
@SpringBootConfiguration注解上使用了@Configuration,表明SpringBoot启动类就是一个配置类。
@Indexed注解,是用来加速应用启动的(不用关心)。
@ComponentScan注解:
@ComponentScan注解是用来进行组件扫描的,扫描启动类所在的包及其子包下所有被@Component及其衍生注解声明的类。
SpringBoot启动类,之所以具备扫描包功能,就是因为包含了@ComponentScan注解。
@EnableAutoConfiguration注解(自动配置核心注解):
使用@Import注解,导入了实现ImportSelector接口的实现类。
AutoConfigurationImportSelector类是ImportSelector接口的实现类。
AutoConfigurationImportSelector类中重写了ImportSelector接口的selectImports()方法:
selectImports()方法底层调用getAutoConfigurationEntry()方法,获取可自动配置的配置类信息集合。
getAutoConfigurationEntry()方法通过调用getCandidateConfigurations(annotationMetadata, attributes)方法获取在配置文件中配置的所有自动配置类的集合。
getCandidateConfigurations方法的功能:
获取所有基于META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports文件、META-INF/spring.factories文件中配置类的集合。
这两个文件通常在引入的起步依赖中
前面演示自动配置的时候,直接在测试类当中注入了一个叫gson的bean对象,进行JSON格式转换。虽然没有配置bean对象,但是可以直接注入使用。原因就是因为在自动配置类当中做了自动配置。在META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports配置文件中指定了第三方依赖Gson的配置类:GsonAutoConfiguration
第三方依赖中提供的GsonAutoConfiguration类:
在GsonAutoConfiguration类上,添加了注解@AutoConfiguration,通过查看源码,可以明确:GsonAutoConfiguration类是一个配置。
自动配置原理就是在配置类中定义一个@Bean标识的方法,而Spring会自动调用配置类中使用@Bean标识的方法,并把方法的返回值注册到IOC容器中。
自动配置源码小结
自动配置原理源码入口就是@SpringBootApplication注解,在这个注解中封装了3个注解,分别是:
- @SpringBootConfiguration
- 声明当前类是一个配置类
- @ComponentScan
- 进行组件扫描(SpringBoot中默认扫描的是启动类所在的当前包及其子包)
- @EnableAutoConfiguration
- 封装了@Import注解(Import注解中指定了一个ImportSelector接口的实现类)
- 在实现类重写的selectImports()方法,读取当前项目下所有依赖jar包中META-INF/spring.factories、META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports两个文件里面定义的配置类(配置类中定义了@Bean注解标识的方法)。
当SpringBoot程序启动时,就会加载配置文件当中所定义的配置类,并将这些配置类信息(类的全限定名)封装到String类型的数组中,最终通过@Import注解将这些配置类全部加载到Spring的IOC容器中,交给IOC容器管理。
在META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports文件中定义的配置类非常多,而且每个配置类中又可以定义很多的bean,这些bean并不是都会注册到Spring的IOC容器中。在声明bean对象时,上面有加一个以@Conditional开头的注解,这种注解的作用就是按照条件进行装配,只有满足条件之后,才会将bean注册到Spring的IOC容器中。
1.3.2.3.2 @Conditional
@Conditional注解:
- 作用:按照一定的条件进行判断,在满足给定条件后才会注册对应的bean对象到Spring的IOC容器中。
- 位置:方法、类
- @Conditional本身是一个父注解,派生出大量的子注解:
- @ConditionalOnClass:判断环境中有对应字节码文件,才注册bean到IOC容器。
- @ConditionalOnMissingBean:判断环境中没有对应的bean(类型或名称),才注册bean到IOC容器。
- @ConditionalOnProperty:判断配置文件中有对应属性和值,才注册bean到IOC容器。
下面通过代码来演示下Conditional注解的使用:
- @ConditionalOnClass注解
@Configuration public class HeaderConfig { @Bean @ConditionalOnClass(name="io.jsonwebtoken.Jwts")//环境中存在指定的这个类,才会将该bean加入IOC容器 public HeaderParser headerParser(){ return new HeaderParser(); } //省略其他代码... }
- pom.xml
<!--JWT令牌--> <dependency> <groupId>io.jsonwebtoken</groupId> <artifactId>jjwt</artifactId> <version>0.9.1</version> </dependency>
- 测试类
@SpringBootTest public class AutoConfigurationTests { @Autowired private ApplicationContext applicationContext; @Test public void testHeaderParser(){ System.out.println(applicationContext.getBean(HeaderParser.class)); } //省略其他代码... }
执行testHeaderParser()测试方法:
因为io.jsonwebtoken.Jwts字节码文件在启动SpringBoot程序时已存在,所以创建HeaderParser对象并注册到IOC容器中。
- @ConditionalOnMissingBean注解
@Configuration public class HeaderConfig { @Bean @ConditionalOnMissingBean //不存在该类型的bean,才会将该bean加入IOC容器 public HeaderParser headerParser(){ return new HeaderParser(); } //省略其他代码... }
执行testHeaderParser()测试方法:
SpringBoot在调用@Bean标识的headerParser()前,IOC容器中是没有HeaderParser类型的bean,所以HeaderParser对象正常创建,并注册到IOC容器中。
再次修改@ConditionalOnMissingBean注解:
@Configuration public class HeaderConfig { @Bean @ConditionalOnMissingBean(name="deptController2")//不存在指定名称的bean,才会将该bean加入IOC容器 public HeaderParser headerParser(){ return new HeaderParser(); } //省略其他代码... }
执行testHeaderParser()测试方法:
因为在SpringBoot环境中不存在名字叫deptController2的bean对象,所以创建HeaderParser对象并注册到IOC容器中。
再次修改@ConditionalOnMissingBean注解:
@Configuration public class HeaderConfig { @Bean @ConditionalOnMissingBean(HeaderConfig.class)//不存在指定类型的bean,才会将bean加入IOC容器 public HeaderParser headerParser(){ return new HeaderParser(); } //省略其他代码... }
@SpringBootTest public class AutoConfigurationTests { @Autowired private ApplicationContext applicationContext; @Test public void testHeaderParser(){ System.out.println(applicationContext.getBean(HeaderParser.class)); } //省略其他代码... }
执行testHeaderParser()测试方法:
因为HeaderConfig类中添加@Configuration注解,而@Configuration注解中包含了@Component,所以SpringBoot启动时会创建HeaderConfig类对象,并注册到IOC容器中。
当IOC容器中有HeaderConfig类型的bean存在时,不会把创建HeaderParser对象注册到IOC容器中。而IOC容器中没有HeaderParser类型的对象时,通过getBean(HeaderParser.class)方法获取bean对象时,引发异常:NoSuchBeanDefinitionException。
- @ConditionalOnProperty注解(这个注解和配置文件当中配置的属性有关系)
先在application.yml配置文件中添加如下的键值对:
name: yishooo
在声明bean的时候就可以指定一个条件@ConditionalOnProperty
@Configuration public class HeaderConfig { @Bean @ConditionalOnProperty(name ="name",havingValue = "yishooo")//配置文件中存在指定属性名与值,才会将bean加入IOC容器 public HeaderParser headerParser(){ return new HeaderParser(); } @Bean public HeaderGenerator headerGenerator(){ return new HeaderGenerator(); } }
执行testHeaderParser()测试方法:
修改@ConditionalOnProperty注解: havingValue的值修改为"itheima2"
@Bean @ConditionalOnProperty(name ="name",havingValue = "yishooo2")//配置文件中存在指定属性名与值,才会将bean加入IOC容器 public HeaderParser headerParser(){ return new HeaderParser(); }
再次执行testHeaderParser()测试方法:
因为application.yml配置文件中,不存在: name: yishooo2,所以HeaderParser对象在IOC容器中不存在。
之前SpringBoot源码时提到的一个配置类:GsonAutoConfiguration
自动配置原理:
自动配置的核心就在@SpringBootApplication注解上,SpringBootApplication这个注解底层包含了3个注解,分别是:
@SpringBootConfiguration
@ComponentScan
@EnableAutoConfiguration
@EnableAutoConfiguration这个注解才是自动配置的核心。
- 它封装了一个@Import注解,Import注解里面指定了一个ImportSelector接口的实现类。
- 在这个实现类中,重写了ImportSelector接口中的selectImports()方法。
- 而selectImports()方法中会去读取两份配置文件,并将配置文件中定义的配置类做为selectImports()方法的返回值返回,返回值代表的就是需要将哪些类交给Spring的IOC容器进行管理。
- 那么所有自动配置类的中声明的bean都会加载到Spring的IOC容器中吗? 其实并不会,因为这些配置类中在声明bean时,通常都会添加@Conditional开头的注解,这个注解就是进行条件装配。而Spring会根据Conditional注解有选择性的进行bean的创建。
- @Enable 开头的注解底层,它就封装了一个注解 import 注解,它里面指定了一个类,是 ImportSelector 接口的实现类。在实现类当中,我们需要去实现 ImportSelector 接口当中的一个方法 selectImports 这个方法。这个方法的返回值代表的就是我需要将哪些类交给 spring 的 IOC容器进行管理。
- 此时它会去读取两份配置文件,一份儿是 spring.factories,另外一份儿是 autoConfiguration.imports。而在 autoConfiguration.imports 这份儿文件当中,它就会去配置大量的自动配置的类。
- 而前面我们也提到过这些所有的自动配置类当中,所有的 bean都会加载到 spring 的 IOC 容器当中吗?其实并不会,因为这些配置类当中,在声明 bean 的时候,通常会加上这么一类@Conditional 开头的注解。这个注解就是进行条件装配。所以SpringBoot非常的智能,它会根据 @Conditional 注解来进行条件装配。只有条件成立,它才会声明这个bean,才会将这个 bean 交给 IOC 容器管理。