引文
聊Springboot的自动装配原理,首先要看的就是启动类,在启动的时候发生了什么。Spring Boot的启动类上有一个@SpringBootApplication
注解,这个注解是Spring Boot项目必不可少的注解.
@SpringBootApplication
public static void main(String[] args) {
ApplicationContext run = SpringApplication.run(EmosVxApiApplication.class, args);
}
启动类中的返回值实际上就是Spring的容器,这在Spring中是一致的。
然后就是看@SpringBootApplication
都做了什么工作。
@SpringBootApplication
@SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan(
excludeFilters = {@Filter(
type = FilterType.CUSTOM,
classes = {TypeExcludeFilter.class}
), @Filter(
type = FilterType.CUSTOM,
classes = {AutoConfigurationExcludeFilter.class}
)}
)
public @interface SpringBootApplication {
}
发现SpringBootApplication注解是一个复合注解,上面有三个关键的注解分别是:@SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan
@SpringBootConfiguration
@SpringBootConfiguration
实际上是一个配置类注解,被这个注解修饰的注解也是一个配置类。
@ComponentScan
@ComponentScan
这个注解应该都知道吧,就是扫描哪些包,忽略哪些包。
@EnableAutoConfiguration
最重要的就是这个注解了。看一下这个注解都包括什么:
@Inherited
@AutoConfigurationPackage
@Import({AutoConfigurationImportSelector.class})
public @interface EnableAutoConfiguration {
String ENABLED_OVERRIDE_PROPERTY = "spring.boot.enableautoconfiguration";
Class<?>[] exclude() default {};
String[] excludeName() default {};
}
这个注解有一个@Import注解
,这个注解有两个作用。
静态加载:将其他类的对象导入IOC容器
@Configuration
@Import({Student.class})
public class JavaConfig {
public static void main(String[] args) {
ApplicationContext context =new AnnotationConfigApplicationContext(JavaConfig.class);
Student student = context.getBean(Student.class);
System.out.println(student);
}
}
动态加载:如果导入的类实现了ImportSelector类,那么就将ImportSelector类selectImports方法的返回值导入到IOC容器,实际上它的返回值就是类的全限定类名。
所以我们只要实现这个类,就可以动态的添加一些对象到容器中。
@Import({MySelector.class})
public class JavaConfig {
public static void main(String[] args) {
ApplicationContext context =new AnnotationConfigApplicationContext(JavaConfig.class);
Student student = context.getBean(Student.class);
System.out.println(context.getBean(Person.class));
System.out.println(student);
}
}
public class MySelector implements ImportSelector {
@Override
public String[] selectImports(AnnotationMetadata importingClassMetadata) {
return new String[]{Person.class.getName(), Logger.class.getName(), Student.class.getName()};
}
@Override
public Predicate<String> getExclusionFilter() {
return ImportSelector.super.getExclusionFilter();
}
}
SpringBoot已经为我们实现了,再来看@EnableAutoConfiguration注解。
Import为我们导入了AutoConfigurationImportSelector类,看类名大家也应该想到了,这个类实现ImportSelector接口
所以这个类也应该实现了接口中的方法,看一下SpringBoot是如何实现的。
public String[] selectImports(AnnotationMetadata annotationMetadata) {
if (!this.isEnabled(annotationMetadata)) {
return NO_IMPORTS;
} else {
AutoConfigurationImportSelector.AutoConfigurationEntry autoConfigurationEntry = this.getAutoConfigurationEntry(annotationMetadata);
return StringUtils.toStringArray(autoConfigurationEntry.getConfigurations());
}
}
我们主要看else里面的代码就可以了。在这个方法中调用了this.getAutoConfigurationEntry(annotationMetadata);这个方法的返回值其实就是我们需要的类的全限定类目。所以我们要看一下它是如何实现的,进入方法查看。
protected AutoConfigurationImportSelector.AutoConfigurationEntry getAutoConfigurationEntry(AnnotationMetadata annotationMetadata) {
if (!this.isEnabled(annotationMetadata)) {
return EMPTY_ENTRY;
} else {
AnnotationAttributes attributes = this.getAttributes(annotationMetadata);
//获取所有的候选配置类,其实就是扫描META-INF/spring.factories
List<String> configurations = this.getCandidateConfigurations(annotationMetadata, attributes);
//排除掉重复的
configurations = this.removeDuplicates(configurations);
//排除不需要的 就是我们在@SpringBootApplication(exclude =xxx.class )写的
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);
}
}
spring.factories会有很多,比如我们引入其他starter,就会有对应的spring.factories
我们发现有100多个配置类被扫描到了,但是实际上我们用不到那么多,如果全部加载到内存到话,会占用内存空间,所以怎么样排除我们不需要的呢?看this.getConfigurationClassFilter().filter(configurations);这个方法是如何实现的。
这个方法很长,我们只看关键的部分,while循环判断所有的配置类,根据this.autoConfigurationMetadata这个条件来判断,这个条件是什么呢?
通过加载Metadata来判断,所以继续看什么是Metadata
static AutoConfigurationMetadata loadMetadata(ClassLoader classLoader) {
return loadMetadata(classLoader, "META-INF/spring-autoconfigure-metadata.properties");
}
发现它是加载META-INF/spring-autoconfigure-metadata.properties文件进行判断的,
现在我们能理解了,配置类是按需加载的。
总结
Spring Boot在启动的时候从类路径下的META-INF/spring.factories中获取EnableAutoConfiguration指定的值,将这些值作为自动配置类导入到容器中,自动配置类就生效,帮我们进行自动配置工作,并且根据当前项目的环境排除一些我们不需要的配置,减少内存消耗。以前我们需要自己配置的东西,自动配置类都帮我们完成了。