深度讲解Spring Bean扫描类：源码深度剖析与实战策略_spring是怎么扫描这些bean的-CSDN博客

本文链接：https://blog.csdn.net/m0_51176516/article/details/139120438

1. 引言

在Spring框架中，Bean的扫描是一个至关重要的过程，它决定了哪些类会被Spring容器管理并作为Bean实例化。对于高级Java工程师而言，深入理解这一过程不仅有助于提升对Spring框架的掌握程度，还能在实际开发中更加灵活地运用Spring的各项特性。本文将对Spring Bean的扫描类进行深度讲解，并结合源码分析，带您领略其幕后的魔法。

2. Spring Bean扫描的基本概念

Spring Bean扫描是Spring框架在启动时自动扫描指定包路径下的类，并根据类上的注解（如@Component、@Service、@Repository、@Controller等）将其实例化为Spring Bean的过程。这一过程由Spring的ClassPathBeanDefinitionScanner类负责实现。

3. 初始化扫描器

ClassPathBeanDefinitionScanner的初始化过程中，会设置一些关键属性，包括resourceLoader（资源加载器）、environment（环境）、registry（注册中心）和includeFilters/excludeFilters（包含/排除过滤器）。

public ClassPathBeanDefinitionScanner(BeanDefinitionRegistry registry, boolean useDefaultFilters,  
        Environment environment, @Nullable ResourceLoader resourceLoader) {  
    // ...  
    this.registry = registry;  
    if (useDefaultFilters) {  
        // 默认会添加@Component, @Repository, @Service, @Controller等注解的过滤器  
        registerDefaultFilters();  
    }  
    // ...  
    this.resourceLoader = resourceLoader;  
    this.environment = environment;  
}

4. 扫描包路径

scan方法是扫描过程的入口，它首先会确定要扫描的包路径，然后调用doScan方法执行实际的扫描。doScan方法是执行扫描的核心方法。它接收一个或多个基础包路径作为参数，并找到这些包下所有的类。

public int scan(String... basePackages) {  
    int beanCountAtScanStart = this.registry.getBeanDefinitionCount();  
    doScan(basePackages);  
    // Post-process after scanning to resolve any placeholder values in bean definitions.  
    if (this.includeAnnotationConfig) {  
        AnnotationConfigUtils.registerAnnotationConfigProcessors(this.registry, this.environment);  
    }  
    return (this.registry.getBeanDefinitionCount() - beanCountAtScanStart);  
}  
  
protected Set<BeanDefinitionHolder> doScan(String... basePackages) {  
    // ... 省略了部分代码 ...  
  
    Set<BeanDefinitionHolder> beanDefinitions = new LinkedHashSet<>();  
    for (String basePackage : basePackages) {  
        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 (!isCandidateComponent(candidate, beanName, candidates)) {  
                continue;  
            }  
  
            // 检查Bean是否已经存在  
            if (!checkCandidate(beanName, candidate)) {  
                continue;  
            }  
  
            BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(candidate, beanName);  
            definitionHolder =  
                    AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);  
            beanDefinitions.add(definitionHolder);  
  
            // 注册BeanDefinition  
            registerBeanDefinition(definitionHolder, this.registry);  
        }  
    }  
  
    return beanDefinitions;  
}

在上面的代码中，findCandidateComponents方法负责查找指定包下的所有类，并应用TypeFilter进行过滤。然后，对于每个候选组件，它会生成Bean的名称，并检查是否已经存在同名的Bean。如果不存在，则将其注册到BeanDefinitionRegistry中。

5. 加载类并检查注解

findCandidateComponents方法是扫描包路径并找到带有指定注解的类的关键方法。它使用了ClassPathScanningCandidateComponentProvider的findCandidateComponents方法，该方法会遍历包路径下的所有类，并使用isCandidateComponent方法检查每个类是否满足条件。

protected Set<BeanDefinition> findCandidateComponents(String basePackage) {  
    // ...  
    Set<BeanDefinition> candidates = new LinkedHashSet<>();  
    try {  
        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);  
                    if (isCandidateComponent(metadataReader)) {  
                        ScannedGenericBeanDefinition sbd = new ScannedGenericBeanDefinition(metadataReader);  
                        sbd.setSource(resource);  
                        if (isCandidateComponent(sbd)) {  
                            candidates.add(sbd);  
                        }  
                    }  
                } catch (Throwable ex) {  
                    // ...  
                }  
            }  
        }  
    } catch (IOException ex) {  
        // ...  
    }  
    return candidates;  
}  
  
protected boolean isCandidateComponent(MetadataReader metadataReader) throws IOException {  
    // 检查类上是否有指定的注解  
    for (TypeFilter tf : this.includeFilters) {  
        if (tf.match(metadataReader, getMetadataReaderFactory())) {  
            return true;  
        }  
    }  
    // ...  
    return false;  
}

6. 创建并注册Bean定义

一旦找到了满足条件的类，ClassPathBeanDefinitionScanner会为其创建一个BeanDefinition对象，并将其注册到BeanDefinitionRegistry中。这通常是通过调用registry.registerBeanDefinition方法完成的。

protected void registerBeanDefinition(BeanDefinitionHolder definitionHolder, BeanDefinitionRegistry registry) {  
    String beanName = definitionHolder.getBeanName();  
    registry.registerBeanDefinition(beanName, definitionHolder.getBeanDefinition());  
}

7. 扫描过程中的过滤器

在Spring Bean扫描过程中，TypeFilter起着关键作用。它允许我们定义哪些类应该被包括在扫描结果中，哪些类应该被排除。Spring提供了几种默认的TypeFilter实现，比如AnnotationTypeFilter，它可以基于类上的特定注解来过滤类。

在ClassPathBeanDefinitionScanner的初始化过程中，如果设置了useDefaultFilters为true，则会注册几个默认的TypeFilter，这些过滤器会包含带有@Component、@Repository、@Service、@Controller等注解的类。

8. 扫描路径的解析

在scan方法中，传入的basePackages参数指定了要扫描的包路径。ClassPathBeanDefinitionScanner会使用PathMatchingResourcePatternResolver来解析这些路径，并找到对应的资源（即类文件）。这个过程中，会使用ResourcePattern（默认为**/*.class）来匹配类文件。

9. 处理扫描结果

在doScan方法中，扫描得到的候选组件会被封装成BeanDefinitionHolder对象，并存储在Set<BeanDefinitionHolder>集合中。这些BeanDefinitionHolder对象包含了Bean的定义信息以及Bean的名称。

然后，ClassPathBeanDefinitionScanner会遍历这个集合，并为每个BeanDefinitionHolder对象调用registerBeanDefinition方法，将其注册到BeanDefinitionRegistry中。这样，这些Bean就被成功地纳入了Spring容器的管理范围。