SpringBoot自动配置原理
一、Condition
Condition 是在Spring 4.0 增加的条件判断功能，通过这个可以功能可以实现选择性的创建 Bean 操作。
思考：SpringBoot是如何知道要创建哪个Bean的？比如SpringBoot是如何知道要创RedisTemplate的？
演示1:
org.springframework.boot
spring-boot-starter-data-redis
1. 没有添加坐标前，发现为空，报错
ConfigurableApplicationContext context = SpringApplication.run(SpringbootCondition01Application.class, args);
Object redisTemplate = context.getBean("redisTemplate");
System.out.println(redisTemplate);
2. 有添加坐标前，发现有对象
ConfigurableApplicationContext context = SpringApplication.run(SpringbootCondition01Application.class, args);
Object redisTemplate = context.getBean("redisTemplate");
System.out.println(redisTemplate);
疑问，他怎么知道的配置哪个类案例：需求1
在 Spring 的 IOC 容器中有一个 User 的 Bean，现要求：
-
导入Jedis坐标后，加载该Bean，没导入，则不加载。
定义ClassCondition
/**
* @author lizhihui
* @version 1.0
* @since 2023/8/15
*/
public class ClassCondition implements Condition {
@Override
public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
boolean flag = true;
try {
Class clazz = Class.forName("redis.clients.jedis.Jedis");
} catch (ClassNotFoundException e) {
flag = false;
}
return flag;
}
}
定义UserConfig
@Configuration
public class UserConfig {
//@Conditional中的ClassCondition.class的matches方法，返回true执行以下代码，否则反之
@Bean
@Conditional(value = ClassCondition.class)
public User user(){
return new User();
}
}
案例：需求2
在 Spring 的 IOC 容器中有一个 User 的 Bean，现要求：
将类的判断定义为动态的。判断哪个字节码文件存在可以动态指定
实现步骤：
-
不使用@Conditional(ClassCondition.class)注解
-
自定义注解@ConditionOnClass,因为他和之前@Conditional注解功能一致，所以直接复制
-
编写ClassCondition中的matches方法
自定义注解@ConditionOnClass
/**
* @author lizhihui
* @version 1.0
* @since 2023/8/15
*/
// 自定义注解
@Target({ElementType.METHOD,ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Conditional(value = ClassCondition.class)
public @interface ConditionOnClass {
String[] value();
}编写ClassCondition中的matches方法
/**
* @author lizhihui
* @version 1.0
* @since 2023/8/15
*/
public class ClassCondition implements Condition {
@Override
public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
Map map = metadata.getAnnotationAttributes(ConditionOnClass.class.getName());
System.out.println(map);
String[] value = (String[]) map.get("value");
boolean flag = true;
try {
for (String v : value) {
Class cls = Class.forName(v);
}
} catch (ClassNotFoundException e) {
flag = false;
}
return flag;
}
}
编写UserConfig
@Configuration
public class UserConfig {
//@Conditional中的ClassCondition.class的matches方法，返回true执行以下代码，否则反之
@Bean
// @ConditionOnClass(value = {"redis.clients.jedis.Jedis"})
@ConditionOnClass(value = {"redis.clients.jedis.Jedis","com.alibaba.fastjson.JSON"})
public User user(){
return new User();
}
}还可以工具配置文件application.properties中是否包含指定的键值对来确定是否创建对象
@Bean
//当容器中有一个key=k1且value=v1的时候user2才会注入
//在application.properties文件中添加k1=v1
@ConditionalOnProperty(name = "k1",havingValue = "v1")
public User user2(){
return new User();
}Condition – 小结
自定义条件：
① 定义条件类：自定义类实现Condition接口，重写 matches 方法，在 matches 方法中进行逻辑判断，返回boolean值 。 matches 方法两个参数：
• context：上下文对象，可以获取属性值，获取类加载器，获取BeanFactory等。
• metadata：元数据对象，用于获取注解属性。
② 判断条件： 在初始化Bean时，使用 @Conditional(条件类.class)注解
SpringBoot 提供的常用条件注解：
以下注解在springBoot-autoconfigure的condition包下
-
ConditionalOnProperty：判断配置文件中是否有对应属性和值才初始化Bean
-
ConditionalOnClass：判断环境中是否有对应字节码文件才初始化Bean
-
ConditionalOnMissingBean：判断环境中没有对应Bean才初始化Bean
-
ConditionalOnBean：判断环境中有对应Bean才初始化Bean
二、Enable注解
SpringBoot中提供了很多Enable开头的注解，这些注解都是用于动态启用某些功能的。而其底层原理是使用@Import注解导入一些配置类，实现Bean的动态加载
思考 SpringBoot 工程是否可以直接获取jar包中定义的Bean？
@Import注解
@Enable底层依赖于@Import注解导入一些类，使用@Import导入的类会被Spring加载到IOC容器中。而@Import提供4中用法：
① 导入Bean
② 导入配置类
③ 导入 ImportSelector 实现类。一般用于加载配置文件中的类
④ 导入 ImportBeanDefinitionRegistrar 实现类。
@SpringBootApplication
//@ComponentScan("com.itzhi.config")
//@Import(User.class)//导入javaBean
//@Import(UserConfig.class)
//@EnableUser
//@Import(MyImportSelector.class)
@Import({MyImportBeanDefinitionRegistrar.class})
//@EnableScheduling
//@EnableCaching
public class SpringbootEnableApplication {
public static void main(String[] args) {
ConfigurableApplicationContext context = SpringApplication.run(SpringbootEnableApplication.class, args);
/**
* @SpringBootApplication中有@ComponentScan注解， 扫描范围：当前引导类所在包及其子包
* 当前引导类所在包com.apesource.springbootenable03
* 注入user类所在包com.apesource.springbootenable_other04.config
* 因此扫描不到，所以容器中没有user
* 解决方案：
* 1.使用@ComponentScan扫描com.apesource.springbootenable_other04.config包
* 2.可以使用@Import注解，加载类。这些类都会被Spring创建，并放入IOC容器
* 3.可以对Import注解进行封装。
*
*/
/**
* Import4种用法：
* 1. 导入Bean
* 2. 导入配置类
* 3. 导入ImportSelector的实现类
* 查看ImportSelector接口源码
* String[] selectImports(AnnotationMetadata importingClassMetadata);
* 代表将“字符串数组”中的的类，全部导入spring容器
* 4. 导入ImportBeanDefinitionRegistrar实现类
*
*/
User user = (User) context.getBean("user");
System.out.println(user);
// User user = context.getBean(User.class);
// Student student = context.getBean(Student.class);
// System.out.println(user);
// System.out.println(student);
}
}三、@EnableAutoConfiguration 注解
1. 主启动类
//@SpringBootApplication 来标注一个主程序类
//说明这是一个Spring Boot应用
@SpringBootApplication
public class SpringbootApplication {
public static void main(String[] args) {
//以为是启动了一个方法，没想到启动了一个服务
SpringApplication.run(SpringbootApplication.class, args);
}
}2. @SpringBootApplication注解内部
@SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan(
excludeFilters = {@Filter(
type = FilterType.CUSTOM,
classes = {TypeExcludeFilter.class}
), @Filter(
type = FilterType.CUSTOM,
classes = {AutoConfigurationExcludeFilter.class}
)}
)
public @interface SpringBootApplication {
// ......
}3. @ComponentScan
这个注解在Spring中很重要 ,它对应XML配置中的元素。
作用：自动扫描并加载符合条件的组件或者bean ， 将这个bean定义加载到IOC容器中
4. @SpringBootConfiguration
作用：SpringBoot的配置类 ，标注在某个类上 ， 表示这是一个SpringBoot的配置类；
//@SpringBootConfiguration注解内部
//这里的 @Configuration，说明这是一个配置类 ，配置类就是对应Spring的xml 配置文件；
@Configuration
public @interface SpringBootConfiguration {}
//里面的 @Component 这就说明，启动类本身也是Spring中的一个组件而已，负责启动应用
@Component
public @interface Configuration {}5. @AutoConfigurationPackage ：自动配置包
//AutoConfigurationPackage的子注解
//Registrar.class 作用：将主启动类的所在包及包下面所有子包里面的所有组件扫描到Spring容器
@Import({Registrar.class})
public @interface AutoConfigurationPackage {
}6. @EnableAutoConfiguration开启自动配置功能
以前我们需要自己配置的东西，而现在SpringBoot可以自动帮我们配置 ；@EnableAutoConfiguration告诉SpringBoot开启自动配置功能，这样自动配置才能生效；
@Import({AutoConfigurationImportSelector.class}) ：给容器导入组件
AutoConfigurationImportSelector ：自动配置导入选择器，给容器中导入一些组件。
AutoConfigurationImportSelector.class
↓
selectImports方法
↓
this.getAutoConfigurationEntry(annotationMetadata)方法
↓
this.getCandidateConfigurations(annotationMetadata, attributes)方法
↓
方法体：
List configurations = SpringFactoriesLoader.loadFactoryNames(this.getSpringFactoriesLoaderFactoryClass(), this.getBeanClassLoader());
Assert.notEmpty(configurations, "No auto configuration classes found in META-INF/spring.factories. If you are using a custom packaging, make sure that file is correct.");
return configurations;
↓
在所有包名叫做autoConfiguration的包下面都有META-INF/spring.factories文件 总结原理：
-
@EnableAutoConfiguration 注解内部使用 @Import(AutoConfigurationImportSelector.class)来加载配置类。
-
配置文件位置：META-INF/spring.factories，该配置文件中定义了大量的配置类，当 SpringBoot 应用启动时，会自动加载这些配置类，初始化Bean
-
并不是所有的Bean都会被初始化，在配置类中使用Condition来加载满足条件的Bean
四、自定义启动器
需求：
自定义redis-starter，要求当导入redis坐标时，SpringBoot自动创建Jedis的Bean
参考：
可以参考mybatis启动类的应用
实现步骤：
-
创建redis-spring-boot-autoconfigure模块
-
创建redis-spring-boot-starter模块,依赖redis-spring-boot-autoconfigure的模块
-
在redis-spring-boot-autoconfigure模块中初始化Jedis的Bean，并定义META-INF/spring.factories文件
-
在测试模块中引入自定义的redis-starter依赖，测试获取Jedis的Bean，操作redis。
定义spring.factories文件
org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
com.itzhi.RedisAutoconfiguration定义RedisAutoconfiguration
package com.itzhi;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import redis.clients.jedis.Jedis;
/**
* @author lizhihui
* @version 1.0
* @since 2023/8/15
*/
@Configuration
@EnableConfigurationProperties(RedisProperties.class)
public class RedisAutoconfiguration {
@Bean
public Jedis jedis(RedisProperties redisProperties){
return new Jedis(redisProperties.getHost(),redisProperties.getPort());
}
}
定义RedisProperties
package com.itzhi;
import org.springframework.boot.context.properties.ConfigurationProperties;
/**
* @author lizhihui
* @version 1.0
* @since 2023/8/15
*/
@ConfigurationProperties(prefix = "spring.redis")
public class RedisProperties {
private String host="localhost";
private int port=6379;
public String getHost() {
return host;
}
public void setHost(String host) {
this.host = host;
}
public int getPort() {
return port;
}
public void setPort(int port) {
this.port = port;
}
}