SpringBoot自动配置原理，以及如何编写自定义的starter

落日映苍穹つ 2023-10-15 23:29 6阅读 0赞

# 简介 #

> Spring Boot 基于 Spring 开发，Spirng Boot 本身并不提供 Spring 框架的核心特性以及扩展功能，只是用于快速、敏捷地开发新一代基于 Spring 框架的应用程序。也就是说，它并不是用来替代 Spring 的解决方案，而是和 Spring 框架紧密结合用于提升 Spring 开发者体验的工具。Spring Boot 以**约定大于配置的核心思想**，默认帮我们进行了很多设置，多数 Spring Boot 应用只需要很少的 Spring 配置。同时它集成了大量常用的第三方库配置（例如 Redis、MongoDB、RabbitMQ等等），Spring Boot 应用中这些第三方库几乎可以零配置的开箱即用。

# 前置知识 #

> 批量注册bean的方式
> 
>  *  通过@Bean标注方法的方式，一个个来注册
>  *  @CompontentScan的方式：默认的@CompontentScan是无能为力的，默认情况下只会注册@Compontent标注的类
>  *  @Import

前两种方式，不适用于频繁变化的场景，且有局限性，所以SpringBoot作为脚手架，自动装配第三方类显然第三种方式更适合；

因此我们首先来了解下@Import注解；

## @Import注解 ##

> 作用：@Import可以用来批量导入需要注册的各种类，如普通的类、配置类，然后完成普通类和配置类中所有bean的注册。

支持如下三种方式：

### 1、直接导入普通类 ###

*  创建一个普通类

kotlin
    
    复制代码
    
    package com.doudou.imports;  public class DouDouBean {  public String print() { return "return doudou bean"; }  }

*  创建一个配置类，导入刚创建的类

less
    
    复制代码
    
    @Configuration @Import({DouDouBean.class}) public class Main {     public static void main(String[] args) {        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(Main.class);        DouDouBean douDouBean = context.getBean(DouDouBean.class);        System.out.println(douDouBean.print());   } }

*  控制台输出结果

![0.png][]

### 2、配合自定义的 ImportSelector 使用 ###

> ImportSelector是一个接口，该接口提供了一个selectImports方法，用来返回全类名数组；可以通过这种方式，动态导入N个bean

*  创建普通类

kotlin
    
    复制代码
    
    @Configuration public class DouDouConfig {  @Bean public String RedBeanBun() { return "Red Bean Bun"; }  @Bean public String OatBag() { return "Oat Bag"; }  }

typescript
    
    复制代码
    
    public class DouDouBean {  public String print() { return "return doudou bean"; }  }

*  实现ImportSelector接口

typescript
    
    复制代码
    
    public class DouDouImportSelector implements ImportSelector {  @Override public String[] selectImports(AnnotationMetadata importingClassMetadata) { return new String[] { DouDouBean.class.getName(), DouDouConfig.class.getName() }; }  }

*  创建一个配置类，导入实现了ImportSelector接口的类

less
    
    复制代码
    
    @Configuration @Import({DouDouImportSelector.class}) public class Main {  public static void main(String[] args) { AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(Main.class); for (String name : context.getBeanDefinitionNames()) { System.out.println(String.format("%s=%s", name, context.getBean(name))); }   } }

*  控制台输出结果

![1.png][]

#### 2.1 重点：DeferredImportSelector ####

> 装个杯，如果让你实现一个框架，比如希望用户如果实现了自己的配置类，跟SpringBoot自动加载的配置类相同，希望以用户的为准，你会怎么做？
> 
> SpringBoot实现上述需要就是使用了DeferredImportSelector；
> 
> SpringBoot中的核心功能@EnableAutoConfiguration就是靠DeferredImportSelector来实现的；
> 
> DeferredImportSelector是ImportSelector的子接口，所以也能够通过@Import导入，跟ImportSelector不同点在于：
> 
>  *  分组
>  *  延时导入

*  创建需要延迟导入的配置类

typescript
    
    复制代码
    
    @Configuration public class DeferredConfig {  @Bean public String dog() { return "dog"; }  }

*  实现DeferredImportSelector接口

typescript
    
    复制代码
    
    public class DouDeferredImportSelect implements DeferredImportSelector { @Override public Class<? extends Group> getImportGroup() { return DeferredImportSelector.super.getImportGroup(); }  @Override public String[] selectImports(AnnotationMetadata importingClassMetadata) { return new String[]{ DeferredConfig.class.getName() }; } }

*  创建一个配置类，导入实现了DeferredImportSelector接口的类

less
    
    复制代码
    
    @Configuration @Import({    DouDeferredImportSelect.class,    DouDouImportSelector.class}) public class Main {     public static void main(String[] args) {        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(Main.class);        for (String name : context.getBeanDefinitionNames()) {            System.out.println(String.format("%s=%s", name, context.getBean(name)));       }   } }

*  控制台输出结果，可以发现DeferredConfig最后输出，跟Import导入顺序不一致

![2.png][]

### 3、配合 ImportBeanDefinitionRegistrar 使用 ###

> ImportBeanDefinitionRegistrar也是一个接口，支持手动的注册bean到容器当中

*  创建需要被手动注册到bean容器当中的类

typescript
    
    复制代码
    
    public class DouDefinitionRegistrarBean {  public String pig() { return "pig"; }  }

*  实现ImportBeanDefinitionRegistrar接口

java
    
    复制代码
    
    public class DouDefinitionRegistrar implements ImportBeanDefinitionRegistrar {  public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) { RootBeanDefinition definition = new RootBeanDefinition(DouDefinitionRegistrarBean.class); registry.registerBeanDefinition("douDefinitionRegistrarBean", definition); }  }

*  创建配置类，导入实现了ImportBeanDefinitionRegistrar接口的类

less
    
    复制代码
    
    @Configuration @Import({    DouDeferredImportSelect.class,    DouDouImportSelector.class,    DouDefinitionRegistrar.class}) public class Main {     public static void main(String[] args) {        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(Main.class);        for (String name : context.getBeanDefinitionNames()) {            System.out.println(String.format("%s=%s", name, context.getBean(name)));       }   } }

*  控制台输出结果，可以发现DouDefinitionRegistrarBean类被注入

![3.png][]

## @Condition注解 ##

> @Condition注解能够实现在满足特定条件下配置类才生效

*  创建一个配置类，实现Condition接口，改接口仅提供了一个matches方法，返回值为boolean类型，该方法返回true，代表配置类生效；反之，不生效；

typescript
    
    复制代码
    
    @Configuration public class DouDouConditionBean implements Condition {  @Override public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) { return true; }  }

*  创建另一个配置类，依赖上述配置类matches方法来判断是否需要生效

less
    
    复制代码
    
    @Configuration @Conditional({DouDouConditionBean.class}) public class ConditionBeanConfig {  }

*  创建配置类，测试ConditionBeanConfig配置类是否被注入

less
    
    复制代码
    
    @Configuration @ComponentScan(basePackages = {"com.doudou.condition"}) public class Main {  public static void main(String[] args) { AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(Main.class); for (String name : context.getBeanDefinitionNames()) { System.out.println(String.format("%s=%s", name, context.getBean(name))); }   } }

*  控制台结果输出，ConditionBeanConfig类生效，被成功注入到IOC容器

![4.png][]

> 拓展注解

<table> 
 <thead> 
  <tr> 
   <th>@Conditional扩展注解</th> 
   <th>（判断是否满足当前指定条件）</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>@ConditionalOnJava</td> 
   <td>系统的java版本是否符合要求</td> 
  </tr> 
  <tr> 
   <td>@ConditionalOnBean</td> 
   <td>容器中存在指定Bean</td> 
  </tr> 
  <tr> 
   <td>@ConditionalOnMissingBean</td> 
   <td>容器中不存在指定Bean</td> 
  </tr> 
  <tr> 
   <td>@ConditionalOnExpression</td> 
   <td>满足SpEL表达式指定</td> 
  </tr> 
  <tr> 
   <td>@ConditionalOnClass</td> 
   <td>系统中有指定的类</td> 
  </tr> 
  <tr> 
   <td>@ConditionalOnMissingClass</td> 
   <td>系统中没有指定的类</td> 
  </tr> 
  <tr> 
   <td>@ConditionalOnSingleCandidate</td> 
   <td>容器中只有一个指定的Bean，或者这个Bean是首选Bean</td> 
  </tr> 
  <tr> 
   <td>@ConditionalOnProperty</td> 
   <td>系统中指定的属性是否有指定的值</td> 
  </tr> 
  <tr> 
   <td>@ConditionalOnResource</td> 
   <td>类路径下是否存在指定资源文件</td> 
  </tr> 
  <tr> 
   <td>@ConditionalOnWebApplication</td> 
   <td>当前是web环境</td> 
  </tr> 
  <tr> 
   <td>@ConditionalOnNotWebApplication</td> 
   <td>当前不是web环境</td> 
  </tr> 
  <tr> 
   <td>@ConditionalOnJndi</td> 
   <td>JNDI存在指定项</td> 
  </tr> 
 </tbody> 
</table>

# 1、SpringBoot自动配置分析 #

> 注意：本篇博文分析，基于SpringBoot 2.5.2版本

> 自动配置原理流程图

![c3bb18754a584dd38e62c157ebfeb9fd.png][]

> 上述识别到需要自动配置的配置类，被生成BeanDefinitionMap，通过BeanFactory生成具体的Bean，该部分内容由Spring IOC完成，非SpringBoot做的事，所以一笔带过，主要让大家别太懵逼；

**具体源码分析，先从启动类入手**：

## @SpringBootApplication注解 ##

> 该注解标注该类是SpringBoot的主配置类

less
    
    复制代码
    
    @Target(ElementType.TYPE) // 设置该注解可以标注在什么地方 @Retention(RetentionPolicy.RUNTIME) @Documented @Inherited // 是否会被继承 @SpringBootConfiguration // 表示这是SpringBoot的主配置类 @EnableAutoConfiguration // 开启自动配置 @ComponentScan(excludeFilters = { @Filter(type = FilterType.CUSTOM, classes = TypeExcludeFilter.class), @Filter(type = FilterType.CUSTOM, classes = AutoConfigurationExcludeFilter.class) }) public @interface SpringBootApplication {

由此可见，最核心的注解还是 **@EnableAutoConfiguration**，展开分析下这个注解都由什么部分组成

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

可以发现，核心的就两个注解 **@AutoConfigurationPackage**、 **@Import(AutoConfigurationImportSelector.class)**

### @AutoConfigurationPackage ###

首先分析下 **@AutoConfigurationPackage**

less
    
    复制代码
    
    @Target(ElementType.TYPE) @Retention(RetentionPolicy.RUNTIME) @Documented @Inherited @Import(AutoConfigurationPackages.Registrar.class) public @interface AutoConfigurationPackage {

看到 **@Import(AutoConfigurationPackages.Registrar.class)** 这个东西，是不是很熟悉了，就是帮我们指定哪些bean需要被注册到Spring IOC容器中；

![5.png][]

通过调试，我们可以看到，他将我们启动类所在的目录注册到Spring IOC容器中去了，换句话说，如果没有 **@AutoConfigurationPackage**注解，我们自己项目的类不会自动被扫描到SpringIOC容器中的；所以，总结一下，该注解主要起到了将启动类所在目录下的包扫描到SpringIOC容器中；

### @Import(AutoConfigurationImportSelector.class) ###

再分析下 **@Import(AutoConfigurationImportSelector.class)**

该类实现了DeferredImportSelector接口，若getImportGroup()方法返回值不为null，将会调用getImportGroup()方法返回值的process()方法；

具体堆栈如下：

makefile
    
    复制代码
    
    process:429, AutoConfigurationImportSelector$AutoConfigurationGroup (org.springframework.boot.autoconfigure) getImports:879, ConfigurationClassParser$DeferredImportSelectorGrouping (org.springframework.context.annotation) processGroupImports:809, ConfigurationClassParser$DeferredImportSelectorGroupingHandler (org.springframework.context.annotation) process:780, ConfigurationClassParser$DeferredImportSelectorHandler (org.springframework.context.annotation) parse:193, ConfigurationClassParser (org.springframework.context.annotation) processConfigBeanDefinitions:331, ConfigurationClassPostProcessor (org.springframework.context.annotation) postProcessBeanDefinitionRegistry:247, ConfigurationClassPostProcessor (org.springframework.context.annotation) invokeBeanDefinitionRegistryPostProcessors:311, PostProcessorRegistrationDelegate (org.springframework.context.support) invokeBeanFactoryPostProcessors:112, PostProcessorRegistrationDelegate (org.springframework.context.support) invokeBeanFactoryPostProcessors:746, AbstractApplicationContext (org.springframework.context.support) refresh:564, AbstractApplicationContext (org.springframework.context.support) refresh:145, ServletWebServerApplicationContext (org.springframework.boot.web.servlet.context) refresh:754, SpringApplication (org.springframework.boot) refreshContext:434, SpringApplication (org.springframework.boot) run:338, SpringApplication (org.springframework.boot) run:1343, SpringApplication (org.springframework.boot) run:1332, SpringApplication (org.springframework.boot) main:10, SpringbootApplication (com.doudou)

详细分析下org.springframework.boot.autoconfigure.AutoConfigurationImportSelector.AutoConfigurationGroup\#process方法

kotlin
    
    复制代码
    
    public class AutoConfigurationImportSelector implements DeferredImportSelector, BeanClassLoaderAware, ResourceLoaderAware, BeanFactoryAware, EnvironmentAware, Ordered {     private static class AutoConfigurationGroup        implements DeferredImportSelector.Group, BeanClassLoaderAware, BeanFactoryAware, ResourceLoaderAware {        @Override        public void process(AnnotationMetadata annotationMetadata, DeferredImportSelector deferredImportSelector) {            Assert.state(deferredImportSelector instanceof AutoConfigurationImportSelector,                         () -> String.format("Only %s implementations are supported, got %s",                                             AutoConfigurationImportSelector.class.getSimpleName(),                                             deferredImportSelector.getClass().getName()));            // 核心代码：获取需要自动加载的配置类            AutoConfigurationEntry autoConfigurationEntry = ((AutoConfigurationImportSelector) deferredImportSelector)               .getAutoConfigurationEntry(annotationMetadata);            this.autoConfigurationEntries.add(autoConfigurationEntry);            for (String importClassName : autoConfigurationEntry.getConfigurations()) {                this.entries.putIfAbsent(importClassName, annotationMetadata);           }       }   } }

深度分析下org.springframework.boot.autoconfigure.AutoConfigurationImportSelector\#getAutoConfigurationEntry方法

scss
    
    复制代码
    
    protected AutoConfigurationEntry getAutoConfigurationEntry(AnnotationMetadata annotationMetadata) {    if (!isEnabled(annotationMetadata)) {        return EMPTY_ENTRY;   }    AnnotationAttributes attributes = getAttributes(annotationMetadata);    // 获取所有jar包 META-INF/spring.factories 下的key为EnableAutoConfiguration的配置类    List<String> configurations = getCandidateConfigurations(annotationMetadata, attributes);    // 配置类去重    configurations = removeDuplicates(configurations);    Set<String> exclusions = getExclusions(annotationMetadata, attributes);    checkExcludedClasses(configurations, exclusions);    configurations.removeAll(exclusions);    // 过滤出满足条件的配置类，过滤规则：META-INF/spring.factories key为AutoConfigurationImportFilter的value值    configurations = getConfigurationClassFilter().filter(configurations);    fireAutoConfigurationImportEvents(configurations, exclusions);    return new AutoConfigurationEntry(configurations, exclusions); }

深度分析下核心方法org.springframework.boot.autoconfigure.AutoConfigurationImportSelector\#getCandidateConfigurations

typescript
    
    复制代码
    
    protected List<String> getCandidateConfigurations(AnnotationMetadata metadata, AnnotationAttributes attributes) {    // getSpringFactoriesLoaderFactoryClass方法比较简单，就是返回EnableAutoConfiguration.class    List<String> configurations = SpringFactoriesLoader.loadFactoryNames(getSpringFactoriesLoaderFactoryClass(),                                                                         getBeanClassLoader());    return configurations; }

分析下org.springframework.core.io.support.SpringFactoriesLoader\#loadFactoryNames

less
    
    复制代码
    
    public static List<String> loadFactoryNames(Class<?> factoryType, @Nullable ClassLoader classLoader) {    ClassLoader classLoaderToUse = classLoader;    if (classLoader == null) {        classLoaderToUse = SpringFactoriesLoader.class.getClassLoader();   } // 这里获取到的内容为EnableAutoConfiguration    String factoryTypeName = factoryType.getName();    // 过滤出key为EnableAutoConfiguration的配置类    return (List)loadSpringFactories(classLoaderToUse).getOrDefault(factoryTypeName, Collections.emptyList()); }

分析下org.springframework.core.io.support.SpringFactoriesLoader\#loadSpringFactories

typescript
    
    复制代码
    
    private static Map<String, List<String>> loadSpringFactories(ClassLoader classLoader) {        Map<String, List<String>> result = (Map)cache.get(classLoader);        if (result != null) {            return result;       } else {            Map<String, List<String>> result = new HashMap();             try {                // 可以看到，通过类加载机制，获取到所有jar包下META-INF/spring.factories的配置信息                Enumeration<URL> urls = classLoader.getResources("META-INF/spring.factories");               ...               });                cache.put(classLoader, result);                return result;           } catch (IOException var14) {                throw new IllegalArgumentException("Unable to load factories from location [META-INF/spring.factories]", var14);           }       }   }

上述多次提到key EnableAutoConfiguration、AutoConfigurationImportFilter，你可能没概念，去到具体文件，截图一下，你就明白了；

![6.png][]

至此，需要自动加载到Spring IOC的配置类均找到了，接下来交给Spring IOC即可；

# 2、如何查看哪些配置类被自动加载至Spring容器中 #

在项目appilication.yml追加以下一条配置项，这样就能够在控制台输出哪些配置类被自动配置；

lua
    
    复制代码
    
    debug: true

控制台输出结果（内容较多，我拣选了核心的出来）：

sql
    
    复制代码
    
    positive matches: // 以下代表被自动配置的配置类信息 -----------------    AopAutoConfiguration matched:     - @ConditionalOnProperty (spring.aop.auto=true) matched (OnPropertyCondition)    AopAutoConfiguration.ClassProxyingConfiguration matched:     - @ConditionalOnMissingClass did not find unwanted class 'org.aspectj.weaver.Advice' (OnClassCondition)     - @ConditionalOnProperty (spring.aop.proxy-target-class=true) matched (OnPropertyCondition)    DispatcherServletAutoConfiguration matched:     - @ConditionalOnClass found required class 'org.springframework.web.servlet.DispatcherServlet' (OnClassCondition)     - found 'session' scope (OnWebApplicationCondition)    DispatcherServletAutoConfiguration.DispatcherServletConfiguration matched:     - @ConditionalOnClass found required class 'javax.servlet.ServletRegistration' (OnClassCondition)     - Default DispatcherServlet did not find dispatcher servlet beans (DispatcherServletAutoConfiguration.DefaultDispatcherServletCondition) Negative matches: // 以下代表条件缺失，没有被自动配置的配置类 -----------------    ActiveMQAutoConfiguration:     Did not match:         - @ConditionalOnClass did not find required class 'javax.jms.ConnectionFactory' (OnClassCondition)    AopAutoConfiguration.AspectJAutoProxyingConfiguration:     Did not match:         - @ConditionalOnClass did not find required class 'org.aspectj.weaver.Advice' (OnClassCondition)    ArtemisAutoConfiguration:     Did not match:         - @ConditionalOnClass did not find required class 'javax.jms.ConnectionFactory' (OnClassCondition)    BatchAutoConfiguration:     Did not match:         - @ConditionalOnClass did not find required class 'org.springframework.batch.core.launch.JobLauncher' (OnClassCondition)         Exclusions: // 哪些类被排除 -----------    None

# 3、单独分析一个满足自动装配条件的类 #

以HttpEncodingAutoConfiguration类为例

less
    
    复制代码
    
    @Configuration(proxyBeanMethods = false) @EnableConfigurationProperties(ServerProperties.class) @ConditionalOnWebApplication(type = ConditionalOnWebApplication.Type.SERVLET) @ConditionalOnClass(CharacterEncodingFilter.class) @ConditionalOnProperty(prefix = "server.servlet.encoding", value = "enabled", matchIfMissing = true) public class HttpEncodingAutoConfiguration {     private final Encoding properties;     public HttpEncodingAutoConfiguration(ServerProperties properties) {        this.properties = properties.getServlet().getEncoding();   }     @Bean    @ConditionalOnMissingBean    public CharacterEncodingFilter characterEncodingFilter() {        CharacterEncodingFilter filter = new OrderedCharacterEncodingFilter();        filter.setEncoding(this.properties.getCharset().name());        filter.setForceRequestEncoding(this.properties.shouldForce(Encoding.Type.REQUEST));        filter.setForceResponseEncoding(this.properties.shouldForce(Encoding.Type.RESPONSE));        return filter;   } }

@Configuration(proxyBeanMethods = false)

@EnableConfigurationProperties(ServerProperties.class) 该注解表示 该配置类对应的配置文件对应的class类，并且将ServerProperties对应的javaBean加入到Spring IOC容器中

@ConditionalOnWebApplication(type = ConditionalOnWebApplication.Type.SERVLET) web环境下生效

@ConditionalOnClass(CharacterEncodingFilter.class) CharacterEncodingFilter类存在，配置类则生效

@ConditionalOnProperty(prefix = "server.servlet.encoding", value = "enabled", matchIfMissing = true)

配置中是否存在某个配置项为server.servlet.encoding，如果不存在，则能够匹配；如果matchIfMissing为false，则需要存在才能够匹配；

# 4、分析下配置项和配置类如何互相绑定 #

以ServerProperties为例

swift
    
    复制代码
    
    @ConfigurationProperties(prefix = "server", ignoreUnknownFields = true) public class ServerProperties {     /** * Server HTTP port. */    private Integer port;     /** * Network address to which the server should bind. */    private InetAddress address; }

ServerProperties是通过@ConfigurationProperties将配置文件与该类进行绑定；

因此你在application.properties或application.yml中给服务绑定端口号时，实际上就给ServerProperties属性赋值；

yaml
    
    复制代码
    
    server: port: 8080

# 5、自定义starter #

> 简介

SpringBoot最强大的功能就是把我们常用的场景抽取成了一个个starter（场景启动器），我们引入SpringBoot为我们提供的这些场景启动器，我们再进行少量的配置就能完成我们的功能。即使是这样，SpringBoot也不能囊括我们所有的场景，往往我们需要自定义starter，来满足我们需要的功能；

## 如何编写starter ##

我们参考spring-boot-starter

![7.png][]

发现是一个空的jar包，分析下他的pom.xml文件

xml
    
    复制代码
    
    <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-autoconfigure</artifactId> <version>2.5.2</version> <scope>compile</scope> </dependency>

发现它依赖了spring-boot-autoconfigure，而spring-boot-autoconfigure包含了starter的配置及代码

![8.png][]

因此，梳理出规则如下：

![9.png][]

*  启动器（starter）是一个空的jar文件，仅仅提供辅助性依赖管理，这些依赖可能用于自动装配或其他类库。
 *  需要专门写一个类似spring-boot-autoconfigure的配置模块
 *  用的时候只需要引入启动器starter，就可以使用自动配置了

命名规范

官方命名空间

*  前缀：spring-boot-starter-
 *  模式：spring-boot-starter-模块名
 *  举例：spring-boot-starter-web、spring-boot-starter-jdbc

自定义命名空间

*  后缀：-spring-boot-starter
 *  模式：模块-spring-boot-starter
 *  举例：mybatis-spring-boot-starter

## 开始编写自己的starter ##

makefile
    
    复制代码
    
    创建一个父工程，和2个Module: 1、doudou-parent （父工程） 2、doudou-spring-boot-starter (子模块，依赖doudou-spring-boot-starter-autoconfigure) 3、doudou-spring-boot-starter-autoconfigure

项目结构概览：

![10.png][]

**doudou-parent：**

xml
    
    复制代码
    
    <?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd"> <modelVersion>4.0.0</modelVersion>  <parent> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-parent</artifactId> <version>2.5.2</version> <relativePath/>  </parent>  <groupId>com.doudou</groupId> <artifactId>doudou-parent</artifactId> <version>0.0.1-SNAPSHOT</version> <name>doudou-parent</name> <description>doudou-parent</description> <packaging>pom</packaging>  <properties> <java.version>1.8</java.version> </properties>  <dependencies> </dependencies>  <modules> <module>doudou-spring-boot-starter</module> <module>doudou-spring-boot-starter-autoconfigure</module> </modules>  </project>

**doudou-spring-boot-starter：**

xml
    
    复制代码
    
    <?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">   <modelVersion>4.0.0</modelVersion>   <parent>       <groupId>com.doudou</groupId>       <artifactId>doudou-parent</artifactId>       <version>0.0.1-SNAPSHOT</version>   </parent>    <artifactId>doudou-spring-boot-starter</artifactId>   <version>0.0.1-SNAPSHOT</version>   <name>doudou-spring-boot-starter</name>   <description>doudou-spring-boot-starter</description>    <properties>       <java.version>1.8</java.version>   </properties>    <dependencies>       <dependency>           <groupId>com.doudou</groupId>           <artifactId>doudou-spring-boot-starter-autoconfigure</artifactId>           <version>0.0.1-SNAPSHOT</version>       </dependency>   </dependencies>  </project>

**doudou-spring-boot-starter-autoconfigure：**

xml
    
    复制代码
    
    <?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">   <modelVersion>4.0.0</modelVersion>   <parent>       <groupId>com.doudou</groupId>       <artifactId>doudou-parent</artifactId>       <version>0.0.1-SNAPSHOT</version>   </parent>    <artifactId>doudou-spring-boot-starter-autoconfigure</artifactId>   <version>0.0.1-SNAPSHOT</version>   <name>doudou-spring-boot-starter-autoconfigure</name>   <description>doudou-spring-boot-starter-autoconfigure</description>    <properties>       <java.version>1.8</java.version>   </properties>    <dependencies>       <dependency>           <groupId>org.springframework.boot</groupId>           <artifactId>spring-boot-starter-web</artifactId>       </dependency>        <dependency>           <groupId>org.springframework.boot</groupId>           <artifactId>spring-boot-configuration-processor</artifactId>           <optional>true</optional>       </dependency>   </dependencies>  </project>

**DoudouAutoConfiguration**：

less
    
    复制代码
    
    @Configuration @EnableConfigurationProperties(DouDouProperties.class) @ConditionalOnProperty(value = "doudou.name") public class DoudouAutoConfiguration {  }

**DouDouProperties：**

typescript
    
    复制代码
    
    @ConfigurationProperties("doudou") public class DouDouProperties {     private String name;     public String getName() {        return name;   }     public void setName(String name) {        this.name = name;   }  }

**DouDouController：**

kotlin
    
    复制代码
    
    @RestController public class DouDouController {     @Autowired    private DouDouProperties douDouProperties;      @RequestMapping("/test/doudou/custom/starter")    public String indexController() {        return douDouProperties.getName();   }  }

**spring.factories：**

ini
    
    复制代码
    
    org.springframework.boot.autoconfigure.EnableAutoConfiguration=\com.doudou.configuration.DoudouAutoConfiguration

## 外部程序依赖自定义的starter ##

> 额外搭建一个SpringBoot工程，依赖doudou-spring-boot-starter

备注：这个搭建比较简单，我主要展示效果

第一步：增加pom依赖

xml
    
    复制代码
    
    <dependency>   <groupId>com.doudou</groupId>   <artifactId>doudou-spring-boot-starter</artifactId>   <version>0.0.1-SNAPSHOT</version> </dependency>

其次在application.yml增加配置：

yaml
    
    复制代码
    
    doudou: name: doudou

启动服务，访问starter提供的接口

![11.png][]

# 6、总结 #

> 如何在面试中回答SpringBoot自动配置原理？

我会从核心注解入手，分析原理：

1、@SpringBootApplication注解标注该工程是一个SpringBoot工程，该注解包含两个核心注解@SpringBootConfiguration、@EnableAutoConfiguration；

2、@SpringBootConfiguration本质就是@Configuration，表示是一个配置类；

3、@EnableAutoConfiguration注解，包含两个核心注解@AutoConfigurationPackage、@Import(AutoConfigurationImportSelector.class)；

4、@AutoConfigurationPackage注解核心在于@Import(AutoConfigurationPackages.Register.class)，该Register类实现了ImportBeanDefinitionRegister接口，我们知道实现该接口，实际上就是手动注册BeanDefinition至Spring IOC容器中，SpringBoot通过@Import(AutoConfigurationPackages.Register.class)实现，将启动类所在目录注册到Spring IOC容器中；这样，我们项目定义的class就能够被Spring IOC注册成bean；

5、@Import(AutoConfigurationImportSelector.class)注解，其中AutoConfigurationImportSelector类实现了DeferredImportSelector接口，DeferredImportSelector接口是ImportSelector的子接口，我们知道实现了ImportSelector接口，主要目的在于手动导入类将其注册成为bean，而DefeeredImportSelector多了一个延时导入的特性，主要目的在于延时导入各种starter jar包下META-INF/spring.factories里面key为EnableAutoConfiuration的配置类，再按照一定过滤规则，过滤出最终需要自动配置的配置类；为什么要延时导入，因为如果外部自定义的配置类跟SpringBoot自动配置的一样，那么注册外部自定义的配置类至Spring IOC容器中，SpringBoot自动配置的无效；

[0.png]: https://img-blog.csdnimg.cn/img_convert/907de3e7b44657816f8948255e39a17c.webp?x-oss-process=image/format,png
[1.png]: https://img-blog.csdnimg.cn/img_convert/d3ae51538e2d411edddc126da796ab87.webp?x-oss-process=image/format,png
[2.png]: https://img-blog.csdnimg.cn/img_convert/510eeee06841de6f2a197e4d940d03e2.webp?x-oss-process=image/format,png
[3.png]: https://img-blog.csdnimg.cn/img_convert/5e25c32db4f223d4bcb63dc429201d3a.webp?x-oss-process=image/format,png
[4.png]: https://img-blog.csdnimg.cn/img_convert/9ff9bc003d2f26bf1fbc880af8290e38.webp?x-oss-process=image/format,png
[c3bb18754a584dd38e62c157ebfeb9fd.png]: https://img-blog.csdnimg.cn/c3bb18754a584dd38e62c157ebfeb9fd.png
[5.png]: https://img-blog.csdnimg.cn/img_convert/e090cb9034f8dc4f45a4ea06f776bf57.webp?x-oss-process=image/format,png
[6.png]: https://img-blog.csdnimg.cn/img_convert/bad6c057026d9a1277a7cab647449a8c.webp?x-oss-process=image/format,png
[7.png]: https://img-blog.csdnimg.cn/img_convert/a84e612a1a6661c4c101a94071ac1277.webp?x-oss-process=image/format,png
[8.png]: https://img-blog.csdnimg.cn/img_convert/f8da49dc8e100cf5bec53e6d1f726585.webp?x-oss-process=image/format,png
[9.png]: https://img-blog.csdnimg.cn/img_convert/754f3695215a50cbd0bbe7868c259c64.webp?x-oss-process=image/format,png
[10.png]: https://img-blog.csdnimg.cn/img_convert/0d381c3d435da68145dd4dedb7fba3ae.webp?x-oss-process=image/format,png
[11.png]: https://img-blog.csdnimg.cn/img_convert/ea10253bf6c23801fec2fb295518a9db.webp?x-oss-process=image/format,png