@SpringBootApplication详解-优快云博客

@SpringBootApplication详解

1 .简介

在Spring Boot的学习中难免需要接触源码，而入手及时从Spring Boot项目启动类开始入手。项目启动类非常简单，仅仅存在一个注解@SpringBootApplication以及一个运行参数为被该注解标注类run函数。

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

对于该启动类的分析，就从这个Spring Boot的核心注解开始入手。

2 .核心注解@SpringBootApplication

字面分析，这个注解是标注一个Spring Boot应用。

@Target(ElementType.TYPE)
 @Retention(RetentionPolicy.RUNTIME)
 @Documented
 @Inherited
 @SpringBootConfiguration
 @EnableAutoConfiguration//引入EnableAutoConfiguration 
 @ComponentScan(excludeFilters = { @Filter(type = FilterType.CUSTOM, classes = TypeExcludeFilter.class),
      @Filter(type = FilterType.CUSTOM, classes = AutoConfigurationExcludeFilter.class) })
 public @interface SpringBootApplication {
    ...//具体参数暂时忽略
 }

进入到这个注解后，可以发现该注解由四个元注解，以及其他三个注解组成分别是：@SpringBootConfiguration、

@EnableAutoConfiguration(自动配置有关的核心注解，主要分析)、

@ComponentScan（包扫描）(excludeFilters = { @Filter(type = FilterType.CUSTOM, classes = TypeExcludeFilter.class),@Filter(type = FilterType.CUSTOM, classes = AutoConfigurationExcludeFilter.class) })

2.1 Spring的配置类@SpringBootConfiguration

字面分析，这是一个Spring Boot的配置类。

@Target({ElementType.TYPE})
 @Retention(RetentionPolicy.RUNTIME)
 @Documented
 @Configuration
 @Indexed
 public @interface SpringBootConfiguration {
     @AliasFor(
         annotation = Configuration.class
     )
     boolean proxyBeanMethods() default true;
 }

从他的源码来看，除了元注解之外，它仅仅被@Configuration注解所标注，那么可以理解@SpringBootConfiguration为他仅仅就是一个配置类。

@Configuration 源码

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

再分析@Configuration的源码，该注解为Spring中的配置类注解，其中被@Component标注为Spring组件，意味着他被注册到IOC容器。

因此，套用官方文档的答案：@SpringBootConfiguration表示一个类提供 Spring Boot 应用程序@Configuration。可以用作 Spring 标准@Configuration注释的替代方法，以便可以自动找到配置（例如在测试中）。

2.2 开启自动配置@EnableAutoConfiguration ！！！

这个注解是Spring Boot的自动装配的核心。


 @Target(ElementType.TYPE)
 @Retention(RetentionPolicy.RUNTIME)
 @Documented
 @Inherited
 @AutoConfigurationPackage
 @Import(AutoConfigurationImportSelector.class)//自动配置的引入选择器实现
 public @interface EnableAutoConfiguration {...}

除了四个元注解，这个注解被两个注解所标注：

@AutoConfigurationPackage、

@Import(AutoConfigurationImportSelector.class)

那么我们先直接往下分析

2.2.1 自动配置包@AutoConfigurationPackage

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

从注解来看，@AutoConfigurationPackage中使用注解@Import(@Import:的作用)导入了AutoConfigurationPackages.Registrar.class到容器中，那么来分析这个类，进入到这个内部类Regisrar：

static class Registrar implements ImportBeanDefinitionRegistrar, DeterminableImports {
 
     @Override
     public void registerBeanDefinitions(AnnotationMetadata metadata, BeanDefinitionRegistry registry) {
         register(registry, new PackageImports(metadata).getPackageNames().toArray(new String[0]));
     }
 
     @Override
     public Set<Object> determineImports(AnnotationMetadata metadata) {
         return Collections.singleton(new PackageImports(metadata));
     }
 
 }

该类引入的重点在于方法registerBeanDefinitions()：

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

首先先分析方法体中所调用的方法register()的第二个参数

PackageImports(metadata).getPackageNames().toArray(new String[0])

进入到类PackageImports的构造方法：

PackageImports(AnnotationMetadata metadata) {
     AnnotationAttributes attributes = AnnotationAttributes
                     .fromMap(metadata.getAnnotationAttributes(AutoConfigurationPackage.class.getName(), false));
     List<String> packageNames = new ArrayList<>(Arrays.asList(attributes.getStringArray("basePackages")));
     for (Class<?> basePackageClass : attributes.getClassArray("basePackageClasses")) {
                 packageNames.add(basePackageClass.getPackage().getName());
     }
     if (packageNames.isEmpty()) {
                 packageNames.add(ClassUtils.getPackageName(metadata.getClassName()));
     }
     this.packageNames = Collections.unmodifiableList(packageNames);
 }

在这个构造方法中将元数据即启动类AnnotationMetadata metadata经过处理

1.获取标签注解信息，注解信息里面的 basePackages 和 basePackageClasses是否有数据。

basePackages、 basePackageClasses为注解@AutoConfigurationPackage中的属性。

2.如果没有数据则获取注解所在的类的名字目录，放到List中

获得packageNames属性也就是启动类所在的包。

回到Registrar中的registerBeanDefinitions()方法中register()方法的第二个参数即为启动类所在的包的名称，并且使用数组来进行表示。

在分析register()方法，register()源码如下：

private static final String BEAN = AutoConfigurationPackages.class.getName();
 
 public static void register(BeanDefinitionRegistry registry, String... packageNames) {
     //BeanDefinitionRegistry registry  其中放方法boolean containsBeanDefinition(String beanName);是为了判断是否已经注册了`AutoConfigurationPackages`的类路径所对应的`bean（AutoConfigurationPackages）`
    if (registry.containsBeanDefinition(BEAN)) {
       BasePackagesBeanDefinition beanDefinition =(BasePackagesBeanDefinition)registry.getBeanDefinition(BEAN);
       beanDefinition.addBasePackages(packageNames);
    }
    else {
       registry.registerBeanDefinition(BEAN, new BasePackagesBeanDefinition(packageNames));
    }
 }

这个方法的if语句为判断registry这个参数中是否已经注册了AutoConfigurationPackages的类路径所对应的bean（AutoConfigurationPackages）。如若已经被注册，则把上面分析的第二个参数所获取的包（启动类所在的包的名称）添加到这个bean的定义中。如若没有，则注册这个bean并且把包名设置到该bean的定义中。

小结：@AutoConfigurationPackage就是添加该注解的类所在的包作为自动配置包进行管理。他的实现就是依赖于工具类AutoConfigurationPackages中的内部类Registrar对所标注的包进行注册。

2.2.2 导入自动配置导入选择器@Import(AutoConfigurationImportSelector.class)

这个@import使用了2.2.1中@import的用法中的通过ImportSelector 方式导入的类，所以我们进入到该类，直接找到selectImports方法。在这个用法中，所返回的字符串数组为所有的将要被导入的类的全类名。那么知道这个方法是做什么的，就开始分析这个方法。

再分析selectImports方法，selectImports()源码如下：

public String[] selectImports(AnnotationMetadata annotationMetadata) {//selectImports方法会被springboot自动调用，从而得到他返回的全类名的字符串数组，然后把对应类的bean对象注入到ioc容器中
         if (!this.isEnabled(annotationMetadata)) {
             return NO_IMPORTS;
         } else {
             AutoConfigurationEntry autoConfigurationEntry = this.getAutoConfigurationEntry(annotationMetadata);
             return StringUtils.toStringArray(autoConfigurationEntry.getConfigurations());
         }
     }

从return开始分析，autoConfigurationEntry自动配置实体中List的属性configurations将被返回。autoConfigurationEntry是通过方法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);
 }

根据return所返回的内容，返回的是一个使用属性configurations所生成的自动配置实体，configurations是使用getCandidateConfigurations()获取候选配置所得到的。

protected List<String> getCandidateConfigurations(AnnotationMetadata metadata, AnnotationAttributes attributes) {
         List<String> configurations = ImportCandidates.load(AutoConfiguration.class, getBeanClassLoader())//load 加载的意思
             .getCandidates();
         Assert.notEmpty(configurations,
                 "No auto configuration classes found in "
                         + "META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports. If you "
                         + "are using a custom packaging, make sure that file is correct.");
         return configurations;
 }

从以上源码可以发现，在springboot3之后，已完全放弃对META-INF/spring.factories的读取。而是从传的AutoConfiguration.class取的类名称。即org.springframework.boot.autoconfigure.AutoConfiguration。拼接之后，META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports(.imports配置文件)。（2.7升级到3.0后的变化）

读取META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports中的org.springframework.boot.autoconfigure.web.servlet.DispatcherServletAutoConfiguration

DispatcherServletAutoConfiguration配置类中还有配置类DispatcherServletConfiguration，其中还有方法dispatcherServlet(WebMvcProperties webMvcProperties)添加了@bean注解springboot会继续解析，直到把@Bean注解的方法都解析到，然后执行这些方法，把返回值注入到ioc容器中，因此自动配置的核心在配置文件里

@AutoConfigureOrder(Ordered.HIGHEST_PRECEDENCE)
 @AutoConfiguration(after = ServletWebServerFactoryAutoConfiguration.class)
 @ConditionalOnWebApplication(type = Type.SERVLET)
 @ConditionalOnClass(DispatcherServlet.class)//如果当前环境存在DispatchServlet类，则注入，否则不注入
     //注意 DispatchServlet类 是引用web启动依赖后会有的
 public class DispatcherServletAutoConfiguration {
     ...
     @Configuration(proxyBeanMethods = false)
     @Conditional(DefaultDispatcherServletCondition.class)
     @ConditionalOnClass(ServletRegistration.class)
     @EnableConfigurationProperties(WebMvcProperties.class)
     protected static class DispatcherServletConfiguration {
 
         @Bean(name = DEFAULT_DISPATCHER_SERVLET_BEAN_NAME)
         public DispatcherServlet dispatcherServlet(WebMvcProperties webMvcProperties) {
             DispatcherServlet dispatcherServlet = new DispatcherServlet();
             dispatcherServlet.setDispatchOptionsRequest(webMvcProperties.isDispatchOptionsRequest());
             dispatcherServlet.setDispatchTraceRequest(webMvcProperties.isDispatchTraceRequest());
             dispatcherServlet.setThrowExceptionIfNoHandlerFound(webMvcProperties.isThrowExceptionIfNoHandlerFound());
             dispatcherServlet.setPublishEvents(webMvcProperties.isPublishRequestHandledEvents());
             dispatcherServlet.setEnableLoggingRequestDetails(webMvcProperties.isLogRequestDetails());
             return dispatcherServlet;
         }
 
         @Bean
         @ConditionalOnBean(MultipartResolver.class)
         @ConditionalOnMissingBean(name = DispatcherServlet.MULTIPART_RESOLVER_BEAN_NAME)
         public MultipartResolver multipartResolver(MultipartResolver resolver) {
             // Detect if the user has created a MultipartResolver but named it incorrectly
             return resolver;
         }
 
     }
     ...
 }

2.2.3总结！！！

@SpringBootApplication是一个组合注解，其中有@EnableAutoConfiguration也是一个组合注解，@EnableAutoConfiguration有`@Import(AutoConfigurationImportSelector.class)，导入了AutoConfigurationImportSelector.class类，AutoConfigurationImportSelector.class实现了selectImports方法，经过层层调用最终读取一个配置文件META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports(注意，springboot2.7前读取的是spring.factories文件，2.7-3.0兼容两个，3.0之后只有.imports)这个配置文件中写了一堆的全类名，其中有一个是org.springframework.boot.autoconfigure.web.servlet.DispatcherServletAutoConfiguration，它是完成DispatcherServlet这个对象的自动注入的，DispatcherServletAutoConfiguration类中有@AutoConfiguration标明是一个自动配置类，@ConditionalOnClass(DispatcherServlet.class)用来去设置bean注册的条件（如果环境里有DispatcherServlet.class这个配置类，DispatcherServletAutoConfiguration这个自动配置类就生效，否则就不生效，注意引入web启动依赖就有DispatcherServlet.class这个配置类），因此说引入了web启动依赖springboot就自动注入了一个DispatcherServlet。