距离上一次更新该文章已经过了 693 天，文章所描述的內容可能已经发生变化，请留意。

探究spring的底层实现原理1

<谨供参考>

这篇文章我将尝试从以下几个方面配合源码讲解spring的原理,并在下一个篇章手写一个简易版spring的小demo来更透彻的分析spring项目是如何"动"起来的

  • BeanFactory
  • Bean的整个生命周期
  • Bean的属性填充
  • 依赖注入

先来看一张图(看不清可以右键打开)

这里需要说的一点是,spring的核心就是AbstractApplicationContext.refresh中的13个方法,关于refresh我会单独写

BeanFactory

java
1
2
3
4
5
6
7
8
9
10
以springboot项目为例,运行主入口类的SpringApplication.run会走到AbstractApplicationContext.refresh方法,
从ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory()到registerListeners()
都是在准备并创建BeanFactory的过程,而这个BeanFactory又是什么呢?

之前看到一个这样的例子,说beanfactory就是一个征婚介绍所,它的资料库里有个各种各样的男生女生,
当有人来征婚的时候,介绍所就会从里面选一个这人所需要的男生或则女生给他/她,这个比喻就很恰当

所以总结一下:
Spring的本质就是一个bean工厂(beanFactory)或者说bean容器，它按照我们的要求，生产我们需要的
各种各样的bean，提供给我们使用。

在开始并完成创建beanfactory的这一过程,spring做了很多事情,而真正去干活的是invokeBeanFactoryPostProcessors

在spring的源码中发现两个秘密,invoke和do开头的方法,大部分都是值得去关注的
比如这个invokeBeanFactoryPostProcessors(beanFactory),来看默认情况下它里面究竟干了些啥

java
1
2
3
4
// 此时beanFactory的beanDefinitionMap中有6个BeanDefinition，5个基础BeanDefinition+AppConfig的BeanDefinition
// 而这6个中只有一个BeanFactoryPostProcessor：ConfigurationClassPostProcessor
// 这里会执行ConfigurationClassPostProcessor进行@Component的扫描，扫描得到BeanDefinition，并注册到beanFactory中
// 扫描的过程中可能又会扫描出其他的BeanFactoryPostProcessor，那么这些BeanFactoryPostProcessor也得在这一步执行

进入方法,看下源码

java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
// beanFactoryPostProcessors中的内容可以通过AnnotationConfigApplicationContext的addBeanFactoryPostProcessor方法添加
Set<String> processedBeans = new HashSet<>();
if (beanFactory instanceof BeanDefinitionRegistry) {
	BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
	List<BeanFactoryPostProcessor> regularPostProcessors = new ArrayList<>();
	List<BeanDefinitionRegistryPostProcessor> registryProcessors = new ArrayList<>();
	// 这个beanFactoryPostProcessors集合一般情况下都是空的，除非我们手动调用容器的addBeanFactoryPostProcessor方法
	for (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) {
		// BeanDefinitionRegistryPostProcessor是一个特殊的BeanFactoryPostProcessor，需要先执行postProcessBeanDefinitionRegistry方法
		if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {
			BeanDefinitionRegistryPostProcessor registryProcessor =
					(BeanDefinitionRegistryPostProcessor) postProcessor;

			registryProcessor.postProcessBeanDefinitionRegistry(registry);
			registryProcessors.add(registryProcessor);
		}
		else {
			regularPostProcessors.add(postProcessor);
		}
	}

	// 保存当前需要执行的实现了BeanDefinitionRegistryPostProcessor接口的后置处理器
	// Do not initialize FactoryBeans here: We need to leave all regular beans
	// uninitialized to let the bean factory post-processors apply to them!
	// Separate between BeanDefinitionRegistryPostProcessors that implement
	// PriorityOrdered, Ordered, and the rest.
	List<BeanDefinitionRegistryPostProcessor> currentRegistryProcessors = new ArrayList<>();

	// First, invoke the BeanDefinitionRegistryPostProcessors that implement PriorityOrdered.
	// 首先，先执行实现了PriorityOrdered接口的BeanDefinitionRegistryPostProcessor的postProcessBeanDefinitionRegistry方法
	String[] postProcessorNames =
			beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
	for (String ppName : postProcessorNames) {
		// 判断这个类是否还实现了PriorityOrdered接口
		if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
			// 这里调用了getBean，所以生成一个BeanDefinitionRegistryPostProcessor的bean对象
			currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
			processedBeans.add(ppName);
		}
	}
	sortPostProcessors(currentRegistryProcessors, beanFactory);
	registryProcessors.addAll(currentRegistryProcessors);
	// 执行postProcessBeanDefinitionRegistry方法
	invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
	currentRegistryProcessors.clear();

	// Next, invoke the BeanDefinitionRegistryPostProcessors that implement Ordered.
	// 首先，先执行实现了Ordered接口的BeanDefinitionRegistryPostProcessor的postProcessBeanDefinitionRegistry方法
	postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
	for (String ppName : postProcessorNames) {
		if (!processedBeans.contains(ppName) && beanFactory.isTypeMatch(ppName, Ordered.class)) {
			currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
			processedBeans.add(ppName);
		}
	}
	sortPostProcessors(currentRegistryProcessors, beanFactory);
	registryProcessors.addAll(currentRegistryProcessors);
	invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
	currentRegistryProcessors.clear();

	// Finally, invoke all other BeanDefinitionRegistryPostProcessors until no further ones appear.
	// 最后，最后其他普通的BeanDefinitionRegistryPostProcessors的postProcessBeanDefinitionRegistry方法
	boolean reiterate = true;
	// 在一个BeanDefinitionRegistryPostProcessor中可以注册另一个BeanDefinitionRegistryPostProcessor，所以需要递归找出所有的BeanDefinitionRegistryPostProcessor
	// 一个没有实现PriorityOrdered接口的BeanDefinitionRegistryPostProcessor如果在内部注册了一个实现了PriorityOrdered接口的BeanDefinitionRegistryPostProcessor，那么就是没有实现PriorityOrdered接口的先执行
	while (reiterate) {
		reiterate = false;
		// 这里会再一次拿到实现了PriorityOrdered接口或Ordered接口的BeanDefinitionRegistryPostProcessor，所以需要processedBeans进行过滤
		postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
		for (String ppName : postProcessorNames) {
			if (!processedBeans.contains(ppName)) {
				currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
				processedBeans.add(ppName);
				reiterate = true;
			}
		}
		sortPostProcessors(currentRegistryProcessors, beanFactory);
		registryProcessors.addAll(currentRegistryProcessors);
		invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
		currentRegistryProcessors.clear();
	}

	// =======BeanDefinition  解析配置类（扫描，- [@Bean](https://my.oschina.net/bean), @Import），手动，接口， [@Import](https://my.oschina.net/u/3201731)

	// Now, invoke the postProcessBeanFactory callback of all processors handled so far.
	// 执行完BeanDefinitionRegistryPostProcessor的postProcessBeanDefinitionRegistry方法后，
	// 再执行BeanDefinitionRegistryPostProcessor的postProcessBeanFactory方法
	invokeBeanFactoryPostProcessors(registryProcessors, beanFactory);

	// 执行手动添加的非BeanDefinitionRegistryPostProcessor类型的Bean工厂后置处理器的postProcessBeanFactory方法
	invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory);
}

else {
	// 如果beanFactory没有可以注册BeanDefinition的功能，则没有BeanDefinitionRegistryPostProcessor，则执行Bean工厂后置处理器的postProcessBeanFactory方法
	// Invoke factory processors registered with the context instance.
	invokeBeanFactoryPostProcessors(beanFactoryPostProcessors, beanFactory);
}

总结一下上面的流程：

  1. 如果beanFactory实现了BeanDefinitionRegistry接口，则表示可以通过BeanDefinitionRegistryPostProcessor接口来注册BeanDefinition
  2. 因为现在是Spring启动过程中的比较早的阶段（还没有开始扫描@Component），所以只能获取Spring默认添加到BeanFactory中的bean工厂后置处理器，以及程序员手动添加的bean工厂后置处理器
  3. 执行的顺序是，先执行BeanDefinitionRegistryPostProcessor中的postProcessBeanDefinitionRegistry方法，因为这个方法可以注册BeanDefinition
  4. 先执行手动添加进行来的BeanDefinitionRegistryPostProcessor的postProcessBeanDefinitionRegistry方法,这个过程中可能会向BeanFactory中注册其他的BeanDefinitionRegistryPostProcessor
  5. 从BeanFactory中获取PriorityOrdered接口的BeanDefinitionRegistryPostProcessor，并执行postProcessBeanDefinitionRegistry方法
  6. 从BeanFactory中获取Ordered接口的BeanDefinitionRegistryPostProcessor，并执行postProcessBeanDefinitionRegistry方法
  7. 在5,6步中都有可能注册新的BeanDefinitionRegistryPostProcessor的
  8. 从BeanFactory中获取普通的BeanDefinitionRegistryPostProcessor，并执行postProcessBeanDefinitionRegistry方法
  9. 在8步中也有可能注册新的BeanDefinitionRegistryPostProcessor，所以第8步会递归，直到没有新的BeanDefinitionRegistryPostProcessor注册进来了
  10. 在前面的步骤中都是执行BeanDefinitionRegistryPostProcessor中的postProcessBeanDefinitionRegistry方法，进行BeanDefinition的注册
  11. BeanDefinition注册完了之后，因为BeanDefinitionRegistryPostProcessor本身也是一个BeanFactoryProcessor，所以最后再执行postProcessBeanFactory方法
  12. 总结一句话就是：先通过BeanDefinitionRegistryPostProcessor注册BeanDefinition，再执行BeanDefinitionRegistryPostProcessor的postProcessBeanFactory方法

在默认情况下，上面的步骤中只有一个BeanDefinitionRegistryPostProcessor会执行，就是ConfigurationClassPostProcessor，因为它是Spring默认在添加进去的. BeanDefinitionRegistryPostProcessor是特殊的BeanFactoryPostProcessor，在上面的逻辑中都处理完了.
所以接下来就是处理普通的BeanFactoryPostProcessor

java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);
// 默认情况下会拿到两个，一个就是ConfigurationClassPostProcessor，一个就是EventListenerMethodProcessor

// Separate between BeanFactoryPostProcessors that implement PriorityOrdered,
// Ordered, and the rest.
// 保存直接实现了BeanFactoryPostProcessor接口和PriorityOrdered接口的后置处理器
List<BeanFactoryPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
// 保存直接实现了BeanFactoryPostProcessor接口和Ordered接口的后置处理器
List<String> orderedPostProcessorNames = new ArrayList<>();
// 保存直接实现了BeanFactoryPostProcessor接口的后置处理器，不包括那些实现了排序接口的类
List<String> nonOrderedPostProcessorNames = new ArrayList<>();
// 把所有BeanFactoryPostProcessor进行分类
for (String ppName : postProcessorNames) {
	// 拿到的BeanFactoryPostProcessor包括了BeanDefinitionRegistryPostProcessor，所以要跳过
	if (processedBeans.contains(ppName)) {
		// skip - already processed in first phase above
	}
	else if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
		priorityOrderedPostProcessors.add(beanFactory.getBean(ppName, BeanFactoryPostProcessor.class));
	}
	else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
		orderedPostProcessorNames.add(ppName);
	}
	else {
		nonOrderedPostProcessorNames.add(ppName);
	}
}

// First, invoke the BeanFactoryPostProcessors that implement PriorityOrdered.
// 先执行实现了PriorityOrdered接口的BeanFactoryPostProcessor
sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory);

// Next, invoke the BeanFactoryPostProcessors that implement Ordered.
// 再执行实现了Ordered接口的BeanFactoryPostProcessor
List<BeanFactoryPostProcessor> orderedPostProcessors = new ArrayList<>(orderedPostProcessorNames.size());
for (String postProcessorName : orderedPostProcessorNames) {
	orderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
}
sortPostProcessors(orderedPostProcessors, beanFactory);
invokeBeanFactoryPostProcessors(orderedPostProcessors, beanFactory);

// Finally, invoke all other BeanFactoryPostProcessors.
// 最后执行普通的BeanFactoryPostProcessor
List<BeanFactoryPostProcessor> nonOrderedPostProcessors = new ArrayList<>(nonOrderedPostProcessorNames.size());
for (String postProcessorName : nonOrderedPostProcessorNames) {
	nonOrderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
}
invokeBeanFactoryPostProcessors(nonOrderedPostProcessors, beanFactory);

// 到此，所有的BeanFactoryPostProcessor都执行完了
// 对于BeanFactoryPostProcessor可以这么理解：它是去完善BeanFactory的，比如向BeanFactory中去注册BeanDefinition
// 就好比：BeanFactory是一张白纸，每个BeanFactoryPostProcessor都去这张白纸上去画上一笔，这个白纸就丰满了

// 所以这段代码，虽然内容很多，但是在默认情况下，主要就是执行了ConfigurationClassPostProcessor
// 1. 先执行了ConfigurationClassPostProcessor的postProcessBeanDefinitionRegistry方法，基本上就是去注册BeanDefinition
// 2. 然后执行了ConfigurationClassPostProcessor的postProcessBeanFactory方法

// Clear cached merged bean definitions since the post-processors might have
// modified the original metadata, e.g. replacing placeholders in values...
beanFactory.clearMetadataCache();
Bean的生命周期- Bean的整个生命周期- Bean的属性填充- 依赖注入
java
1
Bean的创建到属性填充等都是在finishBeanFactoryInitialization方法内执行的,而这里面的核心又在beanFactory.preInstantiateSingletons();

进入方法,看下源码

java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
// 里面放着所有bean
List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);

// Trigger initialization of all non-lazy singleton beans...
// 循环bd，实例化单例bean
for (String beanName : beanNames) {  // userService
	// 对beanDefinition进行合并，基于合并后的BeanDefinition去创建bean
	RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);

	// 判断是否非抽象，单例，非懒加载
	if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {

		// 判断是不是一个SmartFactoryBean
		if (isFactoryBean(beanName)) {
			//  如果是一个FactoryBean，那么则获取LubanFactoryBean对象
			Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
			if (bean instanceof FactoryBean) {
				final FactoryBean<?> factory = (FactoryBean<?>) bean;
				boolean isEagerInit;
				// eager：急切的意思，立马初始化
				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) {
					// 根据beanName去生成FactoryBean中所生成的Bean对象
					getBean(beanName);
				}
			}
		}
		else {
			// 根据beanName去创建bean
			getBean(beanName);
		}
	}
}

getBean的方法走了一堆判断,默认一个空且singleton的bean会先去createBean(好像是废话),然后就到了我刚刚说的秘密: do开头的都是真正干活的

doCreateBean,来看下源码

java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
 // Instantiate the bean.
BeanWrapper instanceWrapper = null;
if (mbd.isSingleton()) {
	// factoryBeanObjectCache：存的是beanName对应的FactoryBean.getObject()所返回的对象
	// factoryBeanInstanceCache：存的是beanName对应的FactoryBean实例对象
	instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
}

// 2、实例化
if (instanceWrapper == null) {
	// 创建bean实例  new USerSerive()
	instanceWrapper = createBeanInstance(beanName, mbd, args);
}

// 原始对象
final Object bean = instanceWrapper.getWrappedInstance();
Class<?> beanType = instanceWrapper.getWrappedClass();
if (beanType != NullBean.class) {
	mbd.resolvedTargetType = beanType;
}

// Allow post-processors to modify the merged bean definition.
synchronized (mbd.postProcessingLock) {
	if (!mbd.postProcessed) {
		try {
			// 运行修改合并好了的BeanDefinition
			// 这里会查找@Autowired的注入点(InjectedElement)，并把这些注入点添加到mbd的属性externallyManagedConfigMembers中
			applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
		}
		catch (Throwable ex) {
			throw new BeanCreationException(mbd.getResourceDescription(), beanName,
					"Post-processing of merged bean definition failed", ex);
		}
		mbd.postProcessed = true;
	}
}

// Eagerly cache singletons to be able to resolve circular references
// even when triggered by lifecycle interfaces like BeanFactoryAware.
// 如果当前创建的是单例bean，并且允许循环依赖，并且还在创建过程中，那么则提早暴露
boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
		isSingletonCurrentlyInCreation(beanName));
if (earlySingletonExposure) {
	if (logger.isTraceEnabled()) {
		logger.trace("Eagerly caching bean '" + beanName +
				"' to allow for resolving potential circular references");
	}
	// 此时的bean还没有完成属性注入，是一个非常简单的对象
	// 构造一个对象工厂添加到singletonFactories中
	// 第四次调用后置处理器
	addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));  // AService
}

// Initialize the bean instance.
// 对象已经暴露出去了
Object exposedObject = bean;
try {
	// 3、填充属性 @Autowired
	populateBean(beanName, mbd, instanceWrapper);  //

	// 4、 初始化 和 BeanPostProcessor 正常AOP  BeanPostProcessor
	exposedObject = initializeBean(beanName, exposedObject, mbd);
}
catch (Throwable ex) {
	if (ex instanceof BeanCreationException && beanName.equals(((BeanCreationException) ex).getBeanName())) {
		throw (BeanCreationException) ex;
	}
	else {
		throw new BeanCreationException(
				mbd.getResourceDescription(), beanName, "Initialization of bean failed", ex);
	}
}

  • 实例化bean:createBeanInstance->BeanUtils.instantiateClass(constructorToUse);(反射)

  • 属性填充:populateBean

依赖注入也是在populateBean中完成的,看下源码

java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
// 是否在BeanDefinition中设置了属性值
PropertyValues pvs = (mbd.hasPropertyValues() ? mbd.getPropertyValues() : null);

//  autowire属性
int resolvedAutowireMode = mbd.getResolvedAutowireMode();  // BeanDefinition AutowireMode
if (resolvedAutowireMode == AUTOWIRE_BY_NAME || resolvedAutowireMode == AUTOWIRE_BY_TYPE) {
	// by_name是根据根据属性名字找bean
	// by_type是根据属性所对应的set方法的参数类型找bean
	// 找到bean之后都要调用set方法进行注入

	MutablePropertyValues newPvs = new MutablePropertyValues(pvs);
	// Add property values based on autowire by name if applicable.
	if (resolvedAutowireMode == AUTOWIRE_BY_NAME) {
		autowireByName(beanName, mbd, bw, newPvs);
	}
	// Add property values based on autowire by type if applicable.
	if (resolvedAutowireMode == AUTOWIRE_BY_TYPE) {
		autowireByType(beanName, mbd, bw, newPvs);
	}
	pvs = newPvs;

	// 总结一下
	// 其实就是Spring自动的根据某个类中的set方法来找bean，byName就是根据某个set方法所对应的属性名去找bean
	// byType，就是根据某个set方法的参数类型去找bean
	// 注意，执行完这里的代码之后，这是把属性以及找到的值存在了pvs里面，并没有完成反射赋值
}

// 执行完了Spring的自动注入之后，就开始解析@Autowired，这里叫做实例化回调
boolean hasInstAwareBpps = hasInstantiationAwareBeanPostProcessors();
boolean needsDepCheck = (mbd.getDependencyCheck() != AbstractBeanDefinition.DEPENDENCY_CHECK_NONE);


// @Autowired注解的 AutowiredAnnotationBeanPostProcessor
// @Resource注解的 CommonAnnotationBeanPostProcessor
PropertyDescriptor[] filteredPds = null;
if (hasInstAwareBpps) {
	if (pvs == null) {
		pvs = mbd.getPropertyValues();
	}
	for (BeanPostProcessor bp : getBeanPostProcessors()) {
		if (bp instanceof InstantiationAwareBeanPostProcessor) {
			InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;

			// 调用BeanPostProcessor分别解析@Autowired、@Resource、@Value，得到属性值
			PropertyValues pvsToUse = ibp.postProcessProperties(pvs, bw.getWrappedInstance(), beanName);

			if (pvsToUse == null) {
				if (filteredPds == null) {
					filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
				}
				pvsToUse = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);
				if (pvsToUse == null) {
					return;
				}
			}
			pvs = pvsToUse;
		}
	}
}
if (needsDepCheck) {
	if (filteredPds == null) {
		filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
	}
	checkDependencies(beanName, mbd, filteredPds, pvs);
}

if (pvs != null) {
	// pvs存的就是属性已经对应的值
	applyPropertyValues(beanName, mbd, bw, pvs);
}

属性填充结束之后就会去调用Aware接口->BeanPostProcessor的before方法->bean的初始化方法(是否实现InitializingBean或者{init-method或@PostConstruct})->BeanPostProcessor的after方法,最终得到完整的Bean

  • 执行Aware接口方法:invokeAwareMethods
  • 初始化前:applyBeanPostProcessorsBeforeInitialization
  • 初始化:invokeInitMethods
  • 初始化后:applyBeanPostProcessorsAfterInitialization