SpringBoot自动装配原理

@SpringBootApplication
public class SpringDemoApplication {
  public static void main(String[] args) {
    SpringApplication.run(SpringDemoApplication.class, args);
  }
}

@Target(ElementType.TYPE)  
@Retention(RetentionPolicy.RUNTIME)  
@Documented  
@Inherited  
@SpringBootConfiguration  
@EnableAutoConfiguration  
@ComponentScan(excludeFilters = { ... })  
public @interface SpringBootApplication {  
    ...  
}

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
// 自动配置包
@AutoConfigurationPackage
// 导入自动配置的组件
@Import(AutoConfigurationImportSelector.class)
public @interface EnableAutoConfiguration {
  ...
}

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
// 导入组件AutoConfigurationPackages.Registrar
@Import(AutoConfigurationPackages.Registrar.class)
public @interface AutoConfigurationPackage {
  ...
}

public class AutoConfigurationImportSelector implements DeferredImportSelector, BeanClassLoaderAware, EnvironmentAware {  
    ...  
    @Override  
    public String[] selectImports(AnnotationMetadata annotationMetadata) {  
        // 这里会加载META-INF/spring.factories中定义的自动配置类  
        ...  
    }  
    ...  
}

static class Registrar implements ImportBeanDefinitionRegistrar, DeterminableImports {
    @Override
    public void registerBeanDefinitions(AnnotationMetadata metadata, BeanDefinitionRegistry registry) {
      // 注册当前主程序的同级以及子集的包组件，其实就是注册了一个Bean的定义
      register(registry, new PackageImports(metadata).getPackageNames().toArray(new String[0]));
    }
    @Override
    public Set<Object> determineImports(AnnotationMetadata metadata) {
      return Collections.singleton(new PackageImports(metadata));
    }
  }

看下@Import(AutoConfigurationImportSelector.class)，通过Spring底层注解@Import，给容器导入一个组件，这个组件就是AutoConfigurationImportSelector.class，它实现了DeferredImportSelector，关键方法是selectImports()

/**
   * 获取需要导入的全限定类名数组
   *
   * @param annotationMetadata
   * @return
   */
  @Override
  public String[] selectImports(AnnotationMetadata annotationMetadata) {
    // 配置参数 spring.boot.enableautoconfiguration 是否打开，默认开启
    if (!isEnabled(annotationMetadata)) {
      return NO_IMPORTS;
    }
    // 获取自动配置对象，对象包含需要配置的全限定类名列表和需要排除的列表
    AutoConfigurationEntry autoConfigurationEntry = getAutoConfigurationEntry(annotationMetadata);
    return StringUtils.toStringArray(autoConfigurationEntry.getConfigurations());
  }
  /**
   * spring.boot.enableautoconfiguration 是否打开，默认处于打开状态
   *
   * @param metadata
   * @return
   */
  protected boolean isEnabled(AnnotationMetadata metadata) {
    if (getClass() == AutoConfigurationImportSelector.class) {
      return getEnvironment().getProperty(EnableAutoConfiguration.ENABLED_OVERRIDE_PROPERTY, Boolean.class, true);
    }
    return true;
  }

/**
   * 基于annotationMetadata发现标有{@link Configuration @Configuration}的配置类并返回{@link AutoConfigurationEntry}
   *
   * @param annotationMetadata 配置类的注解元数据
   * @return 应该被导入的自动配置
   */
  protected AutoConfigurationEntry getAutoConfigurationEntry(AnnotationMetadata annotationMetadata) {
    if (!isEnabled(annotationMetadata)) {
      return EMPTY_ENTRY;
    }
    AnnotationAttributes attributes = getAttributes(annotationMetadata);
    // 获取需要自动配置的类名集合
    List<String> configurations = getCandidateConfigurations(annotationMetadata, attributes);
    // 去重
    configurations = removeDuplicates(configurations);
    // 获取需要排除的列表
    Set<String> exclusions = getExclusions(annotationMetadata, attributes);
    checkExcludedClasses(configurations, exclusions);
    // 移除需要排除的数据
    configurations.removeAll(exclusions);
    // 获取配置过滤器
    configurations = getConfigurationClassFilter().filter(configurations);
    // 触发导入自动配置事件
    fireAutoConfigurationImportEvents(configurations, exclusions);
    // 返回自动配置对象
    return new AutoConfigurationEntry(configurations, exclusions);
  }

/**
   * 返回需要自动配置的类名列表
   *
   * @param metadata   the source metadata
   * @param attributes the {@link #getAttributes(AnnotationMetadata) annotation
   *                   attributes}
   * @return a list of candidate configurations
   */
  protected List<String> getCandidateConfigurations(AnnotationMetadata metadata, AnnotationAttributes attributes) {
    // 获取需要被加载的FactoryClass，也就是key
    Class<?> clazz = getSpringFactoriesLoaderFactoryClass();
    // 获取需要配置的全限定类名集合
    List<String> configurations = SpringFactoriesLoader.loadFactoryNames(clazz, 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;
  }
  
  /**
   * 获取需要加载的工厂类
   * 也就是key为org.springframework.boot.autoconfigure.EnableAutoConfiguration的配置都需要被加载到IoC
   *
   * @return the factory class
   */
  protected Class<?> getSpringFactoriesLoaderFactoryClass() {
    return EnableAutoConfiguration.class;
  }

/**
   * 使用给定的类加载器，从META-INF/spring.factories中加载给定的工厂类型实现
   * 在spring5.3中，如果给定的工厂类型下的实现类名发现不止一次，会进行去重处理
   *
   * @param factoryType factoryType，eg:org.springframework.beans.BeanInfoFactory=xxx
   * @param classLoader 用于加载资源的类加载器
   *                    {@code null} to use the default
   * @throws IllegalArgumentException if an error occurs while loading factory names
   * @see #loadFactories
   */
  public static List<String> loadFactoryNames(Class<?> factoryType, @Nullable ClassLoader classLoader) {
    ClassLoader classLoaderToUse = classLoader;
    if (classLoaderToUse == null) {
      classLoaderToUse = SpringFactoriesLoader.class.getClassLoader();
    }
    String factoryTypeName = factoryType.getName();
    // 加载Factories文件
    return loadSpringFactories(classLoaderToUse).getOrDefault(factoryTypeName, Collections.emptyList());
  }

/**
   * 加载Factories文件
   *
   * @param classLoader factories文件解析之后的map
   * @return
   */
  private static Map<String, List<String>> loadSpringFactories(ClassLoader classLoader) {
    // 现在缓存中查找，classLoader为key
    Map<String, List<String>> result = cache.get(classLoader);
    if (result != null) {
      return result;
    }
    result = new HashMap<>();
    try {
      // 获取资源，这里固定目录为：META-INF/spring.factories
      Enumeration<URL> urls = classLoader.getResources(FACTORIES_RESOURCE_LOCATION);
      while (urls.hasMoreElements()) {
        URL url = urls.nextElement();
        UrlResource resource = new UrlResource(url);
        // 将资源加载为Properties
        Properties properties = PropertiesLoaderUtils.loadProperties(resource);
        // 遍历配置
        for (Map.Entry<?, ?> entry : properties.entrySet()) {
          String factoryTypeName = ((String) entry.getKey()).trim();
          // 获取value的数组，一般为类的全限定名
          // 比如 org.springframework.beans.BeanInfoFactory=org.springframework.beans.ExtendedBeanInfoFactory
          String[] factoryImplementationNames =
              StringUtils.commaDelimitedListToStringArray((String) entry.getValue());
          // 添加到result
          for (String factoryImplementationName : factoryImplementationNames) {
            result.computeIfAbsent(factoryTypeName, key -> new ArrayList<>())
                .add(factoryImplementationName.trim());
          }
        }
      }
      // 对value进行去重
      result.replaceAll((factoryType, implementations) -> implementations.stream().distinct()
          .collect(Collectors.collectingAndThen(Collectors.toList(), Collections::unmodifiableList)));
      // 添加到缓存中
      cache.put(classLoader, result);
    } catch (IOException ex) {
      throw new IllegalArgumentException("Unable to load factories from location [" +
          FACTORIES_RESOURCE_LOCATION + "]", ex);
    }
    return result;
  }

org.springframework.boot.autoconfigure.EnableAutoConfiguration=\  
org.springframework.boot.autoconfigure.admin.SpringApplicationAdminJmxAutoConfiguration,\  
org.springframework.boot.autoconfigure.aop.AopAutoConfiguration,\  
...