本文主要是介绍spring源码------`@ComponentScans`,`@ComponentScan`注解解析以及spring5.0新特性META-INF/spring.components文件...，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！
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的解析
这两个注解的解析过程跟@Conditional注解的解析前的步骤是一样的。最后的解析入口也一样在ConfigurationClassParser类中，对于解析前的准备过程可以去看看@Conditional注解解析分析的还是算比较仔细的。这里就直接从ConfigurationClassParser类入手。
2.1 解析处理Configuration类型bean对象注解的doProcessConfigurationClass方法
ConfigurationClassParser类的doProcessConfigurationClass方法是处理Configuration以及@Bean类型注解的bean上的标签信息的方法。在这里面会处理@Component，@PropertySources，@ComponentScans，@ComponentScan，@Import，@ImportResource以及@Bean注解。这里只截取@ComponentScans，@ComponentScan处理的部分。
@Nullableprotected final SourceClass doProcessConfigurationClass(ConfigurationClass configClass, SourceClass sourceClass)throws IOException {......// ComponentScans是对ComponentScan的包装，一个ComponentScans可以包含多个ComponentScanSet<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对象的beanfor (BeanDefinitionHolder holder : scannedBeanDefinitions) {//检查时候是已经存在的beanBeanDefinition bdCand = holder.getBeanDefinition().getOriginatingBeanDefinition();if (bdCand == null) {bdCand = holder.getBeanDefinition();}//检查是否可作为候选bean，if (ConfigurationClassUtils.checkConfigurationClassCandidate(bdCand, this.metadataReaderFactory)) {//进行解析parse(bdCand.getBeanClassName(), holder.getBeanName());}}}}.....
}
这里的流程其实就是对bean上面的注解进行处理。
- 如果包含
@ComponentScans或者@ComponentScan类型的注解则获取对应的注解中的信息包装成AnnotationAttributes对象集合。 - 检查步骤1中集合是否为空，为空则跳过下面的步骤。不为空则继续检查，贴有
@ComponentScans或者@ComponentScan注解的bean上面是否贴有@Conditional类中注解，又的话则进行匹配判断检查是否匹配来决定是否进入下一个步骤。@Conditional注解的解析 - 循环对上面的集合进行处理，调用
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);}}//设置是否懒加载，默认为trueboolean 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) {@Overrideprotected 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<>();//跌倒需要扫描的包basePackagefor (String basePackage : basePackages) {//寻找合适的候选bean，并封装成BeanDefinitionSet<BeanDefinition> candidates = findCandidateComponents(basePackage);//处理寻找到的候选beanfor (BeanDefinition candidate : candidates) {//调用ScopeMetadataResolver的resolveScopeMetadata为候选bean设置代理的方式ScopedProxyMode，默认是DEFAULT//这里ScopeMetadataResolver跟ScopedProxyMode都可以在ComponentScan中设置，分别是scopeResolver跟scopedProxyScopeMetadata 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的属性设置到BeanDefinitionHolderdefinitionHolder =AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);beanDefinitions.add(definitionHolder);//注册beanregisterBeanDefinition(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为nullif (this.componentsIndex != null && indexSupportsIncludeFilters()) {return addCandidateComponentsFromIndex(this.componentsIndex, basePackage);}else {//只处理basePackagereturn 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;//将对应的包中的类封装成resourcesResource[] 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的MetadataReaderMetadataReader 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;}
上面的主要逻辑就是
- 先获取包的完整路径，并扫描包下的类封装成一个
Resource类型的数组 - 迭代
Resource，循环 3到5步骤。 - 判断
Resource需要是可读的 - 将
Resource转化为MetadataReader对象，然后调用前面在@ComponentScan中指定跟spring加上的excludeFilters和includeFilters判断当前的对象是不是候选的bean。不是则跳到3步骤，否则进行4步骤 - 将
MetadataReader对象转化为ScannedGenericBeanDefinition对象，然后检查对应的对象：1，是不是一个独立的类；2，一个具体的类不是抽象的不是接口类，如果是抽象的那么必须有对应的Lookup注解指定实现的方法。符合则加添到候选bean集合中，否则进入3步骤。 - 返回候选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) {//是否需要忽略indexif (shouldIgnoreIndex) {return null;}try {//解析"META-INF/spring.components"文件Enumeration<URL> urls = classLoader.getResources(COMPONENTS_RESOURCE_LOCATION);if (!urls.hasMoreElements()) {return null;}//将解析的结果转化为PropertiesList<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创建CandidateComponentsIndexreturn (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方法会进行处理并解析的。
这篇关于spring源码------`@ComponentScans`,`@ComponentScan`注解解析以及spring5.0新特性META-INF/spring.components文件...的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！
