在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容器中注册可以解析相关注解的处理类。
