神秘又强大的@SpringBootApplication注解

时间  2021-04-15
标签 java spring 数组 springboot 框架 ide 函数 spring-boot 学习 this 栏目 Java 繁體版
原文   原文链接

1、前言

大部分的配置均可以用Java类+注解来代替，而在SpringBoot项目中见的最多的莫过于@SpringBootApplication注解了，它在每一个SpringBoot的启动类上都有标注。java

这个注解对SpringBoot的启动和自动配置到底有什么样的影响呢？本文将为各位大佬解析它的源码，揭开@SpringBootApplication注解神秘的面纱。spring

2、正文

对SpringBoot工程的自动配置很感兴趣，因而学习其源码并整理了其中一些内容，若是有错误请你们指正~话很少说，直接上源码；数组

@SpringBootApplication注解的源码以下：springboot

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

能够看到这是一个复合注解，一共包括7个不一样的注解，下面对这7个不一样的注解进行分析。框架

2.1 注解

2.1.1 注解1：@Target({ElementType.TYPE})ide

用来表示注解做用范围，TYPE表示做用范围为类或接口。函数

2.1.2 注解2：@Retention(RetentionPolicy.RUNTIME)spring-boot

2.1.3 注解3：@Documented学习

代表这个注释是由 javadoc记录的。this

2.1.4 注解4：@Inherited

放在注解上，当父类加了@SpringBootApplication注解时，子类也会继承这个注解（对接口的实现类无效）。

2.1.5 注解5：@SpringBootConfiguration

底层还是@Configuration注解, 源码以下：

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

2.1.6 注解6：@ComponetScan

@ComponentScan这个注解在Spring中很重要，它对应XML配置中的元素@ComponentScan的功能其实就是自动扫描并加载符合条件的组件（好比@Component和@Repository等）或者bean定义，最终将这些bean定义加载到IoC容器中。

能够经过basePackages等属性来细粒度的定制@ComponentScan自动扫描的范围，若是不指定，则默认Spring框架实现会从声明@ComponentScan所在类的package进行扫描。因此SpringBoot的启动类最好是放在root package下，由于默认不指定basePackages。

2.2 注解：@EnableAutoConfiguration

我的感受@EnableAutoConfiguration这个Annotation最为重要它的做用能够归纳为：借助@Import的帮助，将全部符合自动配置条件的bean定义加载到IoC容器。

其源码以下：

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

这里须要关注@AutoConfigurationPackage和@Import(AutoConfigurationImportSelector.class)两个注解。

2.2.1 注释：@AutoConfigurationPackage

源码以下：

@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注解，表示对于标注该注解的类的包，应当使用AutoConfigurationPackages注册。接着看Registrar这个类：

static class Registrar implements ImportBeanDefinitionRegistrar, DeterminableImports {
​
    @Override
      //metadata是咱们注解所在的元信息
    public void registerBeanDefinitions(AnnotationMetadata metadata, BeanDefinitionRegistry registry) {
            //将咱们注解所在包下全部的组件进行注册
      register(registry, new PackageImport(metadata).getPackageName());
    }
​
    @Override
    public Set<Object> determineImports(AnnotationMetadata metadata) {
      return Collections.singleton(new PackageImport(metadata));
    }
}

这个类中的核心方法是register方法：

private static final String BEAN = AutoConfigurationPackages.class.getName();
  
  public static void register(BeanDefinitionRegistry registry, String... packageNames) {
    if (registry.containsBeanDefinition(BEAN)) {
      BeanDefinition beanDefinition = registry.getBeanDefinition(BEAN);
      ConstructorArgumentValues constructorArguments = beanDefinition.getConstructorArgumentValues();
      constructorArguments.addIndexedArgumentValue(0, addBasePackages(constructorArguments, packageNames));
​    }
    else {
      GenericBeanDefinition beanDefinition = new GenericBeanDefinition();
      beanDefinition.setBeanClass(BasePackages.class);
      beanDefinition.getConstructorArgumentValues().addIndexedArgumentValue(0, packageNames);
      beanDefinition.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
      registry.registerBeanDefinition(BEAN, beanDefinition);
    }
}

register方法的逻辑很是清晰：若是这个bean已经被注册，就获取它的构造函数参数值，并将包名添加进去；不然就建立一个新的bean定义并进行注册。经过@AutoConfigurationPackage这个注解，能够将注解所在包下全部的组件进行注册。

2.2.2 注解：@Import(AutoConfigurationImportSelector.class)

这个注解导入了AutoConfigurationImportSelector这个类这个类的核心方法是selectImports方法，实现ImportSelector接口。方法基于咱们在pom.xml文件中配置的jar包和组件进行导入。因此方法返回的是一个Class全路径的String数组，返回的Class会被Spring容器管理。方法源码以下：

@Override
public String[] selectImports(AnnotationMetadata annotationMetadata) {
  if (!isEnabled(annotationMetadata)) {
    return NO_IMPORTS;
  }
  AutoConfigurationMetadata autoConfigurationMetadata = AutoConfigurationMetadataLoader
      .loadMetadata(this.beanClassLoader);
  AutoConfigurationEntry autoConfigurationEntry = getAutoConfigurationEntry(autoConfigurationMetadata,
      annotationMetadata);
  return StringUtils.toStringArray(autoConfigurationEntry.getConfigurations());
}

这个方法的结构也很清晰，首先经过isEnabled方法判断是否须要进行导入，若是须要导入的话，经过loadMetadata方法获取配置信息，并经过getAutoConfigurationEntry进行自动装配。isEnabled方法源码以下：

protected boolean isEnabled(AnnotationMetadata metadata) {
  if (getClass() == AutoConfigurationImportSelector.class) {
    return getEnvironment().getProperty(EnableAutoConfiguration.ENABLED_OVERRIDE_PROPERTY, Boolean.class, true);
  }
  return true;
}

这个方法经过EnableAutoConfiguration.ENABLED\_OVERRIDE\_PROPERTY这个配置项进行判断是否须要自动配置，默认为true。loadMetadata方法源码以下：

protected static final String PATH = "META-INF/" + "spring-autoconfigure-metadata.properties";
​
  public static AutoConfigurationMetadata loadMetadata(ClassLoader classLoader) {
    return loadMetadata(classLoader, PATH);
  }
​
  static AutoConfigurationMetadata loadMetadata(ClassLoader classLoader, String path) {
    try {
      Enumeration<URL> urls = (classLoader != null) ? classLoader.getResources(path)
          : ClassLoader.getSystemResources(path);
      Properties properties = new Properties();
      while (urls.hasMoreElements()) {
        properties.putAll(PropertiesLoaderUtils.loadProperties(new UrlResource(urls.nextElement())));
      }
      return loadMetadata(properties);
    }
    catch (IOException ex) {
      throw new IllegalArgumentException("Unable to load @ConditionalOnClass location [" + path + "]", ex);
    }
  }
  static AutoConfigurationMetadata loadMetadata(Properties properties) {
    return new PropertiesAutoConfigurationMetadata(properties);
  }

能够看到这个方法会加载META-INF/spring-autoconfigure-metadata.properties下的全部配置信息并包装成AutoConfigurationMetadata对象返回。

注：spring-autoconfigure-metadata.properties文件在spring-boot-autoconfigure-2.1.9.RELEASE.jar/META-INF下。

getAutoConfigurationEntry方法源码以下：

protected AutoConfigurationEntry getAutoConfigurationEntry(AutoConfigurationMetadata autoConfigurationMetadata,
      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 = filter(configurations, autoConfigurationMetadata);
    fireAutoConfigurationImportEvents(configurations, exclusions);
    return new AutoConfigurationEntry(configurations, exclusions);
}

这个方法是AutoConfiguration的主流程方法，能够将这个方法的每一行看作一个步骤，那么处理步骤以下：

1. 加载配置了@EnableAutoConfiguration注解的属性值getAttribute方法：

protected AnnotationAttributes getAttributes(AnnotationMetadata metadata) {
    String name = getAnnotationClass().getName();
    AnnotationAttributes attributes = AnnotationAttributes.fromMap(metadata.getAnnotationAttributes(name, true));
    Assert.notNull(attributes, () -> "No auto-configuration attributes found. Is " + metadata.getClassName()
        + " annotated with " + ClassUtils.getShortName(name) + "?");
    return attributes;
}

2.获得META-INF/spring.factories文件中以@EnableAutoConfiguration彻底限定类名作key的value，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;
}
protected Class<?> getSpringFactoriesLoaderFactoryClass() {
    return EnableAutoConfiguration.class;
}

其中，SpringFactoriesLoader.loadFactoryNames()这个方法的做用是使用给定的类加载器从META-INF/spring.factories加载给定类型的工厂实现的彻底限定类名；

3.去重；

4.获得须要排除的类的类名，这些类能够在@EnableAutoConfiguration注解中配置；

5.检查这两个集合；

6.把须要排除的类移除；

7.根据OnBeanCondition、OnClassCondition等条件进行过滤（有兴趣能够深刻了解）；

8.广播事件，获得AutoConfigurationImportListener全部实现类，而后生成事件进行广播；

9.把须要装配和排除的类彻底限定名封装成了AutoConfigurationEntry对象返回。

所以，@EnableAutoConfiguration能够简单总结为：从classpath中搜寻全部的META-INF/spring.factories配置文件，并将其中EnableAutoConfiguration对应的配置项经过反射实例化为对应的标注了@Configuration的IoC容器配置类，并加载到IoC容器。

3、小结

经过以上分析可知@SpringBootApplication注解的运做是经过@SpringApplicationConfiguration声明被标注类为配置类，从而被AnnotationConfigApplicationContext扫描并初始化Spring容器。

经过@EnableAutoConfiguration来扫描，过滤并加载所须要的组件；经过@ComponentScan扫描并注册全部标注了@Component及其子注解的类；这些注解的共同运做实现了springboot工程强大的自动配置能力。

以上就是本次总结的所有内容，但愿能对你们有所帮助。若是有疏漏错误之处，还请你们不吝指正。

做者：vivo 互联网开发团队-Peng peng
相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程