目录
@Import(AutoConfigurationImportSelector.class)
一、Condition
Condition 是在 Spring 4.0 增加的条件判断功能,通过这个可以功能可以实现选择性的创建 Bean 操作。思考: SpringBoot 是如何知道要创建哪个 Bean 的?比如 SpringBoot 是如何知道要创建 RedisTemplate 的?测试的项目结构
导入坐标
ClassCondition.java<dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-redis</artifactId> </dependency> <dependency> <groupId>redis.clients</groupId> <artifactId>jedis</artifactId> </dependency>
/** * @author zkt * @Version 1.0 * @since 2024/7/24 */ public class ClassCondition implements Condition { /** * * @param context 上下文对象。用于获取环境,IOC容器,ClassLoader对象 * @param metadata 注解元对象。 可以用于获取注解定义的属性值 * @return */ @Override public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) { //1.需求: 导入Jedis坐标后创建Bean //思路:判断redis.clients.jedis.Jedis.class文件是否存在 boolean flag= true; try { Class<?> cls = Class.forName("redis.clients.jedis.Jedis"); } catch (ClassNotFoundException e) { flag = false; } return flag; } }
UserConfig.java
/** * @author zkt * @Version 1.0 * @since 2024/7/24 */ @Configuration public class UserConfig { //@Conditional中的ClassCondition.class的matches方法,返回true执行以下代码,否则反之 @Bean @Conditional(value = ClassCondition.class) public User user(){ return new User(); } }
User.java
/** * @author zkt * @Version 1.0 * @since 2024/7/24 */ public class User { }
SpringbootConditionApplication.java
@SpringBootApplication public class SpringbootCondition01Application { public static void main(String[] args) { //启动SpringBoot的应用,返回Spring的IOC容器 ConfigurableApplicationContext context = SpringApplication.run(SpringbootCondition01Application.class, args); //获取Bean,redisTemplate //情况1 没有添加坐标前,发现为空 //情况2 有添加坐标前,发现有对象 Object redisTemplate = context.getBean("redisTemplate"); System.out.println(redisTemplate); /********************案例1********************/ Object user = context.getBean("user"); System.out.println(user); } }
测试结果:
情况1 没有添加坐标前,发现为空
情况2 有添加坐标前,发现有对象
案例:需求1
在 Spring 的 IOC 容器中有一个 User 的 Bean ,现要求:1. 导入 Jedis 坐标后,加载该 Bean ,没导入,则不加载。
案例:需求2
在 Spring 的 IOC 容器中有一个 User 的 Bean ,现要求:将类的判断定义为动态的。判断哪个字节码文件存在可以动态指定实现步骤:
- 不使用@Conditional(ClassCondition.class)注解
- 自定义注解@ConditionOnClass,因为他和之前@Conditional注解功能一直,所以直接复制
- 编写ClassCondition中的matches方法
测试的项目结构:
导入坐标
<dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-redis</artifactId> </dependency> <dependency> <groupId>redis.clients</groupId> <artifactId>jedis</artifactId> </dependency> <!-- <dependency> --> <!-- <groupId>com.alibaba</groupId> --> <!-- <artifactId>fastjson</artifactId> --> <!-- <version>1.2.62</version> --> <!-- </dependency> -->
在原有的基础上 新建一个自定义注解
@Target({ElementType.TYPE, ElementType.METHOD})//可以修饰在类与方法上 @Retention(RetentionPolicy.RUNTIME)//注解生效节点runtime @Documented//生成文档 @Conditional(value=ClassCondition.class) public @interface ConditionOnClass { String[] value();//设置此注解的属性redis.clients.jedis.Jedis }
修改ClassCondition .java
public class ClassCondition implements Condition { /** * * @param context 上下文对象。用于获取环境,IOC容器,ClassLoader对象 * @param metadata 注解元对象。 可以用于获取注解定义的属性值 * @return */ @Override public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) { //1.需求: 导入Jedis坐标后创建Bean //思路:判断redis.clients.jedis.Jedis.class文件是否存在 // boolean flag = true; // try { // Class<?> cls = Class.forName("redis.clients.jedis.Jedis"); // } catch (ClassNotFoundException e) { // flag = false; // } // return flag; //2.需求: 导入通过注解属性值value指定坐标后创建Bean //获取注解属性值 value Map<String, Object> map = metadata.getAnnotationAttributes(ConditionOnClass.class.getName()); System.out.println(map); String[] value = (String[]) map.get("value"); boolean flag = true; try { for (String className : value) { Class<?> cls = Class.forName(className); } } catch (ClassNotFoundException e) { flag = false; } return flag; } }
测试
情况1
情况2
小结
自定义条件:① 定义条件类:自定义类实现Condition接口,重写 matches 方法,在 matches 方法中进行逻辑判 断,返回 boolean值 。matches 方法两个参数:
- context:上下文对象,可以获取属性值,获取类加载器,获取BeanFactory等。
- metadata:元数据对象,用于获取注解属性。
② 判断条件: 在初始化Bean时,使用 @Conditional(条件类.class)注解SpringBoot 提供的常用条件注解:
注解名 描述 ConditionalOnProperty 判断配置文件中是否有对应属性和值才初始化Bean ConditionalOnClass 判断环境中是否有对应字节码文件才初始化Bean ConditionalOnMissingBean 判断环境中没有对应Bean才初始化Bean
ConditionalOnBean判断环境中有对应Bean才初始化Bean 可以查看RedisAutoConfiguration类说明以上注解使用
具体演示 ConditionalOnProperty
二、@Enable注解
SpringBoot中提供了很多Enable开头的注解,这些注解都是用于动态启用某些功能的。而其底层原理 是使用@Import注 解导入一些配置类,实现Bean的动态加载
测试:
测试的项目结构:
其中 springboot-enable-other用于模拟其他jar包,先在其放到enable项目内部,类似于给项目导入jar包,然后在到外面的SpringBoot项目里获取里面项目的Bean,测试看看能否获取到。
将04 的坐标导入进去
导入坐标
<!-- 导入坐标 --> <dependency> <groupId>com.zkt</groupId> <artifactId>springboot-enable_other-04</artifactId> <version>0.0.1-SNAPSHOT</version> </dependency>
EnableUser.java
@Target(ElementType.TYPE) @Retention(RetentionPolicy.RUNTIME) @Documented @Import(UserConfig.class) public @interface EnableUser { }
UserConfig
/** * @author zkt * @Version 1.0 * @since 2024/7/24 */ @Configuration public class UserConfig { @Bean public User user() { return new User(); } }
user
/** * @author zkt * @Version 1.0 * @since 2024/7/24 */ public class User { }
@SpringBootApplication //@ComponentScan("com.zkt.config") //@Import(User.class)//导入javaBean //@Import(UserConfig.class) @EnableUser //@EnableScheduling //@EnableAsync public class SpringbootEnable03Application { public static void main(String[] args) { ConfigurableApplicationContext context = SpringApplication.run(SpringbootEnable03Application.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注解进行封装。 * */ //获取Bean User user = context.getBean(User.class); System.out.println(user); } }
测试
都不导入
@ComponentScan扫描
导入Bean
导入配置类
可以对Import注解进行封装
![]()
三、@Import注解
@Enable底层依赖于@Import注解导入一些类,使用@Import导入的类会被Spring加载到IOC容器中。而@Import 提供 4 中用法:
- ① 导入Bean
- ② 导入配置类
- ③ 导入 ImportSelector 实现类。一般用于加载配置文件中的类
- ④ 导入 ImportBeanDefinitionRegistrar 实现类。
测试:测试的项目结构:
EnableUser.java@Target({ElementType.TYPE}) @Retention(RetentionPolicy.RUNTIME) @Documented @Import(UserConfig.class) public @interface EnableUser { }
MyImportBeanDefinationRegister.java
public class MyImportBeanDefinitionRegistrar implements ImportBeanDefinitionRegistrar { @Override public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) { //AnnotationMetadata注解 //BeanDefinitionRegistry向spring容器中注入 //1.获取user的definition对象 AbstractBeanDefinition beanDefinition = BeanDefinitionBuilder.rootBeanDefinition(User.class).getBeanDefinition(); //2.通过beanDefinition属性信息,向spring容器中注册id为user的对象 registry.registerBeanDefinition("user", beanDefinition); } }
MyImportSelector.java
public class MyImportSelector implements ImportSelector { @Override public String[] selectImports(AnnotationMetadata importingClassMetadata) { //目前字符串数组的内容是写死的,未来可以设置在配置文件中动态加载 return new String[]{"com.zkt.domain.User", "com.zkt.domain.Student"}; } }
public class Student { }
@SpringBootApplication //@Import(User.class) //@Import(UserConfig.class) //@Import(MyImportSelector.class) //@Import({MyImportBeanDefinitionRegistrar.class}) //@EnableAsync //@EnableScheduling public class SpringbootEnable03Application { public static void main(String[] args) { ConfigurableApplicationContext context = SpringApplication.run(SpringbootEnable03Application.class, args); /** * Import4中用法: * 1. 导入Bean * 2. 导入配置类 * 3. 导入ImportSelector的实现类 * 查看ImportSelector接口源码 * String[] selectImports(AnnotationMetadata importingClassMetadata); * 代表将“字符串数组”中的的类,全部导入spring容器 * 4. 导入ImportBeanDefinitionRegistrar实现类 * */ // User user = context.getBean(User.class); // System.out.println(user); // // Student student = context.getBean(Student.class); // System.out.println(student); User user = (User) context.getBean("user"); System.out.println(user); } }
其余同上
测试结果
什么都不导入
① 导入Bean
② 导入配置类
③ 导入 ImportSelector 实现类。一般用于加载配置文件中的类
④ 导入 ImportBeanDefinitionRegistrar 实现类。
SpringBoot启动类注解 @SpringBootApplication 是通过上面来实现导入其他类的,步骤依次为:
@SpringBootApplication
@EnableAutoConfiguration
@Import(AutoConfigurationImportSelector.class)
interface DeferredImportSelector extends ImportSelector
四、@EnableAutoConfiguration 注解
- @EnableAutoConfiguration 注解内部使用@import(AutoConfigurationImportSelector.class) 来加载配置类
- 配置文件位置:
META-INF/spring.factories
, 改配置文件中定义了大量的配置类,当SpringBoot应用启动时,会自动加载这些配置类,初始化Bean一层一层地查找源码:
主启动类
//@SpringBootApplication 来标注一个主程序类 //说明这是一个Spring Boot应用 @SpringBootApplication public class SpringbootApplication { public static void main(String[] args) { //以为是启动了一个方法,没想到启动了一个服务 SpringApplication.run(SpringbootApplication.class, args); } }
@SpringBootApplication 注解内部@SpringBootConfiguration @EnableAutoConfiguration @ComponentScan( excludeFilters = {@Filter( type = FilterType.CUSTOM, classes = {TypeExcludeFilter.class} ), @Filter( type = FilterType.CUSTOM, classes = {AutoConfigurationExcludeFilter.class} )} ) public @interface SpringBootApplication { // ...... }
@ComponentScan这个注解在 Spring 中很重要 , 它对应 XML 配置中的元素。作用:自动扫描并加载符合条件的组件或者 bean , 将这个 bean 定义加载到 IOC 容器中@SpringBootConfiguration作用: SpringBoot 的配置类 ,标注在某个类上 , 表示这是一个 SpringBoot 的配置类;//@SpringBootConfiguration注解内部 //这里的 @Configuration,说明这是一个配置类 ,配置类就是对应Spring的xml 配置文件; @Configuration public @interface SpringBootConfiguration {} //里面的 @Component 这就说明,启动类本身也是Spring中的一个组件而已,负责启动应用 @Component public @interface Configuration {}
@AutoConfigurationPackage :自动配置包
//AutoConfigurationPackage的子注解 //Registrar.class 作用:将主启动类的所在包及包下面所有子包里面的所有组件扫描到Spring容器 @Import({Registrar.class}) public @interface AutoConfigurationPackage { }
@EnableAutoConfiguration开启自动配置功能
以前我们需要自己配置的东西,而现在 SpringBoot 可以自动帮我们配置 ; @EnableAutoConfiguration 告诉SpringBoot 开启自动配置功能,这样自动配置才能生效;@Import({AutoConfigurationImportSelector.class}) :给容器导入组件 ;AutoConfigurationImportSelector :自动配置导入选择器,给容器中导入一些组件AutoConfigurationImportSelector.class ↓ selectImports方法 ↓ this.getAutoConfigurationEntry(annotationMetadata)方法 ↓ this.getCandidateConfigurations(annotationMetadata, attributes)方法 ↓ 方法体: List<String> 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文件
通过源码的提示可以看到,自动加载类的配置文件在
META-INF/spring.factories
的位置,现在找到org.springframework.boot.autoconfigure
中的spring-boot-autoconfigure-2.5.6.jar
可以找到存在 META-INF文件夹,而里面就有一个spring.factories
的文件,如下图
spring.factories
部分内容如下可以发现它包含了Redis类,从而就加载到了容器中,这就是为什么SpringBoot可以直接获取到redisTemplate的原因
总结原理:
@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。
导入坐标
在 redis-spring-boot-configuration模块中,负责配置 jedis 模拟 Redis的自动配置(注:该模块的test类需删除,否则会报错)
在负责起步依赖的redis-spring-boot-starter模块中,只负责在pom.xml里添加confguration模块的依赖(注:该模块的test类需删除,否则会报错)
项目结构:
RedisProperties.java
用于Redis连接的配置实体类,将作为Bean注入到Spring 容器中@ConfigurationProperties(prefix="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; } }
RedisAutoConfiguration.java
根据之前注入的redisProperties配置Bean来创建一个Jedis Bean 并注入到容器中@Configuration @EnableConfigurationProperties(RedisProperties.class) @ConditionalOnClass(Jedis.class) public class RedisAutoConfiguration { @Bean @ConditionalOnMissingBean(name = "jedis") public Jedis jedis(RedisProperties redisProperties){ System.out.println("RedisAutoConfiguration..."); return new Jedis(redisProperties.getHost(), redisProperties.getPort()); } }
根据之前的源码查找,在声明自动配置类后,需要在resources/META-INF下创建一个
spring.factories
配置文件,用于声明实现了自动扫描的配置类org.springframework.boot.autoconfigure.EnableAutoConfiguration=\ com.zkt.RedisAutoconfiguration
至此,已完成了模拟Redis自动配置的模块,现在到另一个SpringBoot模块中,引入实现的
redis-spring-boot-starter
起步依赖@SpringBootApplication public class SpringbootStarter04Application { public static void main(String[] args) { ConfigurableApplicationContext context = SpringApplication.run(SpringbootStarter04Application.class, args); Jedis bean1 = context.getBean(Jedis.class); System.out.println(bean1); } }
成功
六、自动装配原理
自动装配是什么及作用
springboot的自动装配实际上就是为了从spring.factories文件中获取到对应的需要进行自动装配的类,并生成相应的Bean对象,然后将它们交给spring容器来帮我们进行管理
启动类上注解的作用
这个注解是springboot启动类上的一个注解,是一个组合注解,也就是由其他注解组合起来,它的主要作用就是标记说明这个类是springboot的主配置类,springboot应该运行这个类里面的main()方法来启动程序
这个注解主要由三个子注解组成:
- @SpringBootConfiguration
- @EnableAutoConfiguration
- @ComponentScan
@SpringBootConfiguration
这个注解包含了@Configuration,@Configuration里面又包含了一个@Component注解,也就是说,这个注解标注在哪个类上,就表示当前这个类是一个配置类,而配置类也是spring容器中的组件
@ComponentScan
这个注解的作用就是扫描当前包及子包的注解
@EnableAutoConfiguration
这个注解是开启自动配置的功能,里面包含了两个注解
- @AutoConfigurationPackage
- @Import(AutoConfigurationImportSelector.class)
@AutoConfigurationPackage
这个注解的作用说白了就是将主配置类(@SpringBootApplication标注的类)所在包以及子包里面的所有组件扫描并加载到spring的容器中,这也就是为什么我们在利用springboot进行开发的时候,无论是Controller还是Service的路径都是与主配置类同级或者次级的原因
所以在同一级目录
@Import(AutoConfigurationImportSelector.class)
上一个注解我们把所有组件都加载到了容器里面,这个注解就是将需要自动装配的类以全类名的方式返回,那是怎么找到哪些是需要自动装配的类呢?
- 1、AutoConfigurationImportSelector这个类里面有一个方法selectImports(),如下
2、在selectImport()方法里调用了一个getAutoConfigurationEntry()方法,这个方法里面又调用了一个getCandidateConfigurations()方法
3、在getCandidateConfigurations()方法里面调用了loadFactoryNames()方法
4、loadFactoryNames()方法里面又调用了一个loadSpringFactories()方法
5、关键就在这个loadSpringFactories()方法里面,在这个方法里,它会查找所有在META-INF路径下的spring.factories文件
6、在META-INF/spring.factories这个文件里面的数据是以键=值的方式存储,然后解析这些文件,找出以EnableAutoConfiguration为键的所有值,以列表的方式返回
七、 总结
SpringBoot自动装配
核心注解:@SpringBootApplication 是一个复合注解
@SpringBootApplication = @EnableAutoConfiguration + @Configuration + @ComponentScan
- @EnableAutoConfiguration:启动 SpringBoot 的自动配置机制
- @Configuration:允许上下文注册额外的bean或者导入其它配置类
- @ComponentScan:扫描 @Component(@Service、@Controller)注解的bean,默认会扫描启动类所在的包下的所有类,可以自定义不扫描某些类
@EnableAutoConfiguration 导入了 AutoConfigurationImportSelector 类,这个类负责从 META-INF /spring.factories 文件中加载并过滤自动配置类,根据条件注解(@Conditional )来过滤这些自动配置类. 只有当条件满足时,对应的自动配置类才会被加载