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容器中註冊可以解析相關注解的處理類。