Spring component-scan源码分析(一) -- XML解析

在XML中配置component-scan通常如下

	<context:component-scan base-package="xxx">
		<context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
	</context:component-scan>

exclude-filter常见用于在SpringMVC配置中,扫描@Service、@Repository、@Configuration等注解时防止重复扫描@Controller注解的类

Spring的自定义标签解析可参考:
Spring自定义XML标签解析及其原理分析

XML解析

在ContextNamespaceHandler类中可以看到

	registerBeanDefinitionParser("component-scan", new ComponentScanBeanDefinitionParser());

主要看ContextNamespaceHandler类中parse方法如何实现

	public BeanDefinition parse(Element element, ParserContext parserContext) {
		String basePackage = element.getAttribute(BASE_PACKAGE_ATTRIBUTE);
		//处理${xx}的情况
		basePackage = parserContext.getReaderContext().getEnvironment().resolvePlaceholders(basePackage);
		//多个包名可用分隔符“,”、“;”、“回车”
		String[] basePackages = StringUtils.tokenizeToStringArray(basePackage,
				ConfigurableApplicationContext.CONFIG_LOCATION_DELIMITERS);

		//1 创建真正进行扫描工作的对象
		ClassPathBeanDefinitionScanner scanner = configureScanner(parserContext, element);
		//2 开始扫描,得到封装成BeanDefinitionHolder的集合
		Set<BeanDefinitionHolder> beanDefinitions = scanner.doScan(basePackages);
		//3 注册组件,触发bean注册事件
		registerComponents(parserContext.getReaderContext(), beanDefinitions, element);
		return null;
	}

1 创建真正进行扫描工作的对象

	protected ClassPathBeanDefinitionScanner configureScanner(ParserContext parserContext, Element element) {
		boolean useDefaultFilters = true;
		if (element.hasAttribute(USE_DEFAULT_FILTERS_ATTRIBUTE)) {
			//解析“use-default-filters”属性
			useDefaultFilters = Boolean.valueOf(element.getAttribute(USE_DEFAULT_FILTERS_ATTRIBUTE));
		}
		//扫描bean的代理类,也是返回结果。添加了过滤器,扫描带@Component注解的类
		ClassPathBeanDefinitionScanner scanner = createScanner(parserContext.getReaderContext(), useDefaultFilters);
		scanner.setBeanDefinitionDefaults(parserContext.getDelegate().getBeanDefinitionDefaults());
		//设置注入匹配模式
		scanner.setAutowireCandidatePatterns(parserContext.getDelegate().getAutowireCandidatePatterns());
		//解析resource-pattern属性
		if (element.hasAttribute(RESOURCE_PATTERN_ATTRIBUTE)) {
			scanner.setResourcePattern(element.getAttribute(RESOURCE_PATTERN_ATTRIBUTE));
		}
		try {
			//解析name-generator属性(名字生成器)
			parseBeanNameGenerator(element, scanner);
		}
		catch ...
		try {
			//解析scope-resolver、scoped-proxy属性,两个不能同时共存
			parseScope(element, scanner);
		}
		catch...
		//解析include-filter、exclude-filter子标签
		parseTypeFilters(element, scanner, parserContext);
		return scanner;
	}

ClassPathBeanDefinitionScanner在初始化时,会添加一个过滤器,过滤@Component注解,也就是默认扫描带@Component注解的类。

2 开始扫描,得到封装成BeanDefinitionHolder的集合

	protected Set<BeanDefinitionHolder> doScan(String... basePackages) {
		...
		Set<BeanDefinitionHolder> beanDefinitions = new LinkedHashSet<>();
		for (String basePackage : basePackages) {
			//【标记1】寻找合适的候选组件类,封装成BeanDefinition装进集合里
			Set<BeanDefinition> candidates = findCandidateComponents(basePackage);
			for (BeanDefinition candidate : candidates) {
				//处理声明周期
				ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(candidate);
				candidate.setScope(scopeMetadata.getScopeName());
				//生成名字
				String beanName = this.beanNameGenerator.generateBeanName(candidate, this.registry);
				if (candidate instanceof AbstractBeanDefinition) {
					//设置默认属性
					postProcessBeanDefinition((AbstractBeanDefinition) candidate, beanName);
				}
				if (candidate instanceof AnnotatedBeanDefinition) {
					//解析处理@Lazy、@Primary、@DependsOn、@Role、@Description注解
					AnnotationConfigUtils.processCommonDefinitionAnnotations((AnnotatedBeanDefinition) candidate);
				}
				//检查是否有重复,防止重复扫描得到的结果
				if (checkCandidate(beanName, candidate)) {
					BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(candidate, beanName);
					//是否有代理处理
					definitionHolder =
							AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);
					beanDefinitions.add(definitionHolder);
					//加入spring容器缓存中
					registerBeanDefinition(definitionHolder, this.registry);
				}
			}
		}
		return beanDefinitions;
	}

上面逻辑很清晰,扫描包得到封装成BeanDefinition的候选集合,然后开始遍历筛选合适的加入spring的容器中。

【标记1】寻找合适的候选组件类,封装成BeanDefinition装进集合里

	public Set<BeanDefinition> findCandidateComponents(String basePackage) {
		//spring5的新特性,跟踪进去会发现是扫描META-INF目录的spring.components 文件是否存在component
		if (this.componentsIndex != null && indexSupportsIncludeFilters()) {
			return addCandidateComponentsFromIndex(this.componentsIndex, basePackage);
		}
		else {
			//开始扫描包
			return scanCandidateComponents(basePackage);
		}
	}

spring5的新特性还没用过,所以接着分析scanCandidateComponents方法

	private Set<BeanDefinition> scanCandidateComponents(String basePackage) {
		Set<BeanDefinition> candidates = new LinkedHashSet<>();
		try {
			//默认添加“classpath*:”前缀、"**/*.class"后缀
			String packageSearchPath = ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX +
					resolveBasePackage(basePackage) + '/' + this.resourcePattern;
			//拿到所有资源
			Resource[] resources = getResourcePatternResolver().getResources(packageSearchPath);
			...
			for (Resource resource : resources) {
				...
				if (resource.isReadable()) {
					try {
						//元数据读取类
						MetadataReader metadataReader = getMetadataReaderFactory().getMetadataReader(resource);
						//【标记2】判断是否符合候选条件
						if (isCandidateComponent(metadataReader)) {
							//符合就封装成ScannedGenericBeanDefinition对象
							ScannedGenericBeanDefinition sbd = new ScannedGenericBeanDefinition(metadataReader);
							sbd.setResource(resource);
							sbd.setSource(resource);
							//判断是独立的类且(不是接口或有带@Lookup注解的方法的抽象类)
							if (isCandidateComponent(sbd)) {
								...
								candidates.add(sbd);
							}
						}
					}
					catch ...
				}
			}
		}
		catch...
		return candidates;
	}

可以看到最终返回的集合类型BeanDefinition实际是ScannedGenericBeanDefinition

【标记2】判断是否符合候选条件

	protected boolean isCandidateComponent(MetadataReader metadataReader) throws IOException {
		for (TypeFilter tf : this.excludeFilters) {
			if (tf.match(metadataReader, getMetadataReaderFactory())) {
				return false;
			}
		}
		for (TypeFilter tf : this.includeFilters) {
			if (tf.match(metadataReader, getMetadataReaderFactory())) {
				//对@Conditional注解进行解析
				return isConditionMatch(metadataReader);
			}
		}
		return false;
	}

3 注册组件,触发bean注册事件

	protected void registerComponents(
			XmlReaderContext readerContext, Set<BeanDefinitionHolder> beanDefinitions, Element element) {

		Object source = readerContext.extractSource(element);
		CompositeComponentDefinition compositeDef = new CompositeComponentDefinition(element.getTagName(), source);
		for (BeanDefinitionHolder beanDefHolder : beanDefinitions) {
			compositeDef.addNestedComponent(new BeanComponentDefinition(beanDefHolder));
		}
		// Register annotation config processors, if necessary.
		//这里annotationConfig初始化为true
		boolean annotationConfig = true;
		//当没写annotation-config属性时,annotationConfig仍为true
		if (element.hasAttribute(ANNOTATION_CONFIG_ATTRIBUTE)) {
			annotationConfig = Boolean.valueOf(element.getAttribute(ANNOTATION_CONFIG_ATTRIBUTE));
		}
		//所以配置了<context:component-scan .../>后,无需要配置<context:annotation-config/>
		if (annotationConfig) {
			//注册相关注解的解析处理类到spring容器中
			Set<BeanDefinitionHolder> processorDefinitions =
					AnnotationConfigUtils.registerAnnotationConfigProcessors(readerContext.getRegistry(), source);
			for (BeanDefinitionHolder processorDefinition : processorDefinitions) {
				compositeDef.addNestedComponent(new BeanComponentDefinition(processorDefinition));
			}
		}
		//触发注册事件
		readerContext.fireComponentRegistered(compositeDef);
	}

上面有关键的一句代码是:AnnotationConfigUtils.registerAnnotationConfigProcessors,这句代码向spring容器注册了能解析相关注解的处理类。

总结:

1、spring通过component-scan标签的解析,会扫描得到其指定包的路径中带有@Component注解或继承该注解的类;
2、然后将这些类筛选出合适的解析封装成ScannedGenericBeanDefinition放入spring容器中;
3、最后在往spring容器中注册可以解析相关注解的处理类。

    原文作者:Spring MVC
    原文地址: https://blog.csdn.net/seasonLai/article/details/83017728
    本文转自网络文章,转载此文章仅为分享知识,如有侵权,请联系博主进行删除。
点赞