spring 源码ConfigurationClassParser类解析收集Component、PropertySource、ComponentScan、Import、bean等相关注解（一）

- 日理万妓 2023-10-02 20:26 15阅读 0赞

spring 源码ConfigurationClassParser类解析收集Component、PropertySource、ComponentScan、@Import、@bean等相关注解今天分享，缘由基于spring注解配置逐步取代xml文件的配置的发展思路，也是一种趋势，比如现在常用的springboot 框架基本上都是基于注解的配置扫描，下面我们开始逐个源码分析，同时加上业务伪代码去测试，这样看起来更直观。

五种注解收集的入口如下，ConfigurationClassParser类中：

@Nullable
    	protected final SourceClass doProcessConfigurationClass(
    			ConfigurationClass configClass, SourceClass sourceClass, Predicate<String> filter)
    			throws IOException {
    
    		//判断类上面是否有Component注解
    		if (configClass.getMetadata().isAnnotated(Component.class.getName())) {
    			// Recursively process any member (nested) classes first
    			//递归处理有@Component注解的内部类
    			processMemberClasses(configClass, sourceClass, filter);
    		}
    
    		// Process any @PropertySource annotations
    		//处理PropertySources和 PropertySource注解
    		for (AnnotationAttributes propertySource : AnnotationConfigUtils.attributesForRepeatable(
    				sourceClass.getMetadata(), PropertySources.class,
    				org.springframework.context.annotation.PropertySource.class)) {
    			if (this.environment instanceof ConfigurableEnvironment) {
    				//核心逻辑
    				processPropertySource(propertySource);
    			}
    			else {
    				logger.info("Ignoring @PropertySource annotation on [" + sourceClass.getMetadata().getClassName() +
    						"]. Reason: Environment must implement ConfigurableEnvironment");
    			}
    		}
    
    		// Process any @ComponentScan annotations
    		//处理ComponentScans和ComponentScan注解
    		Set<AnnotationAttributes> componentScans = 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
    				//这个parse里面的逻辑，基本上跟我们<component-scan>自定义标签解析的逻辑差不多
    				Set<BeanDefinitionHolder> scannedBeanDefinitions =
    						this.componentScanParser.parse(componentScan, sourceClass.getMetadata().getClassName());
    				// Check the set of scanned definitions for any further config classes and parse recursively if needed
    				//这里又去递归，扫描到@Component生成beanDefinition后，又递归去校验类上面是否有特殊注解
    				for (BeanDefinitionHolder holder : scannedBeanDefinitions) {
    					BeanDefinition bdCand = holder.getBeanDefinition().getOriginatingBeanDefinition();
    					if (bdCand == null) {
    						bdCand = holder.getBeanDefinition();
    					}
    					//判断是否是候选的BeanDefinition，如果是又parse
    					if (ConfigurationClassUtils.checkConfigurationClassCandidate(bdCand, this.metadataReaderFactory)) {
    						parse(bdCand.getBeanClassName(), holder.getBeanName());
    					}
    				}
    			}
    		}
    
    		//处理@Import注解 getImports(sourceClass) 获取类上面的@Import注解并封装成SourceClass
    		// Process any @Import annotations
    		processImports(configClass, sourceClass, getImports(sourceClass), filter, true);
    
    		//处理@ImportResource注解 ，没啥用，加载xml配置文件
    		// Process any @ImportResource annotations
    		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);
    				//建立xml文件和reader的映射关系
    				configClass.addImportedResource(resolvedResource, readerClass);
    			}
    		}
    
    		//处理@Bean注解，重点
    		// Process individual @Bean methods
    		//收集有@bean 注解的方法
    		Set<MethodMetadata> beanMethods = retrieveBeanMethodMetadata(sourceClass);
    		for (MethodMetadata methodMetadata : beanMethods) {
    			//加入到ConfigurationClass中
    			configClass.addBeanMethod(new BeanMethod(methodMetadata, configClass));
    		}
    
    		//处理接口里面方法有@Bean注解的，逻辑差不多
    		// Process default methods on interfaces
    		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();
    			}
    		}
    
    		// No superclass -> processing is complete
    		return null;
    	}

一、@Component注解分析、

1、收集入口

//判断类上面是否有Component注解
    		if (configClass.getMetadata().isAnnotated(Component.class.getName())) {
    			// Recursively process any member (nested) classes first
    			//递归处理有@Component注解的内部类
    			processMemberClasses(configClass, sourceClass, filter);
    		}

点击processMemberClasses(configClass, sourceClass, filter)：

private void processMemberClasses(ConfigurationClass configClass, SourceClass sourceClass,
    			Predicate<String> filter) throws IOException {
    
    		//获取该类的内部类并又包装成sourceClass对象
    		Collection<SourceClass> memberClasses = sourceClass.getMemberClasses();
    		if (!memberClasses.isEmpty()) {
    			List<SourceClass> candidates = new ArrayList<>(memberClasses.size());
    			for (SourceClass memberClass : memberClasses) {
    				//如果类是候选的
    				if (ConfigurationClassUtils.isConfigurationCandidate(memberClass.getMetadata()) &&
    						!memberClass.getMetadata().getClassName().equals(configClass.getMetadata().getClassName())) {
    					candidates.add(memberClass);
    				}
    			}
    			//排序
    			OrderComparator.sort(candidates);
    			//循环去处理每一个内部类
    			for (SourceClass candidate : candidates) {
    				if (this.importStack.contains(configClass)) {
    					this.problemReporter.error(new CircularImportProblem(configClass, this.importStack));
    				}
    				else {
    					this.importStack.push(configClass);
    					try {
    						//candidate 子  configClass 父，candidate 是 configClass的内部类
                           //此处是递归循环调用，即一直去找下面的注解
    						processConfigurationClass(candidate.asConfigClass(configClass), filter);
    					}
    					finally {
    						this.importStack.pop();
    					}
    				}
    			}
    		}
    	}

2、判断是否有相关注解，点击 ConfigurationClassUtils.isConfigurationCandidate(memberClass.getMetadata())

public static boolean isConfigurationCandidate(AnnotationMetadata metadata) {
    		// Do not consider an interface or an annotation...
    		if (metadata.isInterface()) {
    			return false;
    		}
    
    		// Any of the typical annotations found?
    		for (String indicator : candidateIndicators) {//注解的集合，依次判断
    			if (metadata.isAnnotated(indicator)) {
    				return true;
    			}
    		}
    
    		// Finally, let's look for @Bean methods...
           //判断是否有此@Bean注解的方法
    		try {
    			return metadata.hasAnnotatedMethods(Bean.class.getName());
    		}
    		catch (Throwable ex) {
    			if (logger.isDebugEnabled()) {
    				logger.debug("Failed to introspect @Bean methods on class [" + metadata.getClassName() + "]: " + ex);
    			}
    			return false;
    		}
    	}

如图：

![29de4d6931994259bec14e8a1016dc44.png][] 3、业务伪代码测试

import com.enjoy.jack.bean.Student;
    import org.springframework.context.annotation.Bean;
    import org.springframework.stereotype.Component;
    
     
    @Component
    public class InnerClassDemo {
    
        @Component
        public class SpringSource {
            @Bean
            public Student student() {
                return new Student();
            }
        }
    
        @Component
        public class Mybatis {
    
        }
    }

4、测试如图

![65ec748f1d784ff2ae82328d856c4859.png][]

进入发现两个内部类

![066c669371f247f4ba5b3db0111a15e8.png][]

如果内部类有注解，就会递归循环每一个内部类

![1509b37d68dc4858a67e0183db490cc0.png][] 此流程收集带有@Component注解的类并放入 importStack 中，供后续业务使用。

二、@PropertySource注解分析，首先说明此注解的配置是这样的如下伪代码：

@PropertySource(name = "nandao", value = "classpath:application.properties")
    public class ScanBean {
       //省略其他代码.....
    }

此处的注解的配置和spring.xml的配置功能是一样的，并且前几篇文章分析过了。

<context:property-placeholder location="classpath:application.properties"/>

1、源码解析入口

// Process any @PropertySource annotations
    		//处理PropertySources和 PropertySource注解
    		for (AnnotationAttributes propertySource : AnnotationConfigUtils.attributesForRepeatable(
    				sourceClass.getMetadata(), PropertySources.class,
    				org.springframework.context.annotation.PropertySource.class)) {
    			if (this.environment instanceof ConfigurableEnvironment) {
    				//核心逻辑，点击进入
    				processPropertySource(propertySource);
    			}
    			else {
    				logger.info("Ignoring @PropertySource annotation on [" + sourceClass.getMetadata().getClassName() +
    						"]. Reason: Environment must implement ConfigurableEnvironment");
    			}
    		}

点击processPropertySource(propertySource);方法

private void processPropertySource(AnnotationAttributes propertySource) throws IOException {
    		String name = propertySource.getString("name");
    		if (!StringUtils.hasLength(name)) {
    			name = null;
    		}
    		String encoding = propertySource.getString("encoding");
    		if (!StringUtils.hasLength(encoding)) {
    			encoding = null;
    		}
    		//获取配置文件路径
    		String[] locations = propertySource.getStringArray("value");
    		Assert.isTrue(locations.length > 0, "At least one @PropertySource(value) location is required");
    		boolean ignoreResourceNotFound = propertySource.getBoolean("ignoreResourceNotFound");
    
    		Class<? extends PropertySourceFactory> factoryClass = propertySource.getClass("factory");
    		PropertySourceFactory factory = (factoryClass == PropertySourceFactory.class ?
    				DEFAULT_PROPERTY_SOURCE_FACTORY : BeanUtils.instantiateClass(factoryClass));
    
    		for (String location : locations) {
    			try {
    				//替换占位符
    				String resolvedLocation = this.environment.resolveRequiredPlaceholders(location);
    				//流的方式加载配置文件并封装成Resource对象
    				Resource resource = this.resourceLoader.getResource(resolvedLocation);
    				//加载Resource中的配置属性封装成Properties对象中，并创建PropertySource对象加入到Environment对象中
    				addPropertySource(factory.createPropertySource(name, new EncodedResource(resource, encoding)));
    			}
    			catch (IllegalArgumentException | FileNotFoundException | UnknownHostException ex) {
    				// Placeholders not resolvable or resource not found when trying to open it
    				if (ignoreResourceNotFound) {
    					if (logger.isInfoEnabled()) {
    						logger.info("Properties location [" + location + "] not resolvable: " + ex.getMessage());
    					}
    				}
    				else {
    					throw ex;
    				}
    			}
    		}
    	}

测试获取的路径

![cf76e02fe9f34ea698292cf54328b53c.png][]

点击 addPropertySource 方法

private void addPropertySource(PropertySource<?> propertySource) {
    		String name = propertySource.getName();
    		//获取Environment对象中的MutablePropertySources，并修改此参数，比如添加一下资源
    		MutablePropertySources propertySources = ((ConfigurableEnvironment) this.environment).getPropertySources();
    
    		//如果已经存在了该配置文件的PropertySource则合并久的
    		if (this.propertySourceNames.contains(name)) {
    			// We've already added a version, we need to extend it
    			PropertySource<?> existing = propertySources.get(name);
    			if (existing != null) {
    				PropertySource<?> newSource = (propertySource instanceof ResourcePropertySource ?
    						((ResourcePropertySource) propertySource).withResourceName() : propertySource);
    				//合并二次后的类型
    				if (existing instanceof CompositePropertySource) {
    					((CompositePropertySource) existing).addFirstPropertySource(newSource);
    				}
    				else {
    					if (existing instanceof ResourcePropertySource) {
    						existing = ((ResourcePropertySource) existing).withResourceName();
    					}
    					//其实就是CompositePropertySource里面有一个Set，Set里面装了新和旧的PropertySource对象
    					CompositePropertySource composite = new CompositePropertySource(name);
    					composite.addPropertySource(newSource);
    					composite.addPropertySource(existing);
    					propertySources.replace(name, composite);
    				}
    				return;
    			}
    		}
    
    		if (this.propertySourceNames.isEmpty()) {
    			propertySources.addLast(propertySource);//加入 environment 对象
    		}
    		else {
    			//用于计算插入的位置index
    			String firstProcessed = this.propertySourceNames.get(this.propertySourceNames.size() - 1);
    			//吧propertySource对象存入MutablePropertySources的list中
    			propertySources.addBefore(firstProcessed, propertySource);
    		}
    		this.propertySourceNames.add(name);
    	}

加入测试

![065c9b05015f4b238fd12dd831c2b5ef.png][]

封装好之后，下游业务会对其Environment解析处理。

三、@ComponentScan注解分析

这是通过注解的方式扫描对象，原生是通过spring.xml配置实现的对比一下：

import org.springframework.context.annotation.ComponentScan;
    import org.springframework.context.annotation.ComponentScans;
    import org.springframework.context.annotation.PropertySource;
    import org.springframework.stereotype.Component;
    
     
    @ComponentScans({@ComponentScan("nn"), @ComponentScan("dd")})//扫描的数值目录
    @Component
    @ComponentScan(value = "com.enjoy.jack"/*,includeFilters = ,basePackages = */)//扫描一个目录
    //<context:property-placeholder location="classpath:application.properties"/>
    @PropertySource(name = "nandao", value = "classpath:application.properties")
    public class ScanBean {
       //省略.....
    }

xml 配置

<context:component-scan base-package="com.enjoy.jack">
    
        </context:component-scan>

1、源码入口

// Process any @ComponentScan annotations
    		//处理ComponentScans和ComponentScan注解
    		Set<AnnotationAttributes> componentScans = 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
    				//这个parse里面的逻辑，基本上跟我们<component-scan>自定义标签解析的逻辑差不多
    				Set<BeanDefinitionHolder> scannedBeanDefinitions =
    						this.componentScanParser.parse(componentScan, sourceClass.getMetadata().getClassName());
    				// Check the set of scanned definitions for any further config classes and parse recursively if needed
    				//这里又去递归，扫描到@Component生成beanDefinition后，又递归去校验类上面是否有特殊注解
    				for (BeanDefinitionHolder holder : scannedBeanDefinitions) {
    					BeanDefinition bdCand = holder.getBeanDefinition().getOriginatingBeanDefinition();
    					if (bdCand == null) {
    						bdCand = holder.getBeanDefinition();
    					}
    					//判断是否是候选的BeanDefinition，如果是又parse
    					if (ConfigurationClassUtils.checkConfigurationClassCandidate(bdCand, this.metadataReaderFactory)) {
    						parse(bdCand.getBeanClassName(), holder.getBeanName());
    					}
    				}
    			}
    		}

测试走到这里

![d06a644b23364fcdbec2ec67c67716a4.png][]

2、点击 AnnotationConfigUtils.attributesForRepeatable()

static Set<AnnotationAttributes> attributesForRepeatable(AnnotationMetadata metadata,
    			Class<?> containerClass, Class<?> annotationClass) {
    
    		return attributesForRepeatable(metadata, containerClass.getName(), annotationClass.getName());//点击进入
    	}

测试如图

![c3b8d1728be249529c9bfa458aba8668.png][]来到

@SuppressWarnings("unchecked")
    	static Set<AnnotationAttributes> attributesForRepeatable(
    			AnnotationMetadata metadata, String containerClassName, String annotationClassName) {
    
    		Set<AnnotationAttributes> result = new LinkedHashSet<>();
    
    		// Direct annotation present?
    		addAttributesIfNotNull(result, metadata.getAnnotationAttributes(annotationClassName, false));//点击
    
    		// Container annotation present?
    		Map<String, Object> container = metadata.getAnnotationAttributes(containerClassName, false);
    		if (container != null && container.containsKey("value")) {
    			for (Map<String, Object> containedAttributes : (Map<String, Object>[]) container.get("value")) {
    				addAttributesIfNotNull(result, containedAttributes);
    			}
    		}
    
    		// Return merged result
    		return Collections.unmodifiableSet(result);
    	}

点击addAttributesIfNotNull

private static void addAttributesIfNotNull(
    			Set<AnnotationAttributes> result, @Nullable Map<String, Object> attributes) {
    
    		if (attributes != null) {
    			result.add(AnnotationAttributes.fromMap(attributes));
    		}
    	}

测试数据

![5c584f540ae4466085df1d99292977f9.png][]

返回扫描到注解的三个目录

![bcb1023762d3456e8d81467cb39c8182.png][]

3、下面开始判断并依次扫描每个目录下的文件 ，判断逻辑，this.conditionEvaluator.shouldSkip(sourceClass.getMetadata(), ConfigurationPhase.REGISTER\_BEAN)) 进入

public boolean shouldSkip(@Nullable AnnotatedTypeMetadata metadata, @Nullable ConfigurationPhase phase) {
            //此处业务场景，直接返回 false
    		if (metadata == null || !metadata.isAnnotated(Conditional.class.getName())) {
    			return false;
    		}
    
    		if (phase == null) {
    			if (metadata instanceof AnnotationMetadata &&
    					ConfigurationClassUtils.isConfigurationCandidate((AnnotationMetadata) metadata)) {
    				return shouldSkip(metadata, ConfigurationPhase.PARSE_CONFIGURATION);
    			}
    			return shouldSkip(metadata, ConfigurationPhase.REGISTER_BEAN);
    		}
    
    		List<Condition> conditions = new ArrayList<>();
    		//获取@Conditional注解的value值
    		for (String[] conditionClasses : getConditionClasses(metadata)) {
    			for (String conditionClass : conditionClasses) {
    				//反射实例化Condition对象
    				Condition condition = getCondition(conditionClass, this.context.getClassLoader());
    				conditions.add(condition);
    			}
    		}
    
    		//排序
    		AnnotationAwareOrderComparator.sort(conditions);
    
    		//调用每一个condition的matches方法
    		for (Condition condition : conditions) {
    			ConfigurationPhase requiredPhase = null;
    			if (condition instanceof ConfigurationCondition) {
    				requiredPhase = ((ConfigurationCondition) condition).getConfigurationPhase();
    			}
    			//调用matches方法
    			if ((requiredPhase == null || requiredPhase == phase) && !condition.matches(this.context, metadata)) {
    				return true;
    			}
    		}
    
    		return false;
    	}

返回 封装了13个beanDefinition对象

![e0f367575b984151857de0c29a71f5f7.png][] 然后继续递归循环调用，即继续生成 BeanDefinition 对象。

到此、三种常用的注解分析完毕，大家一定要多多思考，上下分析、前后联系起来，定会进步很快，下篇会分析另外三种注解，敬请期待！

[29de4d6931994259bec14e8a1016dc44.png]: https://img-blog.csdnimg.cn/29de4d6931994259bec14e8a1016dc44.png
[65ec748f1d784ff2ae82328d856c4859.png]: https://img-blog.csdnimg.cn/65ec748f1d784ff2ae82328d856c4859.png
[066c669371f247f4ba5b3db0111a15e8.png]: https://img-blog.csdnimg.cn/066c669371f247f4ba5b3db0111a15e8.png
[1509b37d68dc4858a67e0183db490cc0.png]: https://img-blog.csdnimg.cn/1509b37d68dc4858a67e0183db490cc0.png
[cf76e02fe9f34ea698292cf54328b53c.png]: https://img-blog.csdnimg.cn/cf76e02fe9f34ea698292cf54328b53c.png
[065c9b05015f4b238fd12dd831c2b5ef.png]: https://img-blog.csdnimg.cn/065c9b05015f4b238fd12dd831c2b5ef.png
[d06a644b23364fcdbec2ec67c67716a4.png]: https://img-blog.csdnimg.cn/d06a644b23364fcdbec2ec67c67716a4.png
[c3b8d1728be249529c9bfa458aba8668.png]: https://img-blog.csdnimg.cn/c3b8d1728be249529c9bfa458aba8668.png
[5c584f540ae4466085df1d99292977f9.png]: https://img-blog.csdnimg.cn/5c584f540ae4466085df1d99292977f9.png
[bcb1023762d3456e8d81467cb39c8182.png]: https://img-blog.csdnimg.cn/bcb1023762d3456e8d81467cb39c8182.png
[e0f367575b984151857de0c29a71f5f7.png]: https://img-blog.csdnimg.cn/e0f367575b984151857de0c29a71f5f7.png