SpringBoot 自动装配原理解析

@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 {
  // 省略其他属性...
}

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Configuration
public @interface SpringBootConfiguration {
    @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 class AutoConfigurationImportSelector
  implements DeferredImportSelector, BeanClassLoaderAware, ResourceLoaderAware,
  BeanFactoryAware, EnvironmentAware, Ordered {

  @Override
  public String[] selectImports(AnnotationMetadata annotationMetadata) {
    if (!isEnabled(annotationMetadata)) {
      return NO_IMPORTS;
    }

    // 加载自动配置元数据（用于条件过滤优化）
    AutoConfigurationMetadata autoConfigurationMetadata = AutoConfigurationMetadataLoader
      .loadMetadata(this.beanClassLoader);

    // 获取自动配置的实体
    AutoConfigurationEntry autoConfigurationEntry = getAutoConfigurationEntry(
      autoConfigurationMetadata, annotationMetadata);

    return StringUtils.toStringArray(autoConfigurationEntry.getConfigurations());
  }

  // 具体用来加载自动配置类的方法
  protected AutoConfigurationEntry getAutoConfigurationEntry(
    AutoConfigurationMetadata autoConfigurationMetadata,
    AnnotationMetadata annotationMetadata) {
    if (!isEnabled(annotationMetadata)) {
      return EMPTY_ENTRY;
    }

    AnnotationAttributes attributes = getAttributes(annotationMetadata);
    // 步骤1：获取候选的配置类（从 spring.factories 加载）
    List<String> configurations = getCandidateConfigurations(annotationMetadata, attributes);

    // 步骤2：去重
    configurations = removeDuplicates(configurations);

    // 步骤3：获取排除的配置类
    Set<String> exclusions = getExclusions(annotationMetadata, attributes);
    checkExcludedClasses(configurations, exclusions);

    // 步骤4：移除排除的配置类
    configurations.removeAll(exclusions);

    // 步骤5：条件过滤（根据条件注解决定是否加载）
    configurations = filter(configurations, autoConfigurationMetadata);

    // 步骤6：触发自动配置导入事件
    fireAutoConfigurationImportEvents(configurations, exclusions);

    // 返回最终需要的配置
    return new AutoConfigurationEntry(configurations, exclusions);
  }
}

protected static class AutoConfigurationEntry {

  // 用来存储需要的配置项
  private final List<String> configurations;

  // 用来存储排除的配置项
  private final Set<String> exclusions;

  private AutoConfigurationEntry() {
    this.configurations = Collections.emptyList();
    this.exclusions = Collections.emptySet();
  }
}

protected List<String> getCandidateConfigurations(AnnotationMetadata metadata, AnnotationAttributes attributes) {
  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 Class<?> getSpringFactoriesLoaderFactoryClass() {
  // 返回的是 EnableAutoConfiguration 字节码对象
  return EnableAutoConfiguration.class;
}

protected ClassLoader getBeanClassLoader() {
  return this.beanClassLoader;
}

public static List<String> loadFactoryNames(Class<?> factoryClass, @Nullable ClassLoader classLoader) {
  // 获取 EnableAutoConfiguration.class 的全限定名
  // org.springframework.boot.autoconfigure.EnableAutoConfiguration
  String factoryClassName = factoryClass.getName();
  return loadSpringFactories(classLoader).getOrDefault(factoryClassName, Collections.emptyList());
}

private static Map<String, List<String>> loadSpringFactories(@Nullable ClassLoader classLoader) {
  // 缓存加载的配置类，避免重复加载
  MultiValueMap<String, String> result = cache.get(classLoader);
  if (result != null) {
    return result;
  }
  try {
    // 去资源目录下找或者去系统资源目录下找
    Enumeration<URL> urls = (classLoader != null
      ? classLoader.getResources(FACTORIES_RESOURCE_LOCATION)
      : ClassLoader.getSystemResources(FACTORIES_RESOURCE_LOCATION));

    result = new LinkedMultiValueMap<>();
    while (urls.hasMoreElements()) {
      URL url = urls.nextElement();
      UrlResource resource = new UrlResource(url);
      Properties properties = PropertiesLoaderUtils.loadProperties(resource);
      for (Map.Entry<?, ?> entry : properties.entrySet()) {
        String factoryClassName = ((String) entry.getKey()).trim();
        for (String factoryName : StringUtils.commaDelimitedListToStringArray((String) entry.getValue())) {
          result.add(factoryClassName, factoryName.trim());
        }
      }
    }
    // 加载完成放到缓存中
    cache.put(classLoader, result);
    // 返回加载到的配置类
    return result;
  }
  catch (IOException ex) {
    throw new IllegalArgumentException(
      "Unable to load factories from location [" + FACTORIES_RESOURCE_LOCATION + "]", ex);
  }
}

public final class SpringFactoriesLoader {
  public static final String FACTORIES_RESOURCE_LOCATION = "META-INF/spring.factories";
}

# Auto Configure
org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
org.springframework.boot.autoconfigure.admin.SpringApplicationAdminJmxAutoConfiguration,\
org.springframework.boot.autoconfigure.aop.AopAutoConfiguration,\
org.springframework.boot.autoconfigure.amqp.RabbitAutoConfiguration,\
org.springframework.boot.autoconfigure.batch.BatchAutoConfiguration,\
org.springframework.boot.autoconfigure.cache.CacheAutoConfiguration,\
...

启动应用
    ↓
@SpringBootApplication
    ↓
@EnableAutoConfiguration
    ↓
AutoConfigurationImportSelector.selectImports()
    ↓
getAutoConfigurationEntry()
    ↓
┌─────────────────────────────────────┐
│ 1. 从 spring.factories 加载候选配置类 │
│ 2. 去重处理                          │
│ 3. 排除处理（exclude/excludeName）   │
│ 4. 条件过滤（条件注解）              │
│ 5. 触发导入事件                      │
└─────────────────────────────────────┘
    ↓
返回最终配置类列表
    ↓
Spring 容器加载配置类
    ↓
创建 Bean 实例

@Configuration
@ConditionalOnProperty(
    prefix = "spring.datasource",
    name = "type",
    havingValue = "com.zaxxer.hikari.HikariDataSource",
    matchIfMissing = true  // 如果属性不存在，默认匹配
)
public class HikariDataSourceAutoConfiguration {
    // ...
}

@Configuration
@ConditionalOnExpression("${app.feature.enabled:false} && ${app.feature.mode} == 'auto'")
public class FeatureAutoConfiguration {
    // ...
}

configurations = filter(configurations, autoConfigurationMetadata);

@Configuration(proxyBeanMethods = false)
@ConditionalOnClass({ DataSource.class, EmbeddedDatabaseType.class })
@ConditionalOnMissingBean(type = "javax.sql.DataSource")
@EnableConfigurationProperties(DataSourceProperties.class)
@Import({ DataSourcePoolMetadataProvidersConfiguration.class,
    DataSourceInitializationConfiguration.class })
public class DataSourceAutoConfiguration {
  // ...
}

@Configuration(proxyBeanMethods = false)
@ConditionalOnClass(PlatformTransactionManager.class)
@AutoConfigureAfter({
    JtaAutoConfiguration.class,
    HibernateJpaAutoConfiguration.class,
    DataSourceTransactionManagerAutoConfiguration.class
})
public class TransactionAutoConfiguration {
    // 事务配置需要在数据源配置之后加载
}

@Configuration(proxyBeanMethods = false)
@ConditionalOnClass({ DataSource.class, EmbeddedDatabaseType.class })
@AutoConfigureBefore(DataSourceInitializationConfiguration.class)
public class DataSourceAutoConfiguration {
    // 数据源配置需要在初始化配置之前加载
}

@Configuration(proxyBeanMethods = false)
@AutoConfigureOrder(Ordered.HIGHEST_PRECEDENCE)
public class PriorityConfiguration {
    // 最高优先级，最先执行
}

@Configuration(proxyBeanMethods = false)
@ConditionalOnClass(PlatformTransactionManager.class)
@AutoConfigureAfter({ JtaAutoConfiguration.class, HibernateJpaAutoConfiguration.class,
    DataSourceTransactionManagerAutoConfiguration.class })
@EnableConfigurationProperties(TransactionProperties.class)
public class TransactionAutoConfiguration {
  // ...
}

@Configuration(proxyBeanMethods = false)
@ConditionalOnWebApplication(type = Type.SERVLET)
@ConditionalOnClass({ Servlet.class, DispatcherServlet.class, WebMvcConfigurer.class })
@ConditionalOnMissingBean(WebMvcConfigurationSupport.class)
@AutoConfigureOrder(Ordered.HIGHEST_PRECEDENCE + 10)
@AutoConfigureAfter({ DispatcherServletAutoConfiguration.class,
    TaskExecutionAutoConfiguration.class, ValidationAutoConfiguration.class })
public class WebMvcAutoConfiguration {
    // 自动配置 DispatcherServlet、ViewResolver 等
}

@Configuration(proxyBeanMethods = false)
@ConditionalOnClass(RedisOperations.class)
@EnableConfigurationProperties(RedisProperties.class)
@Import({ LettuceConnectionConfiguration.class, JedisConnectionConfiguration.class })
public class RedisAutoConfiguration {

    @Bean
    @ConditionalOnMissingBean(name = "redisTemplate")
    public RedisTemplate<Object, Object> redisTemplate(
            RedisConnectionFactory redisConnectionFactory) {
        // 自动创建 RedisTemplate
    }
}

@Configuration
@ConditionalOnClass(MyService.class)
@ConditionalOnMissingBean(MyService.class)
@EnableConfigurationProperties(MyServiceProperties.class)
public class MyServiceAutoConfiguration {

    @Bean
    @ConditionalOnProperty(prefix = "my.service", name = "enabled", havingValue = "true", matchIfMissing = true)
    public MyService myService(MyServiceProperties properties) {
        return new MyService(properties);
    }
}

@ConfigurationProperties(prefix = "my.service")
public class MyServiceProperties {
    private String name = "default";
    private int timeout = 1000;

    // getter/setter
}

org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
com.example.autoconfigure.MyServiceAutoConfiguration

my.service.enabled=true
my.service.name=MyCustomService
my.service.timeout=2000

com.example.autoconfigure.MyServiceAutoConfiguration
com.example.autoconfigure.AnotherAutoConfiguration

{
  "groups": [
    {
      "name": "my.service",
      "type": "com.example.MyServiceProperties",
      "sourceType": "com.example.MyServiceProperties"
    }
  ],
  "properties": [
    {
      "name": "my.service.enabled",
      "type": "java.lang.Boolean",
      "defaultValue": true,
      "description": "Enable my service auto-configuration."
    },
    {
      "name": "my.service.timeout",
      "type": "java.lang.Integer",
      "defaultValue": 1000,
      "description": "Service timeout in milliseconds."
    }
  ]
}

@Configuration
@AutoConfigureAfter(DataSourceAutoConfiguration.class)
public class MyConfiguration {
    // 确保在 DataSourceAutoConfiguration 之后执行
}