Spring Boot 自动装配底层源码实现详解

🌟 Spring Boot 自动装配底层源码实现详解

✅ 本文深入源码，完整剖析 Spring Boot 自动装配背后的实现逻辑，适合有一定基础的开发者查漏补缺、面试复习。

---

✅ 总结成流程图（详细调用链）

@SpringBootApplication
     │
     ▼
@EnableAutoConfiguration                           ⬅️ 自动装配启动入口
     │
     ▼
@Import(AutoConfigurationImportSelector.class)     ⬅️ 导入自动配置选择器类
     │
     ▼
SpringApplication.run()
     │
     ▼
ApplicationContext.refresh()                       ⬅️ 启动容器
     │
     ▼
invokeBeanFactoryPostProcessors()                  ⬅️ 调用所有 BeanFactory 后处理器
     │
     ▼
ConfigurationClassPostProcessor                    ⬅️ 处理配置类
     │
     ▼
parse()                                            ⬅️ 解析配置类
     │
     ▼
ConfigurationClassParser
     │
     ├── scan() / processConfigurationClass()
     │
     └── processImports()                          ⬅️ 处理 @Import 注解
              │
              ▼
   AutoConfigurationImportSelector                 ⬅️ 自动装配选择器
              │
              ▼
   selectImports(annotationMetadata)               ⬅️ 返回配置类路径数组
              │
              ├── getAutoConfigurationEntry()
              │        ├── getCandidateConfigurations()
              │        │        ├── SpringFactoriesLoader.loadFactoryNames()
              │        │        │        └── loadSpringFactories()        ⬅️ 加载 spring.factories
              │        │        └── ImportCandidates.load()              ⬅️ 加载 .imports 文件
              │        └── 去重、排除、过滤、事件发布等处理
              │
              ▼
   注册自动配置类为 @Configuration 配置类
     │
     ▼
loadBeanDefinitions()                              ⬅️ 将 @Bean 方法注册为 BeanDefinition
     │
     ▼
容器初始化，自动配置类生效

---

🧠 自动装配的核心流程分为 5 步：

自动配置类加载主要涉及三个类：AutoConfigurationImportSelector、SpringFactoriesLoader，ConfigurationClassBeanDefinitionReader

• AutoConfigurationImportSelector、SpringFactoriesLoader：这两个类主要用来加载第三方自动装配配置类的全类名
• ConfigurationClassBeanDefinitionReader：主要将获取到的全类名加载成 bean。

🥇 1. 启动入口加载配置类

SpringApplication.run(App.class, args);

• 启动 Spring 容器
• 自动注册 ConfigurationClassPostProcessor（处理配置类的后置处理器）

---

🥈 2. @EnableAutoConfiguration 被解析，回调其 AutoConfigurationImportSelector类selectImports() 方法

✅ 加载第三方自动装配配置类的全类名背后逻辑

• @EnableAutoConfiguration 内部通过 @Import(AutoConfigurationImportSelector.class) 导入配置类选择器
• 在配置类解析阶段，Spring 会回调其 AutoConfigurationImportSelector的selectImports() 方法。
• 依赖AutoConfigurationImportSelector、SpringFactoriesLoader：这两个类来加载第三方自动装配配置类的全类名

🔎 2.1 AutoConfigurationImportSelector类解析

selectImports() 方法详解

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

✅ 作用 ：调用 getAutoConfigurationEntry 获取配置类路径，然后返回给 Spring 进行后续解析。

📦 其中AutoConfigurationEntry 结构：

protected static class AutoConfigurationEntry {
    private final List<String> configurations; // 要注入的配置类
    private final Set<String> exclusions;      // 要排除的类
}

---

getAutoConfigurationEntry() 方法详解

protected 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.<String>removeDuplicates(configurations);

        // ③ 获取排除的类（通过exclude属性或@EnableAutoConfiguration(exclude = ...)配置）
        Set<String> exclusions = this.getExclusions(annotationMetadata, attributes);
        this.checkExcludedClasses(configurations, exclusions);
        configurations.removeAll(exclusions);

        // ④ 过滤无效配置类（比如条件不满足的 @ConditionalOnClass）
        configurations = this.getConfigurationClassFilter().filter(configurations);

        // ⑤ 发布事件通知监听器
        this.fireAutoConfigurationImportEvents(configurations, exclusions);

        return new AutoConfigurationEntry(configurations, exclusions);
    }
}

✅ 作用总结：

• 负责真正收集所有需要自动装配的配置类
• 做了去重、排除、过滤、事件通知等处理

---

获取配置类路径 → getCandidateConfigurations()

protected List<String> getCandidateConfigurations(AnnotationMetadata metadata, AnnotationAttributes attributes) {
    List<String> configurations = new ArrayList<>(
    // **获取文件配置类**
        SpringFactoriesLoader.loadFactoryNames(this.getSpringFactoriesLoaderFactoryClass(), this.getBeanClassLoader())
    );

    // Spring Boot 2.7+ 新增的支持 .imports 文件配置方式
    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;
}

✅ 作用总结：

• 在configurations后继续追加 META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports（为了适应2.7+后的配置文件）自动配置类的路径

📦 2.2 SpringFactoriesLoader类 源码解析

🔧 loadFactoryNames() 方法

public static List<String> loadFactoryNames(Class<?> factoryType, @Nullable ClassLoader classLoader) {
    ClassLoader classLoaderToUse = (classLoader != null) ? classLoader : SpringFactoriesLoader.class.getClassLoader();
    // factoryTypeName ：org.springframework.boot.autoconfigure.EnableAutoConfiguration
    String factoryTypeName = factoryType.getName();
    // 根据key返回对应的第三方配置类的全路径名，其中
    return (List) loadSpringFactories(classLoaderToUse)
                  .getOrDefault(factoryTypeName, Collections.emptyList());
}

🔧 loadSpringFactories() 方法

// 加载 META-INF/spring.factories文件成对应的map
// 其中： key：org.springframework.boot.autoconfigure.EnableAutoConfiguration
// value：com.alibaba.boot.nacos.config.autoconfigure.NacosConfigAutoConfiguration 
private static Map<String, List<String>> loadSpringFactories(ClassLoader classLoader) {
    Map<String, List<String>> result = cache.get(classLoader);
    if (result != null) return result;

    result = new HashMap<>();

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

        while (urls.hasMoreElements()) {
            URL url = urls.nextElement();
            UrlResource resource = new UrlResource(url);
            Properties properties = PropertiesLoaderUtils.loadProperties(resource);

            for (Map.Entry<?, ?> entry : properties.entrySet()) {
                String key = ((String) entry.getKey()).trim();
                String[] valueList = StringUtils.commaDelimitedListToStringArray((String) entry.getValue());

                for (String value : valueList) {
                    result.computeIfAbsent(key, k -> new ArrayList<>()).add(value.trim());
                }
            }
        }

        // 去重、封装成不可变集合
        result.replaceAll((factoryType, implementations) ->
            implementations.stream().distinct().collect(Collectors.collectingAndThen(Collectors.toList(), Collections::unmodifiableList))
        );

        cache.put(classLoader, result);
        return result;
    } catch (IOException ex) {
        throw new IllegalArgumentException(\"Unable to load factories from location [META-INF/spring.factories]\", ex);
    }
}

✅ 作用总结：

• 从类路径中加载 META-INF/spring.factories
• 将其转为 Map<String, List<String>> 缓存并返回
• 自动装配类的注册入口：key 是接口，value 是其实现类路径

---

🏅 3. 返回的配置类名 → 注册为配置类

• 上一步中 selectImports() 返回的是 List<String> 类型的配置类路径
• Spring 会将其视为 @Configuration 进行进一步解析

---

🏆 4. 配置类的 @Bean 方法 → 注册为 BeanDefinition

由 ConfigurationClassBeanDefinitionReader 完成：

• 注册配置类本身为 Bean
• 注册其 @Bean 方法为 loadBeanDefinitions
• 最终注册到 DefaultListableBeanFactory
  我们来逐步解读Bean注册 loadBeanDefinitions 源码方法，它们位于 ConfigurationClassBeanDefinitionReader 类中，是 将解析后的配置类注册为 BeanDefinition 的核心流程。

---

🔍 方法一：loadBeanDefinitions()

public void loadBeanDefinitions(Set<ConfigurationClass> configurationModel) {
    TrackedConditionEvaluator trackedConditionEvaluator = new TrackedConditionEvaluator();

    for (ConfigurationClass configClass : configurationModel) {
        this.loadBeanDefinitionsForConfigurationClass(configClass, trackedConditionEvaluator);
    }
}

✨ 作用：

这是入口方法，接收一批配置类（@Configuration、@Import 导入的类等），并逐个调用内部的 loadBeanDefinitionsForConfigurationClass() 方法进行处理。

🧠 参数说明：

• configurationModel：Spring 通过 ConfigurationClassParser 解析得到的完整配置类集合。
• TrackedConditionEvaluator：用于判断配置类是否应被跳过（基于 @Conditional）。

---

🔍 方法二：loadBeanDefinitionsForConfigurationClass()

private void loadBeanDefinitionsForConfigurationClass(ConfigurationClass configClass, TrackedConditionEvaluator trackedConditionEvaluator) {
    if (trackedConditionEvaluator.shouldSkip(configClass)) {
        // 1️⃣ 如果该配置类不应被注册（如被 @Conditional 排除），则移除原有的 BeanDefinition（如果存在）
        String beanName = configClass.getBeanName();
        if (StringUtils.hasLength(beanName) && this.registry.containsBeanDefinition(beanName)) {
            this.registry.removeBeanDefinition(beanName);
        }

        // 同时移除该类对应的 Import 注册信息
        this.importRegistry.removeImportingClass(configClass.getMetadata().getClassName());
    } else {
        // 2️⃣ 注册配置类本身为 BeanDefinition（如果是被 @Import 导入的）
        if (configClass.isImported()) {
            this.registerBeanDefinitionForImportedConfigurationClass(configClass);
        }

        // 3️⃣ 注册 @Bean 方法对应的 BeanDefinition
        for (BeanMethod beanMethod : configClass.getBeanMethods()) {
            this.loadBeanDefinitionsForBeanMethod(beanMethod);
        }

        // 4️⃣ 注册 @ImportResource 引用的外部配置文件（如 XML）
        this.loadBeanDefinitionsFromImportedResources(configClass.getImportedResources());

        // 5️⃣ 注册通过 ImportBeanDefinitionRegistrar 动态注册的 Bean
        this.loadBeanDefinitionsFromRegistrars(configClass.getImportBeanDefinitionRegistrars());
    }
}

---

✅ 小结：整个方法做了 5 件事

步骤	作用	方法
1️⃣	判断是否跳过配置类（@Conditional）	shouldSkip(configClass)
2️⃣	注册被 @Import 导入的配置类	registerBeanDefinitionForImportedConfigurationClass(configClass)
3️⃣	注册配置类中声明的 @Bean 方法	loadBeanDefinitionsForBeanMethod(beanMethod)
4️⃣	注册 XML 等外部资源	loadBeanDefinitionsFromImportedResources()
5️⃣	注册通过 ImportBeanDefinitionRegistrar 动态生成的 Bean	loadBeanDefinitionsFromRegistrars()

---

🧪 5. 容器初始化，实例化 Bean

容器刷新阶段：

• 根据已注册的 BeanDefinition 实例化 Bean
• 自动配置类也就被激活（如：数据源、Redis、WebMvc 等）

---

📌 小结

阶段	核心方法	作用
启动	SpringApplication.run()	启动容器
自动装配发现	selectImports()	获取自动配置类名
解析配置类	getAutoConfigurationEntry()	去重、过滤、排除
加载配置来源	loadFactoryNames() / loadSpringFactories()	从 spring.factories 加载类路径
注册与初始化	loadBeanDefinitions()	注册 @Bean 到 BeanFactory

🎉 总结一句话：

Spring Boot 自动装配的核心就是：@EnableAutoConfiguration + SpringFactoriesLoader 读取配置类名并注册为 Bean！