Springboot自动装配

本文由 简悦 SimpRead 转码， 原文地址 blog.csdn.net

Spring boot 自动装配

文章目录

• Spring boot 自动装配
• • 自动装配是什么？
  • 技能一：condition
  • 技能二：Enable
  • 技能三：import
  • • • 1、导入 bean
      • 2、导入配置类
      • 3、导入 ImportSelector 的实现类
      • 4、导入 ImportBeanDefinitionRegistrar 实现类
  • Boos：启动类上的 @SpringBootApplication
  • • @SpringBootConfiguration 源码：
    • @ComponentScan 作用：
    • @EnableAutoConfiguration 源码：
  • 总结：

自动装配是什么？

问题：我们在导入启动坐标以后，为什么可以用 @Autowired 在 spring 容器中获取对应的类呢？

在学习 Spring 初期，我们发现我们使用 autowried 都是手动注入容器的，比如在配置文件中<bean>或者 @Service、@controller、@Component，还有在配置类中 @bean 来注入容器的。

那为什么我在 pom.xml 文件中导入坐标，没有以上操作，却可以 @autowried 获取对应的实体类呢？

例如，导入 Redis

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>

测试类

@SpringBootTest
class SpringbootCondition01ApplicationTests {

    @Autowired
    RedisTemplate redisTemplate;

    @Test
    void contextLoads() {
        System.out.println(redisTemplate);
    }
}

结果

org.springframework.data.redis.core.RedisTemplate@4ed15347

这就是 SpringBoot 的自动装配。他的原理是什么？探索原理前我们需要知道以下技能。

技能一：condition

功能：condition 是一个条件判断功能，可以选择性的创建 bean

建立一个 user 类

public class User {
}

有一个需求：如果项目导入 Jedis 的坐标，才给 ioc 容器中注入 user 对象

问题来了，SpringBoot 如何知道导入了 Jedis 而实例化 user 呢？

如果直接写一个配置类

@Configuration
public class UserConfig {
    @Bean
    public User user(){
        return new User();
    }
}

那么项目启动时，user 类则会自动注入容器。不符合我们的需求。这时需要使用 condition 注解

Conditional 注解源码

@Target({ElementType.TYPE, ElementType.METHOD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Conditional {
    Class<? extends Condition>[] value();
}

这个注解中只声明了一个 value 的数组，注意泛型：Condition 的实现类

Condition 源码：

@FunctionalInterface
public interface Condition {
    boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata);
}

这个接口只定义了一个 matches 方法，返回值是一个 Boolean 类型。
这个方法返回值如果是 true 则执行注解的方法，如果为 false 则不执行注解的方法

实现一个 condition 接口的类

public class ClassCondition implements Condition {
    @Override
    public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
        return false;
    }
}

可以看到默认返回值类型为 false，所以我们可以给这个类改造一下

public class UserCondition implements Condition {
    /**
     * @param context 上下文对象。用于获取环境，IOC容器，ClassLoader对象
     * @param metadata 注解元对象。 可以用于获取注解定义的属性值
     * @return
     */
    @Override
    public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
        // 定义一个布尔值
        boolean flag = true;
        try {
            // 通过反射的方法，找到Jedis的驱动
            Class<?> aClass = Class.forName("redis.clients.jedis.Jedis");
            // 如果找到默认flag为true
        } catch (ClassNotFoundException e) {
            // 如果没有找到，则flag为false
            flag=false;
        }
        // 最终返回这个Boolean值
        return flag;
    }
}

这样我们可以在我们的 user 类注入方法上，使用 conditional 的注解，用来判断如果 Jedis 导入了就注入 user，如果没有导入则不执行，不注入。

@Configuration
public class UserConfig {
    //@Conditional中的ClassCondition.class的matches方法，返回true执行以下代码，否则反之
    @Bean
    @Conditional(value = UserCondition.class)
    public User user(){
        return new User();
    }
}

测试：

启动类

@SpringBootApplication
public class SpringbootConditionApplication {
    public static void main(String[] args) {
        //启动SpringBoot的应用，返回Spring的IOC容器
        ConfigurableApplicationContext applicationContext = SpringApplication.run(SpringbootCondition01Application.class, args);
        Object user = applicationContext.getBean("user");
        System.out.println(user);
    }
}

pom.xml 中导入 Jedis

<dependency>
    <groupId>redis.clients</groupId>
    <artifactId>jedis</artifactId>
</dependency>

结果

com.ape.springboot_condition_01.domain.User@44924587

pom.xml 中注掉 Jedis

<!--        <dependency>-->
<!--            <groupId>redis.clients</groupId>-->
<!--            <artifactId>jedis</artifactId>-->
<!--        </dependency>-->

结果

org.springframework.beans.factory.NoSuchBeanDefinitionException

至此完成–加载 Jedis 就注入 user，未加载就不注入

总结：

自定义 conditional 注解使用方法：

1. 自定义类实现 condition 接口，重写 matches 方法，在 matches 中进行逻辑判断。

2. 在初始化 bean 时，使用@conditional(自定义condition类.class)注解，可以实现符合逻辑则注入，不符合时不注入。

condition 中有很多子注解：

常用的注解：

ConditionalOnProperty：判断配置文件中是否有对应属性和值才初始化 Bean

ConditionalOnClass：判断环境中是否有对应字节码文件才初始化 Bean

ConditionalOnMissingBean：判断环境中没有对应 Bean 才初始化 Bean

ConditionalOnBean：判断环境中有对应 Bean 才初始化 Bean

技能二：Enable

问题：通过上述 condition，我们可以完成选择性注入 ioc 了，但是我们还是需要写一个配置类，然后在配置类上添加 condition 注解，也不是自动的，怎么样才能完成自动的选择性注入 ioc 呢？

直接来看 Enable 相关源码：

例如：@EnableAsync：

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Import({AsyncConfigurationSelector.class})
public @interface EnableAsync {
    Class<? extends Annotation> annotation() default Annotation.class;

    boolean proxyTargetClass() default false;

    AdviceMode mode() default AdviceMode.PROXY;

    int order() default 2147483647;
}

例如：@EnableScheduling：

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Import({SchedulingConfiguration.class})
@Documented
public @interface EnableScheduling {
}

我们可以观察到，每一类 Enable 注解的背后，都是 @import 导入一个类

所以我们可以将上面的 condition 的配置信息写入一个单独的项目。

我们导入项目，使用自定义的 EnableUser 来实现导入

@Target(ElementType.TYPE)
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Import(UserConfig.class)
public @interface EnableUser {
}

在一个全新的项目中导入上一个项目，使用 EnableUser 注解来实现自动加载

@SpringBootApplication
@EnableUser// 自定义的Enable
public class SpringbootEnableApplication {
    public static void main(String[] args) {
        ConfigurableApplicationContext applicationContext = SpringApplication.run(SpringbootEnable01Application.class, args);
        //获取Bean
        User user = applicationContext.getBean(User.class);
        System.out.println(user);
    }
}

结果

com.ape.springboot_enable_02.domain.User@648ee871

至此已经初具雏形了，完了自动装配的基本原理。

技能三：import

import 的用法：

1. 导入 Bean
2. 导入配置类
3. 导入 ImportSelector 的实现类
4. 导入 ImportBeanDefinitionRegistrar 实现类

import 源码：

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Import {
    Class<?>[] value();
}

核心是一个 value() 的 class 数组

1、导入 bean

导入普通类、实体类，会自动将导入的类注入容器

@Import(User.class)

2、导入配置类

可以在另一个配置类中，使用此配置类中的配置信息，如 @bean 等

@Import(UserConfig.class)

3、导入 ImportSelector 的实现类

importSelector 源码

public interface ImportSelector {
    String[] selectImports(AnnotationMetadata importingClassMetadata);

    @Nullable
    default Predicate<String> getExclusionFilter() {
        return null;
    }
}

如果 @Import 引入一个 ImportSelector 的实现类，代表将 “字符串数组” 中的的类，全部导入 spring 容器

来尝试自定义一个 ImportSelector 的实现类

public class MyImportSelector implements ImportSelector {
    @Override
    public String[] selectImports(AnnotationMetadata importingClassMetadata) {
        //目前字符串数组的内容是写死的，未来可以设置在配置文件中动态加载
        return new String[]{"com.apesource.domain.User", "com.apesource.domain.Student"};
    }
}

两个实体类

public class Student {
}
public class User {
}

在启动类中使用 import 注解导入 MyImportSelector 类

@SpringBootApplication
@Import(MyImportSelector.class)
public class SpringbootEnable03Application {
    public static void main(String[] args) {

        ConfigurableApplicationContext context =  SpringApplication.run(SpringbootEnable03Application.class, args);

          User user = context.getBean(User.class);
          System.out.println(user);
  
          Student student = context.getBean(Student.class);
          System.out.println(student);
    }
}

结果

com.ape.springboot_import_02.domain.User@41477a6d
com.ape.springboot_import_02.domain.Student@6fe46b62

4、导入 ImportBeanDefinitionRegistrar 实现类

这个接口提供了通过 spring 容器 api 的方式直接向容器中注册 bean
ImportBeanDefinitionRegistrar 源码：

public interface ImportBeanDefinitionRegistrar {
    default void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry, BeanNameGenerator importBeanNameGenerator) {
        this.registerBeanDefinitions(importingClassMetadata, registry);
    }

    default void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
    }
}

自定义一个类 MyImportBeanDefinitionRegistrar 实现 ImportBeanDefinitionRegistrar 接口

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);
    }
}

在启动类中使用 import 注解导入 MyImportBeanDefinitionRegistrar 类

@SpringBootApplication
@Import({MyImportBeanDefinitionRegistrar.class})
public class SpringbootEnable03Application {
    public static void main(String[] args) {
        ConfigurableApplicationContext context =  SpringApplication.run(SpringbootEnable03Application.class, args);

        User user = (User) context.getBean("user");
        System.out.println(user);
    }
}

结果

com.ape.springboot_import_02.domain.User@41477a6d

Boos：启动类上的 @SpringBootApplication

启动类上的注解@SpringBootApplication进入查看一下

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited	
@SpringBootConfiguration 
@EnableAutoConfiguration 
@ComponentScan(	
    excludeFilters = {@Filter(
    type = FilterType.CUSTOM,
    classes = {TypeExcludeFilter.class}
), @Filter(
    type = FilterType.CUSTOM,
    classes = {AutoConfigurationExcludeFilter.class}
)}
)
public @interface SpringBootApplication {
    @AliasFor(
        annotation = EnableAutoConfiguration.class
    )
    Class<?>[] exclude() default {};

    @AliasFor(
        annotation = EnableAutoConfiguration.class
    )
    String[] excludeName() default {};

    @AliasFor(
        annotation = ComponentScan.class,
        attribute = "basePackages"
    )
    String[] scanBasePackages() default {};

    @AliasFor(
        annotation = ComponentScan.class,
        attribute = "basePackageClasses"
    )
    Class<?>[] scanBasePackageClasses() default {};

    @AliasFor(
        annotation = ComponentScan.class,
        attribute = "nameGenerator"
    )
    Class<? extends BeanNameGenerator> nameGenerator() default BeanNameGenerator.class;

    @AliasFor(
        annotation = Configuration.class
    )
    boolean proxyBeanMethods() default true;
}

重点：

@SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan

@SpringBootConfiguration源码：

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Configuration
@Indexed
public @interface SpringBootConfiguration {
    @AliasFor(
        annotation = Configuration.class
    )
    boolean proxyBeanMethods() default true;
}

这个源码中只有一个 @Configuration，一个声明配置类，所以我们的启动类也是一个配置类，可以在启动类中 @Bean

@ComponentScan作用：

扫描文件的，这个扫描的范围是启动类的同级路径及子路径，扫描到特定的 @Component、@Service、@Controler、@Repository、@Configuration 等等注解后，会做相应的 bean 注册和配置文件 bean 注册工作。

@EnableAutoConfiguration源码：

@Target({ElementType.TYPE}) 
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@AutoConfigurationPackage 
@Import({AutoConfigurationImportSelector.class})
public @interface EnableAutoConfiguration {
    String ENABLED_OVERRIDE_PROPERTY = "spring.boot.enableautoconfiguration";

    Class<?>[] exclude() default {};

    String[] excludeName() default {};
}

Enable 注解，技能二的介绍的就是用来自动装配的，他的内部就是 import 注解 @Import({AutoConfigurationImportSelector.class})

AutoConfigurationImportSelector 一看名字，就是 import 技能三的第三种用法。

必然重写 selectImports 方法，返回一个 class 类型的数组。

AutoConfigurationImportSelector 类中的 selectImports（）方法源码：

public String[] selectImports(AnnotationMetadata annotationMetadata) {
    if (!this.isEnabled(annotationMetadata)) {
        return NO_IMPORTS;
    } else {
        AutoConfigurationImportSelector.AutoConfigurationEntry autoConfigurationEntry = this.getAutoConfigurationEntry(annotationMetadata);
        return StringUtils.toStringArray(autoConfigurationEntry.getConfigurations());
    }
}

里面太多了，其他省略只找重要的 selectImports 方法，此方法一定要返回一个 String[] 数组，此数组中包括是每个类的完全名称的列表，这样返回给 import 的时候，才会将类注入 Spring 容器

if 中的返回值 NO_IMPORTS，就是一个空数组，不符合

else 中返回的 StringUtils.toStringArray(autoConfigurationEntry.getConfigurations());

autoConfigurationEntry 是通过 getAutoConfigurationEntry 得到的一个 map 的 Entry 对象

getAutoConfigurationEntry（）方法源码

protected AutoConfigurationImportSelector.AutoConfigurationEntry getAutoConfigurationEntry(AnnotationMetadata annotationMetadata) {
    if (!this.isEnabled(annotationMetadata)) {
        return EMPTY_ENTRY;
    } else {
        AnnotationAttributes attributes = this.getAttributes(annotationMetadata);
        List<String> configurations = this.getCandidateConfigurations(annotationMetadata, attributes);
        configurations = this.removeDuplicates(configurations);
        Set<String> exclusions = this.getExclusions(annotationMetadata, attributes);
        this.checkExcludedClasses(configurations, exclusions);
        configurations.removeAll(exclusions);
        configurations = this.getConfigurationClassFilter().filter(configurations);
        this.fireAutoConfigurationImportEvents(configurations, exclusions);
        return new AutoConfigurationImportSelector.AutoConfigurationEntry(configurations, exclusions);
    }
}

此方法中返回了一个 new AutoConfigurationImportSelector.AutoConfigurationEntry(configurations, exclusions);

configurations（配置信息）和 exclusions（排除在外的，不需要的）

向上找 configurations 相关

List<String> configurations = this.getCandidateConfigurations(annotationMetadata, attributes);

所以 SpringBoot 自动配置的配置信息就是从 getCandidateConfigurations() 方法来的

getCandidateConfigurations（）方法源码

protected List<String> getCandidateConfigurations(AnnotationMetadata metadata, AnnotationAttributes attributes) {
    List<String> configurations = new ArrayList(SpringFactoriesLoader.loadFactoryNames(this.getSpringFactoriesLoaderFactoryClass(), this.getBeanClassLoader()));
    ImportCandidates.load(AutoConfiguration.class, this.getBeanClassLoader()).forEach(configurations::add);
    Assert.notEmpty(configurations, "No auto configuration classes found in META-INF/spring.factories nor in META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports. If you are using a custom packaging, make sure that file is correct.");
    return configurations;
}

“No auto configuration classes found in META-INF/spring.factories nor in META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports. If you are using a custom packaging, make sure that file is correct.”

这行解释中，META-INF/spring.factories 就是存放配置信息的关键点

找到 META-INF/spring.factories 文件位置

找一个熟悉的配置类，我们进去看看

org.springframework.boot.autoconfigure.data.redis.RedisAutoConfiguration,\
org.springframework.boot.autoconfigure.data.redis.RedisReactiveAutoConfiguration,\
org.springframework.boot.autoconfigure.data.redis.RedisRepositoriesAutoConfiguration,\

RedisAutoConfiguration 源码

@Configuration
@ConditionalOnClass({RedisOperations.class})
@EnableConfigurationProperties({RedisProperties.class})
@Import({LettuceConnectionConfiguration.class, JedisConnectionConfiguration.class})
public class RedisAutoConfiguration {
    public RedisAutoConfiguration() {
    }

    @Bean
    @ConditionalOnMissingBean(
        name = {"redisTemplate"}
    )
    public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) throws UnknownHostException {
        RedisTemplate<Object, Object> template = new RedisTemplate();
        template.setConnectionFactory(redisConnectionFactory);
        return template;
    }

    @Bean
    @ConditionalOnMissingBean
    public StringRedisTemplate stringRedisTemplate(RedisConnectionFactory redisConnectionFactory) throws UnknownHostException {
        StringRedisTemplate template = new StringRedisTemplate();
        template.setConnectionFactory(redisConnectionFactory);
        return template;
    }
}

RedisTemplate（）和 stringRedisTemplate（）方法上都有一个 ConditionalOnMissingBean，技能一的子注解！！

还是选择性的加载，如果容器中有就不加载，如果没有则加载

以上就是自动装配的过程

打个断点调试一下：
我们可以看到这个 configurations 的 list 集合中，就是所有配置类的完全限定名称

将这些配置类全放在 import 中，依次加载，再根据 condition 注解，进行选择性注入。这就是 SpringBoot 的自动装配

所以 SpringBoot 的自动装配实质就是，SpringBoot 已经帮助我们写了配置类，都做了选择性装配。我们只需要启动项目，就可以完成自动装配。

自动装配的原理即为：

启动类 @SpringBootApplication

里面有一个 @EnableAutoConfiguration – 自动装配开始

Enable 的内部就是 @Import({AutoConfigurationImportSelector.class}) – 技能三中的第三种方法

ImportSelector 的实现类 AutoConfigurationImportSelector 类 – 实现了 ImportSelector 接口

重写了 selectImports() 方法 – 此方法需要返回一个 String[] 数组

方法中就是用 getAutoConfigurationEntry(annotationMetadata) 方法返回数组 – 最终是由此方法的 enrty 类返回数组

获取这个 class 数组的原理就是 List<String> configurations = this.getCandidateConfigurations(annotationMetadata, attributes);

​ – 用来获取所有自动装配的文件中的配置类信息

读取 META-INF/spring.factories 中的 key=EnableAutoConfiguration 的所有值 – 存放配置类信息的地方

一步一步返回到 import 去加载对应的配置类 – import 逐一进行选择性注入 Spring 容器

在配置类中根据 condition 完成选择注入 Spring 容器。即自动装配

注意：在 SpringBoot2.7 版本后，配置信息的位置有些小改变

No auto configuration classes found in META-INF/spring.factories nor in META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports. If you are using a custom packaging, make sure that file is correct.

META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports.

文件位置虽然改变了，但是配置类的信息还是一致的。

总结：

springboot 的自动装配，是通过 import 导入自己在META-INF/spring.factories或META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports.中写好的配置类信息，然后使用 condition 选择性加载 Bean 的。

自动的装配的原理，就是写好配置类，将配置类的完全路径写入 META-INF/spring.factories 中的 EnableAutoConfiguration 键下面，就可以完成自动的装配了。

但是 Springboot 只提供了 100 多个自动装配的对象，那 springboot 没有提供的配置类，又是如何自动装配呢？

第三方的配置类，一般会自己提供自己的配置类，写在 META-INF/spring.factories 中的 EnableAutoConfiguration 的下面，SpringBoot 都会扫描到配置类，完成自动配置

如果没有配置类，我们还是需要手动将第三方技术注入 Spring 容器中。