springboot启动流程 (3) 自动装配

在SpringBoot中，EnableAutoConfiguration注解用于开启自动装配功能。
本文将详细分析该注解的工作流程。
EnableAutoConfiguration注解

启用SpringBoot自动装配功能，尝试猜测和配置可能需要的组件Bean。
自动装配类通常是根据类路径和定义的Bean来应用的。例如，如果类路径上有tomcat-embedded.jar，那么可能需要一个TomcatServletWebServerFactory(除非已经定义了自己的Servlet WebServerFactory Bean)。
自动装配试图尽可能地智能化，并将随着开发者定义自己的配置而取消自动装配相冲突的配置。开发者可以使用exclude()排除不想使用的配置，也可以通过spring.autoconfig.exclude属性排除这些配置。自动装配总是在用户定义的Bean注册之后应用。
用@EnableAutoConfiguration注解标注的类所在包具有特定的意义，通常用作默认扫描的包。通常建议将@EnableAutoConfiguration(如果没有使用@SpringBootApplication注解)放在根包中，以便可以搜索所有子包和类。
自动装配类是普通的Spring @Configuration类，使用SpringFactoriesLoader机制定位。通常使用@Conditional方式装配，最常用的是@ConditionalOnClass和@ConditionalOnMissingBean注解。

1. @AutoConfigurationPackage
2. @Import(AutoConfigurationImportSelector.class)
3. public @interface EnableAutoConfiguration {
5.         /**
6.          * Exclude specific auto-configuration classes such that they will never be applied.
7.          */
8.         Class<?>[] exclude() default {};
10.         /**
11.          * Exclude specific auto-configuration class names such that they will never be
12.          * applied.
13.          * 当类路径下没有指定的类时，可以使用这个属性指定排除的类
14.          */
15.         String[] excludeName() default {};
16. }

复制代码

该注解Import了AutoConfigurationImportSelector类，AutoConfigurationImportSelector类实现了DeferredImportSelector接口。
Import注解和DeferredImportSelector接口在之前的"Spring @Import注解源码分析"中详细分析过，此处在介绍它们，只分析AutoConfigurationImportSelector的工作流程。
AutoConfigurationImportSelector类

DeferredImportSelector接口

A variation of ImportSelector that runs after all @Configuration beans have been processed. This type of selector can be particularly useful when the selected imports are @Conditional.
Implementations can also extend the org.springframework.core.Ordered interface or use the org.springframework.core.annotation.Order annotation to indicate a precedence against other DeferredImportSelectors.
Implementations may also provide an import group which can provide additional sorting and filtering logic across different selectors.
AutoConfigurationGroup类

AutoConfigurationImportSelector的getImportGroup方法返回了AutoConfigurationGroup类。

1. private static class AutoConfigurationGroup implements
2.                 DeferredImportSelector.Group, BeanClassLoaderAware, BeanFactoryAware, ResourceLoaderAware {
4.         private final Map<String, AnnotationMetadata> entries = new LinkedHashMap<>();
6.         private final List<AutoConfigurationEntry> autoConfigurationEntries = new ArrayList<>();
8.         // ... 略
10.         @Override
11.         public void process(
12.                         AnnotationMetadata annotationMetadata,
13.                         DeferredImportSelector deferredImportSelector) {
15.                 // AutoConfigurationEntry类使用List保存Configuration类
16.                 AutoConfigurationEntry autoConfigurationEntry =
17.             ((AutoConfigurationImportSelector) deferredImportSelector)
18.                                 .getAutoConfigurationEntry(annotationMetadata);
20.                 this.autoConfigurationEntries.add(autoConfigurationEntry);
21.                 for (String importClassName : autoConfigurationEntry.getConfigurations()) {
22.                         this.entries.putIfAbsent(importClassName, annotationMetadata);
23.                 }
24.         }
26.         @Override
27.         public Iterable<Entry> selectImports() {
28.                 // 查找排除的配置类
29.                 Set<String> allExclusions = this.autoConfigurationEntries.stream()
30.                                 .map(AutoConfigurationEntry::getExclusions)
31.                                 .flatMap(Collection::stream)
32.                                 .collect(Collectors.toSet());
33.                 // 所有配置类
34.                 Set<String> processedConfigurations = this.autoConfigurationEntries.stream()
35.                                 .map(AutoConfigurationEntry::getConfigurations)
36.                                 .flatMap(Collection::stream)
37.                                 .collect(Collectors.toCollection(LinkedHashSet::new));
38.                 // 将排除的配置类移除掉
39.                 processedConfigurations.removeAll(allExclusions);
41.                 // 排序
42.                 return sortAutoConfigurations(processedConfigurations, getAutoConfigurationMetadata()).stream()
43.                                 .map((importClassName) -> new Entry(this.entries.get(importClassName), importClassName))
44.                                 .collect(Collectors.toList());
45.         }
47.         // ... 略
48. }

复制代码

从上面的代码可以看出，查找自动装配类的逻辑在getAutoConfigurationEntry方法中。
getAutoConfigurationEntry方法

从META-INF/spring.factories文件解析EnableAutoConfiguration配置。
META-INF/spring.factories文件示例：

1. protected AutoConfigurationEntry getAutoConfigurationEntry(AnnotationMetadata annotationMetadata) {
2.         AnnotationAttributes attributes = getAttributes(annotationMetadata);
3.         // 查找自动装配类
4.         List<String> configurations = getCandidateConfigurations(annotationMetadata, attributes);
5.         // 以下几行为查找排除类、过滤等操作
6.         configurations = removeDuplicates(configurations);
7.         Set<String> exclusions = getExclusions(annotationMetadata, attributes);
8.         checkExcludedClasses(configurations, exclusions);
9.         configurations.removeAll(exclusions);
10.         // 这里的Filter是从META-INF/spring.factories文件解析出来的
11.         configurations = getConfigurationClassFilter().filter(configurations);
12.         // 触发事件
13.         fireAutoConfigurationImportEvents(configurations, exclusions);
14.         return new AutoConfigurationEntry(configurations, exclusions);
15. }
17. protected List<String> getCandidateConfigurations(
18.                 AnnotationMetadata metadata, AnnotationAttributes attributes) {
19.         // 从META-INF/spring.factories文件查找EnableAutoConfiguration配置
20.         List<String> configurations = SpringFactoriesLoader.loadFactoryNames(
21.                                                 getSpringFactoriesLoaderFactoryClass(), getBeanClassLoader());
22.         return configurations;
23. }

复制代码

SpringFactoriesLoader类loadFactoryNames方法

Load the fully qualified class names of factory implementations of the given type from "META-INF/spring.factories", using the given class loader.

1. public static List<String> loadFactoryNames(Class<?> factoryType, ClassLoader classLoader) {
2.         String factoryTypeName = factoryType.getName();
3.         return loadSpringFactories(classLoader).getOrDefault(factoryTypeName, Collections.emptyList());
4. }
6. private static Map<String, List<String>> loadSpringFactories(ClassLoader classLoader) {
7.         MultiValueMap<String, String> result = cache.get(classLoader);
8.         if (result != null) {
9.                 return result;
10.         }
12.         try {
13.                 // FACTORIES_RESOURCE_LOCATION = "META-INF/spring.factories"
14.                 // 从类路径下查找META-INF/spring.factories文件
15.                 Enumeration<URL> urls = (classLoader != null ?
16.                                 classLoader.getResources(FACTORIES_RESOURCE_LOCATION) :
17.                                 ClassLoader.getSystemResources(FACTORIES_RESOURCE_LOCATION));
18.                 result = new LinkedMultiValueMap<>();
19.                 while (urls.hasMoreElements()) {
20.                         URL url = urls.nextElement();
21.                         UrlResource resource = new UrlResource(url);
22.                         // 获取properties配置
23.                         Properties properties = PropertiesLoaderUtils.loadProperties(resource);
24.                         for (Map.Entry<?, ?> entry : properties.entrySet()) {
25.                                 String factoryTypeName = ((String) entry.getKey()).trim();
26.                                 for (String factoryImplementationName :
27.                      StringUtils.commaDelimitedListToStringArray((String) entry.getValue())) {
28.                                         result.add(factoryTypeName, factoryImplementationName.trim());
29.                                 }
30.                         }
31.                 }
32.                 // 把配置添加缓存
33.                 cache.put(classLoader, result);
34.                 return result;
35.         } catch (IOException ex) {
36.                 throw new IllegalArgumentException("Unable to load factories from location [" +
37.                                 FACTORIES_RESOURCE_LOCATION + "]", ex);
38.         }
39. }

复制代码

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！