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上面的注解进行处理。
- 如果包含
@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);
}
}
//设置是否懒加载，默认为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;
}
上面的主要逻辑就是
- 先获取包的完整路径，并扫描包下的类封装成一个
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) {
//是否需要忽略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方法会进行处理并解析的。
网友评论