共计 8529 个字符,预计需要花费 22 分钟才能阅读完成。
一、前言
大部分的配置都能够用 Java 类 + 注解来代替,而在 SpringBoot 我的项目中见的最多的莫过于 @SpringBootApplication 注解了,它在每个 SpringBoot 的启动类上都有标注。
这个注解对 SpringBoot 的启动和主动配置到底有什么样的影响呢?本文将为各位大佬解析它的源码,揭开 @SpringBootApplication 注解神秘的面纱。
二、注释
对 SpringBoot 工程的主动配置很感兴趣,于是学习其源码并整顿了其中一些内容,如果有谬误请大家斧正~ 话不多说,间接上源码;
@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 {...}
能够看到这是一个复合注解,一共包含 7 个不同的注解,上面对这 7 个不同的注解进行剖析。
2.1 注解
2.1.1 注解 1:@Target({ElementType.TYPE})
用来示意注解作用范畴,TYPE 示意作用范畴为类或接口。
2.1.2 注解 2:@Retention(RetentionPolicy.RUNTIME)
2.1.3 注解 3:@Documented
表明这个正文是由 javadoc 记录的。
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 容器。
三、小结
通过以上剖析可知 @SpringBootApplication注解的运作是通过 @SpringApplicationConfiguration 申明被标注类为配置类,从而被 AnnotationConfigApplicationContext 扫描并初始化 Spring 容器。
通过 @EnableAutoConfiguration 来扫描,过滤并加载所须要的组件;通过 @ComponentScan 扫描并注册所有标注了 @Component 及其子注解的类;这些注解的独特运作实现了 springboot 工程弱小的主动配置能力。
以上就是本次总结的全部内容,心愿能对大家有所帮忙。如果有疏漏谬误之处,还请大家不吝指正。
作者:vivo 互联网开发团队 -Peng peng