目录
2.3.1、@Component + @ConfigurationProperties
2.3.2、@EnableConfigurationProperties + @ConfigurationProperties
3.1.1、@SpringBootConfiguration
3.1.3、@EnableAutoConfiguration
4.4、Spring Initailizr(项目初始化向导)
1、SpringBoot 特点
1.1、依赖管理
- 父项目做依赖管理
<!-- 依赖管理 -->
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>2.6.5</version>
</parent>
点开 spring-boot-starter-parent,查看其父项目,再点进 第五行的spring-boot-dependencies,可以看到里面设置了几乎所有常用的依赖版本
- 无需关注版本号,自动版本仲裁,可以修改默认版本号
如上所述,SpringBoot 设置了几乎所有常用的依赖版本,所以引入依赖默认都可以不写版本
如果想使用其他版本的依赖,可以在 pom.xml 中设置所需的版本,如下,mysql 驱动的版本就是5.1.47
<properties>
<mysql.version>5.1.47</mysql.version>
</properties>
<dependencies>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
</dependency>
</dependencies>
- 开发导入starter场景启动器
1、见到很多 spring-boot-starter-* : * 就代表某种场景
2、只要引入starter,这个场景的所有常规需要的依赖我们都自动引入
3、SpringBoot所有支持的场景 https://docs.spring.io/spring-boot/docs/current/reference/html/using.html#using.build-systems.starters
4、见到的 *-spring-boot-starter: 第三方为我们提供的简化开发的场景启动器。
5、所有场景启动器最底层的依赖如下
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter</artifactId>
<version>2.6.5</version>
<scope>compile</scope>
</dependency>
1.2、自动配置
1.2.1、自动配好 Tomcat
引入 tomcat、配置 Tomcat
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-tomcat</artifactId>
<version>2.6.5</version>
<scope>compile</scope>
</dependency>
1.2.2、自动配好 SpringMVC
引入SpringMVC全套组件, 自动配好SpringMVC常用组件(功能)
1.2.3、自动配好Web常见功能,如:字符编码问题
SpringBoot帮我们配置好了所有web开发的常见场景,若想要查看,可以在主程序中获取
@SpringBootApplication // 标识为一个SpringBoot应用,被标识的类称为主程序类
public class MainApplication {
public static void main(String[] args) {
// 返回IOC容器
ConfigurableApplicationContext run = SpringApplication.run(MainApplication.class, args);
// 查看容器里面的组件
String[] names = run.getBeanDefinitionNames();
for (String name : names) {
System.out.println(name);
}
}
}
1.2.4、默认的包结构
○ 主程序所在包及其下面的所有子包里面的组件都会被默认扫描进来,如下图
○ 无需以前的包扫描配置
○ 想要改变扫描路径,需要使用 @ComponentScan 指定扫描路径 或者 在@SpringBootApplication注解中使用 scanBasePackages 声明,例如:
@SpringBootApplication(scanBasePackages = "com.zyj")
注:由于 @SpringBootApplication 注解中已经声明 @ComponentScan 注解扫描主程序所在的包,所以 @SpringBootApplication 和 @ComponentScan 不能放在一起使用
1.2.5、各种配置拥有默认值
默认配置最终都是映射到某个类上,如:MultipartProperties
配置文件的值最终会绑定每个类上,这个类会在容器中创建对象
1.2.6、按需加载所有自动配置项
○ 有非常多的starter,可以根据需要引入
○ 引入了哪些场景这个场景的自动配置才会开启
○ SpringBoot所有的自动配置功能都在 spring-boot-autoconfigure 包里面
2、容器功能
2.1、组件添加
2.1.1、@Configuration
Full模式与Lite模式
Full(proxyBeanMethods = true):代理对象调用方法,SpringBoot会检查这个组件在容器中是否已被注册,即保持组件单实例
Lite(proxyBeanMethods = false):不会保持单实例
配置类组件之间无依赖关系用Lite模式加速容器启动过程,减少判断
配置类组件之间有依赖关系,方法会被调用得到之前单实例组件,用Full模式
组件之间有依赖关系:例如一个组件需要另一个组件作为属性,下面示例中,user 组件依赖 pet 组件
示例
① 首先准备两个类,在 src/main/java/com/zyj/boot/bean 下创建 Pet 类和 User 类。
Pet 类属性如下,生成 无参构造,有参构造,set 和 get 方法、toString 方法
private String name;
User 类属性如下,生成无参构造,有参构造,set 和 get 方法、toString 方法
private String name;
private Integer age;
private Pet pet;
② 生成 config 类
在 src/main/java/com/zyj/boot/config 下创建 MyConfig 配置类
/**
* 1、配置类里面使用@Bean标注在方法上给容器注册组件,默认是单实例的
* 2、@Configuration 标识的类也是容器的一个组件
* 3、proxyBeanMethods:代理bean方法
* Full(proxyBeanMethods = true):代理对象调用方法,SpringBoot会检查这个组件在容器中是否已被注册,即保持组件单实例
* Lite(proxyBeanMethods = false):不会保持单实例
* 用于解决组件依赖:组件依赖必须使用Full模式默认。其他默认是Lite模式(减少判断,加快运行)
*/
@Configuration(proxyBeanMethods = true) // 告诉SpringBoot这是一个配置类 == 配置文件
public class MyConfig {
/**
* 在 proxyBeanMethods = true 的情况下:
* 外部无论对配置类中的这个组件方法调用多少次,获取的都是之前注册到容器的单实例对象
* @return
*/
@Bean() //给容器添加组件,默认以方法名作为组件的id(可以在括号中自定义),返回类型就是组件类型,返回的值就是组件在容器中的实例
public User user01(){
User zhangsan = new User("zhangsan", 18);
// user组件依赖了pet组件,需要使用Full模式
zhangsan.setPet(tomcatPet());
return new User("zhangsan", 18);
}
@Bean("tom")
public Pet tomcatPet(){
return new Pet("tomcat");
}
}
③ 主程序类:
@SpringBootApplication(scanBasePackages = "com.zyj") // 标识为一个SpringBoot应用,被标识的类称为主程序类
public class MainApplication {
public static void main(String[] args) {
// 返回IOC容器
ConfigurableApplicationContext run = SpringApplication.run(MainApplication.class, args);
// 查看容器里面的组件
String[] names = run.getBeanDefinitionNames();
for (String name : names) {
System.out.println(name);
}
// 从容器中获取组件
Pet tom01 = run.getBean("tom", Pet.class);
Pet tom02 = run.getBean("tom", Pet.class);
// 若proxyBeanMethods为true,返回true,否则返回false
System.out.println("组件:" + (tom01 == tom02));
MyConfig bean = run.getBean(MyConfig.class);
System.out.println(bean);
// 如果@Configuration(proxyBeanMethods = true),则是代理对象调用方法
// SpringBoot会检查这个组件在容器中是否已被注册,即保持组件单实例
User user1 = bean.user01();
User user2 = bean.user01();
// 若proxyBeanMethods为true,返回true,否则返回false
System.out.println("user比较:" + (user1 == user2));
User user01 = run.getBean("user01", User.class);
Pet tom = run.getBean("tom", Pet.class);
// 若proxyBeanMethods为true,返回false,否则返回true
System.out.println("用户的宠物与容器的宠物比较:" + (user01.getPet() == tom));
}
}
2.1.2、@Import
@Import({User.class, Matcher.class}):给容器自动通过无参构造创建出括号中的组件(多个组件以逗号分隔),默认组件的名字是全类名
配置类:
@Import({User.class, Matcher.class})
@Configuration(proxyBeanMethods = true) // 告诉SpringBoot这是一个配置类 == 配置文件
public class MyConfig {
}
主程序中验证:
// 验证@Import注解获取组件
String[] beanNamesForType = run.getBeanNamesForType(User.class);
System.out.println("===================================");
System.out.println("验证@Import注解获取组件");
for (String s : beanNamesForType) {
System.out.println(s);
}
//com.zyj.boot.bean.User @Import注解生成的
//user01 MyConfig中生成的
Matcher bean1 = run.getBean(Matcher.class);
System.out.println(bean1); //java.util.regex.Matcher[pattern=null region=0,0 lastmatch=]
2.1.3、@Conditional
条件装配:满足Conditional指定的条件,则进行组件注入
例如 @ConditionalOnBean(name = "tom") 注解若在方法上,则容器中有 tom 组件时才注入该方法生成的组件。若在类上,则容器中有 tom 组件时才注入该类的方法生成的组件
配置类:
@ConditionalOnBean(name = "tom")
@Import({User.class, Matcher.class})
@Configuration(proxyBeanMethods = true) // 告诉SpringBoot这是一个配置类 == 配置文件
public class MyConfig {
/**
* 在 proxyBeanMethods = true 的情况下:
* 外部无论对配置类中的这个组件方法调用多少次,获取的都是之前注册到容器的单实例对象
* @return
*/
//@ConditionalOnBean(name = "tom") // 容器中有tom组件时才注入user01组件
@Bean() //给容器添加组件,默认以方法名作为组件的id(可以在括号中自定义),返回类型就是组件类型,返回的值就是组件在容器中的实例
public User user01(){
User zhangsan = new User("zhangsan", 18);
// user组件依赖了pet组件,需要使用Full模式
zhangsan.setPet(tomcatPet());
return new User("zhangsan", 18);
}
@Bean("tom22")
public Pet tomcatPet(){
return new Pet("tomcat");
}
}
主程序类:
// 去掉com.zyj.boot.config.MyConfig.tomcatPet的@Bean("tom")注解后,查看是否有tom组件
boolean tom = run.containsBean("tom");
System.out.println("查看是否有tom组件:" + tom); //false
// 给com.zyj.boot.config.MyConfig.user01添加注解@ConditionalOnBean(name = "tom")后
boolean user01 = run.containsBean("user01");
System.out.println("查看是否有user01组件:" + user01); //false
// 给com.zyj.boot.config.MyConfig添加注解@ConditionalOnBean(name = "tom")后
boolean tom22 = run.containsBean("tom22");
System.out.println("查看是否有tom22组件:" + tom22); //false
2.2、原生配置文件引入
2.2.1、@ImportResource
@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"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
<bean id="haha" class="com.zyj.boot.bean.User">
<property name="name" value="zhangsan"></property>
<property name="age" value="18"></property>
</bean>
<bean id="hehe" class="com.zyj.boot.bean.Pet">
<property name="name" value="tomcat"></property>
</bean>
</beans>
配置类 MyConfig:
@ImportResource("classpath:beans.xml") //导入配置文件
public class MyConfig {
}
主程序类:
boolean haha = run.containsBean("haha");
boolean hehe = run.containsBean("hehe");
//在配置类加入@ImportResource("classpath:bean.xml")之前为false
System.out.println("查看是否有haha组件" + haha);
System.out.println("查看是否有hehe组件" + hehe);
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。
}
}
}
2.3.1、@Component + @ConfigurationProperties
src/main/resources/application.properties
mycar.brand=BYD
mycar.price=100000
在 src/main/java/com/zyj/boot/bean 下创建 Car
// 只有在容器中的组件才有SpringBoot提供的强大功能
@Component
@ConfigurationProperties(prefix = "mycar")
public class Car {
private String brand;
private Integer price;
public Car() {
}
public Car(String brand, Integer price) {
this.brand = brand;
this.price = 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 +
'}';
}
}
在 src/main/java/com/zyj/boot/controller/HelloController.java
@RestController // @RestController可以代替@Controller和@ResponseBody
public class HelloController {
@Autowired
Car car;
@RequestMapping("/car")
public Car car(){
return car;
}
@RequestMapping("/hello")
public String handler01(){
return "hello,Spring Boot 2!" + "你好";
}
}
运行后访问对应地址,页面显示如下
2.3.2、@EnableConfigurationProperties + @ConfigurationProperties
这种方法一定要在配置类中写
src/main/resources/application.properties
mycar.brand=BYD
mycar.price=100000
src/main/java/com/zyj/boot/config/MyConfig.java
@EnableConfigurationProperties(Car.class) //开启Car配置绑定功能,并把Car这个组件自动注册到容器中
public class MyConfig {
}
@ConfigurationProperties(prefix = "mycar")
public class Car {
private String brand;
private Integer price;
public Car() {
}
public Car(String brand, Integer price) {
this.brand = brand;
this.price = 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 +
'}';
}
}
访问对应的地址查看生成的
3、自动配置原理入门
3.1、引导加载自动配置类
查看 SpringBootApplication 的源码,可以看到其中包含了@SpringBootConfiguration、@EnableAutoConfiguration、@ComponentScan
3.1.1、@SpringBootConfiguration
@SpringBootConfiguration 包含注解 @Configuration,代表当前是一个配置类
3.1.2、ComponentScan
指定扫描的包,
3.1.3、@EnableAutoConfiguration
@EnableAutoConfiguration 包含一下两个注解
@AutoConfigurationPackage
@Import({AutoConfigurationImportSelector.class})
public @interface EnableAutoConfiguration {
}
① @AutoConfigurationPackage
P13
@AutoConfigurationPackage 是自动配置包,指定了默认的包原则
@Import({Registrar.class}) //给容器导入一个组件
public @interface AutoConfigurationPackage {
}
点进 Registrar,可以看到是利用 Registrar 给容器中导入一系列组件
public void registerBeanDefinitions(AnnotationMetadata metadata, BeanDefinitionRegistry registry) {
AutoConfigurationPackages.register(registry, (String[])(new AutoConfigurationPackages.PackageImports(metadata)).getPackageNames().toArray(new String[0]));
}
alt + F8,可以看到将主程序所在的包下的所有组件导入容器
② @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,文件里面写死了spring-boot一启动就要给容器中加载的所有配置类
configurations 有133个组件
3.2、按需开启自动配置项
虽然 133 个场景的所有自动配置启动的时候默认全部加载。xxxxAutoConfiguration
但是按照条件装配规则(@Conditional),最终会按需配置。
3.3、修改默认配置
给容器中加入了文件上传解析器
@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() {
}
3.4、总结
-
SpringBoot先加载所有的自动配置类 xxxxxAutoConfiguration
-
每个自动配置类按照条件进行生效,默认都会绑定配置文件指定的值。xxxxProperties里面拿。xxxProperties和配置文件进行了绑定
-
生效的配置类就会给容器中装配很多组件
-
只要容器中有这些组件,相当于这些功能就有了
-
定制化配置
-
用户直接自己@Bean替换底层的组件
-
用户去看这个组件是获取的配置文件什么值就去修改。
xxxxxAutoConfiguration ---> 组件 ---> xxxxProperties里面拿值 ----> application.properties
-
3.5、最佳实践
-
引入场景依赖
-
查看自动配置了哪些(选做)
-
自己分析,引入场景对应的自动配置一般都生效了
-
配置文件中debug=true开启自动配置报告。Negative(不生效)\Positive(生效)
-
-
是否需要修改
-
参照文档修改配置项
-
自己分析。xxxxProperties绑定了配置文件的哪些。
-
自定义加入或者替换组件
-
@Bean、@Component。。。
-
-
自定义器 XXXXXCustomizer;
-
......
-
4、开发小技巧
4.1、Lombok
① 引入依赖
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
</dependency>
② 添加注解
@ConfigurationProperties(prefix = "mycar")
@Data //setter和getter方法
@ToString //toString方法
@AllArgsConstructor //全参构造
@NoArgsConstructor //无参构造
@EqualsAndHashCode //equals和hashCode方法
public class Car {
private String brand;
private Integer price;
}
4.2、@Slf4j
① 添加注解,在控制器方法中添加日志
@RestController // @RestController可以代替@Controller和@ResponseBody
@Slf4j
public class HelloController {
@Autowired
Car car;
@RequestMapping("/car")
public Car car(){
return car;
}
@RequestMapping("/hello")
public String handler01(){
log.info("请求进来了...");
return "hello,Spring Boot 2!" + "你好";
}
}
② 访问对应的地址,控制台输出如下
4.3、dev-tools
实质是重启,如果想要自动加载,可以使用 JRebel(付费)
① 引入依赖
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-devtools</artifactId>
<optional>true</optional>
</dependency>
② 导完依赖,修改页面后,可以按 ctrl + F9(构建项目的快捷键),重新编译,然后刷新网页
4.4、Spring Initailizr(项目初始化向导)
① 在新建项目时,选择 Spring Initailizr,然后根据需求填方框,然后点击下一步
② 选择自己需要的
③ 创建完成后,目录如下,且已经自动引入依赖,并且创建了一个主程序类