@SpringBootApplication
public class SpringstudyApplication {
public static void main(String[] args) {
SpringApplication.run(SpringstudyApplication.class, args);
}
}
@springbootApplication为自动配置的核心注解,如下图是该注解下面的继承的注解
@SpringBootAppliacation下面的两个主要的注解为:
1.@SpringBootConfiguration
2.@EnableAutoConfiguration
@SpringBootConfiguration注解下的一个注解是@Configuration,
这个就是标注@SpringBootConfiguration的类本质上面就是一个配置类
也标注了@SpringBootAppliacation的主启动类本质上也是一个配置类
@EnableAutoConfiguration这是一个自动配置的注解,这下面有两个主要的注解分别是:
1.@AutoConfigurationPackage
2.@import(AutoConfigurationimportSelector.class)
这个注解下面包含一个注解@import(AutoConfigurationPackages.Registrar.class)
这个注解导入了Registrar这个类,这个类是自动配置包下面的一个注册类
贴源码:
static class Registrar implements importBeanDefinitionRegistrar, Determinableimports {
Registrar() {
}
public void registerBeanDefinitions(Annotationmetadata metadata, BeanDefinitionRegistry registry) {
AutoConfigurationPackages.register(registry, (String[])(new AutoConfigurationPackages.Packageimports(metadata)).getPackageNames().toArray(new String[0]));
}
public Set
这个类主要实现了接口的两个方法:
1.通过元数据获得一个Packageimports,并且对其进行注册
2.通过Packageimports返回一个Set集合
这个是Packageimports的构造方法:
Packageimports(Annotationmetadata metadata) {
AnnotationAttributes attributes = AnnotationAttributes.fromMap(metadata.getAnnotationAttributes(AutoConfigurationPackage.class.getName(), false));
List packageNames = new ArrayList(Arrays.asList(attributes.getStringArray("basePackages")));
Class[] var4 = attributes.getClassArray("basePackageClasses");
int var5 = var4.length;
for(int var6 = 0; var6 < var5; ++var6) {
Class> basePackageClass = var4[var6];
packageNames.add(basePackageClass.getPackage().getName());
}
if (packageNames.isEmpty()) {
packageNames.add(ClassUtils.getPackageName(metadata.getClassName()));
}
this.packageNames = Collections.unmodifiableList(packageNames);
}
packageNames 保存了通过元数据得到的类名,这也就说明Packageimports这个类保存了元数据类名
@import({AutoConfigurationimportSelector.class}) 1、AutoConfigurationimportSelector.selectimports这个类是一个导入自动配置的选择器
第一个方法: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());
}
}
第一行if的判断是:ENABLED_OVERRIDE_PROPERTY属性,就是是否可以重写配置属性,如果为true,继续走接下来的代码,否则就会返回一个空数组。
接着就是加载元数据,通过getAutoConfigurationEntry来获得自动配置实体autoConfigurationEntry 。
最后返回的是autoConfigurationEntry.getConfigurations()也就是自动配置实体的配置。
我们接下来看第二个方法:getAutoConfigurationEntry
上面那个selectimports方法中调用了这个方法
protected AutoConfigurationimportSelector.AutoConfigurationEntry getAutoConfigurationEntry(Annotationmetadata annotationmetadata) {
if (!this.isEnabled(annotationmetadata)) {
return EMPTY_ENTRY;
} else {
AnnotationAttributes attributes = this.getAttributes(annotationmetadata);
List configurations = this.getCandidateConfigurations(annotationmetadata, attributes);
configurations = this.removeDuplicates(configurations);
Set 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);
}
}
①if判断跟上面讲的一样
②用了getAttributes来获取元数据的属性attributes
③通过getCandidateConfigurations这个方法来获取候选配置(这个是个重要的地方)
④对获取的候选配置进行一些操作(检查配置,排除一些配置)并通过这些配置来返回自动配置实体
上面的第四步只是对一些配置做过滤以及检查,所以我们对getCandidateConfigurations这个方法继续进行分析
3.AutoConfigurationimportSelector.getCandidateConfigurationsprotected ListgetCandidateConfigurations(Annotationmetadata metadata, AnnotationAttributes attributes) { List configurations = SpringFactoriesLoader.loadFactoryNames(this.getSpringFactoriesLoaderFactoryClass(), this.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; }
这里面调用了SpringFactoriesLoader里面的loadFactoryNames方法来获取配置并把这个配置返回
loadFactoryNames方法:
public static ListloadFactoryNames(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()); }
这个方法首先获取工厂类的类名又调用了loadSpringFactories方法,继续分析:
loadSpringFactories
private static Map> loadSpringFactories(ClassLoader classLoader) { Map > result = (Map)cache.get(classLoader); if (result != null) { return result; } else { HashMap result = new HashMap(); try { 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); } } }
这个方法大概就是从meta-INF/spring.factories里获得url,然后对url进行遍历,并把遍历出的内容放在缓存中进行返回。
我们继续分析spring.factories文件
springfactories在spring-boot-autoconfiguration:2.5.0jar包下的meta-INF,自动配置就是回到了springboot自动配置的jar包
这里面有初始化,监听器,过滤器等等,最最最重要的就是里面包含了大量XXAutoConfiguration的自动配置类
重点!!!
随便进入一个包里面看比如WebMvcAutoConfiguration可以看到如下注解:
@ConditionalOnXxxx:在达成该注解的要求后,该自动配置类才会生效,比如:
@ConditionalOnClass:在指定的类存在(即有被导入)后生效 @ConditionalOnMissingBean:spring
IoC容器中不存在指定的bean时生效 …
@EnableConfigurationProperties:与一个XxxxProperties的配置类绑定。基本每一个XxxxAutoConfiguration都会与一个或多个XxxxProperties所绑定,该注解不仅会在XxxxAutoConfiguration上,也可能在其的静态内部类上标注
@ConditionalOnWebApplication(
type = Type.SERVLET
)
@ConditionalOnClass({Servlet.class, DispatcherServlet.class, WebMvcConfigurer.class})
@ConditionalOnMissingBean({WebMvcConfigurationSupport.class})
@EnableConfigurationProperties({WebProperties.class})
8.XxxxProperties
末尾总结:与XxxxAutoConfiguration绑定的配置类,通常标有@ConfigurationProperties注解
@ConfigurationProperties:可传入参数prefix前缀,表示可以把springboot配置文件中以指定前缀开头的属性加载到本配置文件中
XxxxProperties中的属性与springboot配置文件中以prefix前缀开头的属性一一对应,因此在配置文件中配置的内容,会通过XxxxProperties传入XxxxAutoConfiguration中,从而达到自定义配置的效果
自动配置最最最核心的是@EnableAutoConfiguration所导入的AutoConfigurationimportSelector.class
这个类: ①用getCandidateConfigurations方法来加载候选配置
②上面的方法是用SpringFactoriesLoader.loadFactoryNames方法来获取配置
③上述方法调用的是loadSpringFactories方法
④loadSpringFactories的方法里面加载了spring.factories文件的内容
⑤spring.factories文件里面又有大量的XXXAutoConfiguration类
⑥XXXAutoConfiguration类中通过@ConditionalOnXXX来决定自动配置是否生效,然后通过@EnableConfigurationProperties来绑定XXXProperties配置类
⑦XXXProperties配置类中通过@ConfigurationProperties导入springboot配置文件中的自定义配置
XXXAutoConfiguration中已经写好了大量配置以及bean,因此,我们可以通过导入指定的类或达成指定的条件,使我们需要的XXXAutoConfiguration自动配置类生效,即可完成springboot的自动配置,并可以在配置文件中以指定的前缀修改自动配置的参数属性。



