• 前言
• 1.什么是自动装配
• 2.自动装配原理分析
  • EnableAutoConfiguration注解
  • selectImports 的具体实现
• 3.自动装配步骤总结

前言

以往我们使用 Spring MVC 来构建一个项目需要很多基础操作：添加很多 jar，配置 web.xml，配置 Spring 的 XML 或 javaConfig 类。 而 SpingBoot 给我们省略了很多基础工作，快速开发，不用再写繁琐的 XML，而这些都由各种 Starter 组件及自动装配来替代。 什么是 Starter，什么是自动装配呢？对于 Spring Boot，我们不仅要会用，也要明白其原理，很可能你面试就被问到。本文将通过分析源码讲解 Spring Boot 的自动装配原理。

1.什么是自动装配

什么是自动装配，Spring Boot 是怎么实现自动装配的呢？先来看个例子。 首先我们新建一个 Maven 工程，引入 spring-boot-starter-data-redis：

<dependency>
       <groupId>org.springframework.boot</groupId>
       <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>

在配置文件中添加数据源：

spring.redis.host=localhost
#密码
spring.redis.password=
#单节点 默认 6379
spring.redis.port=6379

写一个测试类：

/**
* @author Mr.Fire
* @date 2021/8/14 11:03
* @desc
  */
  @Service
  public class DistributedCache {

  @Autowired
  RedisTemplate<String, Object> redisTemplate;

  public boolean exists(Object key) {
  return false;
  }


    public List<ValueWrapper> mGet(List<? extends String> keys) {
         List<Object> valueList = redisTemplate.opsForValue().multiGet(createCacheKeys(keys));
         return valueList.stream().map(t -> new SimpleValueWrapper(t)).collect(Collectors.toList());
    }
    ...
}

我们并没有通过过XML的形式或注解的方式把RedisTemplate装配到 IOC 容器中。却可以直接使用@Autowired注入RedisTemplate来使用。 说明IOC容器中已经存在 bean，这就是 Spring Boot 的自动装配，相信大家都不陌生，接下来讲解其原理。

2.自动装配原理分析

EnableAutoConfiguration注解

Spring Boot的自动装配是通过EnableAutoConfiguration注解来开启的。下面我们来看看这个注解。 下面这段代码是笔者的一个 Demo 程序入口。

 /**
  * @author Mr.Fire
  */
  @EnableCaching
  @SpringBootApplication
  @MapperScan("com.fire.blog.mapper")
  public class ServerApplication extends SpringBootServletInitializer {


    public static void main(String[] args) {
        new SpringApplicationBuilder(ServerApplication.class).beanNameGenerator(new BeanNameGenerator()).run(args);
    }


}

EnableAutoConfiguration 声明在 @SpringBootApplication 中。点击进入源码，可以看到 @EnableAutoConfigurationde 声明。

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


/**
* Exclude specific auto-configuration classes such that they will never be applied.
* @return the classes to exclude
  */
  @AliasFor(annotation = EnableAutoConfiguration.class)
  Class<?>[] exclude() default {};


/**
* Exclude specific auto-configuration class names such that they will never be
* applied.
* @return the class names to exclude
* @since 1.3.0
  */
  @AliasFor(annotation = EnableAutoConfiguration.class)
  String[] excludeName() default {};
  ...

进入到 @EnableAutoConfiguration：

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@AutoConfigurationPackage
@Import(AutoConfigurationImportSelector.class)
public @interface EnableAutoConfiguration {


/**
* Environment property that can be used to override when auto-configuration is
* enabled.
  */
  String ENABLED_OVERRIDE_PROPERTY = "spring.boot.enableautoconfiguration";
  /**
* Exclude specific auto-configuration classes such that they will never be applied.
* @return the classes to exclude
  */
  Class<?>[] exclude() default {};

这里我们主要关注两个：

• @AutoConfigurationPackage：该注解的作用是将 添加该注解的类所在的 package 作为 自动配置 package 进行管理。 通俗来讲就是把使用了该注解的类所在的包及其子包下的所有组件扫描到 IOC 容器中。

• @Import(AutoConfigurationImportSelector.class)：Import 注解是用来导入配置类或者一些需要前置加载的类。该注解有三种用法：

  • 带有 @Configuration 的配置类

  • ImportSelector 的实现

  • ImportBeanDefinitionRegistrar 的实现

这里我们看到的 @Import 正是用的第二种方式，导入的一个 AutoConfigurationImportSelector 类。该类实现了ImportSelector接口。ImportSelector和Configuration的区别就是可以批量选择装配哪些bean， 接下来我们重点分析这个类。

定位到AutoConfigurationImportSelector类：

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

源码太长，此处省略了具体的实现，看文章时尽量自己到源码中看。

可以看到 AutoConfigurationImportSelector 实现了 ImportSelector 的 selectImports 方法， 这个方法可以选择性返回需要装配的 bean，返回结果是一个数组。改方法主要实现两个功能：

• 从 META-INF/spring.factories 加载配置类
• 筛选出符合条件的配置类集合

selectImports 的具体实现

下面是 selectImports 的具体实现：

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

selectImports 方法里通过调用getAutoConfigurationEntry拿到 AutoConfigurationEntry 配置对象，在通过 autoConfigurationEntry.getConfigurations() 拿到所有符合条件的配置类。

getAutoConfigurationEntry 方法分析：

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);
}

• getAttributes：获得 @EnableAutoConfiguration 注解中的 exclude、excludeName 属性

• getCandidateConfigurations：获得所有自动装配的配置类

• removeDuplicates：去除重复配置项

• checkExcludedClasses：根据 exclude、excludeName 属性移除不需要的配置

• fireAutoConfigurationImportEvents：广播事件

• AutoConfigurationEntry：返回过滤后的配置类

如何获得这些配置类呢，这里关键看 getCandidateConfigurations 方法。

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

这里用到了 SpringFactoriesLoader，Spring 内部提供的一种加载方式，类似于 Java 的 SPI 机制，主要是扫描 classpath 下的 META-INF/spring.factories 文件，spring.factories 是 key=value 的形式存储，SpringFactoriesLoader 根据 key 得到 value，来看 loadFactoryNames 方法：

public static List<String> loadFactoryNames(Class<?> factoryType, @Nullable ClassLoader classLoader) {
  ClassLoader classLoaderToUse = classLoader;
  if (classLoaderToUse == null) {
     classLoaderToUse = SpringFactoriesLoader.class.getClassLoader();
  }
  String factoryTypeName = factoryType.getName();
  return loadSpringFactories(classLoaderToUse).getOrDefault(factoryTypeName, Collections.emptyList());
}

这里的 loadSpringFactories 方法内部实现就是扫描所有 META-INF/spring.factories 文件，构建成一个 Map<String, List>， key 为 factoryTypeName，value 为基于 javaConfig 形式的配置类集合。接下来就是把这些 Bean 都装配到 IOC 容器中，到这我们就明白 Spring Boot 是如何实现自动装配。

3.自动装配步骤总结

1. 通过@Import(AutoConfigurationImportSelector.class)导入实现类

2. 实现 ImportSelector 的 selectImports 方法，选择性批量装配配置类

3. 通过 Spring 提供的 SpringFactoriesLoader 机制，扫描 META-INF/spring.factories

4. 读取需要装配的配置类，筛选符合条件的配置类，把不符合的排除

5. 通过 javaConfig 的形式装配 Bean。