Spring组件注册注解之@ComponentScan，@ComponentScans

已于 2023-04-21 11:38:08 修改
阅读量4.9w 收藏 83
点赞数 23
分类专栏： Spring注解 Spring注解解析 文章标签： spring 注解 annotation ComponentScan
于 2019-01-05 21:35:26 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/luojinbai/article/details/85877956
版权

目录

1. 说明

2. @ComponentScan注解属性

3. @ComponentScan过滤规则说明

4. 自定义扫描过滤规则

5. @ComponentScan原理分析

6. @ComponentScans

1. 说明

与ComponentScan注解相对应的XML配置就是<context:component-scan/>， 根据指定的配置自动扫描package，将符合条件的组件加入到IOC容器中；

XML的配置方式如下：

	<context:component-scan
		base-package="com.yibai.spring.annotation" use-default-filters="false">
		<context:include-filter type="custom"
			expression="com.yibai.spring.annotation.filter.ColorBeanLoadFilter" />
		<context:exclude-filter type="annotation"
			expression="org.springframework.stereotype.Component" />
	</context:component-scan>

2. @ComponentScan注解属性

@ComponentScan有如下属性：

value：指定要扫描的package；
includeFilters=Filter[]：指定只包含的组件
excludeFilters=Filter[]：指定需要排除的组件；
useDefaultFilters=true/false：指定是否需要使用Spring默认的扫描规则：被@Component, @Repository, @Service, @Controller或者已经声明过@Component自定义注解标记的组件；

在过滤规则Filter中：
FilterType：指定过滤规则，支持的过滤规则有
    ANNOTATION：按照注解规则，过滤被指定注解标记的类；
    ASSIGNABLE_TYPE：按照给定的类型；
    ASPECTJ：按照ASPECTJ表达式；
    REGEX：按照正则表达式
    CUSTOM：自定义规则；
value：指定在该规则下过滤的表达式；

3. @ComponentScan过滤规则说明

规则表达式说明

1. 扫描指定类文件
   @ComponentScan(basePackageClasses = Person.class)
2. 扫描指定包，使用默认扫描规则，即被@Component, @Repository, @Service, @Controller或者已经声明过@Component自定义注解标记的组件；
   @ComponentScan(value = "com.yibai")
3. 扫描指定包，加载被@Component注解标记的组件和默认规则的扫描（因为useDefaultFilters默认为true）
   @ComponentScan(value = "com.yibai", includeFilters = { @Filter(type = FilterType.ANNOTATION, value = Component.class) })
4. 扫描指定包，只加载Person类型的组件
   @ComponentScan(value = "com.yibai", includeFilters = { @Filter(type = FilterType.ASSIGNABLE_TYPE, value = Person.class) }, useDefaultFilters = false)
5. 扫描指定包，过滤掉被@Component标记的组件
   @ComponentScan(value = "com.yibai", excludeFilters = { @Filter(type = FilterType.ANNOTATION, value = Component.class) })
6. 扫描指定包，自定义过滤规则
   @ComponentScan(value = "com.yibai", includeFilters = { @Filter(type = FilterType.CUSTOM, value = ColorBeanLoadFilter.class) }, useDefaultFilters = true)

4. 自定义扫描过滤规则

自定义规则实现类ColorBeanLoadFilter 

/**
 * Project Name:yibai-spring-annotation
 * File Name:ColorBeanLoadFIlter.java
 * Package Name:com.yibai.spring.annotation.filter
 * Date:2019年1月5日下午12:15:54
 * Copyright (c) 2019, www.windo-soft.com All Rights Reserved.
 *
*/

package com.yibai.spring.annotation.filter;

import java.io.IOException;

import org.springframework.core.io.Resource;
import org.springframework.core.type.AnnotationMetadata;
import org.springframework.core.type.ClassMetadata;
import org.springframework.core.type.classreading.MetadataReader;
import org.springframework.core.type.classreading.MetadataReaderFactory;
import org.springframework.core.type.filter.TypeFilter;

import com.yibai.spring.annotation.bean.color.Color;

public class ColorBeanLoadFilter implements TypeFilter {

	@Override
	public boolean match(MetadataReader metadataReader, MetadataReaderFactory metadataReaderFactory)
			throws IOException {
		// 当前被扫描类的注解信息
		@SuppressWarnings("unused")
		AnnotationMetadata annotationMetadata = metadataReader.getAnnotationMetadata();
		// 当前被扫描类信息
		ClassMetadata classMetadata = metadataReader.getClassMetadata();
		// 当前被扫描类资源信息
		@SuppressWarnings("unused")
		Resource resource = metadataReader.getResource();
		try {
			String className = classMetadata.getClassName();
			Class<?> forName = Class.forName(className);
			if (Color.class.isAssignableFrom(forName)) {
				// 如果是Color的子类，就加载到IOC容器
				return true;
			}
		} catch (ClassNotFoundException e) {
//			e.printStackTrace();
		}
		return false;
	}

}

5. @ComponentScan原理分析

@ComponentScan的解析器是org.springframework.context.annotation.ComponentScanAnnotationParser；

useDefaultFilters = true指定的规则过滤器是 org.springframework.core.type.filter.AnnotationTypeFilter；’

public Set<BeanDefinitionHolder> parse(AnnotationAttributes componentScan, final String declaringClass) {

        /** componentScan为@ComponentScan的注解信息：
            {value=[com.yibai.spring.annotation], basePackages=[com.yibai.spring.annotation], lazyInit=false, scopeResolver=class org.springframework.context.annotation.AnnotationScopeMetadataResolver, scopedProxy=DEFAULT, nameGenerator=interface org.springframework.beans.factory.support.BeanNameGenerator, useDefaultFilters=true, basePackageClasses=[], includeFilters=[], resourcePattern=**/*.class, excludeFilters=[]}
*/

		Assert.state(this.environment != null, "Environment must not be null");
		Assert.state(this.resourceLoader != null, "ResourceLoader must not be null");

		ClassPathBeanDefinitionScanner scanner = new ClassPathBeanDefinitionScanner(this.registry,
				componentScan.getBoolean("useDefaultFilters"), this.environment, this.resourceLoader);

		//....
        //..
        //.
        //中间代码省略了，大概做的事情就是创建包扫描器，然后被@CompontentScan注解设置的属性都设置搭配扫描器中，然后准备扫描
        
        // 经过一些列的scanner的属性设置，进入扫描流程
		return scanner.doScan(StringUtils.toStringArray(basePackages));
	}

然后进入org.springframework.context.annotation.ClassPathBeanDefinitionScanner.doScan(String...) 进行扫描，并生成组件定义信息；

protected Set<BeanDefinitionHolder> doScan(String... basePackages) {
	Assert.notEmpty(basePackages, "At least one base package must be specified");
	Set<BeanDefinitionHolder> beanDefinitions = new LinkedHashSet<BeanDefinitionHolder>();
	for (String basePackage : basePackages) {
           
        // 根据扫描规则扫描出符合条件的组件
		Set<BeanDefinition> candidates = findCandidateComponents(basePackage);

        //下面就是将扫描出的组件实加载到IOC容器中；
		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) {
				AnnotationConfigUtils.processCommonDefinitionAnnotations((AnnotatedBeanDefinition) candidate);
			}
			if (checkCandidate(beanName, candidate)) {
				BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(candidate, beanName);
				definitionHolder =
						AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);
				beanDefinitions.add(definitionHolder);
				registerBeanDefinition(definitionHolder, this.registry);
			}
		}
	}
	return beanDefinitions;
}

通过org.springframework.context.annotation.ClassPathScanningCandidateComponentProvider.findCandidateComponents(String)找出符合条件的组件

public Set<BeanDefinition> findCandidateComponents(String basePackage) {
       Set<BeanDefinition> candidates = new LinkedHashSet<BeanDefinition>();
	try {
        //classpath*:com/yibai/spring/annotation/**/*.class
		String packageSearchPath = ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX +
				resolveBasePackage(basePackage) + '/' + this.resourcePattern;
        //resources 就是指定包下的所有类
		Resource[] resources = this.resourcePatternResolver.getResources(packageSearchPath);
		boolean traceEnabled = logger.isTraceEnabled();
		boolean debugEnabled = logger.isDebugEnabled();
        //遍历所有类，判断是否符合规则
		for (Resource resource : resources) {
			if (traceEnabled) {
				logger.trace("Scanning " + resource);
			}
			if (resource.isReadable()) {
				try {
					MetadataReader metadataReader = this.metadataReaderFactory.getMetadataReader(resource);
                    //注意这里，根据过滤规则进行判断
					if (isCandidateComponent(metadataReader)) {
                        //如果符合条件，这将组件让如待返回的集合中去；
						ScannedGenericBeanDefinition sbd = new ScannedGenericBeanDefinition(metadataReader);
						sbd.setResource(resource);
						sbd.setSource(resource);
						if (isCandidateComponent(sbd)) {
							if (debugEnabled) {
								logger.debug("Identified candidate component class: " + resource);
							}
							candidates.add(sbd);
						}
						else {
							if (debugEnabled) {
								logger.debug("Ignored because not a concrete top-level class: " + resource);
							}
						}
					}
					else {
						if (traceEnabled) {
							logger.trace("Ignored because not matching any filter: " + resource);
						}
					}
				}
				catch (Throwable ex) {
					throw new BeanDefinitionStoreException(
							"Failed to read candidate component class: " + resource, ex);
				}
			}
			else {
				if (traceEnabled) {
					logger.trace("Ignored because not readable: " + resource);
				}
			}
		}
	}
	catch (IOException ex) {
		throw new BeanDefinitionStoreException("I/O failure during classpath scanning", ex);
	}
	return candidates;
}

通过org.springframework.context.annotation.ClassPathScanningCandidateComponentProvider.isCandidateComponent(MetadataReader)方法，根据过滤器规则判断类是否满足条件

protected boolean isCandidateComponent(MetadataReader metadataReader) throws IOException {
    //是否满足排除的条件
	for (TypeFilter tf : this.excludeFilters) {
		if (tf.match(metadataReader, this.metadataReaderFactory)) {
			return false;
		}
	}
    // 是否满足包含的条件
	for (TypeFilter tf : this.includeFilters) {
        //判断是否过滤器满足
		if (tf.match(metadataReader, this.metadataReaderFactory)) {
            // 判断是否条件满足
			return isConditionMatch(metadataReader);
		}
	}
	return false;
}

当断点到自定义过滤类里面的时候，调用栈如下

6. @ComponentScans

可以一次声明多个@ComponentScan

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
@Documented
@Repeatable(ComponentScans.class)  //指定ComponentScan可以被ComponentScans作为数组使用
public @interface ComponentScan {
}


@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
@Documented
public @interface ComponentScans {
    
	ComponentScan[] value();

}
@ComponentScans(value = { @ComponentScan(value = "com.yibai.spring.annotation"),
		@ComponentScan(value = "com.yibai.spring.annotation", includeFilters = {
				@Filter(type = FilterType.CUSTOM, value = ColorBeanLoadFilter.class) }) })
public class MainConfig {

	@Bean(name = "pers", initMethod = "init", destroyMethod = "destory")
	public Person person() {
		return new Person();
	}

}

一白.
关注
专栏目录
SpringBoot主启动类使用@ComponentScans、@ComponentScan扫描组件类，注意避坑
hkl_Forever的博客
11-30 4526
【1】因为 @SpringBootApplication 中已经包含 @ComponentScan 注解、并且用以扫描主启动类同级目录下的组件配置类，所以我们。1、@SpringBootApplication 是联合注解，包含了 @ComponentScan 会默认扫描主启动类同级包目录下所有的组件类、配置类。2、如果我们需要扫描主启动类同级以外的包目录怎么？【4】在主启动单独使用 @ComponentScans 的时候，不需要指明主启动类同级包目录，不会影响默认扫描主启动类同级包目录。
@ComponentScan
最新发布
weixin_63490470的博客
08-13 370
是一个注解，用于Spring框架，它允许开发者指定Spring应该扫描哪个包或包下的子包来寻找组件（如@Component@Service等注解标注的类）。通过使用，开发者可以自动化地注册这些组件，使得它们能够被Spring容器管理。
（新手勿进，全是代码）@ComponentScan、@ComponentScans详解
2401_83384536的博客
03-15 2191
xml中bean元素的方式@Bean注解标注方法的方式通常情况下，项目中大部分类都需要交给spring去管理，按照上面这2种方式，代码量还是挺大的。为了更方便bean的注册，Spring提供了批量的方式注册bean，方便大量bean批量注册，spring中的@ComponentScan就是干这个事情的。@Component@Component//@3重点在于@1和@2这2个地方的代码，通过上面的参数可以间接给@Component注解中的value设置值。
（二）Spring组件注册-@ComponentScan和@ComponentScans
欧阳惜竹的博客
08-02 769
文章目录链接视频github老的方式注解@ComponentScan测试用例配置类启动类结果结果解析ComponentScan注解ComponentScan的excludeFilters配置类启动类结果结果解析ComponentScan的includeFilters配置类结果结果解析真正的配置正常xml配置配置类配置结果ComponentScans配置类运行结果 链接 视频 https://www.bilibili.com/medialist/play/ml1022680573/p3 github http
@ComponentScan注解
学而不思则忘
02-20 6145
1. 作用 定义扫描的路径，从中找出标识了需要装配的类，自动将这些类装配到Spring的容器中。 2. @ComponentScan注解详细作用 下面这些注解： @Component @Repository @Service @Controller @Configuration 查看它们的源码可以知道：都有一个共同的注解**@Component**，而**@ComponentScan**就会默认装配标识了上述注解的类到容器中。 3. 源码解释 @Retention(RetentionPolicy.RUN
面试官说：Spring这几个问题你回答下，月薪3万，下周来上班！
路人甲Java
03-16 9021
灵魂拷问@ComponentScan注解是做什么的？basePackages的方式和basePackageClasses的方式有什么区别？你建议用哪个？...
componentscan注解的用法和作用_救救孩子吧，现在没搞懂@ComponentScan注解的使用
weixin_39807067的博客
11-27 1430
一、注解定义@ComponentScan注解的定义如下：@Retention(RetentionPolicy.RUNTIME)@Target(ElementType.TYPE)@Documented@Repeatable(ComponentScans.class)public @interface ComponentScan { /** * 扫描路径 * @ComponentSca...
@ComponentScan 注解
2301_76607156的博客
03-29 4047
/ basePackages 的别名// 在没有其他属性的情况下可以如此写：@ComponentScan("com.cxyxj.componentscan")// 而不需要：@ComponentScan(basePackages = "com.cxyxj.componentscan")// 扫描带注解的包路径，默认是@Component// 扫描指定带注解的类，同时会扫描该类所在的包，默认是@Component。
Spring进阶（十三）之你真的懂@ComponentScan注解吗
weixin_56644618的博客
10-06 1006
@ComponentScan注解详解
@ComponentScan注解 -【Spring底层原理
2401_84048034的博客
04-08 1060
看完美团、字节、腾讯这三家的一二三面试问题，是不是感觉问的特别多，可能咱们真的又得开启面试造火箭、工作拧螺丝的模式去准备下一次的面试了。开篇有提及我可是足足背下了Java互联网工程师面试1000题，多少还是有点用的呢，换汤不换药，不管面试官怎么问你，抓住本质即可！能读到此处的都是真爱Java互联网工程师面试1000题。
【Spring注解驱动开发】使用@ComponentScan自动扫描组件并指定扫描规则(1)
2401_83915664的博客
04-18 284
按照上面的过程，4个月的时间刚刚好。当然Java的体系是很庞大的，还有很多更高级的技能需要掌握，但不要着急，这些完全可以放到以后工作中边用别学。学习编程就是一个由混沌到有序的过程，所以你在学习过程中，如果一时碰到理解不了的知识点，大可不必沮丧，更不要气馁，这都是正常的不能再正常的事情了，不过是“人同此心，心同此理”的暂时而已。道路是曲折的，前途是光明的！《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取！发知识点，真正体系化！**
（1）spring注解学习之@ComponentScans
u013019255的博客
07-08 329
@ComponentScans注解 1.只有一个属性 value 2.value值是一个ComponentScan的数组 3.点进去看到@ComponentScan，@Repeatable 注解表明是可以重复声明的 4.在@ComponentScan里面需要声明 （1）value值，表示的是基本包（basePackages）； （2）useDefaultFilters，表示默认过滤：只要有 @Component，@Repository, { @Service}, or { @Controller}注解
@ComponentScan注解使用
热门推荐
weixin_43808717的博客
06-24 1万+
1、基本简介 @ComponentScan注解是一个Spring的注解，用于扫描包上的注解将组件加载到IOC容器中。 它的出现主要是对标component-scan标签，标签只能使用在xml的配置文件中，而现在越来越流行使用注解的形式注册bean @ComponentScan还有个父亲是@ComponentScans；用于存放多个@ComponentScan注解。 @ComponentScan注解只能使用在有@Configuration配置注解的地方，因为component-scan标签必须
Spring学习-@ComponentScan注解
liguangbenren的博客
06-28 461
Spring的配置主要有两种方式，一种是基于xml配置文件，另一种是基于JavaConfig注解配置，由于基于注解的配置能够保证类型安全，使用起来更加方便，得到了越来越多用户的青睐。@ComponentScan是一个使用非常频繁的注解，该类的作用使得Spring定义Bean非常灵活方便，通过将当前类所在目录的子路径全部扫描，获取包含@Component注解的类，从而生成Bean。本文主要探讨@Co...
@ComponentScans注解的总结
Chen_BS的博客
04-15 897
今天主要从以下几个方面来介绍一下@ComponentScan注解： @ComponentScan注解是什么 @ComponentScan注解的详细使用 1，@ComponentScan注解是什么 其实很简单，@ComponentScan主要就是定义扫描的路径从中找出标识了需要装配的类自动装配到spring的bean容器中 2，@ComponentSc...
@Component and @ComponentScan
Trival_dreamy的博客
11-15 253
    @ComponentScan 如果你理解了ComponentScan，你就理解了Spring. Spring是一个依赖注入(dependency injection)框架。所有的内容都是关于bean的定义及其依赖关系。 定义Spring Beans的第一步是使用正确的注解-@Component或@Service或@Repository. 但是，Spring不知道你定义了某个be...
componentScan
07-11
`componentScan`是Spring框架中的一个配置注解，用于自动扫描指定包下的Java组件，如@Controller、@Service、@Repository等。当你在Spring Boot应用中启用`componentScan`时，它会使得容器能够自动发现并注册那些带有特定注解的类作为bean，而无需手动在配置文件中逐一列举。 例如，在Spring Boot启动类上添加`@ComponentScan("com.example.package")`，Spring会扫描"com.example.package"及其所有子包，寻找并管理带有@Component、@Service、@Repository等注解的类。这大大简化了依赖注入的配置，并有助于降低配置复杂度。
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值