分析@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注解配置了一些自定義的過濾規則。
