文章目录
二、依赖管理与自动配置
2.1 父项目做依赖管理
父项目里面会声明非常多的依赖,子项目只要继承了这个父项目,子项目以后写依赖,就不需要版本号了。我们这个父项目是2.3.4版本,我们子项目写依赖,都是不需要加版本号的。
比如以后我们想要引入mysql-connector
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
</dependency>
几乎声明了所有开发中常用的依赖的版本号,自动仲裁机制。
如果不想用它给的这个版本,而是想自定义版本:
我们写一个来声明我们的mysql版本,把我们满意的版本写进去
<properties>
<mysql.version>5.1.43</mysql.version>
</properties>
2.2 各种场景启动器
我们现在可以看到,我们开发一个web应用,无需关心到底要导哪些包,我们只需要导入一个
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
未来我们在SpringBoot里会见到非常多的以spring-boot-starter-*
命名的东西。“*”代表某种场景。
我们只需要引入这个starter,这个场景下我们常规所需要的依赖,都会自动引入。
几乎我们常用的开发场景,SpringBoot都有抽取。
当然,也有第三方starter,也就是如果SpringBoot给你提供的这些场景还不能满足你的开发,你自己可以自定义一些starter。
所有场景启动器最底层的依赖:
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter</artifactId>
<version>2.3.4.RELEASE</version>
<scope>compile</scope>
</dependency>
这是SpringBoot自动配置的核心依赖。
2.3 自动配置
-
自动配好Tomcat
- 引入Tomcat依赖
- 配置Tomcat
-
自动配好SpringMVC
- 引入SpringMVC全套组件
- 自动配好SpringMVC常用组件(功能)
-
自动配好Web常见功能,如:字符编码问题
- SpringBoot帮我们配置好了所有web开发的常见场景
-
默认的包结构
-
我们以前在整合的时候,我们得指定一些base-package=“com.cff.springwork”,包扫描,来指定一些规则。但是我们没有配任何的包扫描,但是我们写的一些例如controller组件,它就能发现。官方文档中说了,这是因为构造我们的代码有一个默认的包扫描规则,主程序所在的包及其下面的所有子包,里面的组件都会被默认扫描进来。这就解释了为什么连包扫描都不用配,我们的controller就都能进来。但是,如果在主程序所在的包的外面,就不行了。(新建一个controller文件夹,把控制类放到文件夹里,只是起到一个目录分类的作用,当然你把controller.java直接和主程序并列放置也是可以的,因为都是在同一目录下)
-
如果确实想让同一目录外面的也能生效(主程序在com.wyl.boot目录下),我们可以在主程序类上面的注解里添加
@SpringBootApplication(scanBasePackages="com.wyl")
,这样的话,改变扫描路径,也相当于使包扫描的范围扩大了一点。 -
除了这个方法,还可以添加一个包扫描的注解,@ComponentScan指定扫描路径,也是一样的效果(这三行等于原来的一行):
//@SpringBootApplication @SpringBootConfiguration @EnableAutoConfiguration @ComponentScan("com.wyl")
-
-
各种配置拥有默认值
- 默认配置最终都是映射到MutiPartProperties
- 配置文件的值最终会绑定到某个类上,这个类会在容器中创建对象
-
按需加载所有自动配置项
- 非常多的starter
- 引入了哪些场景,这个场景的自动配置才会开启
- SpringBoot所有的自动配置功能都在 spring-boot-autoconfigure 包里面
三、容器功能
3.1 组件添加@Configuration和@Bean
我们原来在Spring开发的时候,例如在com.wyl.boot.bean目录下创建了两个组件:Pet和User:
public class Pet {
private String name;
public Pet() {
}
public Pet(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return "Pet{" +
"name='" + name + '\'' +
'}';
}
}
public class User {
private String name;
private Integer age;
public User() {
}
public User(String name, Integer age) {
this.name = name;
this.age = age;
}
public void setName(String name) {
this.name = name;
}
public void setAge(Integer age) {
this.age = age;
}
public String getName() {
return name;
}
public Integer getAge() {
return age;
}
@Override
public String toString() {
return "User{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
如果想要把这两个组件添加到容器中,需要先在resources目录下创建一个Spring的配置文件beans.xml
,然后使用标签进行创建:
<bean id="user01" class="com.wyl.boot.bean.User">
<property name="name" value="zhangsan"></property>
<property name="age" value="18"></property>
</bean>
<bean id="cat" class="com.wyl.boot.bean.Pet">
<property name="name" value="Tom"></property>
</bean>
现在我们给容器中注册了一个User组件和一个Pet组件,这是我们以前Spring中用xml配置的方式。现在我们SpringBoot不用写这些xml文件,也有配置的办法。
@Configuration这个注解就是配置的意思。我们可以来编写一个类,这个类放在config文件夹下,比如就叫MyConfig,然后在这个类上表上这个注解
@Configuration
public class MyConfig {
}
我们创建一个类就相当于创建了一个文件,然后给这个类说明上@Configuration,就相当于这个类就是配置文件。@Configuration就是告诉SpringBoot这是一个配置类,相当于beans.xml配置文件。
在配置类里面,我们就不能写标签了,我们要写方法:
public User user01(){
return new User("zhangsan",18);
}
直接获取一个User对象(根据有参构造器)
然后,我们不用标签了,我们用@Bean注解:
@Bean
public User user01(){
return new User("zhangsan",18);
}
@Bean注解,就是以方法名作为组件的id。返回类型就是组件类型。返回的对象/值就是在容器中的实例。
于是,我们可以看到,我们的容器中就注册了这两个组件。
@Configuration
public class MyConfig {
@Bean
public User user01(){
return new User("zhangsan",18);
}
@Bean
public Pet catPet(){
return new Pet("Tom");
}
}
组件的名字默认是方法名,如果你想给它取一个自定义的名字,你也可以在@Bean标签中给它定义一个名字:
@Bean("cat")
public Pet catPet(){
return new Pet("Tom");
}
我们给容器中注册的这两个组件,它默认是单实例的,就是无论从容器中获取多少次,都是一样的。
我们可以在主程序中获取组件看看:
@SpringBootApplication
public class MainApplication {
public static void main(String[] args) {
//返回我们的IOC容器
ConfigurableApplicationContext run = SpringApplication.run(MainApplication.class, args);
//从容器中获取组件
Pet cat01 = run.getBean("cat", Pet.class);
Pet cat02 = run.getBean("cat", Pet.class);
System.out.println("组件" + (cat01 == cat02)); //输出结果:组件true
}
}
值得注意的是,我们这个@Configuration标注的这个类MyConfig,它本身也是一个组件,因为在我们这个容器中,你既然是一个配置类,配置类也是一个组件。我们可以在主程序里获取它验证一下:
MyConfig bean = run.getBean(MyConfig.class);
System.out.println(bean);
输入:com.wyl.boot.config.MyConfig$$EnhancerBySpringCGLIB$$246692b6@2aa27288
,可以获取到。
@Configuration中有一个属性proxyBeanMethods很重要:
由于MyConfig这个配置类本身也是一个组件,这个组件里有两个方法user01()和catPet(),那么我们可以调用这两个方法。我们连续调用两次user01()方法,看看获取的这个对象,它是从容器中拿,还是就是个普通的调用方法
MyConfig bean = run.getBean(MyConfig.class);
User user = bean.user01();
User user1 = bean.user01();
System.out.println(user == user1);//输出结果:true
也就是说,我们配置类里面一旦组件配置了一个方法,无论外部方法对这个组件注册方法调用多少次,获取的都是容器中的那个单实例对象。原因是什么,原因就是我们@Configuration(proxyBeanMethods=true)
,这个属性为true的意思就是,我们的方法会不会被代理,会。MyConfig本身它不是一个普通对象,它是被SpringCGLIB增强了的代理对象,所以我们MyConfig bean = run.getBean(MyConfig.class);
本身获取到的就是一个代理对象,代理对象调这个方法bean.user01();
,我们SpringBoot里面的默认逻辑就是,如果@Configuration(proxyBeanMethods=true),那么我们这个类获取到的就是代理对象调用方法,SpringBoot就会检查容器中有没有这个方法已经返回的组件,如果有就拿,如果没有就new一个,也就是SpringBoot总会检查这个组件是否在容器中有,也就是它要保持组件单实例。如果把这个改为false,proxyBeanMethods=false,那么这个对象MyConfig拿到的就不再是代理对象,多次调用方法得到的就不是相等的值(user==user1就会为false了)。
这个也引申出了,SpringBoot在底层,Configuration的两种配置:
Full全配置,@Configuration(proxyBeanMethods=true)
Lite轻量级配置,@Configuration(proxyBeanMethods=false)
这个解决什么场景呢,组件依赖。举一个例子,来到bean->User里,假设我们这个User要养一个宠物Pet
public class User {
private String name;
private Integer age;
private Pet pet;
...
相当于,我给这个容器中注册了一个组件User,但是呢,这个用户想要用我们容器中之前注册的宠物Pet。如果我们是proxyBeanMethods=false模式。我们这个zhangsan用户,它想要我们容器中的这个宠物,这个宠物由于这个方法已经在容器中放好了,我们可以把这个方法调用一下。但是,如果proxyBeanMethods=true的话,它就是对的,我们用户的这个宠物,跟容器中的宠物,就是一模一样的。这说明我们User组件依赖了Pet组件。如果我们是true模式,这种依赖就是成立的。但是如果我们是false模式,我们用户想用我们的宠物,我们把原先的方法调了一下,但是这个方法又不是经过代理的,它就是直接调用,就又new了一个宠物对象。
@Bean
public User user01(){
User zhangsan = new User("zhangsan",18);
zhangsan.setPet(catPet()); //调用
return zhangsan;
}
调成false的优点就是,SpringBoot启动比较快,因为它不用去检查容器中是否已经存有这个对象。如果我们只是往容器中注册组件,且别的组件不依赖这个组件,我们一般把它调成false,这样的话SpringBoot整个启动过程会很快。但是我们的组件,明显别人要用,我们就调成true,来保证它依赖的组件就是容器中那个一模一样的组件。
总结:
1、配置类里面使用@Bean标注在方法上,给容器注册组件,默认是单实例的。
2、配置类本身也是组件。
3、proxyBeanMethods:代理bean的方法。Full全配置,
@Configuration(proxyBeanMethods=true);
Lite轻量级配置,@Configuration(proxyBeanMethods=false);
组件依赖。
3.2 @Component、@Controller、@Service、@Repository
在类上面加上
@Component,代表它是一个组件;
@Controller,代表它是一个控制器;
@Service,代表它是一个业务逻辑组件;
@Repository,代表它是一个数据库层组件。
而且,只要我们这些组件写在我们包扫描的范围内,就可以生效。于是我们的主程序类也可以叫做主配置类。
3.3 @Import
写在任何一个组件上面都行。你的这个类可以是配置类也可以是其他的Controller什么的都行。只要是容器中的组件上就行。
import的本意就是导入。我们可以使用@Import({ … })导入很多组件,它里面是一个数组。我们可以给它导入我们注册的组件比如User.class,我们也可以导入第三方jar包提供的一些组件
@Import({User.class, DBHelper.class})
@Configuration(proxyBeanMethods = true)
public class MyConfig {
...
通过@Import({User.class, DBHelper.class})
,可以给容器中自动创建出这两个类型的组件。
通过注解的方式获取的组件的名字就是全类名,例如com.wyl.boot.bean.User
,而不是刚刚我们使用@Bean注解得到的user01
这样的名字。
3.4 @Conditional条件装配
翻译过来就是,按照什么条件。也就是条件装配,当满足它指定的条件的时候,我们才给容器中注入相关的组件,或者做相应的事。
它是一个根注解,下面派生了很多的派生注解,每个派生注解都代表了不同的功能。比如@ConditionalOnBean。
我们希望的效果是,我们用户组件,因为它依赖宠物组件,那么,如果容器中没有这个宠物组件,那你也别给我注册我的用户组件了。可以使用这个条件注解:@ConditionalOnBean,容器中有没有某个组件,使用name来指定。
public class MyConfig {
@ConditionalOnBean(name = "cat")
@Bean
public User user01(){
User zhangsan = new User("zhangsan",18);
zhangsan.setPet(catPet());
return zhangsan;
}
// @Bean("cat") 注释掉了组件注入,容器中没有这个组件
public Pet catPet(){
return new Pet("Tom");
}
}
当我们容器中有cat这个组件的时候,我们再给容器中注入user01。
我们也可以把这个注解直接标在类上,也就是容器中有这个组件的时候,类中所有的东西才能生效。
@ConditionalOnBean(name = "cat")
public class MyConfig {
@Bean
public User user01(){
User zhangsan = new User("zhangsan",18);
zhangsan.setPet(catPet());
return zhangsan;
}
// @Bean("cat")
public Pet catPet(){
return new Pet("Tom");
}
}
3.5 @ImportResource
翻译过来就是“导入资源”。它的使用场景是。我们以前可能会在Spring中给容器写非常多的组件导入,
<bean id="haha" class="com.wyl.boot.bean.User">
<property name="name" value="zhangsan"></property>
<property name="age" value="18"></property>
</bean>
<bean id="hehe" class="com.wyl.boot.bean.Pet">
<property name="name" value="Tom"></property>
</bean>
因为以前很多人是用Spring的xml注解的方式导入组件的。如果我们想把这些xml组件都迁移成@Bean注解的方式,感觉有点麻烦,或者我们引入的人家第三方包,比较老,包里就是使用的xml配置方式。那对于这些组件,我们容器中肯定是没有的,因为你通过写xml配置文件的方式,我们的SpringBoot也不知道你是想干什么的。
如果你已经有了xml配置文件,你不想一点一点迁移成@Bean注解的形式,你也可以这样,随便在某一个配置类上写一个@ImportSource(“classpath:beans.xml”)
相当于你给我把这个配置文件里面的内容重新解析,放到容器里面。
3.6 @ConfigurationProperties配置绑定
场景例子。我们习惯于把经常变化的一些东西写到配置文件里面。我们以前比如把数据库的一些属性,配到配置文件里面。为了方便,我们会把配置文件里面的内容,又一一解析,解析到某个对象里面。
例如我们要把数据库配置文件.properties中的配置文件,封装到JavaBean中,以供随时使用。
如果用Java原生的方法,还是比较麻烦的。我们要先获取Properties对象,然后通过FileInputStream读取.properties文件的文件流,然后再获取里面每一个键值对,然后一一对应,封装到JavaBean指定的属性里面。这还算比较简单的,如果比较复杂,可能还要涉及到正则表达式等一大堆的东西,才能把它完成。
但是在SpringBoot里面,这个过程就会变得非常简单,这个过程叫配置绑定。
比如我们的bean目录里面有个Car,包含品牌、价格(get、set方法,以及构造器、toString方法暂且省略不写在这里面了):
public class Car {
private String brand;
private Integer price;
}
我现在想把跟汽车有关的东西放到配置文件里面,就放到SpringBoot的application.properties
配置文件里面。
mycar.brand=BYD
mycar.price=100000
现在我配了汽车的两个信息。以前我们读取这个信息并且封装很麻烦。现在怎么办?一个注解,就可以完成。
@ConfigurationProperties(prefix = "mycar")
prefix就是前缀,指的是,我们这个类里面的每一个属性,跟配置文件哪个前缀下的所有属性一一绑定。此处是"mycar"。写上以后,我们为了使它生效,我们把它加到容器中。因为只有是容器中的组件,才可以拥有SpringBoot给它提供的一些强大的功能。所以加一个@Component注解。
@Component
@ConfigurationProperties(prefix = "mycar")
public class Car {
private String brand;
private Integer price;
}
我们可以测试一下,在某个controller类中写一个方法。
public Car car(){
return
}
直接返回一个类型为Car的对象,那么我们这个Car从哪来。因为我们的Car已经通过@Component放到容器中了,而且它里面每个属性的值,是跟配置文件绑定了的。我在这想要用的话,我直接利用Spring的自动注入,把容器中的Car拿过来就行。@AutoWired。在方法中直接return car;来返回这个car。然后再加上一个@RequestMapping处理一个请求。
@Autowired
Car car;
@RequestMapping("/car")
public Car car(){
return car;
}
访问一下
如果配置文件改了,那么获取到的属性也会跟着改。
所以现在配置文件绑定一个JavaBean,就很简单了。
除了这种@Component+@ConfigurationProperties注解的方式,
还有另外一种方式,叫@EnableConfigurationProperties注解的方式,这种方式一定要在配置类里面写,因为,首先配置类它在容器中、是容器中的组件,然后,配置类上写@EnableConfigurationProperties,意思就是开启属性配置功能,开启谁的属性配置功能?因为我们的Car想要跟人绑定,所以我们把Car,传进来。
@EnableConfigurationProperties(Car.class)
public class MyConfig {
...
}
这个注解,它其实就有两个功能。
1、开启Car的配置绑定功能。你只有开启了Car的属性配置功能,你Car上的@ConfigurationProperties(prefix = “mycar”)属性配置才能生效。
2、把这个Car这个组件自动注册到容器中。
这样写,就不用写@Component了。为什么要这样写,因为有些时候我们不是引用的自己写的Car,而是引用的第三方包里面的,那你不能给人家的类上面标@Component吧。就可以用这种方式。
四、自动配置原理
看一看SpringBoot是如何帮我们做了那么做的事情,好让我们我们只需要关心业务逻辑开发。
4.1 引导加载自动配置类
刚才说了,主程序类上@SpringBootApplication
等于以下三个注解的结合。
1、@SpringBootConfiguration
点进去看一下,它上面也标有@Configuration。代表当前是一个配置类。也就是主程序实际上也就是一个主配置类。
2、@ComponentScan
指定扫描哪些Spring注解。
3、@EnableAutoConfiguration
点进去看,它是@AutoConfigurationPackage和@Import(AutoConfigurationImportSelector.class)这两个注解的合成。
@AutoConfigurationPackage:
翻译一下就叫,自动配置包。点进去看一下,它头上也有一个@Import(AutoConfigurationPackage.Registrar.class),就是给容器导入一个组件。Registrar可以给容器中导入一系列组件。将指定的一个包下的所有组件导入进来,MainApplication所在的包。com.wyl.boot。也可以看出来,每一个功能都在源码中有所体现。
@Import(AutoConfigurationImportSelector.class):
1)利用getAutoConfigurationEntry(annotationMetadata);给容器中批量导入一些组件;
2)调用List configurations = getCandidateConfigurations(annotationMetadata, attributes)获取到所有需要导入到容器中的配置类;
3)利用工厂加载 Map<String, List> loadSpringFactories(@Nullable Classloader classLoader); 得到所有的组件。
4)从META-INF/spring.factories位置来加载一个文件。
默认扫描我们当前系统里面所有META-INF/spring.factories位置的文件。
spring-boot-autoconfiguration-2.3.4.RELEASE.jar包里面也有META-INF/spring.factories。文件里面写死了spring-boot一启动就要给容器中加载的所有配置类(有127个)。
4.2 按需开启自动配置项
虽然我们127个场景的所有自动配置启动的时候会默认全部加载。
但是按照条件装配规则(@Conditional),最终会按需配置。
- SpringBoot先加载所有的自动配置类,xxxxAutoConfiguration
- 每个自动配置类按照条件进行生效,默认都会绑定配置文件指定的值,xxxxProperties里面拿。xxxxProperties又和配置文件进行了绑定。
- 生效的配置类就会给容器中装配很多组件
- 只要容器中有这些组件,相当于这些功能就有了
- 只要用户有自己配置的,就以用户的优先
- 定制化配置
- 用户直接自己@Bean替换底层的组件
- 用户去看这个组件是获取的配置文件什么值,在application.properties里去修改赋值就行了。