【小家Spring】Spring解析@ComponentScan注解源码分析（ComponentScanAnnotationParser、ClassPathBeanDefinitionScanner）

版权声明： https://blog.csdn.net/f641385712/article/details/88641317

每篇一句

一个做事的人，哪能害怕变化。而是应该希望变化才对，否则哪能轮到我们呢？（功劳不都被PPT工程师了吗？）

相关阅读

【小家Spring】Spring IOC容器启动流程 AbstractApplicationContext#refresh()方法源码分析（一）
【小家Spring】Spring IOC容器启动流程 AbstractApplicationContext#refresh()方法源码分析（二）
【小家Spring】AbstractBeanFactory#getBean()、doGetBean完成Bean的初始化、实例化，以及BeanPostProcessor后置处理器源码级详细分析
【小家Spring】AbstractAutowireCapableBeanFactory#populateBean实现Bean的依赖注入（属性赋值）和initializeBean对Bean的初始化
【小家Spring】Spring解析@Configuration注解的处理器：ConfigurationClassPostProcessor（ConfigurationClassParser）

【小家Spring】细说Spring IOC容器的自动装配（@Autowired），以及Spring4.0新特性之【泛型依赖注入】的源码级解析
【小家Spring】BeanFactory体系和ApplicationContext体系，两大体系各接口分析、区别和联系

前言

前面我在这篇博文：【小家Spring】Spring解析@Configuration注解的处理器：ConfigurationClassPostProcessor（ConfigurationClassParser） 解释Spring解析@Configuration的时候，提到过了解析：@PropertySource、@ComponentScan、@Import…等等的解析过程。

它在这个类里大概如下：ConfigurationClassParser#doProcessConfigurationClass：

protected final SourceClass doProcessConfigurationClass(ConfigurationClass configClass, SourceClass sourceClass){
	//1、Process any @PropertySource annotations
	//2、Process any @ComponentScan annotations ===
	==== 这一步解析，现在就是我们今天的主题，下面会对源码进行分析 ====
	//3、Process any @Import annotations
	//4、Process any @ImportResource annotations
	//5、Process individual @Bean methods
	//6、Process default methods on interfaces
	//7、Process superclass, if any
}

因为扫描模式在应用（我们自己在涉及自己的框架的时候，扫描模式也会被大量的、广泛的应用）使用非常的广泛，因此本文有必要来说说@ComponentScan的原理，旨在掌握它的运行过程，然后学以致用。

Spring Boot默认扫描Bean的处理，就是基于@ComponentScan这个注解的

源码分析

入口处源码

前言部分已经提到了入口处，因此这里直接贴出此部分的源码吧：

		// Process any @ComponentScan annotations
		// 拿到该类上面所有的@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
				// 最终委托给了componentScanParser去完成这件事：至于componentScanParser是什么呢？下面有解释
				// 备注：这个方法虽然有返回值，但是其实内部都已经把Bean定义信息加入到工厂里面去了
				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
				
				//这里面有一个重要的一步，还需要把每个Bean检测一遍。因为Scan出来的Bean，还有可能是@Configuration的，或者标注有@Import等等一些列注解的，因此需要再次交给parse一遍，防止疏漏
				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());
					}
				}
			}
		}

`componentScanParser`是什么呢？
	private final ComponentScanAnnotationParser componentScanParser;
	// 然后在ConfigurationClassParser的构造函数里，对他进行了初始化
	public ConfigurationClassParser(MetadataReaderFactory metadataReaderFactory,
			ProblemReporter problemReporter, Environment environment, ResourceLoader resourceLoader,
			BeanNameGenerator componentScanBeanNameGenerator, BeanDefinitionRegistry registry) {

		this.metadataReaderFactory = metadataReaderFactory;
		this.problemReporter = problemReporter;
		this.environment = environment;
		this.resourceLoader = resourceLoader;
		this.registry = registry;

		// 这里对componentScanParser 进行初始化。持有环境、ResourceLoader、名字生成器、注册器的引用
		this.componentScanParser = new ComponentScanAnnotationParser(environment, resourceLoader, componentScanBeanNameGenerator, registry);
		// 初始化condition的计算器，持有注册器、环境、ResourceLoader的引用
		this.conditionEvaluator = new ConditionEvaluator(registry, environment, resourceLoader);
	}

ComponentScanAnnotationParser：准们解析@ComponentScan的类

从访问权限（Default）来看，它被定义为Spring的一个自己内部使用的工具类。它的惟一一个public方法为：parse()：

	public Set<BeanDefinitionHolder> parse(AnnotationAttributes componentScan, final String declaringClass) {
		
		// 第一句代码就看出了端倪：原来扫描的工作最终还是委托给了ClassPathBeanDefinitionScanner去做
		// 注意：useDefaultFilters这个值特别的重要，能够解释伙伴们为何要配置的原因~~~下面讲解它的时候会有详解
		ClassPathBeanDefinitionScanner scanner = new ClassPathBeanDefinitionScanner(this.registry, componentScan.getBoolean("useDefaultFilters"), this.environment, this.resourceLoader);
		
		// BeanName的生成器，我们可以单独制定。若不指定（大部分情况下都不指定），那就是默认的AnnotationBeanNameGenerator
		// 它的处理方式是：类名首字母小写
		Class<? extends BeanNameGenerator> generatorClass = componentScan.getClass("nameGenerator");
		boolean useInheritedGenerator = (BeanNameGenerator.class == generatorClass);
		scanner.setBeanNameGenerator(useInheritedGenerator ? this.beanNameGenerator :
				BeanUtils.instantiateClass(generatorClass));
		
		// 这两个属性和scope代理相关的，这里略过，使用较少
		ScopedProxyMode scopedProxyMode = componentScan.getEnum("scopedProxy");
		if (scopedProxyMode != ScopedProxyMode.DEFAULT) {
			scanner.setScopedProxyMode(scopedProxyMode);
		} else {
			Class<? extends ScopeMetadataResolver> resolverClass = componentScan.getClass("scopeResolver");
			scanner.setScopeMetadataResolver(BeanUtils.instantiateClass(resolverClass));
		}
		
		// 控制去扫描哪些.clsss文件的模版。一般不设置   默认值为：**/*.class  全扫嘛
		scanner.setResourcePattern(componentScan.getString("resourcePattern"));
		
		// includeFilters和excludeFilters算是内部处理最复杂的逻辑了，但还好，对使用者是十分友好的
		for (AnnotationAttributes filter : componentScan.getAnnotationArray("includeFilters")) {
			for (TypeFilter typeFilter : typeFiltersFor(filter)) {
				scanner.addIncludeFilter(typeFilter);
			}
		}
		for (AnnotationAttributes filter : componentScan.getAnnotationArray("excludeFilters")) {
			for (TypeFilter typeFilter : typeFiltersFor(filter)) {
				scanner.addExcludeFilter(typeFilter);
			}
		}

		// Spring4.1后出现的。哪怕我是扫描的Bean，也支持懒加载啦
		boolean lazyInit = componentScan.getBoolean("lazyInit");
		if (lazyInit) {
			scanner.getBeanDefinitionDefaults().setLazyInit(true);
		}
		
		// 这里属于核心逻辑，核心逻辑，核心逻辑
		Set<String> basePackages = new LinkedHashSet<>();	
		String[] basePackagesArray = componentScan.getStringArray("basePackages");
		
		// Spring在此处有强大的容错处理。瑞然他是支持数组的，但是它这里也容错处理：支持,;换行等的符号分隔处理
		// 并且，并且更强大的地方在于：它支持${...}这种占位符的形式，非常的强大。我们可以动态的进行扫包了~~~~~厉害了我的哥
		for (String pkg : basePackagesArray) {
			String[] tokenized = StringUtils.tokenizeToStringArray(this.environment.resolvePlaceholders(pkg),
					ConfigurableApplicationContext.CONFIG_LOCATION_DELIMITERS);
			Collections.addAll(basePackages, tokenized);
		}

		//basePackageClasses有时候也挺好使的。它可以指定class，然后这个class所在的包（含子包）都会被扫描
		for (Class<?> clazz : componentScan.getClassArray("basePackageClasses")) {
			basePackages.add(ClassUtils.getPackageName(clazz));
		}

		// 如果我们没有指定此值，它会取当前配置类所在的包  比如SpringBoot就是这么来干的
		if (basePackages.isEmpty()) {
			basePackages.add(ClassUtils.getPackageName(declaringClass));
		}

		scanner.addExcludeFilter(new AbstractTypeHierarchyTraversingFilter(false, false) {
			@Override
			protected boolean matchClassName(String className) {
				return declaringClass.equals(className);
			}
		});
		
		// 最后，最后，把@ComponentScan的属性都解析好了，就交给scanner去扫描吧  
		// 因为都准备好了，所以这里直接调用的doScan()哦~
		return scanner.doScan(StringUtils.toStringArray(basePackages));
	}

ClassPathBeanDefinitionScanner 类路径下的Bean定义扫描器

参考博文：【小家Spring】Spring容器加载Bean定义信息的两员大将：AnnotatedBeanDefinitionReader和ClassPathBeanDefinitionScanner

其实这个类我们早就接触过了，前面讲到AnnotationConfigApplicationContext容器初始化的时候，就讲到了它，它可以去扫描特定类型的组件。它有它自己的默认扫描策略。它继承自ClassPathScanningCandidateComponentProvider：

下面我们先从它的构造函数说起：

	public ClassPathBeanDefinitionScanner(BeanDefinitionRegistry registry, boolean useDefaultFilters,
			Environment environment, @Nullable ResourceLoader resourceLoader) {

		Assert.notNull(registry, "BeanDefinitionRegistry must not be null");
		this.registry = registry;
		
		// 我们发现这个useDefaultFilters特别重要，默认情况下他是true，只会扫描默认的注解们
		// 至于是哪些注解，看下面
		if (useDefaultFilters) {
			registerDefaultFilters();
		}
		setEnvironment(environment);
		setResourceLoader(resourceLoader);
	}

//registerDefaultFilters();
	protected void registerDefaultFilters() {
		// @Component显然默认是必须要扫描的嘛
		this.includeFilters.add(new AnnotationTypeFilter(Component.class));
		ClassLoader cl = ClassPathScanningCandidateComponentProvider.class.getClassLoader();
		
		// 下面两个是，默认也支持JSR-250规范的`@ManagedBean`和JSR-330规范的@Named注解(但是我并不建议大家使用，还是使用Spring源生的吧)
		try {
			this.includeFilters.add(new AnnotationTypeFilter(
					((Class<? extends Annotation>) ClassUtils.forName("javax.annotation.ManagedBean", cl)), false));
			logger.debug("JSR-250 'javax.annotation.ManagedBean' found and supported for component scanning");
		}
		catch (ClassNotFoundException ex) {
			// JSR-250 1.1 API (as included in Java EE 6) not available - simply skip.
		}
		try {
			this.includeFilters.add(new AnnotationTypeFilter(
					((Class<? extends Annotation>) ClassUtils.forName("javax.inject.Named", cl)), false));
			logger.debug("JSR-330 'javax.inject.Named' annotation found and supported for component scanning");
		}
		catch (ClassNotFoundException ex) {
			// JSR-330 API not available - simply skip.
		}
	}

需要说明的是：@Controller、@ControllerAdvice、@Service、@Repository都属于@Component范畴。当然还有@Configuration它也是

doScan()如下：

	protected Set<BeanDefinitionHolder> doScan(String... basePackages) {
		Assert.notEmpty(basePackages, "At least one base package must be specified");
		Set<BeanDefinitionHolder> beanDefinitions = new LinkedHashSet<>();

		for (String basePackage : basePackages) {
			// 这里面findCandidateComponents是核心。这边就不再详解了，因为上面贴出的那篇博文已经有详解了
			// 总之就是找到候选的Bean定义们
			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);
			
				// 给刚扫描出来的Bean定义设置一些默认值
				if (candidate instanceof AbstractBeanDefinition) {
					postProcessBeanDefinition((AbstractBeanDefinition) candidate, beanName);
				}
					
				//解析@Primary、@Lazy...等等基础注解
				if (candidate instanceof AnnotatedBeanDefinition) {
					AnnotationConfigUtils.processCommonDefinitionAnnotations((AnnotatedBeanDefinition) candidate);
				}
				
				// 检查一些Bean定义，若之前已经存在了，看看采用什么策略吧（覆盖or不管？）
				// 原则：在同意文件内，覆盖吧  在不同文件内  不管吧~~~~
				if (checkCandidate(beanName, candidate)) {
					BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(candidate, beanName);
					definitionHolder = AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);
					beanDefinitions.add(definitionHolder);
		
					// 内部就已经把该Bean定义注册进去了，所以外部可以不用再重复注册了
					registerBeanDefinition(definitionHolder, this.registry);
				}
			}
		}
		return beanDefinitions;
	}

至此，整个@ComponentScan扫描完成，并且符合条件的组件也都注册进去了

总结

Scan扫描的思想，是一种批量处理的思想。它在设计模式中是具有非常好的通用性的。
本文以Spring内部的处理做源码分析为例，我们可以在自己设计框架的时候，也借鉴此些思想，达到更灵活配置，更通用，更能扩展的效果。

知识交流

若群二维码失效，请加微信号（或者扫描下方二维码）：fsx641385712。
并且备注：“java入群” 字样，会手动邀请入群