SpringBoot自动装配原理

Created time: May 15, 2022 6:36 PM
Done: Doing
Last edited time: May 25, 2022 6:13 PM
Tags: Spring, 后端, 总结

0 关于自动配置

pom.xml

spring-boot-dependencies：核心依赖在父工程中
在写或者引入一些springboot依赖时，不需要指定版本，因为有这些版本仓库。

启动器

 <dependency>

    <groupId>org.springframework.boot</groupId>

    <artifactId>spring-boot-starter-web</artifactId>

</dependency>

启动器，SpringBoot的启动场景
spring-boot-starter-web 自动导入web环境所有的依赖
springboot会将所有的功能场景变成一个一个启动器

主程序

 //标注这个类是一个springboot的应用

@SpringBootApplication

public class Springboot01HelloworldApplication {

    public static void main(String[] args) {

        SpringApplication.run(Springboot01HelloworldApplication.class, args);

    }

}

1 SpringBoot四大核心

四大核心
- ```
EnableAutoConfiguration
```
  自动装配
- ```
Starter
```
  组件,开箱即用
- ```
Actutor
```
  监控
- SpringBoot Cli为SpringCloud提供SpringBoot命令行功能

1.1 注解

在了解Spring注解之前先了解一些相关注解的知识。

 //标注这个类是一个springboot的应用

@SpringBootApplication

//SpringBoot的配置

@SpringBootConfiguration

  @Configuration //Spring配置类

  @Component//本质还是一个Spring组件

//自动配置

@EnableAutoConfiguration

  @AutoConfigurationPackage//自动配置包

  @Import(AutoConfigurationPackages.Registrar.class)//导入选择器包注册

  @Import(AutoConfigurationImportSelector.class)//自动配置导入选择(自动导入包的核心)

  //获取所有的配置

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

 //getCandidateConfigurations获取所有的候选配置**

protected List<String> getCandidateConfigurations(AnnotationMetadata metadata, AnnotationAttributes attributes) {

    List<String> configurations = SpringFactoriesLoader.loadFactoryNames(**getSpringFactoriesLoaderFactoryClass**(),

	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;

	}

	//EnableAutoConfiguration注解被SpringBootApplication继承

	protected Class<?> getSpringFactoriesLoaderFactoryClass() {

	  return EnableAutoConfiguration.class;

	}

META-INF/spring.factories自动配置的核心文件

 //所有的资源加载到类中

Properties properties = PropertiesLoaderUtils.loadProperties(resource);

结论

SpringBoot所有自动配置都是在启动的时候扫描并加载：spring.factories所有的自动配置类都在这里面，但不一定生效，要判断条件是否成立，只要导入对应的start，就有对应的启动器了，有了启动器，自动装配就会生效，然后就配置成功。

2 Enable注解作用

EnableAutoConfiguration
自动装配相关的Eable注解.

开启相关支持,如

```
EnableScheduling
```
,开启计划任务支持
```
EnableAutoConfiguration
```
,开启自动装配支持

在

EnableAutoConfiguration.java

中涉及到Enable开头的注解都会有一个

@Import

的注解

3 SpringBoot中的自动装配原理

自动装配作为Starter的基础，也是SpringBoot的核心

SpringBoot的自动装配是基于

EnableAutoConfiguration

实现的，先了解一下传统意义的自动装配方式。

首先需要了解一些前置关于注解的知识 。

3.1 Configuration注解

Spring3以后，支持两种配置bean的方式，一种xml文件方式和JavaConfig。

JavaConfig方式

Configuration

注解是JavaConfig形式基于Spring IOC容器配置类使用的一种注解。在启动类里边标注

@Configuration

也表示它是一个IOC容器的配置类。

 public class DemoClass {



    public void say(){

        System.out.println("sya hello ... ");

    }

}

 @Configuration

@Import(UserClass.class)

public class DemoConfiguration {



    @Bean

    public DemoClass getDemoClass(){

        return new DemoClass();

    }

}

 public class DemoConfigurationMain {



    public static void main(String[] args) {

        ApplicationContext ac = new AnnotationConfigApplicationContext(DemoConfiguration.class);

        DemoClass bean = ac.getBean(DemoClass.class);

        bean.say();

    }

}

3.2 Configuration本质

Configuration注解本质就是一个Component注解，会被

AnnotationConfigApplicationContext

加载，而

AnnotationConfigApplicationContext

是

ApplicationContext

的具体实现，会根据配置注解启动应用上下文。所以在Main中通过

AnnotationConfigApplicationContext

加载JavaConfig后，可以得到IOC容器中Bean的实例。

 @Configuration  //也会被Spring容器托管，注册到容器中，因为本身就是一个@Component

@ComponentScan("com.kuang.pojo")

@Import(MyConfig2.class)

public class MyConfig {



    //注册一个Bean相当于之前写的一个Bean标签

    //这个方法的名字就相当于Bean标签中的id属性

    //这个方法的返回值，就相当于Bean标签中的class属性

    @Bean

    public User getUser(){

        return new User();  //返回要注入到Bean的对象

    }

}

 public class MyTest {

    public static void main(String[] args) {

        //如果完全使用了配置类方式去做，只能通过AnnotationConfigApplicationContext来获取容器，通过配置类的class对象加载

        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(MyConfig.class);

        User getUser = (User) context.getBean("getUser");

        System.out.println(getUser.getName());

    }

}

 @Component

public class User {

    private String name;



    public String getName() {

        return name;

    }



    @Value("xxx")

    public void setName(String name) {

        this.name = name;

    }



    @Override

    public String toString() {

        return "User{" +

                "name='" + name + '\'' +

                '}';

    }

}

3.3 ComponentScan注解

相当于xml配置文件中的
context:component-scan
，主要作用是扫描指定路径下标识了需要装配的类，自动装配到IOC容器中

 @Configuration  //也会被Spring容器托管，注册到容器中，因为本身就是一个@Component

@ComponentScan("com.kuang.pojo")

@Import(MyConfig2.class)

public class MyConfig {



    //注册一个Bean相当于之前写的一个Bean标签

    //这个方法的名字就相当于Bean标签中的id属性

    //这个方法的返回值，就相当于Bean标签中的class属性

    @Bean

    public User getUser(){

        return new User();  //返回要注入到Bean的对象

    }

}

3.4 Import注解

等同于xml形式下的

&lt;import resource/&gt;

注解，将多个分开的容器合并在一个容器中。

方式一：@Import，直接
@Import(MyConfig2.class)

方式二：ImportSelector，动态加载实现
ImportSelector
接口

方式三：ImportBeanDefinitionRegistrar方式，实现
ImportBeanDefinitionRegistrar
接口

3.5 深入EnableAutoConfiguration原理

EnableAutoConfiguration

通过

@Import(AutoConfigurationImportSelector.class)

导入第三方的提供的Bean配置类

AutoConfigurationImportSelector

 public String[] selectImports(AnnotationMetadata annotationMetadata) {

    if (!this.isEnabled(annotationMetadata)) {

        return NO_IMPORTS;

    } else {

        try {

// 加载META-INF/spring-autoconfigure-metadata.properties 下的元数据信息



            AutoConfigurationMetadata autoConfigurationMetadata = AutoConfigurationMetadataLoader.loadMetadata(this.beanClassLoader);

            AnnotationAttributes attributes = this.getAttributes(annotationMetadata);

// 获取候选加载的配置信息 META-INF/spring.factories

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

// 去掉重复的配置信息

            configurations = this.removeDuplicates(configurations);

// 排序

            configurations = this.sort(configurations, autoConfigurationMetadata);

            // 获取 注解中配置的 exclusion 信息

Set<String> exclusions = this.getExclusions(annotationMetadata, attributes);

// 检查

            this.checkExcludedClasses(configurations, exclusions);

// 移除需要排除的信息

            configurations.removeAll(exclusions);

// 过滤，检查候选配置类上的注解@ConditionalOnClass，如果要求的类不存在，则这个候选类会被过滤不被加载

            configurations = this.filter(configurations, autoConfigurationMetadata);

// 广播事件

            this.fireAutoConfigurationImportEvents(configurations, exclusions);

            // 返回要被加载的类数组

return (String[])configurations.toArray(new String[configurations.size()]);

        } catch (IOException var6) {

            throw new IllegalStateException(var6);

        }

    }

}

EnableAutoConfiguration

会帮助SpringBoot应用将所有符合

@Configuration

配置都加载到当前SpringBoot创建的IOC容器，这里面借助了Spring框架提供的一个工具类

SpringFactoriesLoader

的支持。以及用到了Spring提供的条件注解

@Conditional

，选择性的针对需要加载的bean进行条件过滤。

3.6 关于条件过滤

分析
AutoConfigurationImportSelector
的源码时，会先扫描
spring-autoconfiguration-metadata.properties
文件，最后在扫描
spring.factories
对应的类时，会结合前面的元数据进行过滤，为什么要过滤呢？原因是很多的
@Configuration
其实是依托于其他的框架来加载的，如果当前的
classpath
环境下没有相关联的依赖，则意味着这些类没必要进行加载，所以，通过这种条件过滤可以有效的减少
@configuration
类的数量从而降低
SpringBoot
的启动时间。

4 总结

SpringBoot自动装配实现是从classpath中搜寻 spring.factory自动装配的核心文件 ，将包下对应的org.springframework.boot.autoconfigure的配置项通过反射实例化为对应标注的@Configuration的JavaConfig形式的IOC容器配置类，将然后汇总为实例加载至IOC容器中。

备注：思路还是不太清晰，后续还需再整理一遍深入理解。

SpringBoot自动装配初步浅理解