spring源码------`@ComponentScans`,

1.@ComponentScans,@ComponentScan作用

 @ComponentScan这个注解作用大家应该都熟悉，这里的作用大家应该都知道。用来指定spring注册bean的时候需要扫描的包或者类，还可以指定我们定义的bean名称生成器，代理类型，扫描过滤器等与xml配置形式的<context:component-scan>标签作用一样。看看其中的元素就知道。

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
@Documented
@Repeatable(ComponentScans.class)
public @interface ComponentScan {
    @AliasFor("basePackages")
    String[] value() default {};

    @AliasFor("value")
    String[] basePackages() default {};

    Class<?>[] basePackageClasses() default {};
    
    Class<? extends BeanNameGenerator> nameGenerator() default BeanNameGenerator.class;

    Class<? extends ScopeMetadataResolver> scopeResolver() default AnnotationScopeMetadataResolver.class;
    ......
}

 @ComponentScans注解用的比较少，作用跟@ComponentScan一样，只不过@ComponentScans可以包含多个@ComponentScan注解。

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
@Documented
public @interface ComponentScans {

    ComponentScan[] value();

}

2.@ComponentScans,@ComponentScan的解析

 这两个注解的解析过程跟@Import注解的解析前的步骤是一样的。最后的解析入口也一样在ConfigurationClassParser类中，对于解析前的准备过程可以去看看@Import注解解析分析的还是算比较仔细的。这里就直接从ConfigurationClassParser类入手。

2.1 解析处理Configuration类型bean对象注解的doProcessConfigurationClass方法

 ConfigurationClassParser类的doProcessConfigurationClass方法是处理Configuration以及@Bean类型注解的bean上的标签信息的方法。在这里面会处理@Component，@PropertySources，@ComponentScans，@ComponentScan，@Import，@ImportResource以及@Bean注解。这里只截取@ComponentScans，@ComponentScan处理的部分。

    @Nullable
    protected final SourceClass doProcessConfigurationClass(ConfigurationClass configClass, SourceClass sourceClass)
            throws IOException {
        ......
        
        // ComponentScans是对ComponentScan的包装，一个ComponentScans可以包含多个ComponentScan
        Set<AnnotationAttributes> componentScans = AnnotationConfigUtils.attributesForRepeatable(
                sourceClass.getMetadata(), ComponentScans.class, ComponentScan.class);
        //如果解析注解后存在扫描相关的注解，并且贴有当前注解的bean不需要跳过注册（贴有@condition注解）
        if (!componentScans.isEmpty() &&
                !this.conditionEvaluator.shouldSkip(sourceClass.getMetadata(), ConfigurationPhase.REGISTER_BEAN)) {
            //对对应的注解信息进行循环处理
            for (AnnotationAttributes componentScan : componentScans) {
                //ComponentScanAnnotationParser进行解析
                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
                //处理扫描到的并封装成BeanDefinitionHolder对象的bean
                for (BeanDefinitionHolder holder : scannedBeanDefinitions) {
                    //检查时候是已经存在的bean
                    BeanDefinition bdCand = holder.getBeanDefinition().getOriginatingBeanDefinition();
                    if (bdCand == null) {
                        bdCand = holder.getBeanDefinition();
                    }
                    //检查是否可作为候选bean，
                    if (ConfigurationClassUtils.checkConfigurationClassCandidate(bdCand, this.metadataReaderFactory)) {
                        //进行解析
                        parse(bdCand.getBeanClassName(), holder.getBeanName());
                    }
                }
            }
        }

    .....
}

 这里的流程其实就是对bean上面的注解进行处理。

1. 如果包含@ComponentScans或者@ComponentScan类型的注解则获取对应的注解中的信息包装成AnnotationAttributes对象集合。
2. 检查步骤1中集合是否为空，为空则跳过下面的步骤。不为空则继续检查，贴有@ComponentScans或者@ComponentScan注解的bean上面是否贴有@Conditional类中注解，又的话则进行匹配判断检查是否匹配来决定是否进入下一个步骤。@Conditional注解的解析
3. 循环对上面的集合进行处理，调用ComponentScanAnnotationParser的解析方法，获取扫描结果，然后对结果集进行解析。分析是否是候选bean，是的则进行注册。

 这里可以看出具体的扫描的逻辑在ComponentScanAnnotationParser中。

2.2 ComponentScanAnnotationParser中parse对注解的属性的分解

 在进行扫面之前，会先对@ComponentScan注解中用户设置的属性进行分析封装，然后在进行解析。

class ComponentScanAnnotationParser {
    ......
    
    public Set<BeanDefinitionHolder> parse(AnnotationAttributes componentScan, final String declaringClass) {
        //创建一个ClassPathBeanDefinitionScanner用来最终的解析，
        // 检查是否使用默认的过滤器useDefaultFilters，默认的过滤器中会加入，@Component，@Repository，@Controller，@ManagedBean，@Named注解的支持
        ClassPathBeanDefinitionScanner scanner = new ClassPathBeanDefinitionScanner(this.registry,
                componentScan.getBoolean("useDefaultFilters"), this.environment, this.resourceLoader);
        //获取指定的nameGenerator，如果没有指定则用默认的BeanNameGenerator,存在则用指定的
        Class<? extends BeanNameGenerator> generatorClass = componentScan.getClass("nameGenerator");
        boolean useInheritedGenerator = (BeanNameGenerator.class == generatorClass);
        scanner.setBeanNameGenerator(useInheritedGenerator ? this.beanNameGenerator :
                BeanUtils.instantiateClass(generatorClass));
        //检查是否指定了bean实例化时候的代理方式，没有则用使用默认的，有则用指定的
        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));
        }
        //设置匹配模式，默认是的 "**/*.class" ，resourcePattern不能为空
        scanner.setResourcePattern(componentScan.getString("resourcePattern"));
        //添加指定解析时候的包含过滤器
        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);
            }
        }
        //设置是否懒加载，默认为true
        boolean lazyInit = componentScan.getBoolean("lazyInit");
        if (lazyInit) {
            scanner.getBeanDefinitionDefaults().setLazyInit(true);
        }
        //设置扫描的包路径
        Set<String> basePackages = new LinkedHashSet<>();
        String[] basePackagesArray = componentScan.getStringArray("basePackages");
        for (String pkg : basePackagesArray) {
            String[] tokenized = StringUtils.tokenizeToStringArray(this.environment.resolvePlaceholders(pkg),
                    ConfigurableApplicationContext.CONFIG_LOCATION_DELIMITERS);
            Collections.addAll(basePackages, tokenized);
        }
        //根据设置的basePackageClasses属性获取对应的报名，然后放到basePackages中
        for (Class<?> clazz : componentScan.getClassArray("basePackageClasses")) {
            basePackages.add(ClassUtils.getPackageName(clazz));
        }
        //如果没有指定扫描包即basePackages是空的，则用传进来的贴有ComponentScan或者ComponentScans注解的类的包路径作为扫描包
        if (basePackages.isEmpty()) {
            basePackages.add(ClassUtils.getPackageName(declaringClass));
        }
        //添加AbstractTypeHierarchyTraversingFilter用来排除自己扫描到自己的情况，这样后面解析的会造成死循环。
        scanner.addExcludeFilter(new AbstractTypeHierarchyTraversingFilter(false, false) {
            @Override
            protected boolean matchClassName(String className) {
                return declaringClass.equals(className);
            }
        });
        //属性获取完毕之后进行解析
        return scanner.doScan(StringUtils.toStringArray(basePackages));
    }

    ......
}

 在 ComponentScanAnnotationParser的parse方法中主要的就是对封装了@ComponentScan注解信息的AnnotationAttributes对象的解析以及封装。最后交给ClassPathBeanDefinitionScanner类进行最后的解析逻辑。
 这里需要注意的一点：@ComponentScan的useDefaultFilters属性决定了是否对@Component，@Repository，@Controller，@ManagedBean，@Named这些注解的支持，如果设置为了false则不会对这些注解的对象进行解析。

2.3 进行扫描并封装bean信息的ClassPathBeanDefinitionScanner类与ClassPathScanningCandidateComponentProvider

 上面说到了，解析的工作会交给ClassPathBeanDefinitionScanner然而其实在ClassPathBeanDefinitionScanner中制作了一部分的工作。主要的扫描工作还是在他的父类ClassPathScanningCandidateComponentProvider中进行的。这里直接先看doScan方法

    protected Set<BeanDefinitionHolder> doScan(String... basePackages) {
        Assert.notEmpty(basePackages, "At least one base package must be specified");
        Set<BeanDefinitionHolder> beanDefinitions = new LinkedHashSet<>();
        //跌倒需要扫描的包basePackage
        for (String basePackage : basePackages) {
            //寻找合适的候选bean，并封装成BeanDefinition
            Set<BeanDefinition> candidates = findCandidateComponents(basePackage);
            //处理寻找到的候选bean
            for (BeanDefinition candidate : candidates) {
                //调用ScopeMetadataResolver的resolveScopeMetadata为候选bean设置代理的方式ScopedProxyMode，默认是DEFAULT
                //这里ScopeMetadataResolver跟ScopedProxyMode都可以在ComponentScan中设置，分别是scopeResolver跟scopedProxy
                ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(candidate);
                candidate.setScope(scopeMetadata.getScopeName());
                //使用BeanNameGenerator为候选bean生产bean的名称，默认使用的是AnnotationBeanNameGenerator。可以通过nameGenerator指定
                String beanName = this.beanNameGenerator.generateBeanName(candidate, this.registry);
                //如果bean是AbstractBeanDefinition类型的，则使用AbstractBeanDefinition的默认属性
                if (candidate instanceof AbstractBeanDefinition) {
                    postProcessBeanDefinition((AbstractBeanDefinition) candidate, beanName);
                }
                //如果是AnnotatedBeanDefinition类型的则设置对应的默认属性
                if (candidate instanceof AnnotatedBeanDefinition) {
                    AnnotationConfigUtils.processCommonDefinitionAnnotations((AnnotatedBeanDefinition) candidate);
                }
                //检查是不是候选bean，就是检查是否已经存在了
                if (checkCandidate(beanName, candidate)) {
                    //创建BeanDefinitionHolder对象
                    BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(candidate, beanName);
                    //将BeanDefinition的属性设置到BeanDefinitionHolder
                    definitionHolder =
                            AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);
                    beanDefinitions.add(definitionHolder);
                    //注册bean
                    registerBeanDefinition(definitionHolder, this.registry);
                }
            }
        }
        return beanDefinitions;
    }

 可以看到上面的逻辑其实主要是对扫描之后获取到的封装了bean部分信息的BeanDefinition对象的进一步的处理，最后转换成一个BeanDefinitionHolder对象然后进行注册。其扫描的逻辑还是交给了父类去处理。这里主要看扫描的逻辑。

    public Set<BeanDefinition> findCandidateComponents(String basePackage) {
        //componentsIndex对象包含了扫描“META-INF/spring.components”文件后封装起来的需要注册的bean的信息，在这里与来basePackage同时进行处理，
        //如果“META-INF/spring.components”文件不存在，则componentsIndex为null
        if (this.componentsIndex != null && indexSupportsIncludeFilters()) {
            return addCandidateComponentsFromIndex(this.componentsIndex, basePackage);
        }
        else {
            //只处理basePackage
            return scanCandidateComponents(basePackage);
        }
    }

 这里关于componentsIndex属性的设置过程以及“META-INF/spring.components”最后做个补充 。这里发现有两个解析的方法，但是其实这两个方法是大同小异的。区别在于addCandidateComponentsFromIndex会把componentsIndex属性中包含的额外的bean信息跟basePackage合并起来之后在处理，而scanCandidateComponents则是直接处理。这里把addCandidateComponentsFromIndex的多的步骤贴出来

private Set<BeanDefinition> addCandidateComponentsFromIndex(CandidateComponentsIndex index, String basePackage) {
        Set<BeanDefinition> candidates = new LinkedHashSet<>();
        try {
            Set<String> types = new HashSet<>();
            for (TypeFilter filter : this.includeFilters) {
                String stereotype = extractStereotype(filter);
                if (stereotype == null) {
                    throw new IllegalArgumentException("Failed to extract stereotype from " + filter);
                }
                types.addAll(index.getCandidateTypes(basePackage, stereotype));
            }
            //后面与scanCandidateComponents方法一样
            ......
}

 接下来分析剩下的解析过程,这里以scanCandidateComponents方法为例子，因为平常都是不会用上面说的文件方式定义bean 的

    private Set<BeanDefinition> scanCandidateComponents(String basePackage) {
        Set<BeanDefinition> candidates = new LinkedHashSet<>();
        try {
            //获取包路径
            String packageSearchPath = ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX +
                    resolveBasePackage(basePackage) + '/' + this.resourcePattern;
            //将对应的包中的类封装成resources
            Resource[] resources = getResourcePatternResolver().getResources(packageSearchPath);
            boolean traceEnabled = logger.isTraceEnabled();
            boolean debugEnabled = logger.isDebugEnabled();
            for (Resource resource : resources) {
                if (traceEnabled) {
                    logger.trace("Scanning " + resource);
                }
                //需要时可读的
                if (resource.isReadable()) {
                    try {
                        //获取封装了resource的MetadataReader
                        MetadataReader metadataReader = getMetadataReaderFactory().getMetadataReader(resource);
                        //检查metadataReader中的对象的className是否符合指定的excludeFilters跟includeFilters的筛选
                        if (isCandidateComponent(metadataReader)) {
                            //创建一个ScannedGenericBeanDefinition对象
                            ScannedGenericBeanDefinition sbd = new ScannedGenericBeanDefinition(metadataReader);
                            sbd.setResource(resource);
                            sbd.setSource(resource);
                            //检查对应的对象1.是不是一个独立的类；2.一个具体的类不是抽象的不是接口类，如果是抽象的那么必须有对应的Lookup注解指定实现的方法
                            if (isCandidateComponent(sbd)) {
                                if (debugEnabled) {
                                    logger.debug("Identified candidate component class: " + resource);
                                }
                                //加入到候选的bean中
                                candidates.add(sbd);
            ......//主要是打印不符合候选bean的原因以及抛异常
        return candidates;
    }

 上面的主要逻辑就是

1. 先获取包的完整路径，并扫描包下的类封装成一个Resource类型的数组
2. 迭代Resource，循环 3到5步骤。
3. 判断Resource需要是可读的
4. 将Resource转化为MetadataReader对象，然后调用前面在@ComponentScan中指定跟spring加上的excludeFilters和includeFilters判断当前的对象是不是候选的bean。不是则跳到3步骤，否则进行4步骤
5. 将MetadataReader对象转化为ScannedGenericBeanDefinition对象，然后检查对应的对象：1，是不是一个独立的类；2，一个具体的类不是抽象的不是接口类，如果是抽象的那么必须有对应的Lookup注解指定实现的方法。符合则加添到候选bean集合中，否则进入3步骤。
6. 返回候选bean 的集合

 整个的逻辑就是这样的。在扫描完了这些bean并注册了之后，还是需要进入到ConfigurationClassParser中继续进行解析。这样循环直到所有的bean都被处理。

3. 额外的说明

对于“META-INF/spring.components”文件，这个是spring在5.0版本的时候新增的一个功能。这个文件也可以用来定义需要注册的bean，格式如下
类的全限定名=注解的全限定名或者类的全限定名=带有Indexed注解的类的全限定名

example.scannable.DefaultNamedComponent=org.springframework.stereotype.Component

 这个文件的读取时机是在ClassPathBeanDefinitionScanner类被初始化的时候也就是上面parse方法调用的第一行。

    public ClassPathBeanDefinitionScanner(BeanDefinitionRegistry registry, boolean useDefaultFilters,
            Environment environment, @Nullable ResourceLoader resourceLoader) {
        ......
        setResourceLoader(resourceLoader);
    }
    
    public void setResourceLoader(@Nullable ResourceLoader resourceLoader) {
        ......
        this.componentsIndex = CandidateComponentsIndexLoader.loadIndex(this.resourcePatternResolver.getClassLoader());
    }

 在初始化的时候会设置resourceLoader，而在设置resourceLoader的时候又会调用CandidateComponentsIndexLoader类的loadIndex方法。加载逻辑就在这个类里面。

    public static CandidateComponentsIndex loadIndex(@Nullable ClassLoader classLoader) {
        ClassLoader classLoaderToUse = classLoader;
        if (classLoaderToUse == null) {
            classLoaderToUse = CandidateComponentsIndexLoader.class.getClassLoader();
        }
        return cache.computeIfAbsent(classLoaderToUse, CandidateComponentsIndexLoader::doLoadIndex);
    }

 这里的classLoader不会是null所以直接进入，后面调用的doLoadIndex方法。

    private static CandidateComponentsIndex doLoadIndex(ClassLoader classLoader) {
        //是否需要忽略index
        if (shouldIgnoreIndex) {
            return null;
        }
        try {
            //解析"META-INF/spring.components"文件
            Enumeration<URL> urls = classLoader.getResources(COMPONENTS_RESOURCE_LOCATION);
            if (!urls.hasMoreElements()) {
                return null;
            }
            //将解析的结果转化为Properties
            List<Properties> result = new ArrayList<>();
            while (urls.hasMoreElements()) {
                URL url = urls.nextElement();
                Properties properties = PropertiesLoaderUtils.loadProperties(new UrlResource(url));
                result.add(properties);
            }
            if (logger.isDebugEnabled()) {
                logger.debug("Loaded " + result.size() + "] index(es)");
            }
            int totalCount = result.stream().mapToInt(Properties::size).sum();
            //根据Properties创建CandidateComponentsIndex
            return (totalCount > 0 ? new CandidateComponentsIndex(result) : null);
        }
        catch (IOException ex) {
            throw new IllegalStateException("Unable to load indexes from location [" +
                    COMPONENTS_RESOURCE_LOCATION + "]", ex);
        }
    }

 到此，"META-INF/spring.components"文件就解析完毕，如果不为空ClassPathScanningCandidateComponentProvider的findCandidateComponents方法会进行处理并解析的。