SpringBoot———自动装配原理

SpringBoot———自动装配原理_springboot自动装配原理_追JAVA的小菜鸟的博客-CSDN博客

SpringBoot自动装配

  • spring支持两种bean的配置方式：基于xml文件和JavaConfig

主启动类上的注解@SpringBootApplication

在这里插入图片描述
@SpringBootApplication里有三个重要注解

在这里插入图片描述

@SpringBootConfiguration

  • 作用： 声明定义Bean，嵌套了@Component组件
    1. @SpringBootConfiguration源码是@Configuration：表示该类为主配置类，可用来装配bean
    1. @Configuration的源码是@Component：说明Spring的配置类也是Spring的一个组件。
      在这里插入图片描述
  • 它是JavaConfig形式的基于Spring IOC容器的配置类使用的一种注解。SpringBoot本质上就是一个Spring应用，通过这个注解来加载IOC容器的配置。所以在启动类里面标注了@Configuration，意味着它也是一个IOC容器的配置类

@ComponentScan

  • 作用：扫描主配置类包的所有包下的类，相当于xml配置文件中的context:component-scan。eg:pojo中的User类

@EnableAutoConfiguration（重点！！！）

  • 作用：开启自动装配类

@EnableAutoConfiguration里有两个重要注解

在这里插入图片描述

  1. @AutoConfigurationPackage：自动配置包
    • 作用：给Spring容器中导入一个Registrar注册器组件

在这里插入图片描述

@AutoConfigurationPackage和@ComponentScan一样，也是将主配置类所在的包及其子包里面的组件扫描到IOC容器中，但是区别是

  • @AutoConfigurationPackage扫描@Enitity、@MapperScan等第三方依赖的注解
  • @ComponentScan只扫描@Controller/@Service/@Component/@Repository这些常见注解。所以这两个注解扫描的对象是不一样的。
  1. @Import(AutoConfigurationImportSelector.class)——核心注解
    • 作用：通过import导入第三方提供的bean的配置类：AutoConfigurationImportSelector：给容器中导入组件
    • 该类中有selectImports()方法，调用了getAutoConfigurationEntry()
      在这里插入图片描述
      其下又调用了getCandidateConfigurations()
      在这里插入图片描述
      getCandidateConfigurations()中SpringFactoriesLoader.loadFactoryNames()方法
      在这里插入图片描述
      SpringFactoriesLoader.loadFactoryNames()中传入参数EnableAutoConfiguration.class
      在这里插入图片描述
    • 作用：扫描所有jar包类路径下的META-INF/spring.factories文件，将扫描到的这些文件包装成properties对象，从properties中获取到EnableAutoConfiguration.class类名对应的值，将这些值添加到容器中，用这些类做自动配置功能

在spring-boot-autoconfigure-.jar包中找到spring.factories文件
在这里插入图片描述
其中spring.factories文件是一组组的key=value的形式

    • key=接口 value=接口实现类（多个，逗号隔开）
      在这里插入图片描述
      以HttpEncodingAutoConfiguration为例解释：
      在这里插入图片描述

@Configuration(proxyBeanMethods = false)————表示该类为配置类
@EnableConfigurationProperties(ServerProperties.class)————将配置文件中设置的值与properties中的属性绑定，将组件添加到IOC容器
————@Conditionalxxx：若满足不同的条件，则配置类中的配置生效
@ConditionalOnWebApplication(type = ConditionalOnWebApplication.Type.SERVLET)
@ConditionalOnClass(CharacterEncodingFilter.class)
@ConditionalOnProperty(prefix = “server.servlet.encoding”, value = “enabled”, matchIfMissing = true)
在这里插入图片描述

其中ServerProperties.class中的属性值，可与xx.yaml配置文件绑定并修改
精髓：根据当前配置类的条件判断配置类是否生效，若生效，则添加各种组件，会从properties类中获取属性，可以在配置文件xxx.yaml中设置属性的值

  • Properties类：封装配置文件的相关属性。
  • AutoConfiguration类：自动配置类，添加到IOC容器中。
SpringFactoriesLoader
  • 作用：从classpath/META-INF/spring.factories文件中，根据key来加载对应的类到spring IOC容器中。

自动装配过程

  1. 通过各种注解实现了类与类之间的依赖关系，容器在启动的时候SpringApplication.run()，调用EnableAutoConfigurationImportSelector.class的selectImports方法
  2. selectImports方法调用SpringFactoriesLoader.loadFactoryNames方法扫描jar包类路径下的META-INF/spring.factories文件下，获取BeanConfiguration列表
  3. loadFactoryNames方法会读取spring.factories中EnableAutoConfiguration.class类名对应的值
  4. 根据这些类上的注解判断，若条件满足，则该配置类生效，将配置文件中自己设置的属性值配置到对应的配置类中，最后注入到IOC容器中实现自动配置

总结

SpringBoot启动的时候通过@EnableAutoConfiguration注解找到META-INF/spring.factories文件中的所有自动配置类，并对其加载，这些自动配置类都是以AutoConfiguration结尾来命名的。它实际上就是一个JavaConfig形式的IOC容器配置类，通过以Properties结尾命名的类中取得在全局配置文件中配置的属性，如server.port。

Spring Boot 自动装配原理与实现 - 知乎 (zhihu.com)

  1. 什么是 SpringBoot 自动装配？
  2. SpringBoot 是如何实现自动装配的？如何实现按需加载？
  3. 如何实现一个 Starter？

前言

使用过 Spring 的小伙伴，一定有被 XML 配置统治的恐惧。即使 Spring 后面引入了基于注解的配置，我们在开启某些 Spring 特性或者引入第三方依赖的时候，还是需要用 XML 或 Java 进行显式配置。

举个例子。没有 Spring Boot 的时候，我们写一个 RestFul Web 服务，还首先需要进行如下配置。

spring-servlet.xml

但是，Spring Boot 项目，我们只需要添加相关依赖，无需配置，通过启动下面的 main 方法即可。

并且，我们通过 Spring Boot 的全局配置文件 application.properties或application.yml即可对项目进行设置比如更换端口号，配置 JPA 属性等等。

为什么 Spring Boot 使用起来这么酸爽呢？ 这得益于其自动装配。自动装配可以说是 Spring Boot 的核心，那究竟什么是自动装配呢？

1、什么是 SpringBoot 自动装配？

我们现在提到自动装配的时候，一般会和 Spring Boot 联系在一起。但是，实际上 Spring Framework 早就实现了这个功能。Spring Boot 只是在其基础上，通过 SPI 的方式，做了进一步优化。

SpringBoot 定义了一套接口规范，这套规范规定：SpringBoot 在启动时会扫描外部引用 jar 包中的META-INF/spring.factories文件，将文件中配置的类型信息加载到 Spring 容器（此处涉及到 JVM 类加载机制与 Spring 的容器知识），并执行类中定义的各种操作。对于外部 jar 来说，只需要按照 SpringBoot 定义的标准，就能将自己的功能装置进 SpringBoot。

没有 Spring Boot 的情况下，如果我们需要引入第三方依赖，需要手动配置，非常麻烦。但是，Spring Boot 中，我们直接引入一个 starter 即可。比如你想要在项目中使用 redis 的话，直接在项目中引入对应的 starter 即可。

引入 starter 之后，我们通过少量注解和一些简单的配置就能使用第三方组件提供的功能了。

在我看来，自动装配可以简单理解为：通过注解或者一些简单的配置就能在 Spring Boot 的帮助下实现某块功能。

2、SpringBoot 是如何实现自动装配的？

我们先看一下 SpringBoot 的核心注解 SpringBootApplication 。

大概可以把 @SpringBootApplication看作是 @Configuration、@EnableAutoConfiguration、@ComponentScan 注解的集合。根据 SpringBoot 官网，这三个注解的作用分别是：

  • @EnableAutoConfiguration：启用 SpringBoot 的自动配置机制
  • @Configuration：允许在上下文中注册额外的 bean 或导入其他配置类
  • @ComponentScan：扫描被@Component (@Service,@Controller)注解的 bean，注解默认会扫描启动类所在的包下所有的类 ，可以自定义不扫描某些 bean。如下图所示，容器中将排除TypeExcludeFilter和AutoConfigurationExcludeFilter。

@EnableAutoConfiguration 是实现自动装配的重要注解，我们以这个注解入手。

@EnableAutoConfiguration:实现自动装配的核心注解

EnableAutoConfiguration 只是一个简单地注解，自动装配核心功能的实现实际是通过 AutoConfigurationImportSelector类。

我们现在重点分析下AutoConfigurationImportSelector 类到底做了什么？

AutoConfigurationImportSelector:加载自动装配类

AutoConfigurationImportSelector类的继承体系如下：

可以看出，AutoConfigurationImportSelector 类实现了 ImportSelector接口，也就实现了这个接口中的 selectImports方法，该方法主要用于获取所有符合条件的类的全限定类名，这些类需要被加载到 IoC 容器中。

private static final String[] NO_IMPORTS = new String[0];

public String[] selectImports(AnnotationMetadata annotationMetadata) {
        // <1>.判断自动装配开关是否打开
        if (!this.isEnabled(annotationMetadata)) {
            return NO_IMPORTS;
        } else {
          //<2>.获取所有需要装配的bean
            AutoConfigurationMetadata autoConfigurationMetadata = AutoConfigurationMetadataLoader.loadMetadata(this.beanClassLoader);
            AutoConfigurationImportSelector.AutoConfigurationEntry autoConfigurationEntry = this.getAutoConfigurationEntry(autoConfigurationMetadata, annotationMetadata);
            return StringUtils.toStringArray(autoConfigurationEntry.getConfigurations());
        }
    }

这里我们需要重点关注一下getAutoConfigurationEntry()方法，这个方法主要负责加载自动配置类的。

该方法调用链如下：

现在我们结合getAutoConfigurationEntry()的源码来详细分析一下：

private static final AutoConfigurationEntry EMPTY_ENTRY = new AutoConfigurationEntry();

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

第 1 步:

判断自动装配开关是否打开。默认spring.boot.enableautoconfiguration=true，可在 application.properties 或 application.yml 中设置

第 2 步 ：

用于获取EnableAutoConfiguration注解中的 exclude 和 excludeName。

第 3 步

获取需要自动装配的所有配置类，读取META-INF/spring.factories

spring-boot/spring-boot-project/spring-boot-autoconfigure/src/main/resources/META-INF/spring.factories

从下图可以看到这个文件的配置内容都被我们读取到了。XXXAutoConfiguration的作用就是按需加载组件。

不光是这个依赖下的META-INF/spring.factories被读取到，所有 Spring Boot Starter 下的META-INF/spring.factories都会被读取到。

所以，你可以清楚滴看到， druid 数据库连接池的 Spring Boot Starter 就创建了META-INF/spring.factories文件。

如果，我们自己要创建一个 Spring Boot Starter，这一步是必不可少的。

第 4 步 ：

到这里可能面试官会问你:“spring.factories中这么多配置，每次启动都要全部加载么？”。

很明显，这是不现实的。我们 debug 到后面你会发现，configurations 的值变小了。

因为，这一步有经历了一遍筛选，@ConditionalOnXXX 中的所有条件都满足，该类才会生效。

@Configuration
// 检查相关的类：RabbitTemplate 和 Channel是否存在
// 存在才会加载
@ConditionalOnClass({ RabbitTemplate.class, Channel.class })
@EnableConfigurationProperties(RabbitProperties.class)
@Import(RabbitAnnotationDrivenConfiguration.class)
public class RabbitAutoConfiguration {
}

有兴趣的童鞋可以详细了解下 Spring Boot 提供的条件注解

  • @ConditionalOnBean：当容器里有指定 Bean 的条件下
  • @ConditionalOnMissingBean：当容器里没有指定 Bean 的情况下
  • @ConditionalOnSingleCandidate：当指定 Bean 在容器中只有一个，或者虽然有多个但是指定首选 Bean
  • @ConditionalOnClass：当类路径下有指定类的条件下
  • @ConditionalOnMissingClass：当类路径下没有指定类的条件下
  • @ConditionalOnProperty：指定的属性是否有指定的值
  • @ConditionalOnResource：类路径是否有指定的值
  • @ConditionalOnExpression：基于 SpEL 表达式作为判断条件
  • @ConditionalOnJava：基于 Java 版本作为判断条件
  • @ConditionalOnJndi：在 JNDI 存在的条件下差在指定的位置
  • @ConditionalOnNotWebApplication：当前项目不是 Web 项目的条件下
  • @ConditionalOnWebApplication：当前项目是 Web 项 目的条件下

3、如何实现一个 Starter

光说不练假把式，现在就来撸一个 starter，实现自定义线程池

第一步，创建threadpool-spring-boot-starter工程

第二步，引入 Spring Boot 相关依赖

第三步，创建ThreadPoolAutoConfiguration

第四步，在threadpool-spring-boot-starter工程的 resources 包下创建META-INF/spring.factories文件

最后新建工程引入threadpool-spring-boot-starter

测试通过！！！

总结

Spring Boot 通过@EnableAutoConfiguration开启自动装配，通过 SpringFactoriesLoader 最终加载META-INF/spring.factories中的自动配置类实现自动装配，自动配置类其实就是通过@Conditional按需加载的配置类，想要其生效必须引入spring-boot-starter-xxx包实现起步依赖

posted @ 2023-09-21 21:38  CharyGao  阅读(2362)  评论(0)  编辑  收藏  举报