spring源码之BeanDefinitionScanner的底层源码详解

柔光的暖阳◎ 2024-04-06 10:52 14阅读 0赞

spring源码系列整体栏目

> 只谈源码，只玩真实。和面试官认真的谈一次源码吧

--------------------

【一】spring源码安装超级详解

[【二】spring源码底层核心原理初探超级详解][spring]

【三】spring源码之ApplicationContext超级详解

[【四】spring源码之BeanDefinitionScan超级详解][spring_BeanDefinitionScan]

【五】spring源码之BeanDefinitionRead超级详解

【六】spring源码之IOC的加载流程超级详解以及Bean的生命周期

【七】spring源码之AOP的加载流程以及底层原理

【八】spring源码之AOP的使用详解

【九】spring源码之循环依赖超级详解

【十】spring源码之自定义注解超级详解

【十一】spring源码之事务底层超级详解

【十二】spring源码之事件底层超级详解

--------------------

#### BeanDefinitionScanner底层原理 ####

*  一，BeanDefinitionScanner加载流程
 *   *  1，源码分析前准备
     *  2，源码分析
 *  二，总结
 *   *  1，BeanDifinitionScanner执行流程总结
     *  2，@Component注解总结

## 一，BeanDefinitionScanner加载流程 ##

### 1，源码分析前准备 ###

在分析这个源码的时候，首先需要去官网下载这个spring的源码包，建议下载5.x.x的版本

我这里安装的是：[https://github.com/spring-projects/spring-framework/tree/5.2.x][https_github.com_spring-projects_spring-framework_tree_5.2.x]

### 2，源码分析 ###

1，ApplicationContext是参与了整个springIoc的加载流程，因此ApplicationContext也是作为SpringIoc的一个入口了。由于ApplicationContext接口有很多的实现类，因此这里使用注解的方式来获取上下文的内容。

首先通过这个注解类AnnotationConfigApplicationContext获取这个上下文的全部信息，然后加载里面的配置信息，环境等。

AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext(MainConfig.class);

2，然后进入这个AnnotationConfigApplicationContext类里面，可以发现有一个无参构造方法，注册配置类的方法和一个refresh刷新IOC容器的方法，这里的话主要先看这个无参的构造方法。

public AnnotationConfigApplicationContext(Class<?>... annotatedClasses) {
        
    	//调用构造函数
    	this();
    	//注册我们的配置类
    	register(annotatedClasses);
    	//IOC容器刷新接口
    	refresh();
    }

3，在这个构造函数里面，会实例化一个BeanDefinitionReader的读取器和一个BeanDefinitionScanner的扫描器。读取器就是为了读取注解，扫描器是为了扫描这个包和类，最后注册成一个BeanDefinition，这个**BeanDefinitionScanner** 也是本篇文章的核心内容

public AnnotationConfigApplicationContext(DefaultListableBeanFactory beanFactory) {
        
    	super(beanFactory);
    	this.reader = new AnnotatedBeanDefinitionReader(this);
    	this.scanner = new ClassPathBeanDefinitionScanner(this);
    }

4，在这个ClassPathBeanDefinitionScanner类的构造方法里面，首先会设置一下这个当前的环境以及资源加载器，还有一个重要的就是有一个初始化一个默认的过滤器的方法。

public ClassPathBeanDefinitionScanner(BeanDefinitionRegistry registry, boolean useDefaultFilters,
    	Environment environment, @Nullable ResourceLoader resourceLoader) {
        
    	this.registry = registry;
        
    	if (useDefaultFilters) {
        
    		registerDefaultFilters();
    	}
    	//设置环境对象
    	setEnvironment(environment);
    	//设置资源加载器
    	setResourceLoader(resourceLoader);
    }

然后可以来查看一下这个registerDefaultFilters的方法，里面会初始化这个includeFilter的这个包含过滤器，其底层就是一个List集合。**这个包含过滤器里面会去添加所有的加了@Component注解的类，并且在spring中，这个@Component的这个注解就是在这个阶段进行扫描的**。这个包含过滤器会在后面是否成为一个候选的bean的时候起到作用。

private final List<TypeFilter> includeFilters = new LinkedList<>();
    
    protected void registerDefaultFilters() {
        
    	//加入扫描我们的@Component的
    	this.includeFilters.add(new AnnotationTypeFilter(Component.class));
    }

5，接下来进入这个**ClassPathBeanDefinitionScanner**扫描类里面，会有一个scan方法，然后开始进行真正的对这个包路径的扫描。

public int scan(String... basePackages) {
        
        //对这些pachage的这些包进行扫描
    	doScan(basePackages);
    }

接下来进入这个doScan的这个方法里面，就是开始扫描包。

protected Set < BeanDefinitionHolder > doScan(String...basePackages) {
        
    	//创建bean定义的holder对象用于保存扫描后生成的bean定义对象
    	Set <BeanDefinitionHolder> beanDefinitions = new LinkedHashSet <> ();
    	//循环我们的包路径集合
    	for (String basePackage: basePackages) {
        
    		//找到候选的Components
    		Set < BeanDefinition > candidates = findCandidateComponents(basePackage);
            
    		for (BeanDefinition candidate: candidates) {
        
    
    			ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(candidate);
    			candidate.setScope(scopeMetadata.getScopeName());
    			//设置我们的beanName
    			String beanName = this.beanNameGenerator.generateBeanName(candidate, this.registry);
    			//这是默认配置 autowire-candidate
    			if (candidate instanceof AbstractBeanDefinition) {
        
    				postProcessBeanDefinition((AbstractBeanDefinition) candidate, beanName);
    			}
    			//获取@Lazy @DependsOn等注解的数据设置到BeanDefinition中
    			if (candidate instanceof AnnotatedBeanDefinition) {
        
    				AnnotationConfigUtils.processCommonDefinitionAnnotations((AnnotatedBeanDefinition) candidate);
    			}
    			//把我们解析出来的组件bean定义注册到我们的IOC容器中（容器中没有才注册）
    			if (checkCandidate(beanName, candidate)) {
        
    				BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(candidate, beanName);
    				definitionHolder =
    					AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);
    				beanDefinitions.add(definitionHolder);
    				registerBeanDefinition(definitionHolder, this.registry);
    			}
    		}
    	}
    	return beanDefinitions;
    }

6，在上面的doScan方法里面，会有一个**findCandidateComponents(basePackage)** 的方法，主要是为了找到需要生成beanDefinition的候选者。进入这个方法，里面会有一个这个scanCandidateComponents方法用于扫描全部的候选者。并且里面有一个componentsIndex的一个索引，主要是为了增加这个查询的效率

public Set < BeanDefinition > findCandidateComponents(String basePackage) {
        
    	if (this.componentsIndex != null && indexSupportsIncludeFilters()) {
        
    		return addCandidateComponentsFromIndex(this.componentsIndex, basePackage);
    	} else {
        
    		return scanCandidateComponents(basePackage);
    	}
    }

7，接下来在查看这个**scanCandidateComponents**方法，就是用来扫描这些候选的Component配置类的。这里面的basePackage就是具体的包路径，比如说com.zhs.study，最后会将这个包路径转化为资源路径com/zhs/study。然后会去遍历这个资源集合，最后判断这些包路径下面的类是不是一个候选的component

private Set <BeanDefinition> scanCandidateComponents(String basePackage) {
        
    	Set <BeanDefinition> candidates = new LinkedHashSet<>();
    	try {
        
    		//把我们的包路径转为资源路径 com/zhs/study
    		String packageSearchPath = ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX +
    				resolveBasePackage(basePackage) + '/' + this.resourcePattern;
    		//扫描指定包路径下面的所有.class文件
    		Resource[] resources = getResourcePatternResolver().getResources(packageSearchPath);
            
            //遍历这个resources集合
    		for (Resource resource : resources) {
        
                try {
        
                    //获取这个当前类的一个读取器，就可以读取当前类的类名，注解等
    				MetadataReader metadataReader = getMetadataReaderFactory().getMetadataReader(resource);
                    //判断当前类是不是一个候选的bean
                    if (isCandidateComponent(metadataReader)) {
        
                        //如果这个类是一个有效的bean
    					ScannedGenericBeanDefinition sbd = new ScannedGenericBeanDefinition(metadataReader);
    					//判断类的属性，如是否是接口，抽象类，内部类等，如果是也不能注册
    					if (isCandidateComponent(sbd)) {
        		
    						//加入到集合中
    						candidates.add(sbd);
    					}
                    }
                }
            }
    	}
    }

8，判断这个类是不是一个有效的bean的方法如下，主要是在这个 **isCandidateComponent** 方法里面实现。

*  首先会判断一下这个类在不在这个excludeFilters排除过滤器里面，如果在里面，那么直接返回false；
 *  如果不在排除过滤器里面，那么会判断在不在这个includeFilters包含过滤器里面，就是判断一下这个类上面有没有这个@Component的这个注解。
 *  如果有这个@Component注解，又会去判断一下这个类上面有没有这个@Conditional这个条件注解，如果有这个注解，则会判断是否符合里面的条件，如果符合条件，那么可以成为一个BeanDefinition；如果没有这个注解，则可以通过这个过滤器，可以成为一个BeanDefinition
 *  如果都不在这两个过滤器里面，那么也会返回一个false，表示不符合条件

protected boolean isCandidateComponent(MetadataReader metadataReader) throws IOException {
        
    	//通过excludeFilters 进行是否需要排除的
    	for (TypeFilter tf: this.excludeFilters) {
        
    		if (tf.match(metadataReader, getMetadataReaderFactory())) {
        
    			return false;
    		}
    	}
    	//includeFilters 是否需要进行包含的
    	for (TypeFilter tf: this.includeFilters) {
        
    		if (tf.match(metadataReader, getMetadataReaderFactory())) {
        
    			return isConditionMatch(metadataReader);
    		}
    	}
    	return false;
    }
    
    //如果有这个@Component的这个注解，又会再判断一下这个这个类上面有没有加这个@Conditional的这个注解
    private boolean isConditionMatch(MetadataReader metadataReader) {
        
    	if (this.conditionEvaluator == null) {
        
    		this.conditionEvaluator =
    			new ConditionEvaluator(getRegistry(), this.environment, this.resourcePatternResolver);
    	}
    	return !this.conditionEvaluator.shouldSkip(metadataReader.getAnnotationMetadata());
    }

9，如果这个类是一个有效的bean，那么里面又内嵌了一个 **isCandidateComponent** 的布尔类型的方法，主要是判断一下这个有效bean的类是一个什么类型的类。如果里面不是一些接口，抽象类，内部类等，那么才能将这个有效的BeanDefinition对象加入set集合给返回。

protected boolean isCandidateComponent(AnnotatedBeanDefinition beanDefinition) {
        
    	AnnotationMetadata metadata = beanDefinition.getMetadata();
    	// metadata.isIndependent()=顶级类、嵌套类、静态内部类
    	// metadata.isConcrete() =非接口、非抽象类
    	// metadata.isAbstract() && metadata.hasAnnotatedMethods(Lookup.class.getName() = 抽象类并且必须方法中有@LookUp
    	return (metadata.isIndependent() && (metadata.isConcrete() ||
    		(metadata.isAbstract() && metadata.hasAnnotatedMethods(Lookup.class.getName()))));
    }

10，回到5里面的doScan方法，再获取到这个全部需要生成的BeanDefinition之后，就会去给这个BeanDefinition进行一个初始的赋值。比如说设置一些作用域，bean的名字，是否懒加载等。

String beanName = this.beanNameGenerator.generateBeanName(candidate, this.registry);
    //这是默认配置 autowire-candidate
    if (candidate instanceof AbstractBeanDefinition) {
        
    	postProcessBeanDefinition((AbstractBeanDefinition) candidate, beanName);
    }
    //获取@Lazy @DependsOn等注解的数据设置到BeanDefinition中
    if (candidate instanceof AnnotatedBeanDefinition) {
        
    	AnnotationConfigUtils.processCommonDefinitionAnnotations((AnnotatedBeanDefinition) candidate);
    }

11，依旧是回到5里面的doScan的方法里面，再设置完一些属性之后，就会开始将这个BeanDefinition注册到这个springIoc的容器里面了。首先会判断一下这个BeanDefinition在这个容器里面是否存在，如果不存在，那么就会将这个BeanDefinition注册到这个springIoc的容器里面。

//把我们解析出来的组件bean定义注册到我们的IOC容器中（容器中没有才注册）
    if (checkCandidate(beanName, candidate)) {
        
    	BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(candidate, beanName);
    	definitionHolder =
    		AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);
    	beanDefinitions.add(definitionHolder);
    	registerBeanDefinition(definitionHolder, this.registry);
    }

## 二，总结 ##

### 1，BeanDifinitionScanner执行流程总结 ###

![在这里插入图片描述][7aecbc5366c54a508afac77e9a40b84c.png]

*  1，首先会调用一个scan的一个方法，然后调用里面的doscan方法开始真正的扫描。
 *  2，首先会扫描所有的包路径，会获取包下面所有的类，然后会这些类都会成为一个被候选的类，如果满足条件那么就可以成为最终的BeanDefinition。
 *  3，候选的规则如下，首先会判断一下这个类在不在一个excludeFilters的排除过滤器里面，如果在里面，那么直接返回；再判断一下这个类在不在一个includeFilters的包含过滤器里面，就是这个类上面有没有一个@Component这个类的注解，没有则直接return返回；有的话则继续判断一下这个类上面有没有一个@Conditional的条件注解，如果有的话看一下这个类是否满足里里面的条件表达式，如果不满足则直接return返回，如果满足的话就可以成为一个有效的BeanDifinition，如果这个类上面没有这个@Conditional的这个注解，那么也会成为一个有效的BeanDifinition
 *  4，在成为一个有效的BeanDefinition之后，会判断一下这个BeanDefinition的类是一个什么类型，如果是接口，抽象类，内部类等，那么直接return ；如果不是接口，抽象类，内部类等，那么会将这个有效类加入到这个set集合里面，最后返回这个set集合
 *  5，在获取到所有的BeanDefinition之后，会设置一些BeanDefinition的一些属性，如一些作用域、是否懒加载等，并且这些BeanDefinition都会加入到一个BeanDefinitionMap里面
 *  6，最后会去判断一下这个Ioc容器里面是否存在这个BeanDefinition，如果不存在，那么会通过这个beanDefinitionRegistry将这个BeanDefinition注册到Spring的Ioc容器里面

### 2，@Component注解总结 ###

就是在spring启动时，这个加了@Component这个注解上面的类，是在这个@IncludeFilter包含过滤器里面被创建和加载的。在创建这个@IncludeFilter的时候，就会去获取所有加了这个@Component这个注解的类，会把这些类加载到这个Spring的容器里面。

[spring]: https://blog.csdn.net/zhenghuishengq/article/details/126917692?spm=1001.2014.3001.5502
[spring_BeanDefinitionScan]: https://blog.csdn.net/zhenghuishengq/article/details/126941869?spm=1001.2014.3001.5501
[https_github.com_spring-projects_spring-framework_tree_5.2.x]: https://github.com/spring-projects/spring-framework/tree/5.2.x
[7aecbc5366c54a508afac77e9a40b84c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/06/8bc16102e43649d38d62f322e5b2a4b9.png