刨析 SpringBoot 自动装配原理，其实很简单

// 扫描规则，将要被管理的 Bean 交给 IOC 容器
@ComponentScan("cn.j3.mystarter")
public class MyStarterApplication {
    // 配置
}

@Service
public class MyStarterService {
    public void myService(String example) {
        System.out.println("您传入得值为：" + example);
    }
}

<dependency>
    <groupId>cn.j3</groupId>
    <artifactId>my-starter</artifactId>
    <version>0.0.1-SNAPSHOT</version>
</dependency>

@RestController
@RequestMapping("/test")
public class MvcTestController {
    
    // 正常注入
    @Autowired
    private MyStarterService myStarterService;

    @GetMapping("/mvc")
    public String mvcTest(){
        System.out.println("mvc success!");
        // 正常调用
        myStarterService.myService("测试自动装配！");
        return "success!";
    }
}

org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
cn.j3.mystarter.MyStarterApplication

// 我们要分析的注解
@SpringBootApplication
public class StudySpringbootApplication {
    public static void main(String[] args) {
        SpringApplication.run(StudySpringbootApplication.class, args);
    }
}

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan(excludeFilters = { @Filter(type = FilterType.CUSTOM, classes = TypeExcludeFilter.class),
      @Filter(type = FilterType.CUSTOM, classes = AutoConfigurationExcludeFilter.class) })
public @interface SpringBootApplication {

   @AliasFor(annotation = EnableAutoConfiguration.class)
   Class<?>[] exclude() default {};

   @AliasFor(annotation = EnableAutoConfiguration.class)
   String[] excludeName() default {};

   @AliasFor(annotation = ComponentScan.class, attribute = "basePackages")
   String[] scanBasePackages() default {};

   @AliasFor(annotation = ComponentScan.class, attribute = "basePackageClasses")
   Class<?>[] scanBasePackageClasses() default {};

   @AliasFor(annotation = ComponentScan.class, attribute = "nameGenerator")
   Class<? extends BeanNameGenerator> nameGenerator() default BeanNameGenerator.class;

   @AliasFor(annotation = Configuration.class)
   boolean proxyBeanMethods() default true;
}

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@AutoConfigurationPackage
@Import(AutoConfigurationImportSelector.class)
public @interface EnableAutoConfiguration {
    // 用来覆盖配置开启 / 关闭自动配置的功能
    String ENABLED_OVERRIDE_PROPERTY = "spring.boot.enableautoconfiguration";
    // 根据类排除指定的自动配置
    Class<?>[] exclude() default {};
    // 根据类名排除指定的自动配置
    String[] excludeName() default {};
}

public interface ImportSelector {

    // 根据导入的Configuration类的注解元数据选择哪一个类需要被导入，返回的数组就是需要被导入的类名
    String[] selectImports(AnnotationMetadata importingClassMetadata);
    // 排除不需要导入的类
    @Nullable
    default Predicate<String> getExclusionFilter() {
        return null;
    }
}

@Override
public String[] selectImports(AnnotationMetadata annotationMetadata) {
    // 检查自动配置功能是否开启，默认开启
    if (!isEnabled(annotationMetadata)) {
        return NO_IMPORTS;
    }
    // 封装将被引入的自动配置信息
    AutoConfigurationEntry autoConfigurationEntry = getAutoConfigurationEntry(annotationMetadata);
    // 返回符合条件的配置类的全限定类名数组
    return StringUtils.toStringArray(autoConfigurationEntry.getConfigurations());
}

protected AutoConfigurationEntry getAutoConfigurationEntry(AnnotationMetadata annotationMetadata) {
    // 是否开启自动装配
    if (!isEnabled(annotationMetadata)) {
        // 未开启，返回空
        return EMPTY_ENTRY;
    }
    AnnotationAttributes attributes = getAttributes(annotationMetadata);
    // 通过 SpringFactoriesLoader 类提供的方法加载类路径中 META-INF 目录下的 spring.factories 文件中针对 EnableAutoConfiguration 的注册配置类
    List<String> configurations = getCandidateConfigurations(annotationMetadata, attributes);
    // 队获得的注册配置类集合进行去重处理，防止多个项目引入同样的配置类
    configurations = removeDuplicates(configurations);
    // 获得注解中被 exclude 或 excludeName 所派出的类的集合
    Set<String> exclusions = getExclusions(annotationMetadata, attributes);
    // 检查被排除类是否可实例化，是否被自动注册配置所使用，不符合条件则抛出异常
    checkExcludedClasses(configurations, exclusions);
    // 从自动配置类集合中取出被排除的类
    configurations.removeAll(exclusions);
    // 检查配置类的注解是否符合 spring.factories 文件中 AutoConfigurationImportFilter 指定的注解检查条件
    configurations = getConfigurationClassFilter().filter(configurations);
    // 将赛选完成的配置类和排查的配置类构建为事件类，并传入监听器。监听器的配置在于 spring.factories 文件中，通过 AutoConfigurationImportListener z
    fireAutoConfigurationImportEvents(configurations, exclusions);
    return new AutoConfigurationEntry(configurations, exclusions);
}

protected List<String> getCandidateConfigurations(AnnotationMetadata metadata, AnnotationAttributes attributes) {
    // 重点，获取 META-INF/spring.factories 文件中 EnableAutoConfiguration 类型的值
    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;
}

protected Set<String> getExclusions(AnnotationMetadata metadata, AnnotationAttributes attributes) {
   Set<String> excluded = new LinkedHashSet<>();
    // 排除配置的自动装配类
   excluded.addAll(asList(attributes, "exclude"));
   excluded.addAll(Arrays.asList(attributes.getStringArray("excludeName")));
    // 排除通过配置文件 spring.autoconfigure.exclude = 类，的方法进行排除
   excluded.addAll(getExcludeAutoConfigurationsProperty());
   return excluded;
}

configurations = getConfigurationClassFilter().filter(configurations);

private ConfigurationClassFilter getConfigurationClassFilter() {
    if (this.configurationClassFilter == null) {
        // 加载文件中的过滤器
        List<AutoConfigurationImportFilter> filters = getAutoConfigurationImportFilters();
        for (AutoConfigurationImportFilter filter : filters) {
            // 给过滤器配置相应的环境属性值，可以认为是初始化过滤器的一些属性值
            invokeAwareMethods(filter);
        }
        // 封装过滤器配置对象
        this.configurationClassFilter = new ConfigurationClassFilter(this.beanClassLoader, filters);
    }
    return this.configurationClassFilter;
}
// 具体的加载 META-INF/spring.factories 中的 AutoConfigurationImportFilter 值
protected List<AutoConfigurationImportFilter> getAutoConfigurationImportFilters() {
    return SpringFactoriesLoader.loadFactories(AutoConfigurationImportFilter.class, this.beanClassLoader);
}

List<String> filter(List<String> configurations) {
    long startTime = System.nanoTime();
    // 将所有加载的自动配置类封装成数组
    String[] candidates = StringUtils.toStringArray(configurations);
    boolean skipped = false;
    // 挨个遍历过滤器进行判断，自动装配是否生效
    for (AutoConfigurationImportFilter filter : this.filters) {
        // 这是判断生效逻辑，candidates 是自动装配类数组，this.autoConfigurationMetadata 这个是 META-INF/spring-autoconfigure-metadata.properties 文件中的值
        boolean[] match = filter.match(candidates, this.autoConfigurationMetadata);
        for (int i = 0; i < match.length; i++) {
            if (!match[i]) {
                // 将不生效的自动配置类替换为 null 值
                candidates[i] = null;
                // 这个是一个标志位，保证下面需要进行剔除
                skipped = true;
            }
        }
    }
    // 判断标志位，有改动，说明要往下走，如果没有改动那就全部生效，不进行剔除
    if (!skipped) {
        return configurations;
    }
    // 剔除操作
    List<String> result = new ArrayList<>(candidates.length);
    // 遍历所有的自动装配类数组
    for (String candidate : candidates) {
        // 将不为 null 的值返回出去
        if (candidate != null) {
            result.add(candidate);
        }
    }
    if (logger.isTraceEnabled()) {
        int numberFiltered = configurations.size() - result.size();
        logger.trace("Filtered " + numberFiltered + " auto configuration class in "
                     + TimeUnit.NANOSECONDS.toMillis(System.nanoTime() - startTime) + " ms");
    }
    // 最终需要自动装配类的集合
    return result;
}

private void fireAutoConfigurationImportEvents(List<String> configurations, Set<String> exclusions) {
    // 加载 META-INF/spring.factories 文件中类型为 AutoConfigurationImportListener 的监听器，
    List<AutoConfigurationImportListener> listeners = getAutoConfigurationImportListeners();
    if (!listeners.isEmpty()) {
        // 封装自动装配导入事件，AutoConfigurationImportEvent
        AutoConfigurationImportEvent event = new AutoConfigurationImportEvent(this, configurations, exclusions);
        // 遍历监听器
        for (AutoConfigurationImportListener listener : listeners) {
            invokeAwareMethods(listener);
            // 广播事件，所有监听 AutoConfigurationImportEvent 事件的都会做出相关的反应
            listener.onAutoConfigurationImportEvent(event);
        }
    }
}