@SpringBootApplication注解（版本2.7.10）

首先，关注@SpringBootApplication注解：

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

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

    ...

}

先分析@SpringBootConfiguration：

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Configuration
@Indexed
public @interface SpringBootConfiguration {
    ....
}

@SpringBootConfiguration除了元注解之外，就只有一个@Configuration，那也就是说这个注解就相当于@Configuration，作用为声明一个类为配置类，并且不需要进行额外的xml配置。

接下来看@EnableAutoConfiguration：

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

@EnableAutoConfiguration可以开启自动配置功能，可以看到它是由@AutoConfigurationPackage，@Import({EnableAutoConfigurationImportSelector.class}) 这两个注解组成。

先看@AutoConfigurationPackage，作用是让自动配置的包能够被扫描到spring容器中。

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

@AutoConfigurationPackage使用@Import将Registrar类注入Spring容器中：

static class Registrar implements ImportBeanDefinitionRegistrar, DeterminableImports {
    ....

    public void registerBeanDefinitions(AnnotationMetadata metadata, BeanDefinitionRegistry registry) {
        AutoConfigurationPackages.register(registry, (String[])(
            new AutoConfigurationPackages.PackageImports(metadata)).getPackageNames().toArray(new String[0])
        );
    }
    ....
}

通过(String[])(new AutoConfigurationPackages.PackageImports(metadata)).getPackageNames()方法可以获取到扫描的包路径，可以看到在调用该方法时传入了metadata参数，而metadata正是标注了@SpringBootApplication的主配置类。

再看看注解@Import({AutoConfigurationImportSelector.class})，注入AutoConfigurationImportSelector类。而AutoConfigurationImportSelector继承了DeferredImportSelector继承了ImportSelector，ImportSelector有一个方法：selectImports。

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

selectImports会给容器注入很多的自动配置类（xxxAutoConfiguration），有了自动配置类便免去了手动编写配置的工作。selectImports调用了getAutoConfigurationEntry()方法，作用是引入已经加载好的一些类。

protected AutoConfigurationImportSelector.AutoConfigurationEntry getAutoConfigurationEntry(AnnotationMetadata annotationMetadata) {
    if (!this.isEnabled(annotationMetadata)) {
        return EMPTY_ENTRY;
    } else {
        AnnotationAttributes attributes = this.getAttributes(annotationMetadata);
        List<String> configurations = this.getCandidateConfigurations(annotationMetadata, attributes);
        configurations = this.removeDuplicates(configurations);
        Set<String> exclusions = this.getExclusions(annotationMetadata, attributes);
        this.checkExcludedClasses(configurations, exclusions);
        configurations.removeAll(exclusions);
        configurations = this.getConfigurationClassFilter().filter(configurations);
        this.fireAutoConfigurationImportEvents(configurations, exclusions);
        return new AutoConfigurationImportSelector.AutoConfigurationEntry(configurations, exclusions);
    }
}

getAutoConfigurationEntry()调用getCandidateConfigurations()，getCandidateConfigurations()调用loadFactoryNames()，loadFactoryNames()调用loadSpringFactories()，loadSpringFactories()会从META-INF/spring.factories中获取资源，然后通过Properties加载资源：

private static Map<String, List<String>> loadSpringFactories(ClassLoader classLoader) {
    Map<String, List<String>> result = (Map)cache.get(classLoader);
    if (result != null) {
        return result;
    } else {
        HashMap result = new HashMap();
        try {
            Enumeration urls = classLoader.getResources("META-INF/spring.factories");
            while(urls.hasMoreElements()) {
                URL url = (URL)urls.nextElement();
                UrlResource resource = new UrlResource(url);
                Properties properties = PropertiesLoaderUtils.loadProperties(resource);
                Iterator var6 = properties.entrySet().iterator();
                while(var6.hasNext()) {
                    Entry<?, ?> entry = (Entry)var6.next();
                    String factoryTypeName = ((String)entry.getKey()).trim();
                    String[] factoryImplementationNames = StringUtils.commaDelimitedListToStringArray((String)entry.getValue());
                    String[] var10 = factoryImplementationNames;
                    int var11 = factoryImplementationNames.length;
                    for(int var12 = 0; var12 < var11; ++var12) {
                        String factoryImplementationName = var10[var12];
                        ((List)result.computeIfAbsent(factoryTypeName, (key) -> {
                            return new ArrayList();
                        })).add(factoryImplementationName.trim());
                    }
                }
            }
            result.replaceAll((factoryType, implementations) -> {
                return (List)implementations.stream().distinct().collect(Collectors.collectingAndThen(Collectors.toList(), Collections::unmodifiableList));
            });
            cache.put(classLoader, result);
            return result;
        } catch (IOException var14) {
            throw new IllegalArgumentException("Unable to load factories from location [META-INF/spring.factories]", var14);
        }
    }
}

由此所知，SpringBoot在启动的时候从类路径下的META-INF/spring.factories中获取EnableAutoConfiguration指定的值，将这些值作为自动配置类导入到容器中，自动配置类就能生效，完成自动配置工作。

最后来看@ComponentScan，其作用是扫描特定路径下的包及其子包下的所有组件并将它们装载到Spring容器中。

总结：@SpringBootApplication注解就是将系统所需要的全部东西都配置好，而具体如何使用就取决于程序了。