tulip notes
EffectTang
2023-09-23
目录

自动装配

# 自动装配

springboot和spring的自动装配有些不同，文章后半部分会讲到spring的自动装配，先来一起看看springboot的自动装配吧。

# 什么是自动装配

自动装配 在 Spring Boot 中是指基于条件的自动配置特性，它根据类路径中的依赖库和应用上下文的状态自动配置应用程序。Spring Boot 提供了许多预定义的自动配置类，这些类使用条件注解来决定是否注册某些 Bean，并设置合理的默认值。

其中的条件如：Spring Boot 通过一系列条件注解（如 @ConditionalOnClass、@ConditionalOnProperty、@ConditionalOnMissingBean 等）判断是否满足配置条件。

换成更通俗易懂的话就是：自动装配是一个过程，扫描环境，根据环境条件开始实例化各种Bean，然后为Bean们完成属性注入，然后启动springboot应用。

下面就是springboot的自动装配过程讲解：（可能有些地方不太全面，或者随着版本迭代会有些变动-仅提供参考）

# @SpringBootApplication

@SpringBootApplication
public class DemoApplication {
    public static void main(String[] args) {
			SpringApplication.run(DemoApplication.class, args);
    }
}
1
2
3
4
5
6

从启动类开始，springboot应用从标注有@SpringBootApplication注解的类开始启动，

该注解是一个组合注解。由

@SpringBootConfiguration、

@EnableAutoConfiguration和@ComponentScan三个子注解组成

.....
@SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan(
    excludeFilters = {@Filter(
    type = FilterType.CUSTOM,
    classes = {TypeExcludeFilter.class}
), @Filter(
    type = FilterType.CUSTOM,
    classes = {AutoConfigurationExcludeFilter.class}
)}
)
public @interface SpringBootApplication {
		// .......
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

# @SpringBootConfiguration

这个注解包含了@Configuration，@Configuration里面又包含了一个@Component注解，也就是说，这个注解标注在哪个类上，就表示当前这个类是一个配置类，而配置类也是Spring容器中的组件。

# @ComponentScan

@ComponentScan：它的作用就是根据定义的扫描路径，把符合扫描规则的类装配到Spring容器中，以待后续使用（让其实例化）。

# @EnableAutoConfiguration

根据名称，可以猜测它应该是开启自动配置的一个注解。

@EnableAutoConfiguration它里面又包含了两个注解，分别是

  • @AutoConfigurationPackage
  • @Import(AutoConfigurationImportSelector.class)
.....
@AutoConfigurationPackage
@Import({AutoConfigurationImportSelector.class})
public @interface EnableAutoConfiguration {
    String ENABLED_OVERRIDE_PROPERTY = "spring.boot.enableautoconfiguration";

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

    String[] excludeName() default {};
}
1
2
3
4
5
6
7
8
9
10

其中@AutoConfigurationPackage主要作用是标识自动配置的包，这样Spring Boot在启动时就可以自动扫描该包及其子包下的类，并将其纳入自动配置的范围。

而@Import(AutoConfigurationImportSelector.class)则是将配置类信息交给SpringFactory加载器进行一系列的容器创建过程。

# @AutoConfigurationPackage

@AutoConfigurationPackage：该注解包含了@Import({Registrar.class})

@Import({Registrar.class})
public @interface AutoConfigurationPackage {
    String[] basePackages() default {};

    Class<?>[] basePackageClasses() default {};
}
1
2
3
4
5
6

它利用Registrar给容器中导入一系列组件，将指定的一个包下的所有组件导入进来。(指定包：即为该注解所在的包也就是@SpringBootApplication-启动类所在的包)

以下是对应部分源码(AutoConfigurationPackages)的实现：

public static void register(BeanDefinitionRegistry registry, String... packageNames) {
        if (registry.containsBeanDefinition(BEAN)) {
            AutoConfigurationPackages.BasePackagesBeanDefinition beanDefinition = (AutoConfigurationPackages.BasePackagesBeanDefinition)registry.getBeanDefinition(BEAN);
            beanDefinition.addBasePackages(packageNames);
        } else {
            registry.registerBeanDefinition(BEAN, new AutoConfigurationPackages.BasePackagesBeanDefinition(packageNames));
        }

    }

static final class BasePackagesBeanDefinition extends GenericBeanDefinition {
        private final Set<String> basePackages = new LinkedHashSet();

        BasePackagesBeanDefinition(String... basePackages) {
            this.setBeanClass(AutoConfigurationPackages.BasePackages.class);
            this.setRole(2);
            this.addBasePackages(basePackages);
        }

        public Supplier<?> getInstanceSupplier() {
            return () -> {
                return new AutoConfigurationPackages.BasePackages(StringUtils.toStringArray(this.basePackages));
            };
        }

        private void addBasePackages(String[] additionalBasePackages) {
            this.basePackages.addAll(Arrays.asList(additionalBasePackages));
        }
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

# @Import({AutoConfigurationImportSelector.class})

AutoConfigurationImportSelector类通过selectImports方法，将配置类信息交给SpringFactory加载器进行一系列的容器创建。

  1. 利用getAutoConfigurationEntry(annotationMetadata);给容器中批量导入一些组件
  2. 调用List< String> configurations = getCandidateConfigurations(annotationMetadata, attributes)获取到所有需要导入到容器中的配置类
  3. 利用工厂加载 Map<String, List< String>> loadSpringFactories(@Nullable ClassLoader classLoader)；得到所有的组件
  4. 从META-INF/spring.factories位置来加载一个文件。 默认扫描我们当前系统里面所有META-INF/spring.factories位置的文件 spring-boot-autoconfigure-2.3.4.RELEASE.jar包里面也有META-INF/spring.factories

以下是对应的部分源码：

// 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());
        }
    }
// ......
  
  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);
        }
    }

//  获取待用配置信息
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;
    }

// 让springfactories 通过配置文件进行加载

public static List<String> loadFactoryNames(Class<?> factoryType, @Nullable ClassLoader classLoader) {
        ClassLoader classLoaderToUse = classLoader;
        if (classLoader == null) {
            classLoaderToUse = SpringFactoriesLoader.class.getClassLoader();
        }

        String factoryTypeName = factoryType.getName();
        return (List)loadSpringFactories(classLoaderToUse).getOrDefault(factoryTypeName, Collections.emptyList());
    }

private static Map<String, List<String>> loadSpringFactories(ClassLoader classLoader) {
        Map<String, List<String>> result = (Map)cache.get(classLoader);
        if (result != null) {
            return result;
        } else {
            HashMap result = new HashMap();

            try {
                Enumeration urls = classLoader.getResources("META-INF/spring.factories");

                while(urls.hasMoreElements()) {
                    URL url = (URL)urls.nextElement();
                    UrlResource resource = new UrlResource(url);
                    Properties properties = PropertiesLoaderUtils.loadProperties(resource);
                    Iterator var6 = properties.entrySet().iterator();
//......
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64

这里会加载一个名为META-INF/spring.factories的配置文件，该文件也是自定义starter的一个重要步骤。

META-INF/spring.factories 文件在 Spring 和 Spring Boot 应用程序中扮演着重要的角色，主要用于自动发现和加载特定类型的配置类或组件。这个机制允许开发者通过简单的声明来扩展框架的功能，而不需要额外的代码来注册这些组件。

它的作用有：

  1. 自动配置类注册：
    • 在 Spring Boot 中，spring.factories 文件用于注册自动配置类（带有 @Configuration 注解的类），这些类会在应用启动时被自动加载并应用。
    • 这些自动配置类通常使用条件注解（如 @ConditionalOnClass, @ConditionalOnMissingBean 等）来确保只有在满足特定条件时才会生效。
  2. 组件和服务的自动发现：
    • 除了自动配置类，spring.factories 文件还可以用于注册其他类型的组件和服务，如自定义的 EnvironmentPostProcessor, ApplicationListener, CommandLineRunner 等。
    • 这使得第三方库或模块可以轻松地集成到 Spring Boot 应用中，而无需用户手动配置。
  3. SPI（服务提供者接口）机制：
    • spring.factories 文件是 Java SPI 机制的一种实现方式。它允许框架扫描并加载实现了特定接口的类，从而实现插件化开发。
    • 例如，Spring Boot 使用这种机制来加载和应用各种 Starter 模块中的自动配置。

# 总结

虽然通过@EnableAutoConfiguration，会在容器中加载所有的bean

但实际确是只生效一部分，会按照条件装配规则（@Conditional），最终按需配置。

Spring Boot 使用 @Conditional 注解及其变体（如 @ConditionalOnClass, @ConditionalOnMissingBean, @ConditionalOnProperty 等）来确保只有在满足特定条件时才会应用某些自动配置。

# @Conditional

@Conditional 注解及其变体（如 @ConditionalOnClass, @ConditionalOnMissingBean, @ConditionalOnProperty 等）主要用于控制 Bean 的注册条件，可以应用于配置类、方法或单独的 Bean 定义上。通过这些注解，Spring 可以根据应用程序的具体条件决定是否创建和初始化特定的 Bean。

比如，如果你想确保只有在类路径中存在某个类时才加载整个配置类，可以在配置类上使用 @ConditionalOnClass：

import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
import org.springframework.context.annotation.Configuration;

@Configuration
@ConditionalOnClass(name = "org.example.SomeLibraryClass")
public class MyConfiguration {
    
    @Bean
    public MyService myService() {
        return new MyServiceImpl();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12

springboot中的自动装配流程:

  1. 启动 Spring Boot 应用：首先，你需要启动一个 Spring Boot 应用。这可以通过直接运行应用的主类（通常是一个带有 public static void main(String[] args) 方法的类）来实现。当 Spring Boot 应用启动时，它会自动创建并初始化一个 Spring 应用上下文（ApplicationContext）。
  2. 加载配置文件：Spring Boot 会加载应用类路径（classpath）下的配置文件。默认情况下，它会查找名为 application.properties 或 application.yml 的文件。这些文件中包含了 Spring Boot 的配置信息，比如数据库连接、端口号等。
  3. 创建 Bean：Spring Boot 会根据配置文件中的信息创建各种 Bean。例如，如果配置文件中指定了数据源的连接信息，Spring Boot 会自动创建一个数据源 Bean。这个过程是通过 Spring Boot 的自动配置特性实现的。
  4. 自动装配：在创建了各种 Bean 之后，Spring Boot 会根据这些 Bean 之间的关系进行自动装配。例如，如果一个类需要一个数据源，而 Spring Boot 已经创建了一个数据源 Bean，那么 Spring Boot 就会自动将这个数据源 Bean 注入到需要的类中。这个过程是通过 Spring 的依赖注入（DI）机制实现的。
  5. 应用启动：最后，当所有的 Bean 都已经被创建并装配好之后，Spring Boot 应用就可以正常运行了。

在整个过程中，Spring Boot 的自动装配-autoConfigurationXXX特性发挥了很大的作用。它可以根据 Bean 的名称、类型、属性等信息来自动进行配置。

再精简一些就是：

  • 启动流程
  1. 执行 SpringApplication.run() 时，触发 @EnableAutoConfiguration 注解。
  2. 通过 SpringFactoriesLoader 加载所有 spring.factories 中的自动配置类。
  3. 根据条件注解筛选出有效的配置类，注册到 Spring 容器中。

# spring的自动装配

在 Spring 框架 中，自动装配主要是指依赖注入的过程。它允许 Spring 自动解析并注入其他 Bean 作为依赖项，而不需要显式地在 XML 文件或注解中指定这些依赖关系。

spring的自动装配 范围要小于 springboot的自动装配

Spring 提供了多种自动装配的方式（其实就三种）：

  • 构造器注入：推荐使用，确保所有必需的依赖都已注入。
@Service
public class MyService {
    private final MyRepository myRepository;

    @Autowired
    public MyService(MyRepository myRepository) {
        this.myRepository = myRepository;
    }
}
1
2
3
4
5
6
7
8
9
  • 字段注入：简单直接，但不如构造器注入安全。
@Service
public class MyService {
    @Autowired
    private MyRepository myRepository;
}
1
2
3
4
5
  • Setter 方法注入：适合需要修改依赖的情况。
@Service
public class MyService {
    private MyRepository myRepository;

    @Autowired
    public void setMyRepository(MyRepository myRepository) {
        this.myRepository = myRepository;
    }
}
1
2
3
4
5
6
7
8
9
上次更新: 2025/04/23, 16:23:16
一些常用注解
spring中开启事务

← spring中开启事务→

最近更新
01
面向切面跟自定义注解的结合
05-22
02
时间跟其他数据的序列化
05-19
03
数据加密与安全
05-17
更多文章>
Theme by Vdoing | Copyright © 2023-2025 EffectTang