Spring源码之invokeBeanFactoryPostProcessors扫描、BeanDefinition生成

---

前言

Bean的生命周期就是指：在Spring中，一个Bean是如何生成的，如何销毁的

在了解如何生成Bean之前，需要了解Spring的底层扫描逻辑、以及生成BeanDefintion

这一篇主要讲源码底层扫描逻辑，下一篇开始讲生成和销毁流程

---

零、BeanDefinition是什么？

要知道创建一个Bean，他是基于BeanDefinition来生成Bean的，

而BeanDefinition 是定义 Bean 的配置元信息接口，他包含一个Bean所需的属性

大概包含以下几点

Bean 的类名
设置父 bean 名称、是否为 primary、
Bean 行为配置信息，作用域、自动绑定模式、生命周期回调、延迟加载、初始方法、销毁方法等
Bean 之间的依赖设置，dependencies
构造参数、属性设置

---

一、Spring扫描、BeanDefinition生成(invokeBeanFactoryPostProcessors核心方法)

1、 生成BeanDefinition

Spring启动的时候会进行扫描，会先调用下面的这段代码，主要是扫描某个包路径，并得到BeanDefinition的Set集合。

// 在启动时，调用refresh()->this.invokeBeanFactoryPostProcessors(beanFactory)-->下会调用下面这个扫描的方法

org.springframework.context.annotation.ClassPathScanningCandidateComponentProvider#scanCandidateComponents(String basePackage)

关于Spring启动流程，后续会有后续章节详细细讲，这里主要以Spring扫描的底层实现

---

2、Spring扫描底层总流程

1、首先，通过ResourcePatternResolver获得指定包路径下的所有.class文件（Spring源码中将此文件包装成了Resource对象）

2、遍历每个Resource对象

3、利用MetadataReaderFactory解析Resource对象得到MetadataReader（在Spring源码中MetadataReaderFactory具体的实现类为CachingMetadataReaderFactory，MetadataReader的具体实现类为SimpleMetadataReader）

4、利用MetadataReader进行excludeFilters和includeFilters，以及条件注解@Conditional的筛选（条件注解并不能理解：某个类上是否存在@Conditional注解，如果存在则调用注解中所指定的类的match方法进行匹配，匹配成功则通过筛选，匹配失败则pass掉。）

5、筛选通过后，基于metadataReader生成ScannedGenericBeanDefinition

6、再基于metadataReader判断是不是对应的类是不是接口或抽象类

7、如果筛选通过，那么就表示扫描到了一个Bean，将ScannedGenericBeanDefinition加入结果集

8、后续则是一些校验…end

---

3、扫描流程图

4、扫描核心源码解析

这里就不过多贴每个细节的源码， 有需要可以自己在本地点进去看。

protected Set<BeanDefinitionHolder> doScan(String... basePackages) {

		Assert.notEmpty(basePackages, "At least one base package must be specified");
		Set<BeanDefinitionHolder> beanDefinitions = new LinkedHashSet<>();
		// 1、遍历包路径
		for (String basePackage : basePackages) {
			// 2、扫描到包路径下的bean定义
			Set<BeanDefinition> candidates = findCandidateComponents(basePackage);
			// 3、遍历Bean定义
			for (BeanDefinition candidate : candidates) {
				// 4、通过ASM解析得到Bean定义元数据
				ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(candidate);
				// 5、设置作用域
				candidate.setScope(scopeMetadata.getScopeName());
				// 6、生成beanName，方便后续赋值给bean定义
				String beanName = this.beanNameGenerator.generateBeanName(candidate, this.registry);
				if (candidate instanceof AbstractBeanDefinition) {
					postProcessBeanDefinition((AbstractBeanDefinition) candidate, beanName);
				}
				if (candidate instanceof AnnotatedBeanDefinition) {
					// 7、解析@Lazy、@Primary、@DependsOn、@Role、@Description赋值给BeanDefinition
					AnnotationConfigUtils.processCommonDefinitionAnnotations((AnnotatedBeanDefinition) candidate);
				}
				// 8、Bean定义是否已经存在bean,不存在则通过
				if (checkCandidate(beanName, candidate)) {
					BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(candidate, beanName);
					definitionHolder =
							AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);
					beanDefinitions.add(definitionHolder);
					// 9、注册BeanDefinition
					registerBeanDefinition(definitionHolder, this.registry);
				}
			}
		}
		return beanDefinitions;
	}

---

5、扫描到包路径下的beanDefintion

private Set<BeanDefinition> scanCandidateComponents(String basePackage) {
		Set<BeanDefinition> candidates = new LinkedHashSet<>();
		try {
			// 1、组装解析文件类的url
			String packageSearchPath = ResourcePatternResolver.CLASSPATH_ALL_URL_PREFIX +
					resolveBasePackage(basePackage) + '/' + this.resourcePattern;
			// 2、利用resource加载url
			Resource[] resources = getResourcePatternResolver().getResources(packageSearchPath);
			boolean traceEnabled = logger.isTraceEnabled();
			boolean debugEnabled = logger.isDebugEnabled();
			// 3、遍历所有的文件类对象
			for (Resource resource : resources) {
				if (traceEnabled) {
					logger.trace("Scanning " + resource);
				}
				if (resource.isReadable()) {
					try {
						// 4、元数据解析资源
						MetadataReader metadataReader = getMetadataReaderFactory().getMetadataReader(resource);
						// 5、是否文件类对象注解上有@Component、以及有@Conding，并且满足条件则通过
						if (isCandidateComponent(metadataReader)) {
							// 6、生成ScannedGenericBeanDefinition 
							ScannedGenericBeanDefinition sbd = new ScannedGenericBeanDefinition(metadataReader);
							// 7、设置资源
							sbd.setSource(resource);
							if (isCandidateComponent(sbd)) {
								if (debugEnabled) {
									logger.debug("Identified candidate component class: " + resource);
								}
								// 添加到集合，返回
								candidates.add(sbd);
							}
							else {
								if (debugEnabled) {
									logger.debug("Ignored because not a concrete top-level class: " + resource);
								}
							}
						}
						else {
							if (traceEnabled) {
								logger.trace("Ignored because not matching any filter: " + resource);
							}
						}
					}
					catch (Throwable ex) {
						throw new BeanDefinitionStoreException(
								"Failed to read candidate component class: " + resource, ex);
					}
				}
				else {
					if (traceEnabled) {
						logger.trace("Ignored because not readable: " + resource);
					}
				}
			}
		}
		catch (IOException ex) {
			throw new BeanDefinitionStoreException("I/O failure during classpath scanning", ex);
		}
		return candidates;
	}

---

二、MetadataReader表示类的元数据读取器

主要包含了一个AnnotationMetadata，功能有

获取类的名字
获取父类的名字
获取所实现的所有接口名
获取所有内部类的名字
判断是不是抽象类
判断是不是接口
判断是不是一个注解
获取拥有某个注解的方法集合
获取类上添加的所有注解信息
获取类上添加的所有注解类型集合

值得注意的是，CachingMetadataReaderFactory解析某个.class文件得到MetadataReader对象是利用的ASM技术，并没有加载这个类到JVM。

并且，最终得到的ScannedGenericBeanDefinition对象，beanClass属性存储的是当前类的名字，而不是class对象。（beanClass属性的类型是Object，它即可以存储类的名字，也可以存储class对象）
​

最后，上面是说的通过扫描得到BeanDefinition对象，我们还可以通过直接定义BeanDefinition，或解析spring.xml文件的，或者@Bean注解得到BeanDefinition对象。

---

三、合并BeanDefinition

通过扫描得到所有BeanDefinition之后，就可以根据BeanDefinition创建Bean对象了，但是在Spring中支持父子BeanDefinition，和Java父子类类似，但是完全不是一回事。

父子BeanDefinition实际用的比较少，使用是这样的，比如：

<bean id="parent" class="com.ljc.service.Parent" scope="prototype"/>
<bean id="child" class="com.ljc.service.Child"/>

这么定义的情况下，child是单例Bean。

<bean id="parent" class="com.ljc.service.Parent" scope="prototype"/>
<bean id="child" class="com.ljc.service.Child" parent="parent"/>

但是这么定义的情况下，child就是原型Bean了。​

因为child的父BeanDefinition是parent，所以会继承parent上所定义的scope属性。​

而在根据child来生成Bean对象之前，需要进行BeanDefinition的合并，得到完整的child的BeanDefinition。

3.1、源码调用地方

RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);

在不影响原本存在的BeanDefintion的情况下，创建了新的RootBeanDefinition。

synchronized (this.mergedBeanDefinitions) {
			RootBeanDefinition mbd = null;
			RootBeanDefinition previous = null;
			
			if (mbd == null || mbd.stale) {
				previous = mbd;
				if (bd.getParentName() == null) {
					// 创建RootBeanDefinition
					if (bd instanceof RootBeanDefinition) {
						mbd = ((RootBeanDefinition) bd).cloneBeanDefinition();
					}
					else {
						mbd = new RootBeanDefinition(bd);
					}
				}

---

四、FactoryBean–可以创建自定义Bean

可以通过实现FactoryBean接口创造出来的自定义的Bean，只会经过初始化后，其他Spring的生命周期步骤是不会经过的

for (String beanName : beanNames) {
			// 合并后的BeanDefintion
			RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
			// 校验不是抽象的并且是单例并且不是懒加载
			if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
				// 看他是不是一个FactoryBean
				if (isFactoryBean(beanName)) {
					// 拿到Bean
					Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
					// 判断他是否实现了FactoryBean
					if (bean instanceof FactoryBean) {
						FactoryBean<?> factory = (FactoryBean<?>) bean;
						boolean isEagerInit;
						if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
							isEagerInit = AccessController.doPrivileged(
									(PrivilegedAction<Boolean>) ((SmartFactoryBean<?>) factory)::isEagerInit,
									getAccessControlContext());
						}
						else {
							isEagerInit = (factory instanceof SmartFactoryBean &&
									((SmartFactoryBean<?>) factory).isEagerInit());
						}
						if (isEagerInit) {
							getBean(beanName);
						}
					}
				}
				else {
					getBean(beanName);
				}
			}
		}

在合并完BeanDefinition后，判断他不是抽象的并且是单例并且不是懒加载，则判断他实现了FactoryBean,最后开始真正创建Bean，调用getBean方法，进行创建Bean