分析@SpringBootApplication注解做了哪些事。
总结：@SpringBootApplication注解内部有三个注解：
1、SpringBootConfiguration：springBootConfiguration注解上有configuration注解，所以作用和configuration注解类似。
2、EnableAutoConfiguration：这个注解上有AutoConfigurationPackage注解和@Import(AutoConfigurationImportSelector.class)注解。
AutoConfigurationPackage注解：会将启动类的包名下、以及子包下，所有的类，注入到ioc容器。
@Import(AutoConfigurationImportSelector.class)：会通过SpringFactoriesLoader.loadFactories方法获取META-INF/spirng.factories下的EnableAutoConfiguration接口的所有组件实现类，比如AopAutoConfiguration、RabbitAutoConfiguration，进行各个组件的自动化配置。
3、ComponentScan：这个注解用于自定义spring boot扫描指定的包下的类加入ioc容器，以及可以配置过滤规则，过滤哪些不需要加入ioc容器。SpringBootApplication注解配置了一些自定义的过滤规则。
@SpringBootApplication
public class Application {
public static void main(String[] args) {
SpringApplication.run(Application.class, args);
}
}
@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注解上有configuration注解，所以作用类似
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Configuration
public @interface SpringBootConfiguration
看这个类前，先说@import注解。
import注解有三种使用方式：
1、直接普通的类的全类名写上去，会注入ioc容器。
@Import（{com.test.A, com.test.B } ）
public class C{
}
2、注入的类，实现了ImportSelector接口，ImportSelector接口的抽象方法会返回需要注入的类的名称数组。
3、注入的类，实现了ImportBeanDefinitionRegistrar，ImportBeanDefinitionRegistrar接口的抽象方法，会传入参数BeanDefinitionRegistry ，用于手动注入到ioc容器。
可以看到这个注解上有两部分，AutoConfigurationPackage注解和import注解。
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@AutoConfigurationPackage
@Import(AutoConfigurationImportSelector.class)
public @interface EnableAutoConfiguration
AutoConfigurationPackages.Registrar实现了ImportBeanDefinitionRegistrar接口，用于手动注入类到ioc中，可以看到方法内部传参是启动类的包名。把启动类的包名下的所有类都注入ioc。
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@Import(AutoConfigurationPackages.Registrar.class)
public @interface AutoConfigurationPackage {
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));
}
}
public static void register(BeanDefinitionRegistry registry, String... packageNames) {
if (registry.containsBeanDefinition(BEAN)) {
BasePackagesBeanDefinition beanDefinition = (BasePackagesBeanDefinition) registry.getBeanDefinition(BEAN);
beanDefinition.addBasePackages(packageNames);
}
else {
// 手动注入到ioc，传参：启动类的包名。把启动类的包名下的所有类都注入ioc。
registry.registerBeanDefinition(BEAN, new BasePackagesBeanDefinition(packageNames));
}
}
回过头来再看这个注解，接着看@Import(AutoConfigurationImportSelector.class)
@AutoConfigurationPackage
@Import(AutoConfigurationImportSelector.class)
public @interface EnableAutoConfiguration {
实现了ImportSelector接口，说明selectImports方法返回的类名数组会注入到ioc容器。
public class AutoConfigurationImportSelector implements DeferredImportSelector, BeanClassLoaderAware,
ResourceLoaderAware, BeanFactoryAware, EnvironmentAware, Ordered {
@Override
public String[] selectImports(AnnotationMetadata annotationMetadata) {
if (!isEnabled(annotationMetadata)) {
return NO_IMPORTS;
}
AutoConfigurationEntry autoConfigurationEntry = getAutoConfigurationEntry(annotationMetadata);
return StringUtils.toStringArray(autoConfigurationEntry.getConfigurations());
}
protected AutoConfigurationEntry getAutoConfigurationEntry(AnnotationMetadata annotationMetadata) {
if (!isEnabled(annotationMetadata)) {
return EMPTY_ENTRY;
}
// 获取注解属性
AnnotationAttributes attributes = getAttributes(annotationMetadata);
// 核心。获取候选的configuration的全类名数组。
List<String> configurations = getCandidateConfigurations(annotationMetadata, attributes);
// 下面都是对候选的configuration进行一些去重处理
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);
}
SpringFactoriesLoader.loadFactories方法会获取META-INF/spirng.factories下的指定类的所有实现类。
这里获取配置的EnableAutoConfiguration的所有实现类。
spring boot自动化配置各种组件的方式就是如此，spring-boot-autoconfiguration.jar包的spring.factories文件里定义好了各种组件的AutoConfiguration，包里也有各个AutoConfiguration类,比如AopAutoConfiguration、RabbitAutoConfiguration。组件又通过ConditionalOnClass达到自适应加载。
@Configuration(proxyBeanMethods = false)
@ConditionalOnClass({ RabbitTemplate.class, Channel.class })
@EnableConfigurationProperties(RabbitProperties.class)
@Import(RabbitAnnotationDrivenConfiguration.class)
public class RabbitAutoConfiguration {
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;
}
发布自动配置导入事件：获取META-INF/spirng.factories下配置的AutoConfigurationImportListener的所有实现类，循环调用各个类的监听事件方法。
private void fireAutoConfigurationImportEvents(List<String> configurations, Set<String> exclusions) {
// 获取META-INF/spirng.factories下配置的AutoConfigurationImportListener的所有实现类
List<AutoConfigurationImportListener> listeners = getAutoConfigurationImportListeners();
if (!listeners.isEmpty()) {
AutoConfigurationImportEvent event = new AutoConfigurationImportEvent(this, configurations, exclusions);
for (AutoConfigurationImportListener listener : listeners) {
// 如果监听器实现了Aware接口，就填充Aware的所需的参数。
invokeAwareMethods(listener);
// 调用事件监听器的监听事件
listener.onAutoConfigurationImportEvent(event);
}
}
}
protected List<AutoConfigurationImportListener> getAutoConfigurationImportListeners() {
// SpringFactoriesLoader.loadFactories方法会获取META-INF/spirng.factories下的指定类的所有实现类。
// 这了获取配置的AutoConfigurationImportListener的所有实现类
return SpringFactoriesLoader.loadFactories(AutoConfigurationImportListener.class, this.beanClassLoader);
}
看一下SpringFactoriesLoader.loadFactoryNames方法。
1、存在一个缓存，也就是说多次调用，不会重复解析加载
2、 获取所有的META-INF/spring.factories路径，包括各个jar包的。
3、循环解析，存到result这个map中，并返回这个map。
public static List<String> loadFactoryNames(Class<?> factoryType, @Nullable ClassLoader classLoader) {
ClassLoader classLoaderToUse = classLoader;
if (classLoaderToUse == null) {
classLoaderToUse = SpringFactoriesLoader.class.getClassLoader();
}
String factoryTypeName = factoryType.getName();
return loadSpringFactories(classLoaderToUse).getOrDefault(factoryTypeName, Collections.emptyList());
}
public static final String FACTORIES_RESOURCE_LOCATION = "META-INF/spring.factories";
private static Map<String, List<String>> loadSpringFactories(ClassLoader classLoader) {
// 存在一个缓存，也就是说多次调用，不会重复解析加载
Map<String, List<String>> result = cache.get(classLoader);
if (result != null) {
return result;
}
result = new HashMap<>();
try {
// 获取所有的META-INF/spring.factories路径，包括各个jar包的。
Enumeration<URL> urls = classLoader.getResources(FACTORIES_RESOURCE_LOCATION);
// 循环解析，存到result这个map中。
while (urls.hasMoreElements()) {
URL url = urls.nextElement();
UrlResource resource = new UrlResource(url);
Properties properties = PropertiesLoaderUtils.loadProperties(resource);
for (Map.Entry<?, ?> entry : properties.entrySet()) {
String factoryTypeName = ((String) entry.getKey()).trim();
String[] factoryImplementationNames =
StringUtils.commaDelimitedListToStringArray((String) entry.getValue());
for (String factoryImplementationName : factoryImplementationNames) {
result.computeIfAbsent(factoryTypeName, key -> new ArrayList<>())
.add(factoryImplementationName.trim());
}
}
}
// Replace all lists with unmodifiable lists containing unique elements
result.replaceAll((factoryType, implementations) -> implementations.stream().distinct()
.collect(Collectors.collectingAndThen(Collectors.toList(), Collections::unmodifiableList)));
cache.put(classLoader, result);
}
catch (IOException ex) {
throw new IllegalArgumentException("Unable to load factories from location [" +
FACTORIES_RESOURCE_LOCATION + "]", ex);
}
return result;
}
总结：@SpringBootApplication注解内部有三个注解：
1、SpringBootConfiguration：springBootConfiguration注解上有configuration注解，所以作用和configuration注解类似。
2、EnableAutoConfiguration：这个注解上有AutoConfigurationPackage注解和@Import(AutoConfigurationImportSelector.class)注解。
AutoConfigurationPackage注解：会将启动类的包名下、以及子包下，所有的类，注入到ioc容器。
@Import(AutoConfigurationImportSelector.class)：会通过SpringFactoriesLoader.loadFactories方法获取META-INF/spirng.factories下的EnableAutoConfiguration接口的所有组件实现类，比如AopAutoConfiguration、RabbitAutoConfiguration，进行各个组件的自动化配置。
3、ComponentScan：这个注解用于自定义spring boot扫描指定的包下的类加入ioc容器，以及可以配置过滤规则，过滤哪些不需要加入ioc容器。SpringBootApplication注解配置了一些自定义的过滤规则。
