Spring Boot自动装配原理
1.通过@SpringBootConfiguration引入了@EnableAutoConfiguration(负责启动自动配置功能)
2.@EnableAutoConfiguration引入了@lmport
3.Spring容器启动时:加载loc容器时会解析@lmport 注解
4.@lmport导入了一个deferredlmportselector(它会使SpringBoot的自动配置类的顺序在最后，这样方便我们扩展和覆盖
5.然后读取所有的/META-INF/org.springframework.boot.autoconfigure.AutoConfiguration.imports文件(SPI)
6.过滤出所有AutoConfigurtionClass类型的类
7.最后通过@ConditioOnXXX排除无效的自动配置类
源码阅读
1、@SpringBootApplication
这个注解是springboot启动类上的一个注解，是一个组合注解，也就是由其他注解组合起来，它的
主要作用就是标记说明这个类是springboot的主配置类，springboot应该运行这个类里面的 main()
@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：将该类注入容器@EnableAutoConfiguration：开启自动配置的功能@ComponentScan：配置扫描Bean的包路径
2、@SpringBootConfiguration
这个注解包含了 @Configuration，@Configuration 里面又包含了一个@Component注解，也就是说，这个注解标注在哪个类上，就表示当前这个类是一个配置类，而配置类也是spring容器中的组件
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Configuration
@Indexed
public @interface SpringBootConfiguration {
@AliasFor(annotation = Configuration.class)
boolean proxyBeanMethods() default true;
}@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Component
public @interface Configuration {
@AliasFor(
annotation = Component.class
)
String value() default "";
boolean proxyBeanMethods() default true;
}3、@EnableAutoConfiguration
@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：将启动类所在包以及子包里面的所有组件扫描并加载到spring的容器中@Import：作用是注入AutoConfigurationImportSelector
4、AutoConfigurationImportSelector
public class AutoConfigurationImportSelector implements DeferredImportSelector, BeanClassLoaderAware, ResourceLoaderAware, BeanFactoryAware, EnvironmentAware, Ordered {
}AutoConfigurationImportSelector 对象实现了 DeferredImportSelector 接口，而 DeferredImportSelector 接口继承的接口 ImportSelector 中有一个如下的方法：
String[] selectImports(AnnotationMetadata importingClassMetadata);AutoConfigurationImportSelector 实现的 selectImports 方法：
public String[] selectImports(AnnotationMetadata annotationMetadata) {
// 判断是否配置自动装配功能,默认开启
if (!this.isEnabled(annotationMetadata)) {
return NO_IMPORTS;
} else {
// 该行返回了自动配置对象
AutoConfigurationImportSelector.AutoConfigurationEntry autoConfigurationEntry =
this.getAutoConfigurationEntry(annotationMetadata);
return StringUtils.toStringArray(autoConfigurationEntry.getConfigurations());
}
}调用了 getAutoConfigurationEntry 方法返回自动配置对象
protected AutoConfigurationImportSelector.AutoConfigurationEntry getAutoConfigurationEntry(AnnotationMetadata annotationMetadata) {
if (!this.isEnabled(annotationMetadata)) {
return EMPTY_ENTRY;
} else {
// 获取注解属性列表
AnnotationAttributes attributes = this.getAttributes(annotationMetadata);
// 获取候选配置对象列表
List<String> configurations = this.getCandidateConfigurations(annotationMetadata, attributes);
// 移除重复的配置类
configurations = this.removeDuplicates(configurations);
// 获取需要排除的配置类
Set<String> exclusions = this.getExclusions(annotationMetadata, attributes);
// 检查排除的配置类
this.checkExcludedClasses(configurations, exclusions);
// 移除所有需要排除的
configurations.removeAll(exclusions);
// 对配置类列表进行过滤
configurations = this.getConfigurationClassFilter().filter(configurations);
// 关掉自动配置导入事件
this.fireAutoConfigurationImportEvents(configurations, exclusions);
return new AutoConfigurationImportSelector.AutoConfigurationEntry(configurations, exclusions);
}
}
getCandidateConfigurations() 使用来获取所有的自动配置类，即 xxxAutoConfiguration
protected List<String> getCandidateConfigurations(AnnotationMetadata metadata, AnnotationAttributes attributes) {
List<String> configurations = new ArrayList(SpringFactoriesLoader.loadFactoryNames(this.getSpringFactoriesLoaderFactoryClass(), this.getBeanClassLoader()));
ImportCandidates.load(AutoConfiguration.class, this.getBeanClassLoader()).forEach(configurations::add);
Assert.notEmpty(configurations, "No auto configuration classes found in META-INF/spring.factories nor 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;
}configurations 是通过 spring 的工厂加载器加载的名称。
public static List<String> loadFactoryNames(Class<?> factoryType, @Nullable ClassLoader classLoader) {
ClassLoader classLoaderToUse = classLoader;
if (classLoader == null) {
classLoaderToUse = SpringFactoriesLoader.class.getClassLoader();
}
String factoryTypeName = factoryType.getName();
return (List)loadSpringFactories(classLoaderToUse).getOrDefault(factoryTypeName, Collections.emptyList());
}方法最后的 return 调用了方法 loadSpringFactories 具体执行了加载方法
private static Map<String, List<String>> loadSpringFactories(ClassLoader classLoader) {
Map<String, List<String>> result = (Map)cache.get(classLoader);
if (result != null) {
return result;
} else {
HashMap result = new HashMap();
try {
// 获取 META-INF/spring.factories 文件并加载其中的类
Enumeration urls = classLoader.getResources("META-INF/spring.factories");
while(urls.hasMoreElements()) {
URL url = (URL)urls.nextElement();
UrlResource resource = new UrlResource(url);
Properties properties = PropertiesLoaderUtils.loadProperties(resource);
Iterator var6 = properties.entrySet().iterator();
while(var6.hasNext()) {
Entry<?, ?> entry = (Entry)var6.next();
String factoryTypeName = ((String)entry.getKey()).trim();
String[] factoryImplementationNames = StringUtils.commaDelimitedListToStringArray((String)entry.getValue());
String[] var10 = factoryImplementationNames;
int var11 = factoryImplementationNames.length;
for(int var12 = 0; var12 < var11; ++var12) {
String factoryImplementationName = var10[var12];
((List)result.computeIfAbsent(factoryTypeName, (key) -> {
return new ArrayList();
})).add(factoryImplementationName.trim());
}
}
}
result.replaceAll((factoryType, implementations) -> {
return (List)implementations.stream().distinct().collect(Collectors.collectingAndThen(Collectors.toList(), Collections::unmodifiableList));
});
cache.put(classLoader, result);
return result;
} catch (IOException var14) {
throw new IllegalArgumentException("Unable to load factories from location [META-INF/spring.factories]", var14);
}
}
}只需要了解该方法里面有一行：
Enumeration urls = classLoader.getResources("META-INF/spring.factories");
