Spring Boot是如何实现自动配置的？

 作者简介：大家好，我是码炫码哥，前中兴通讯、美团架构师，现任某互联网公司CTO，兼职码炫课堂主讲源码系列专题

代表作：《jdk源码&多线程&高并发》，《深入tomcat源码解析》，《深入netty源码解析》，《深入dubbo源码解析》，《深入springboot源码解析》，《深入spring源码解析》，《深入redis源码解析》等

联系qq：184480602，加我进群，大家一起学习，一起进步，一起对抗互联网寒冬。码炫课堂的个人空间-码炫码哥个人主页-面试，源码等

回答

Spring Boot 的自动配置核心是基于条件化配置来实现的。通过注解 @EnableAutoConfiguration ，Spring Boot 可以扫描并加载相关的自动配置类，这些类会根据当前上下文中的条件来决定是否生效。

核心机制是通过条件注解（如 @ConditionalOnClass、@ConditionalOnMissingBean）配合 META-INF/spring.factories 文件中的配置，完成 Bean 的动态加载。简单来说，就是通过查看当前环境和依赖的情况，动态地为应用配置必要的 Bean，而不需要手动去定义。

打个比方，就是说 Spring Boot 的自动配置就像一个智能助手，能根据我们给出的提示（比如引入的依赖或者设置的配置）自动完成大部分繁琐的配置工作，这极大地提升了我们的开发效率。

详解

Spring Boot 是如何实现自动装配机制的

我们先看 Spring Boot 的核心注解 @SpringBootApplication：

@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 {
  //...
}

这里我们可以把 @SpringBootApplication 看做是 Configuration、@EnableAutoConfiguration、@ComponentScan 注解的集合，三个注解的作用如下：

• @EnableAutoConfiguration：启用 SpringBoot 的自动配置机制，它会根据应用程序的依赖关系和当前环境，自动注册所需的 Bean。
• @Configuration：允许在上下文中注册额外的 bean 或导入其他配置类
• @ComponentScan：该注解用于启用组件扫描，以便 Spring Boot 可以自动发现和注册标有 @Component、@Service、@Repository 和 @Controller 注解的类。

所以，@EnableAutoConfiguration 是实现自动装配机制的核心，我们直接看：

@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 {};

}

使用 @Import 导入 AutoConfigurationImportSelector，所以我们需要进入 AutoConfigurationImportSelector。

AutoConfigurationImportSelector 是 Spring Boot 实现自动注解的核心组件，它用于从 META-INF/spring.factories 文件中加载自动配置类，并将这些配置类引入到 Spring 应用上下文中。

注： 在 Spring Boot 2.7 版本后，spring.factories 方式已经被标记为废弃，SpringBoot 2.7 版本后建议使用新的配置文件：/META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports 。 但是，加载的时候，会同时加载这两个文件。

AutoConfigurationImportSelector 定义如下：

public class AutoConfigurationImportSelector implements DeferredImportSelector, BeanClassLoaderAware,
    ResourceLoaderAware, BeanFactoryAware, EnvironmentAware, Ordered {
     // ....
}

实现的接口看着挺多，其实就两类，一个是 DeferredImportSelector，一个是 XxxAware 类接口。

这里我们重点分析 DeferredImportSelector，所以直接看 selectImports()：

public String[] selectImports(AnnotationMetadata annotationMetadata) {
  // 判断自动装配开关是否已打开
  if (!isEnabled(annotationMetadata)) {
    return NO_IMPORTS;
  }
  AutoConfigurationEntry autoConfigurationEntry = getAutoConfigurationEntry(annotationMetadata);
  return StringUtils.toStringArray(autoConfigurationEntry.getConfigurations());
}

这个方法很好理解，就是先判断自动装配开关是否已打开，如果打开了就获取所有需要自动装配的 Bean 的类全限定名，并封装为一个数组返回，getAutoConfigurationEntry() 是获取的：

protected AutoConfigurationEntry getAutoConfigurationEntry(AnnotationMetadata annotationMetadata) {
  if (!isEnabled(annotationMetadata)) {
    return EMPTY_ENTRY;
  }
  // 获取 @EnableAutoConfiguration 中的 exclude 和 excludeName
  AnnotationAttributes attributes = getAttributes(annotationMetadata);
  // 获取自动装配 Bean 的类全限定名
  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);
}

首先调用 getAttributes() 获取 @EnableAutoConfiguration 中的 exclude 和 excludeName，然后调用 getCandidateConfigurations() 获取所有需要自动装配的类全限定名，然后就是过滤。所以核心就是 getCandidateConfigurations()，我们一路跟踪会跟踪到 SpringFactoriesLoader#loadSpringFactories()：

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 {
    // 从 META-INF/spring.factories 加载资源数据
    Enumeration<URL> urls = classLoader.getResources(FACTORIES_RESOURCE_LOCATION);
    while (urls.hasMoreElements()) {
      // 加载
    }

    // Replace all lists with unmodifiable lists containing unique elements
    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;
}

FACTORIES_RESOURCE_LOCATION 定义如下：

public static final String FACTORIES_RESOURCE_LOCATION = "META-INF/spring.factories";

我们去包下面看下：

点开这个文件内容会非常多，码哥只列几个常见的：

org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
org.springframework.boot.autoconfigure.data.redis.RedisAutoConfiguration,\
org.springframework.boot.autoconfigure.data.redis.RedisReactiveAutoConfiguration,\
org.springframework.boot.autoconfigure.data.redis.RedisRepositoriesAutoConfiguration,\
//...
org.springframework.boot.autoconfigure.jackson.JacksonAutoConfiguration,\
org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration,\
org.springframework.boot.autoconfigure.jdbc.JdbcTemplateAutoConfiguration,\
//...
org.springframework.boot.autoconfigure.kafka.KafkaAutoConfiguration,\
//...
org.springframework.boot.autoconfigure.orm.jpa.HibernateJpaAutoConfiguration,\

获取后就会执行过滤，码哥的网站最终的结果是：

当 selectImports() 将这些内容封装成一个数组返回后，Spring 容器会将这些内容加载为 Bean，但是他们能否真的被加载成功，还得依赖 @Condition 。以 RedisAutoConfiguration 为例：

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

  @Bean
  @ConditionalOnMissingBean(name = "redisTemplate")
  @ConditionalOnSingleCandidate(RedisConnectionFactory.class)
  public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
    RedisTemplate<Object, Object> template = new RedisTemplate<>();
    template.setConnectionFactory(redisConnectionFactory);
    return template;
  }

  @Bean
  @ConditionalOnMissingBean
  @ConditionalOnSingleCandidate(RedisConnectionFactory.class)
  public StringRedisTemplate stringRedisTemplate(RedisConnectionFactory redisConnectionFactory) {
    StringRedisTemplate template = new StringRedisTemplate();
    template.setConnectionFactory(redisConnectionFactory);
    return template;
  }

}

这里有诸多 @Conditional 相关的注解，码哥一一解释下：

• @ConditionalOnClass(RedisOperations.class)：只有当类 RedisOperations 存在时才会加载 RedisAutoConfiguration。如果我们在应用中没有引入 Redis 相关的依赖，则 RedisAutoConfiguration 是不会被加载的。
• @ConditionalOnMissingBean(name = "redisTemplate")：只有当 redisTemplate 这个 Bean 不存在时才会加载 RedisTemplate。它避免了 redisTemplate 被重复加载。
• @ConditionalOnSingleCandidate(RedisConnectionFactory.class)：只有当容器中存在且只有一个类型为 RedisConnectionFactory 的 Bean 时才会被记载，它确保了 RedisConnectionFactory 的唯一性。

这三个 @Conditional 相关注解保证了我们需要首先有 Redis 的相关依赖，同时我们也没有自定义 RedisTemplate 且存在唯一的 RedisConnectionFactory，则 Spring Boot 自动装配这个默认的 Bean，并加载 redisTemplate Bean。