1. 程式人生 > >Spring component-scan原始碼分析(一)

Spring component-scan原始碼分析(一)

在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註解的類

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