SpringBoot源码学习（十）-Spring类级别注解解析原理
SpringBoot源码学习（十）-Spring类级别注解解析原理
写一点笔记
发布于 2020-10-10 10:59:38
发布于 2020-10-10 10:59:38
到目前为止我们大概知道了Spring初始化过程，甚至知道了SpringMvc的影子。通过之前的分析我们大概还有两个问题，第一是注解解析和相关的扫描。第二是getBean方法，因为getBean就是从BeanDefineMap中实例化bean并注册到IOC中具体实现了，因此与之相关的处理会很多。其实仔细思考，注解解析的步骤获取不难。为什么这么说的原因是在解析的时候我们之前写过解析注解的实例。通过之前的例子我们自己好好扩展一下也可以实现注解的解析，然后按beanDefinition的规则逐个注册上去，这部分工作就算是做完了。因为这边只是解析，不需要考虑循环依赖的问题。为啥可以将所有的bean都可以扫描进去的原因在于代码在SpringApplication类的load()方法首先将启动类注册到beanDefinitionMap中了。而启动类上边的注解就是秘密的根源。怀着这样的猜测，让我们刨根溯源，发掘神秘背后的故事。
通过之前第四篇文章的描述，我们直接看ConfigurationClassPostProcessor类。
因为该类是一个后置处理器，那么必然会实现BeanDefinitionRegistryPostProcessors接口，这里考虑为何不用BeanFactoryPostProcessos接口？因为BeanDefinitionRegistryPostProcessors比BeanFactoryPostProcessors执行的早。除此之外还实现了PriorityOrdered, ResourceLoaderAware, BeanClassLoaderAware, EnvironmentAware 。通过之前对BeanPostProcessors接口的学习，我们大概知道bean在实例化的过程大概是先执行aware类型的接口、bean初始化的前置处理、initlized接口、bean初始化的后置处理。那么这里的priorityOrdered我们在解析后置处理器和beanPostProcessors的执行的见到了。该接口主要用来排序和优先级的。所以这些都不是问题的关键。这里需要研究的就是BeanDefinitionRegistryPostProcessors接口。
publicvoid postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) {
int registryId = System.identityHashCode(registry);
if (this.registriesPostProcessed.contains(registryId)) {
throw new IllegalStateException(
"postProcessBeanDefinitionRegistry already called on this post-processor against " + registry);
}
if (this.factoriesPostProcessed.contains(registryId)) {
throw new IllegalStateException(
"postProcessBeanFactory already called on this post-processor against " + registry);
}
this.registriesPostProcessed.add(registryId);
processConfigBeanDefinitions(registry);
}查看这块代码发现也是做一些判断处理，这里的registriesPostProcessed采用的是set数据类型，set我们都知道事去重的。其中hashSet的底层是HashMap，其key就是要存储的值，而value是一个定值。除此之外均和HashMap没有区别。ConcurentHashMap是HashMap的加锁变体，其中加锁的地方是链表的根或者红黑树的树根。其他均和HashMap一样。
这里我们详细看一下processConfigBeanDefinitions都做了哪些事情。
发现这块代码很多，基本就是我们要分析的核心了。
public void processConfigBeanDefinitions(BeanDefinitionRegistry registry) {
ListconfigCandidates =new ArrayList<>();//获取所有目前注册到beanDefinitionMap的类
String[] candidateNames = registry.getBeanDefinitionNames();
for (String beanName : candidateNames) {//拿到配置
BeanDefinition beanDef = registry.getBeanDefinition(beanName);
if (ConfigurationClassUtils.isFullConfigurationClass(beanDef) ||
ConfigurationClassUtils.isLiteConfigurationClass(beanDef)) {
if (logger.isDebugEnabled()) {
logger.debug("Bean definition has already been processed as a configuration class: " + beanDef);
}
}
else if (ConfigurationClassUtils.checkConfigurationClassCandidate(beanDef, this.metadataReaderFactory)) {//如果是configuration注解的类就添加到list队列中
configCandidates.add(new BeanDefinitionHolder(beanDef, beanName));
}
}
// 如果没有Configuration注解的类的时候，直接返回
if (configCandidates.isEmpty()) {
return;
}
// 对@Order注解的bean进行排序
configCandidates.sort((bd1, bd2) -> {
int i1 = ConfigurationClassUtils.getOrder(bd1.getBeanDefinition());
int i2 = ConfigurationClassUtils.getOrder(bd2.getBeanDefinition());
return Integer.compare(i1, i2);
});
//单例bean的注册类，转化为单例IOC容器的注册器 SingletonBeanRegistry sbr = null;
if (registry instanceof SingletonBeanRegistry) {
sbr = (SingletonBeanRegistry) registry;
if (!this.localBeanNameGeneratorSet) {
BeanNameGenerator generator = (BeanNameGenerator) sbr.getSingleton(CONFIGURATION_BEAN_NAME_GENERATOR);
if (generator != null) {
this.componentScanBeanNameGenerator = generator;
this.importBeanNameGenerator = generator;
}
}
}
if (this.environment == null) {
this.environment = new StandardEnvironment();
}
//实例化一个configuration注解解析器 ，这里注入了各种解析需要的工具，包括包扫描的。其中registry就是目标的容器 ConfigurationClassParser parser = new ConfigurationClassParser(
this.metadataReaderFactory, this.problemReporter, this.environment,
this.resourceLoader, this.componentScanBeanNameGenerator, registry);
//使用set排一下重
Setcandidates =new LinkedHashSet<>(configCandidates);
SetalreadyParsed =new HashSet<>(configCandidates.size());
do {//使用configuration解析器解析所有已经加载到的被configuration修饰的bean
parser.parse(candidates);//解析完毕之后，我们需要的bean都被注册到beanDefinitionMap中，这里做一次校验
parser.validate();//将解析出来的具有Configuration相关的类放到configClasses中。
SetconfigClasses =new LinkedHashSet<>(parser.getConfigurationClasses());//这里先移除
configClasses.removeAll(alreadyParsed);
//创建一个配置阅读器，解析@Import注解的类，这里发现入参还是configClasses，说明了Import注解需要和Configuration注解配合使用。if (this.reader == null) {
this.reader = new ConfigurationClassBeanDefinitionReader(
registry, this.sourceExtractor, this.resourceLoader, this.environment,
this.importBeanNameGenerator, parser.getImportRegistry());
}//解析@Import注解
this.reader.loadBeanDefinitions(configClasses);//再添加回来
alreadyParsed.addAll(configClasses);
//清除之前的配置list
candidates.clear();//到这里，注册的bean已经很多了，有可能已经大于之前的candidateNames的数量了
if (registry.getBeanDefinitionCount() > candidateNames.length) {//拿到类名字，这会应该包含了很多
String[] newCandidateNames = registry.getBeanDefinitionNames();//拿到之前解析的类名
SetoldCandidateNames =new HashSet<>(Arrays.asList(candidateNames));//已经存在的解析类
SetalreadyParsedClasses =new HashSet<>();
for (ConfigurationClass configurationClass : alreadyParsed) {
alreadyParsedClasses.add(configurationClass.getMetadata().getClassName());
}
for (String candidateName : newCandidateNames) {//如果老的没有包含，那么就获取并添加进去
if (!oldCandidateNames.contains(candidateName)) {
BeanDefinition bd = registry.getBeanDefinition(candidateName);//检验是否为configuration注解修饰的类并且不是解析类本身
if (ConfigurationClassUtils.checkConfigurationClassCandidate(bd, this.metadataReaderFactory) &&
!alreadyParsedClasses.contains(bd.getBeanClassName())) {//添加进去
candidates.add(new BeanDefinitionHolder(bd, candidateName));
}
}
}//相当于扩容了
candidateNames = newCandidateNames;
}
}
while (!candidates.isEmpty());
// 将ImportRegistry注册进去
if (sbr != null && !sbr.containsSingleton(IMPORT_REGISTRY_BEAN_NAME)) {
sbr.registerSingleton(IMPORT_REGISTRY_BEAN_NAME, parser.getImportRegistry());
}
if (this.metadataReaderFactory instanceof CachingMetadataReaderFactory) {
//清空一下缓存
((CachingMetadataReaderFactory) this.metadataReaderFactory).clearCache();
}
}判断是否为configuration注解
public static boolean isFullConfigurationCandidate(AnnotationMetadata metadata) {
return metadata.isAnnotated(Configuration.class.getName());
}解析Order注解
@Nullable
public static Integer getOrder(AnnotationMetadata metadata) {
Map, Object> orderAttributes = metadata.getAnnotationAttributes(Order.class.getName());
return (orderAttributes != null ? ((Integer) orderAttributes.get(AnnotationUtils.VALUE)) : null);
}到这里我们基本了解了@Configuration和@Import的解析过程了。因为传入的类是启动类，而启动类必然会包含这个Configuration的注解因为@SpringBootApplication是个组合注解。解析到@Configuration注解的类之后就开始解析了。解析之后就包含了很多类了。然后再对@Import注解的解析。这是这块代码主要做的事情。那么这块我们看一下parse方法和import的解析过程吧。按理说这两个方法都不太难。
public void parse(SetconfigCandidates) {
for (BeanDefinitionHolder holder : configCandidates) {
BeanDefinition bd = holder.getBeanDefinition();
try {//判断是否有注解
if (bd instanceof AnnotatedBeanDefinition) {//解析一下注解
parse(((AnnotatedBeanDefinition) bd).getMetadata(), holder.getBeanName());
}
else if (bd instanceof AbstractBeanDefinition && ((AbstractBeanDefinition) bd).hasBeanClass()) {
parse(((AbstractBeanDefinition) bd).getBeanClass(), holder.getBeanName());
}
else {
parse(bd.getBeanClassName(), holder.getBeanName());
}
}
catch (BeanDefinitionStoreException ex) {
throw ex;
}
catch (Throwable ex) {
throw new BeanDefinitionStoreException(
"Failed to parse configuration class [" + bd.getBeanClassName() + "]", ex);
}
}
this.deferredImportSelectorHandler.process();
}
protected void processConfigurationClass(ConfigurationClass configClass) throws IOException {
if (this.conditionEvaluator.shouldSkip(configClass.getMetadata(), ConfigurationPhase.PARSE_CONFIGURATION)) {
return;
}//获取configuration修饰的类
ConfigurationClass existingClass = this.configurationClasses.get(configClass);
if (existingClass != null) {//看是否为是否已经被注入了
if (configClass.isImported()) {
if (existingClass.isImported()) {
existingClass.mergeImportedBy(configClass);
}
return;
}
else {
this.configurationClasses.remove(configClass);
this.knownSuperclasses.values().removeIf(configClass::equals);
}
}
SourceClass sourceClass = asSourceClass(configClass);
do {
sourceClass = doProcessConfigurationClass(configClass, sourceClass);
}
while (sourceClass != null);
this.configurationClasses.put(configClass, configClass);
}
protected final SourceClass doProcessConfigurationClass(ConfigurationClass configClass, SourceClass sourceClass)
throws IOException {//判断是否为Compoent注解。
if (configClass.getMetadata().isAnnotated(Component.class.getName())) {//解析成员类。经过测试，可以在configuration注解修改时类的内部类定义被Compoent注解修饰的类，并成功注册到ioc
processMemberClasses(configClass, sourceClass);
}
// 解析@PropertySource，PropertiesCource的注解内容为数组，所以这里循环解析 for (AnnotationAttributes propertySource : AnnotationConfigUtils.attributesForRepeatable(
sourceClass.getMetadata(), PropertySources.class,
org.springframework.context.annotation.PropertySource.class)) {
if (this.environment instanceof ConfigurableEnvironment) {//这里的解析就是将配置文件读取，然后加入的到env中。
processPropertySource(propertySource);
}
else {
logger.info("Ignoring @PropertySource annotation on [" + sourceClass.getMetadata().getClassName() +
"]. Reason: Environment must implement ConfigurableEnvironment");
}
}
// 解析包扫描注解，同样的compoentScans注解是一个数组，所以循环遍历 SetcomponentScans = AnnotationConfigUtils.attributesForRepeatable(
sourceClass.getMetadata(), ComponentScans.class, ComponentScan.class);
if (!componentScans.isEmpty() &&
!this.conditionEvaluator.shouldSkip(sourceClass.getMetadata(), ConfigurationPhase.REGISTER_BEAN)) {
for (AnnotationAttributes componentScan : componentScans) {
// The config class is annotated with @ComponentScan -> perform the scan immediately
SetscannedBeanDefinitions =
this.componentScanParser.parse(componentScan, sourceClass.getMetadata().getClassName());
// Check the set of scanned definitions for any further config classes and parse recursively if needed
for (BeanDefinitionHolder holder : scannedBeanDefinitions) {
BeanDefinition bdCand = holder.getBeanDefinition().getOriginatingBeanDefinition();
if (bdCand == null) {
bdCand = holder.getBeanDefinition();
}
if (ConfigurationClassUtils.checkConfigurationClassCandidate(bdCand, this.metadataReaderFactory)) {
parse(bdCand.getBeanClassName(), holder.getBeanName());
}
}
}
}
//解析@import注解 processImports(configClass, sourceClass, getImports(sourceClass), true);
// 解析@ImportResource注解 AnnotationAttributes importResource =
AnnotationConfigUtils.attributesFor(sourceClass.getMetadata(), ImportResource.class);
if (importResource != null) {
String[] resources = importResource.getStringArray("locations");
Class<? extends BeanDefinitionReader> readerClass = importResource.getClass("reader");
for (String resource : resources) {
String resolvedResource = this.environment.resolveRequiredPlaceholders(resource);
configClass.addImportedResource(resolvedResource, readerClass);
}
}
// Process individual @Bean methods
SetbeanMethods = retrieveBeanMethodMetadata(sourceClass);
for (MethodMetadata methodMetadata : beanMethods) {
configClass.addBeanMethod(new BeanMethod(methodMetadata, configClass));
}
// 处理虚方法
processInterfaces(configClass, sourceClass);
// Process superclass, if any
if (sourceClass.getMetadata().hasSuperClass()) {
String superclass = sourceClass.getMetadata().getSuperClassName();
if (superclass != null && !superclass.startsWith("java") &&
!this.knownSuperclasses.containsKey(superclass)) {
this.knownSuperclasses.put(superclass, configClass);
// Superclass found, return its annotation metadata and recurse
return sourceClass.getSuperClass();
}
return null;
}在ComponentScans解析的时候，最终调的scanner.doScan方法其中解析的时候，也是循环的调用之前的方法。
注解相关的验证
PropertiesSource和内部类component注解以及虚方法实例
总结：通过分析，我们看到这里大概将存在于类上的spring注解全部注册进去了。并通过扫描将项目体系中需要的类全部都注册了进去。但是到目前还有解析@Bean或者@Autowired等类内部的注解。除此之外我们需要注意的是今天学习的@Import、@ComponentScans、ImportRsource等注解需要结合@Configuration注解一起使用。
本文参与 腾讯云自媒体分享计划，分享自微信公众号。
原始发表：2020-09-27，如有侵权请联系 cloudcommunity@tencent.com 删除
评论
登录后参与评论
推荐阅读