diff --git a/README.md b/README.md
index f88c4f1..934d74c 100644
--- a/README.md
+++ b/README.md
@@ -136,7 +136,7 @@
-## 源码【12.21更新】
+## 源码【01.01更新】
@@ -144,7 +144,7 @@
[02.第2章-后置工厂处理器和Bean生命周期](docs/spring-sourcecode-v1/02.第2章-后置工厂处理器和Bean生命周期.md)
-
+[03.第3章-后置处理器和Bean生命周期](docs/spring-sourcecode-v1/03.第3章-后置处理器和Bean生命周期.md)
# Netty
diff --git a/docs/os/操作系统-IO与零拷贝.md b/docs/os/操作系统-IO与零拷贝.md
index a5f2838..286d37b 100644
--- a/docs/os/操作系统-IO与零拷贝.md
+++ b/docs/os/操作系统-IO与零拷贝.md
@@ -9,7 +9,7 @@ categories:
- 操作系统
keywords: 操作系统，IO，零拷贝
description: 基本面试会问到的IO进行了详解，同时本篇文章也对面试以及平时工作中会看到的零拷贝进行了充分的解析。万字长文系列，读到就是赚到。
-cover: 'https://unpkg.zhimg.com/youthlql@1.0.0/os/os_logo.jpg'
+cover: 'https://unpkg.zhimg.com/youthlql@1.0.9/os/os_logo.jpg'
abbrlink: e959db2e
date: 2021-04-08 15:21:58
---
@@ -47,7 +47,7 @@ date: 2021-04-08 15:21:58
3. 而在用户进程这边，整 个进程会被阻塞。当**内核**一直等到数据准备好了，它就会将数据从**内核**中拷贝到用户内存，然后**内核**返回果，用户进程才解除 block的状态，重新运行起来。
4. **所以，blocking IO的特点就是在IO执行的两个阶段都被block了。**
-
+
@@ -58,7 +58,7 @@ date: 2021-04-08 15:21:58
3. 虽然用户线程每次发起IO请求后可以立即返回，但是为了等到数据，仍需要不断地轮询、重复请求，消耗了大量的CPU的资源。一般很少直接使用这种模型，而是在其他IO模型中使用非阻塞IO这一特性。
4. **所以，用户进程第一个阶段不是阻塞的,需要不断的主动询问内核数据好了没有；第二个阶段依然总是阻塞的。**
-
+
@@ -76,7 +76,7 @@ date: 2021-04-08 15:21:58
2. 它的基本原理就是select /epoll这个函数会不断的轮询所负责的所有socket，当某个socket有数据到达了，就通知用户进程，正式发起read请求。
3. 从流程上来看，使用select函数进行IO请求和同步阻塞模型没有太大的区别，甚至还多了添加监视socket，以及调用select函数的额外操作，效率更差。但是，使用select以后最大的优势是用户可以在一个线程内同时处理多个socket的IO请求。用户可以注册多个socket，然后不断地调用select读取被激活的socket(也就是数据准备好了的socket)，即可达到在同一个线程内同时处理多个IO请求的目的。而在同步阻塞模型中，必须通过多线程的方式才能达到这个目的。
-
+
**select函数**
@@ -106,7 +106,7 @@ date: 2021-04-08 15:21:58
3. 而另一方面，从**内核**的角度，当它受到一个异步读之后，首先它会立刻返回，所以不会对用户进程产生任何阻塞。然后，内核会等待数据准备完成，然后将数据拷贝到用户内存，当这一切都 完成之后，**内核**会给用户进程发送一个信号，告诉它read操作完成了，用户线程直接使用即可。 在这整个过程中，进程完全没有被阻塞。
4. 异步IO模型使用了Proactor设计模式实现了这一机制。**(具体怎么搞得，看上面的文章链接)**
-
+
diff --git a/docs/spring-sourcecode-v1/03.第3章-后置处理器和Bean生命周期.md b/docs/spring-sourcecode-v1/03.第3章-后置处理器和Bean生命周期.md
new file mode 100644
index 0000000..3b312ac
--- /dev/null
+++ b/docs/spring-sourcecode-v1/03.第3章-后置处理器和Bean生命周期.md
@@ -0,0 +1,1540 @@
+---
+title: Spring源码系列-第3章-后置处理器和Bean生命周期
+tags:
+ - Spring源码
+categories:
+ - Spring
+ - 源码V1
+keywords: Spring，框架，spring源码
+description: 前面讲了Bean工厂后置处理器，这一篇开始讲Bean后置处理器
+cover: 'https://gitee.com/youthlql/randombg/raw/master/logo/spring.png'
+abbrlink: 66c146e7
+date: 2022-01-01 00:01:02
+---
+
+
+# 第3章-后置处理器和Bean生命周期
+
+## 再来看一下我们的测试类
+
+> 为了分析后面的，测试类有些许变动
+
+### MyBeanPostProcessor
+
+```java
+@Component
+public class MyBeanPostProcessor implements BeanPostProcessor {
+ public MyBeanPostProcessor() {
+ System.out.println("MyBeanPostProcessor...");
+ }
+
+ public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
+ System.out.println("MyBeanPostProcessor...postProcessAfterInitialization..." + bean + "==>" + beanName);
+ return bean;
+ }
+
+ public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
+ System.out.println("MyBeanPostProcessor...postProcessBeforeInitialization..." + bean + "==>" + beanName);
+ return bean; // new Object();
+ }
+}
+```
+
+### MyInstantiationAwareBeanPostProcessor
+
+```java
+@Component
+public class MyInstantiationAwareBeanPostProcessor implements InstantiationAwareBeanPostProcessor {
+ public MyInstantiationAwareBeanPostProcessor() {
+ System.out.println("MyInstantiationAwareBeanPostProcessor...");
+ } //初始化之前进行后置处理，Spring留给我们给这个组件创建对象的回调。
+
+ public Object postProcessBeforeInstantiation(Class beanClass, String beanName) throws BeansException {
+ System.out.println("MyInstantiationAwareBeanPostProcessor...postProcessBeforeInstantiation=>" + beanClass + "--" + beanName); //if(class.isAssFrom(Cat.class)){return new Dog()}
+ return null; //如果我们自己创建了对象返回。Spring则不会帮我们创建对象，用我们自己创建的对象？ 我们创建的这个对象，Spring会保存单实例？还是每次getBean都调到我们这里创建一个新的？
+ }
+
+ public boolean postProcessAfterInstantiation(Object bean, String beanName) throws BeansException {
+ System.out.println("MyInstantiationAwareBeanPostProcessor...postProcessAfterInstantiation=>" + bean + "--" + beanName); //提前改变一些Spring不管的bean里面的属性
+ return true; //返回false则bean的赋值全部结束
+ } //解析自定义注解进行属性值注入；pvs 封装了所有的属性信息。
+
+ public PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName)
+ throws BeansException {
+ System.out.println("MyInstantiationAwareBeanPostProcessor...postProcessProperties=>" + bean + "--" + beanName);
+ return null;
+ }
+}
+```
+
+### MyMergedBeanDefinitionPostProcessor
+
+```java
+@Component
+public class MyMergedBeanDefinitionPostProcessor implements MergedBeanDefinitionPostProcessor {
+ public MyMergedBeanDefinitionPostProcessor() {
+ System.out.println("MyMergedBeanDefinitionPostProcessor...");
+ }
+
+ @Override
+ public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
+ System.out.println("MyMergedBeanDefinitionPostProcessor...postProcessBeforeInitialization...=>" + bean + "--" + beanName);
+ return bean; //null
+ }
+
+ @Override
+ public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
+ System.out.println("MyMergedBeanDefinitionPostProcessor...postProcessAfterInitialization..=>" + bean + "--" + beanName);
+ return null;
+ }
+
+ @Override
+ public void postProcessMergedBeanDefinition(RootBeanDefinition beanDefinition, Class beanType, String beanName) {
+ System.out.println("MyMergedBeanDefinitionPostProcessor...postProcessMergedBeanDefinition..=>" + beanName + "--" + beanType + "---" + beanDefinition);
+ }
+
+ @Override
+ public void resetBeanDefinition(String beanName) {
+ System.out.println("MyMergedBeanDefinitionPostProcessor...resetBeanDefinition.." + beanName);
+
+ }
+}
+```
+
+### MySmartInstantiationAwareBeanPostProcessor
+
+```java
+@Component //bean进行代理增强期间进行使用
+public class MySmartInstantiationAwareBeanPostProcessor implements SmartInstantiationAwareBeanPostProcessor {
+
+ public MySmartInstantiationAwareBeanPostProcessor() {
+ System.out.println("MySmartInstantiationAwareBeanPostProcessor...");
+ } //预测bean的类型，最后一次改变组件类型。
+
+ public Class predictBeanType(Class beanClass, String beanName) throws BeansException {
+ System.out.println("MySmartInstantiationAwareBeanPostProcessor...predictBeanType=>" + beanClass + "--" + beanName);
+ return null;
+ }
+
+ //返回我们要使用的构造器候选列表
+ public Constructor[] determineCandidateConstructors(Class beanClass, String beanName)
+ throws BeansException {
+ System.out.println("MySmartInstantiationAwareBeanPostProcessor...determineCandidateConstructors=>" + beanClass + "--" + beanName);
+ //返回一个我们指定的构造器
+ return null;
+ }
+
+ //返回早期的bean引用
+ public Object getEarlyBeanReference(Object bean, String beanName) throws BeansException {
+ System.out.println("MySmartInstantiationAwareBeanPostProcessor...getEarlyBeanReference=>" + bean + "--" + beanName);
+
+ return bean;
+ }
+
+}
+```
+
+
+
+### MyBeanFactoryPostProcessor
+
+```java
+/**
+ * BeanFactory的后置处理器
+ */
+@Component
+public class MyBeanFactoryPostProcessor implements BeanFactoryPostProcessor {
+
+ public MyBeanFactoryPostProcessor(){
+ System.out.println("MyBeanFactoryPostProcessor...");
+ }
+
+ @Override
+ public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
+ System.out.println("BeanFactoryPostProcessor....postProcessBeanFactory==>"+beanFactory);
+ }
+}
+```
+
+### MyBeanDefinitionRegistryPostProcessor
+
+```java
+@Component
+public class MyBeanDefinitionRegistryPostProcessor implements BeanDefinitionRegistryPostProcessor {
+
+ public MyBeanDefinitionRegistryPostProcessor(){
+ System.out.println("MyBeanDefinitionRegistryPostProcessor");
+ }
+
+ @Override //紧接着执行
+ public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
+ System.out.println("MyBeanDefinitionRegistryPostProcessor....postProcessBeanFactory...");
+ }
+
+ @Override //先执行的
+ public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException {
+ System.out.println("MyBeanDefinitionRegistryPostProcessor...postProcessBeanDefinitionRegistry...");
+ //增强bean定义信息的注册中心，比如自己注册组件
+
+ }
+}
+```
+
+### Cat
+
+```java
+@Component
+public class Cat implements InitializingBean {
+
+ public Cat() {
+ System.out.println("cat被创建了...");
+ }
+
+ private String name;
+
+
+ @Value("${JAVA_HOME}") //自动赋值功能
+ public void setName(String name) {
+ System.out.println("cat....setName正在赋值调用....");
+ this.name = name;
+ }
+
+ //注解怎么定义这个是初始化方法？
+ public String getName() {
+ return name;
+ }
+
+ @Override
+ public void afterPropertiesSet() throws Exception {
+ System.out.println("CatInitializingBean..afterPropertiesSet...");
+ }
+}
+```
+
+### beans2.xml
+
+```java
+
+
+
+
+
+
+
+```
+
+### MainTest
+
+```java
+public class MainTest {
+
+ public static void main(String[] args) {
+ ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("beans2.xml");
+ Person bean = context.getBean(Person.class);
+ System.out.println(bean);
+ }
+
+}
+```
+
+
+
+
+
+## 继续Bean生命周期
+
+
+
+### 流程图-Bean生命周期与后置处理器
+
+
+
+### BeanPostProcessor-执行无参构造
+
+> 前面两个工厂后置处理器执行完之后，接下来就是我们的Bean后置处理器，第一个执行的就是BeanPostProcessor
+
+#### Debug调用栈
+
+
+
+#### AbstractApplicationContext#registerBeanPostProcessors()注册Bean后置处理器
+
+```java
+protected void registerBeanPostProcessors(ConfigurableListableBeanFactory beanFactory) {
+ PostProcessorRegistrationDelegate.registerBeanPostProcessors(beanFactory, this);
+}
+```
+
+#### PostProcessorRegistrationDelegate#registerBeanPostProcessors()
+
+```java
+ public static void registerBeanPostProcessors(
+ ConfigurableListableBeanFactory beanFactory, AbstractApplicationContext applicationContext) {
+
+ //获取到容器中所有的 BeanPostProcessor； Bean的后置处理器
+ String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false);
+
+ // Register BeanPostProcessorChecker that logs an info message when
+ // a bean is created during BeanPostProcessor instantiation, i.e. when
+ // a bean is not eligible for getting processed by all BeanPostProcessors.
+ int beanProcessorTargetCount = beanFactory.getBeanPostProcessorCount() + 1 + postProcessorNames.length;
+ beanFactory.addBeanPostProcessor(new BeanPostProcessorChecker(beanFactory, beanProcessorTargetCount));
+
+ // Separate between BeanPostProcessors that implement PriorityOrdered,
+ // Ordered, and the rest.
+ List priorityOrderedPostProcessors = new ArrayList<>();
+ List internalPostProcessors = new ArrayList<>();
+ List orderedPostProcessorNames = new ArrayList<>();
+ List nonOrderedPostProcessorNames = new ArrayList<>();
+ for (String ppName : postProcessorNames) {
+ if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) { //获取所有实现了 PriorityOrdered 的 BeanPostProcessor
+ BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
+ priorityOrderedPostProcessors.add(pp);
+ if (pp instanceof MergedBeanDefinitionPostProcessor) {
+ internalPostProcessors.add(pp);
+ }
+ }
+ else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
+ orderedPostProcessorNames.add(ppName);
+ }
+ else {
+ nonOrderedPostProcessorNames.add(ppName);
+ }
+ }
+
+ //首先，注册所有的实现了 PriorityOrdered 的 BeanPostProcessor ； First, register the BeanPostProcessors that implement PriorityOrdered.
+ sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
+ registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);
+
+ //接下来，注册所有的实现了 Ordered 的 BeanPostProcessor Next, register the BeanPostProcessors that implement Ordered.
+ List orderedPostProcessors = new ArrayList<>(orderedPostProcessorNames.size());
+ for (String ppName : orderedPostProcessorNames) {
+ BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
+ orderedPostProcessors.add(pp);
+ if (pp instanceof MergedBeanDefinitionPostProcessor) {
+ internalPostProcessors.add(pp);
+ }
+ }
+ sortPostProcessors(orderedPostProcessors, beanFactory);
+ registerBeanPostProcessors(beanFactory, orderedPostProcessors);
+
+ // 最后，注册所有普通的 BeanPostProcessor ；Now, register all regular BeanPostProcessors.
+ List nonOrderedPostProcessors = new ArrayList<>(nonOrderedPostProcessorNames.size());
+ for (String ppName : nonOrderedPostProcessorNames) {
+ BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class); //从容器中获取这个组件
+ nonOrderedPostProcessors.add(pp);
+ if (pp instanceof MergedBeanDefinitionPostProcessor) {
+ internalPostProcessors.add(pp);
+ }
+ }
+ registerBeanPostProcessors(beanFactory, nonOrderedPostProcessors);//所谓的注册其实就是保存到一个Map里面，后续用的时候可以直接拿
+
+ // Finally, re-register all internal BeanPostProcessors.
+ sortPostProcessors(internalPostProcessors, beanFactory);
+ registerBeanPostProcessors(beanFactory, internalPostProcessors);
+
+ // Re-register post-processor for detecting inner beans as ApplicationListeners,
+ // moving it to the end of the processor chain (for picking up proxies etc).
+ beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext));
+ }
+```
+
+- Bean工厂后置处理器调用的是`invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory , List )`
+- Bean后置处理器调用的是`registerBeanPostProcessors(ConfigurableListableBeanFactory , AbstractApplicationContext )`
+
+
+
+
+
+### InstantiationAwareBeanPostProcessor-执行无参构造
+
+> 1. BeanPostProcessor执行顺序和BeanFactoryPostProcessor有点不一样
+> 2. BeanFactoryPostProcessor是先执行完每一个的无参构造和实现的几个方法，再去执行下一个BeanFactoryPostProcessor
+> 3. BeanPostProcessor是先执行所有BeanPostProcessor的无参构造，再执行所有BeanPostProcessor实现的方法。
+
+
+
+### MergedBeanDefinitionPostProcessor-执行无参构造
+
+同上
+
+### SmartInstantiationAwareBeanPostProcessor-执行无参构造
+
+同上
+
+
+
+
+
+
+
+### SmartInstantiationAwareBeanPostProcessor-执行predictBeanType方法
+
+#### Debug调用栈
+
+
+
+
+
+#### AbstractApplicationContext#refresh()
+
+```java
+ @Override //容器刷新的十二大步。
+ public void refresh() throws BeansException, IllegalStateException {
+ synchronized (this.startupShutdownMonitor) {
+ StartupStep contextRefresh = this.applicationStartup.start("spring.context.refresh");
+
+ // Prepare this context for refreshing.
+ prepareRefresh();
+
+ // Tell the subclass to refresh the internal bean factory.
+ // 工厂创建：BeanFactory第一次开始创建的时候,有xml解析逻辑。
+ ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
+
+ // Prepare the bean factory for use in this context.
+ prepareBeanFactory(beanFactory);
+
+ try {
+ // Allows post-processing of the bean factory in context subclasses.
+ postProcessBeanFactory(beanFactory);
+
+ StartupStep beanPostProcess = this.applicationStartup.start("spring.context.beans.post-process");
+ //工厂增强：执行所有的BeanFactory后置增强器；利用BeanFactory后置增强器对工厂进行修改或者增强,配置类会在这里进行解析。 Invoke factory processors registered as beans in the context.
+ invokeBeanFactoryPostProcessors(beanFactory);
+
+ //注册所有的Bean的后置处理器 Register bean processors that intercept bean creation.
+ registerBeanPostProcessors(beanFactory);
+ beanPostProcess.end();
+
+ // Initialize message source for this context.
+ initMessageSource();
+
+ // Initialize event multicaster for this context.
+ initApplicationEventMulticaster();
+
+ // Initialize other special beans in specific context subclasses.
+ onRefresh();
+
+ //注册监听器，从容器中获取所有的ApplicationListener； Check for listener beans and register them.
+ registerListeners();
+
+ // Instantiate all remaining (non-lazy-init) singletons.
+ //bean创建；完成 BeanFactory 初始化。（工厂里面所有的组件都好了）
+ finishBeanFactoryInitialization(beanFactory);
+
+ // Last step: publish corresponding event.
+ finishRefresh();
+ }
+
+ catch (BeansException ex) {
+ if (logger.isWarnEnabled()) {
+ logger.warn("Exception encountered during context initialization - " +
+ "cancelling refresh attempt: " + ex);
+ }
+
+ // Destroy already created singletons to avoid dangling resources.
+ destroyBeans();
+
+ // Reset 'active' flag.
+ cancelRefresh(ex);
+
+ // Propagate exception to caller.
+ throw ex;
+ }
+
+ finally {
+ // Reset common introspection caches in Spring's core, since we
+ // might not ever need metadata for singleton beans anymore...
+ resetCommonCaches();
+ contextRefresh.end();
+ }
+ }
+ }
+
+
+ protected void registerListeners() {
+ // Register statically specified listeners first.
+ for (ApplicationListener listener : getApplicationListeners()) {
+ getApplicationEventMulticaster().addApplicationListener(listener);
+ }
+
+ // Do not initialize FactoryBeans here: We need to leave all regular beans
+ // uninitialized to let post-processors apply to them! 获取ApplicationListener在ioc容器中注册的bean的名字
+ String[] listenerBeanNames = getBeanNamesForType(ApplicationListener.class, true, false);
+ for (String listenerBeanName : listenerBeanNames) {
+ getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName); //获取所有的容器中的监听器，并保存他们的名字
+ }
+
+ // Publish early application events now that we finally have a multicaster...
+ Set earlyEventsToProcess = this.earlyApplicationEvents;
+ this.earlyApplicationEvents = null;
+ if (!CollectionUtils.isEmpty(earlyEventsToProcess)) {
+ for (ApplicationEvent earlyEvent : earlyEventsToProcess) {
+ getApplicationEventMulticaster().multicastEvent(earlyEvent);
+ }
+ }
+ }
+```
+
+在调用registerListeners()的时候，竟然进入到了我们的后置处理器逻辑，我们接着往后看
+
+#### DefaultListableBeanFactory#doGetBeanNamesForType()获取某一个组件在容器中的名字
+
+调过一些不重要的调用，逻辑到了这里
+
+```java
+ //获取某一个组件在容器中的名字。
+ private String[] doGetBeanNamesForType(ResolvableType type, boolean includeNonSingletons, boolean allowEagerInit) {
+ List result = new ArrayList<>();
+
+ // Check all bean definitions. 因为Spring没有直接保存class--bean名字的对应信息，只能遍历所有的beanname，拿出他们beanname的定义信息，再看是否我指定的类型。
+ for (String beanName : this.beanDefinitionNames) {
+ // Only consider bean as eligible if the bean name is not defined as alias for some other bean.
+ if (!isAlias(beanName)) { //判断是否别名
+ try {
+ RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
+ // Only check bean definition if it is complete.
+ if (!mbd.isAbstract() && (allowEagerInit ||
+ (mbd.hasBeanClass() || !mbd.isLazyInit() || isAllowEagerClassLoading()) &&
+ !requiresEagerInitForType(mbd.getFactoryBeanName()))) {
+ boolean isFactoryBean = isFactoryBean(beanName, mbd); //是否FactoryBean
+ BeanDefinitionHolder dbd = mbd.getDecoratedDefinition();
+ boolean matchFound = false;
+ boolean allowFactoryBeanInit = (allowEagerInit || containsSingleton(beanName));
+ boolean isNonLazyDecorated = (dbd != null && !mbd.isLazyInit());
+ if (!isFactoryBean) {
+ if (includeNonSingletons || isSingleton(beanName, mbd, dbd)) {
+ matchFound = isTypeMatch(beanName, type, allowFactoryBeanInit); //是否类型匹配？
+ }
+ }
+ else {
+ if (includeNonSingletons || isNonLazyDecorated ||
+ (allowFactoryBeanInit && isSingleton(beanName, mbd, dbd))) {
+ matchFound = isTypeMatch(beanName, type, allowFactoryBeanInit);
+ }
+ if (!matchFound) {
+ // In case of FactoryBean, try to match FactoryBean instance itself next.
+ beanName = FACTORY_BEAN_PREFIX + beanName;
+ matchFound = isTypeMatch(beanName, type, allowFactoryBeanInit);
+ }
+ }
+ if (matchFound) {
+ result.add(beanName);
+ }
+ }
+ }
+ // ......
+ }
+ }
+ // ......
+
+ return StringUtils.toStringArray(result);
+ }
+```
+
+1. 下面是容器中现在有的bean定义信息，但是这些bean不一定都创建好了。
+2. Spring在这里是想要按照类型去容器中去找组件，在这里就是想找ApplicationListener.class类型的组件。但是Spring中只存储了BeanName=>BeanType的对应关系（BeanDefinitions），没有存BeanType=>BeanName的对应关系。
+ 1. 所以在这里只能遍历循环beanDefinitionNames
+ 2. 通过beanName再去BeanDefinitions拿beanType
+ 3. 判断是不是想要的类型。
+3. 这里有没有优化空间，再存一个BeanType=>BeanName的对应关系？但是这样的关系是一对多的，同一个BeanType下可能有多个beanName，Spring可能是考虑到空间成本，没有这样弄。
+
+
+
+
+
+#### AbstractBeanFactory#isTypeMatch()
+
+1. 有一个小细节，在debug的时候我们发现这里，只有Cat类进入到了后续判断，为什么上面的其它9个类没有进入后续逻辑呢？
+
+这里是因为其它9个对象都已经在之前创建好了对象，只有Cat还没有创建对象。Spring在这里给我们一个机会，在对象创建之前，我们可以最后一次决定Cat的类型。什么意思？往后看
+
+2. 我们来看看此时单例池里有哪些对象
+
+
+
+```java
+ protected boolean isTypeMatch(String name, ResolvableType typeToMatch, boolean allowFactoryBeanInit)
+ throws NoSuchBeanDefinitionException {
+
+ String beanName = transformedBeanName(name);
+ boolean isFactoryDereference = BeanFactoryUtils.isFactoryDereference(name);
+
+ // 检查是否已经有这个beanName的单例对象，有了直接用对象的Class，没有可以最后一次决定这个组件的类型；SmartInstantiationAwareBeanPostProcessor.predictBeanType() Check manually registered singletons.
+ Object beanInstance = getSingleton(beanName, false);
+ if (beanInstance != null && beanInstance.getClass() != NullBean.class) {
+ if (beanInstance instanceof FactoryBean) {
+ if (!isFactoryDereference) {
+ Class type = getTypeForFactoryBean((FactoryBean) beanInstance);
+ return (type != null && typeToMatch.isAssignableFrom(type));
+ }
+ else {
+ return typeToMatch.isInstance(beanInstance);
+ }
+ }
+ else if (!isFactoryDereference) {
+ if (typeToMatch.isInstance(beanInstance)) {
+ // Direct match for exposed instance?
+ return true;
+ }
+ else if (typeToMatch.hasGenerics() && containsBeanDefinition(beanName)) {
+ // ......
+ return (resolvableType != null && typeToMatch.isAssignableFrom(resolvableType));
+ }
+ }
+ return false;
+ }
+ else if (containsSingleton(beanName) && !containsBeanDefinition(beanName)) {
+ // null instance registered
+ return false;
+ }
+
+ // No singleton instance found -> check bean definition.
+ BeanFactory parentBeanFactory = getParentBeanFactory();
+ if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
+ // No bean definition found in this factory -> delegate to parent.
+ return parentBeanFactory.isTypeMatch(originalBeanName(name), typeToMatch);
+ }
+
+ // Retrieve corresponding bean definition.
+ RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
+ BeanDefinitionHolder dbd = mbd.getDecoratedDefinition();
+
+ // Setup the types that we want to match against
+ Class classToMatch = typeToMatch.resolve();
+ if (classToMatch == null) {
+ classToMatch = FactoryBean.class;
+ }
+ Class[] typesToMatch = (FactoryBean.class == classToMatch ?
+ new Class[] {classToMatch} : new Class[] {FactoryBean.class, classToMatch});
+
+
+ // Attempt to predict the bean type
+ Class predictedType = null;
+
+ if (!isFactoryDereference && dbd != null && isFactoryBean(beanName, mbd)) {
+ // ...
+ }
+
+ // 通过后置处理器，可以返回自定义的类型 If we couldn't use the target type, try regular prediction.
+ if (predictedType == null) {
+ predictedType = predictBeanType(beanName, mbd, typesToMatch);
+ if (predictedType == null) {
+ return false;
+ }
+ }
+
+ //......
+ // If we don't have a bean type, fallback to the predicted type
+ return typeToMatch.isAssignableFrom(predictedType);
+ }
+```
+
+预测BeanType是什么意思呢？因为每个组件都会经过我们自定义的方法，假设你现在有个Cat类，你可以在这里写个if判断。你可以让猫变成狗，有点类似于指鹿为马
+
+```java
+ public Class predictBeanType(Class beanClass, String beanName) throws BeansException {
+ System.out.println("MySmartInstantiationAwareBeanPostProcessor...predictBeanType=>" + beanClass + "--" + beanName);
+ if(beanClass == Cat.class){
+ return Dog.class;
+ }
+ return null;
+ }
+```
+
+
+
+#### AbstractAutowireCapableBeanFactory#predictBeanType()
+
+```java
+ protected Class predictBeanType(String beanName, RootBeanDefinition mbd, Class... typesToMatch) {
+ Class targetType = determineTargetType(beanName, mbd, typesToMatch);
+ // Apply SmartInstantiationAwareBeanPostProcessors to predict the
+ // eventual type after a before-instantiation shortcut.
+ if (targetType != null && !mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
+ boolean matchingOnlyFactoryBean = typesToMatch.length == 1 && typesToMatch[0] == FactoryBean.class;
+ for (SmartInstantiationAwareBeanPostProcessor bp : getBeanPostProcessorCache().smartInstantiationAware) {
+ // 在这里调用我们自定义的predictBeanType,也就是MySmartInstantiationAwareBeanPostProcessor#predictBeanType
+ Class predicted = bp.predictBeanType(targetType, beanName);//还是可以理解为模板模式
+ if (predicted != null &&
+ (!matchingOnlyFactoryBean || FactoryBean.class.isAssignableFrom(predicted))) {
+ return predicted;
+ }
+ }
+ }
+ return targetType;
+ }
+```
+
+
+
+#### 此方法能做什么？
+
+
+
+1. SmartInstantiationAwareBeanPostProcessor起名为**智能实例化感知后置处理器**，smart也是聪明的意思，表示这是一个聪明的后置处理器
+2. 之所以这样起名，意思是我们可以实现这个接口然后实现它的方法，就可以告诉Spring：我们要使用的构造器候选列表。我们期望它是什么BeanType，甚至可以返回早期的bean引用（后面说）
+3. 那应用场景什么呢？
+ 1. 当一个组件需要代理对象的时候，你如果返回原来的BeanType肯定是不对的，这时候这个功能就起作用了
+ 2. 还有我们可以在这里强制Spring全部使用有参构造器创建我们自己的Bean
+ 3. bean进行代理增强期间这个接口用的比较多
+4. 在Spring中只要调用了`doGetBeanNamesForType方法`或者`getBeanNamesForType方法`，就一定会经过SmartInstantiationAwareBeanPostProcessor的处理
+
+
+
+在此方法里为什么Cat会进来两次呢？往后面看
+
+
+
+### InstantiationAwareBeanPostProcessor-执行postProcessBeforeInstantiation方法
+
+#### Debug调用栈
+
+
+
+#### AbstractApplicationContext#finishBeanFactoryInitialization()完成BeanFactory初始化
+
+```java
+ protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
+ // 给工厂设置好 ConversionService【负责类型转换的组件服务】， Initialize conversion service for this context.
+ if (beanFactory.containsBean(CONVERSION_SERVICE_BEAN_NAME) &&
+ beanFactory.isTypeMatch(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class)) {
+ beanFactory.setConversionService(
+ beanFactory.getBean(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class));
+ }
+
+ // 注册一个默认的值解析器（"${}"） ；Register a default embedded value resolver if no BeanFactoryPostProcessor
+ // (such as a PropertySourcesPlaceholderConfigurer bean) registered any before:
+ // at this point, primarily for resolution in annotation attribute values.
+ if (!beanFactory.hasEmbeddedValueResolver()) {
+ beanFactory.addEmbeddedValueResolver(strVal -> getEnvironment().resolvePlaceholders(strVal));
+ }
+
+ // LoadTimeWeaverAware；aspectj：加载时织入功能【aop】。 Initialize LoadTimeWeaverAware beans early to allow for registering their transformers early.
+ String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
+ for (String weaverAwareName : weaverAwareNames) {
+ getBean(weaverAwareName); //从容器中获取组件，有则直接获取，没则进行创建
+ }
+
+ // Stop using the temporary ClassLoader for type matching.
+ beanFactory.setTempClassLoader(null);
+
+ // Allow for caching all bean definition metadata, not expecting further changes.
+ beanFactory.freezeConfiguration();
+
+ // Instantiate all remaining (non-lazy-init) singletons.
+ //初始化所有的非懒加载的单实例Bean
+ beanFactory.preInstantiateSingletons();
+ }
+```
+
+1. 前面刚说过只要调用`getBeanNamesForType`，就会经过`SmartInstantiationAwareBeanPostProcessor`的处理。
+
+```java
+ //注册监听器，从容器中获取所有的ApplicationListener； Check for listener beans and register them.
+ registerListeners();
+
+ // Instantiate all remaining (non-lazy-init) singletons.
+ //bean创建；完成 BeanFactory 初始化。（工厂里面所有的组件都好了）
+ finishBeanFactoryInitialization(beanFactory);
+```
+
+这两方法都调用了`getBeanNamesForType`，所以上面Cat会打印两次
+
+2. 上面我们也看了只有Cat的对象还没创建，还没初始化，所以下面就开始创建对象了。
+
+
+
+
+
+#### AbstractAutowireCapableBeanFactory#createBean()创建Bean
+
+```java
+ protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
+ throws BeanCreationException {
+
+ if (logger.isTraceEnabled()) {
+ logger.trace("Creating instance of bean '" + beanName + "'");
+ }
+ RootBeanDefinition mbdToUse = mbd;
+
+ // Make sure bean class is actually resolved at this point, and
+ // clone the bean definition in case of a dynamically resolved Class
+ // which cannot be stored in the shared merged bean definition.
+ Class resolvedClass = resolveBeanClass(mbd, beanName);
+ if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
+ mbdToUse = new RootBeanDefinition(mbd);
+ mbdToUse.setBeanClass(resolvedClass);
+ }
+
+ // Prepare method overrides.
+ try {
+ mbdToUse.prepareMethodOverrides();
+ }
+ catch (BeanDefinitionValidationException ex) {
+ throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(),
+ beanName, "Validation of method overrides failed", ex);
+ }
+
+ try {
+ // 提前给我们一个机会，去返回组件的代理对象。 Give BeanPostProcessors a chance to return a proxy instead of the target bean instance.
+ Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
+ if (bean != null) {
+ return bean;
+ }
+ }
+ catch (Throwable ex) {
+ throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName,
+ "BeanPostProcessor before instantiation of bean failed", ex);
+ }
+
+ try { //Spring真正自己创建对象
+ Object beanInstance = doCreateBean(beanName, mbdToUse, args);
+ if (logger.isTraceEnabled()) {
+ logger.trace("Finished creating instance of bean '" + beanName + "'");
+ }
+ return beanInstance;
+ }
+ catch (BeanCreationException | ImplicitlyAppearedSingletonException ex) {
+ // A previously detected exception with proper bean creation context already,
+ // or illegal singleton state to be communicated up to DefaultSingletonBeanRegistry.
+ throw ex;
+ }
+ catch (Throwable ex) {
+ throw new BeanCreationException(
+ mbdToUse.getResourceDescription(), beanName, "Unexpected exception during bean creation", ex);
+ }
+ }
+
+
+
+ @Nullable
+ protected Object resolveBeforeInstantiation(String beanName, RootBeanDefinition mbd) {
+ Object bean = null;
+ if (!Boolean.FALSE.equals(mbd.beforeInstantiationResolved)) {
+ // Make sure bean class is actually resolved at this point.
+ if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
+ Class targetType = determineTargetType(beanName, mbd);
+ if (targetType != null) {
+ bean = applyBeanPostProcessorsBeforeInstantiation(targetType, beanName);
+ if (bean != null) {
+ bean = applyBeanPostProcessorsAfterInitialization(bean, beanName);
+ }
+ }
+ }
+ mbd.beforeInstantiationResolved = (bean != null);
+ }
+ return bean;
+ }
+
+
+ @Nullable
+ protected Object applyBeanPostProcessorsBeforeInstantiation(Class beanClass, String beanName) {
+ for (InstantiationAwareBeanPostProcessor bp : getBeanPostProcessorCache().instantiationAware) {
+ Object result = bp.postProcessBeforeInstantiation(beanClass, beanName); //还是老样子，调用我们自己写的InstantiationAwareBeanPostProcessor
+ if (result != null) {
+ return result;
+ }
+ }
+ return null;
+ }
+```
+
+#### 此方法能做什么？
+
+后置处理器在此处提前给我们一个机会，去返回组件的代理对象
+
+```java
+ public Object postProcessBeforeInstantiation(Class beanClass, String beanName) throws BeansException {
+ System.out.println("MyInstantiationAwareBeanPostProcessor...postProcessBeforeInstantiation=>" + beanClass + "--" + beanName); //if(class.isAssFrom(Cat.class)){return new Dog()}
+ return null; //如果我们自己创建了对象返回。Spring则不会帮我们创建对象，用我们自己创建的对象（可以是代理对象）
+ }
+```
+
+
+
+### SmartInstantiationAwareBeanPostProcessor-执行determineCandidateConstructors方法
+
+#### Debug调用栈
+
+
+
+> 前面还是一样的执行逻辑，直接来到下面
+
+#### AbstractAutowireCapableBeanFactory#doCreateBean()无参构造创建Bean，属性赋值，初始化等
+
+```java
+ protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
+ throws BeanCreationException {
+
+ // Instantiate the bean.
+ BeanWrapper instanceWrapper = null;
+ if (mbd.isSingleton()) { //是否单例的
+ instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
+ }
+ if (instanceWrapper == null) {
+ //创建Bean的实例,默认使用无参构造器创建的对象，组件的原始对象就创建了
+ instanceWrapper = createBeanInstance(beanName, mbd, args);
+ }
+ Object bean = instanceWrapper.getWrappedInstance();
+ Class beanType = instanceWrapper.getWrappedClass();
+ if (beanType != NullBean.class) {
+ mbd.resolvedTargetType = beanType;
+ }
+
+ //允许 后置处理器 再来修改下beanDefinition；MergedBeanDefinitionPostProcessor.postProcessMergedBeanDefinition；； Allow post-processors to modify the merged bean definition.
+ synchronized (mbd.postProcessingLock) {
+ if (!mbd.postProcessed) {
+ try {
+ 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.
+ 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");
+ }
+ addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
+ }
+
+ // Initialize the bean instance.
+ Object exposedObject = bean;
+ try {
+ populateBean(beanName, mbd, instanceWrapper); //给创建好的对象每个属性进行赋值，@Autowired发生在这里
+ exposedObject = initializeBean(beanName, exposedObject, mbd);//初始化bean
+ }
+ // ......
+ return exposedObject;
+ }
+
+```
+
+#### AbstractAutowireCapableBeanFactory#createBeanInstance()使用构造器创建Bean
+
+```java
+ protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) {
+ //获取Bean的类型 Make sure bean class is actually resolved at this point.
+ Class beanClass = resolveBeanClass(mbd, beanName);
+
+ if (beanClass != null && !Modifier.isPublic(beanClass.getModifiers()) && !mbd.isNonPublicAccessAllowed()) {
+ throw new BeanCreationException(mbd.getResourceDescription(), beanName,
+ "Bean class isn't public, and non-public access not allowed: " + beanClass.getName());
+ }
+ //定义Bean的实例提供者
+ Supplier instanceSupplier = mbd.getInstanceSupplier();
+ if (instanceSupplier != null) {
+ return obtainFromSupplier(instanceSupplier, beanName);
+ }
+ //@Bean注解等可能会调用此方法进行创建出来，Spring把@Bean标注的方法理解为工厂方法
+ if (mbd.getFactoryMethodName() != null) {
+ return instantiateUsingFactoryMethod(beanName, mbd, args);
+ }
+
+ //快速创建？ Shortcut when re-creating the same bean...
+ boolean resolved = false;
+ boolean autowireNecessary = false;
+ if (args == null) {
+ synchronized (mbd.constructorArgumentLock) {
+ if (mbd.resolvedConstructorOrFactoryMethod != null) {
+ resolved = true;
+ autowireNecessary = mbd.constructorArgumentsResolved;
+ }
+ }
+ }
+ if (resolved) {
+ if (autowireNecessary) {
+ return autowireConstructor(beanName, mbd, null, null);
+ }
+ else {
+ return instantiateBean(beanName, mbd);
+ }
+ }
+
+ //后置处理器有机会在这里决定当前bean用哪个构造器？SmartInstantiationAwareBeanPostProcessor.determineCandidateConstructors() Candidate constructors for autowiring?
+ Constructor[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
+ if (ctors != null || mbd.getResolvedAutowireMode() == AUTOWIRE_CONSTRUCTOR ||
+ mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args)) {
+ return autowireConstructor(beanName, mbd, ctors, args); //构造器方式的自动注入与对象创建
+ }
+
+ //使用默认的自己设置的高优先级的构造器 Preferred constructors for default construction?
+ ctors = mbd.getPreferredConstructors();
+ if (ctors != null) {
+ return autowireConstructor(beanName, mbd, ctors, null);
+ }
+
+ // 默认使用无参构造器为当前组件创建对象；No special handling: simply use no-arg constructor.
+ return instantiateBean(beanName, mbd);
+ }
+
+
+
+ @Nullable
+ protected Constructor[] determineConstructorsFromBeanPostProcessors(@Nullable Class beanClass, String beanName)
+ throws BeansException {
+
+ if (beanClass != null && hasInstantiationAwareBeanPostProcessors()) {
+ for (SmartInstantiationAwareBeanPostProcessor bp : getBeanPostProcessorCache().smartInstantiationAware) {
+ Constructor[] ctors = bp.determineCandidateConstructors(beanClass, beanName);// 一样的，调我们自定义的
+ if (ctors != null) {
+ return ctors;
+ }
+ }
+ }
+ return null;
+ }
+```
+
+
+
+1. 实例提供者：
+
+
+
+
+
+#### 此方法能做什么？
+
+后置处理器有机会在这里决定当前bean用哪个构造器
+
+```java
+ //返回我们要使用的构造器候选列表
+ public Constructor[] determineCandidateConstructors(Class beanClass, String beanName)
+ throws BeansException {
+ System.out.println("MySmartInstantiationAwareBeanPostProcessor...determineCandidateConstructors=>" + beanClass + "--" + beanName);
+ //返回一个我们指定的构造器
+ return null;
+ }
+```
+
+
+
+### Cat-执行无参构造方法
+
+
+
+
+
+以前讲过。
+
+
+
+### MergedBeanDefinitionPostProcessor-执行postProcessMergedBeanDefinition方法
+
+
+
+#### Debug调用栈
+
+
+
+
+
+
+
+#### 此方法能做什么？
+
+看这个传进来的参数，应该就是能修改下beanDefinition
+
+```java
+ public void postProcessMergedBeanDefinition(RootBeanDefinition beanDefinition, Class beanType, String beanName) {
+ System.out.println("MyMergedBeanDefinitionPostProcessor...postProcessMergedBeanDefinition..=>" + beanName + "--" + beanType + "---" + beanDefinition);
+ }
+```
+
+
+
+### InstantiationAwareBeanPostProcessor-执行postProcessAfterInstantiation方法
+
+#### Debug调用栈
+
+
+
+#### AbstractAutowireCapableBeanFactory#populateBean()属性赋值
+
+```java
+ protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) {
+ if (bw == null) {
+ if (mbd.hasPropertyValues()) {
+ throw new BeanCreationException(
+ mbd.getResourceDescription(), beanName, "Cannot apply property values to null instance");
+ }
+ else {
+ // Skip property population phase for null instance.
+ return;
+ }
+ }
+
+ // @Autowired赋值也在这里(但是没做事)。可以中断初始化行为； 在属性赋值之前，后置处理器可以提前准备些东西 Give any InstantiationAwareBeanPostProcessors the opportunity to modify the
+ // state of the bean before properties are set. This can be used, for example,
+ // to support styles of field injection.
+ if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
+ for (InstantiationAwareBeanPostProcessor bp : getBeanPostProcessorCache().instantiationAware) {
+ if (!bp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
+ return;
+ }
+ }
+ } //以上的后置处理器可以中断以下的行为
+
+ PropertyValues pvs = (mbd.hasPropertyValues() ? mbd.getPropertyValues() : null);
+
+ int resolvedAutowireMode = mbd.getResolvedAutowireMode();
+ if (resolvedAutowireMode == AUTOWIRE_BY_NAME || resolvedAutowireMode == AUTOWIRE_BY_TYPE) {
+ 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;
+ }
+
+ boolean hasInstAwareBpps = hasInstantiationAwareBeanPostProcessors();
+ boolean needsDepCheck = (mbd.getDependencyCheck() != AbstractBeanDefinition.DEPENDENCY_CHECK_NONE);
+
+ PropertyDescriptor[] filteredPds = null;
+ if (hasInstAwareBpps) {
+ if (pvs == null) {
+ pvs = mbd.getPropertyValues(); //xml中property标签指定的
+ } //使用后置处理器处理属性
+ for (InstantiationAwareBeanPostProcessor bp : getBeanPostProcessorCache().instantiationAware) {
+ PropertyValues pvsToUse = bp.postProcessProperties(pvs, bw.getWrappedInstance(), beanName);
+ if (pvsToUse == null) {
+ if (filteredPds == null) {
+ filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
+ }
+ pvsToUse = bp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);
+ if (pvsToUse == null) {
+ return;
+ }
+ }
+ pvs = pvsToUse; //封装了当前bean的所有属性名和值，可以由后置处理器处理得到
+ }
+ // 在这里设置过的属性，在后面就不用处理了
+ }
+ if (needsDepCheck) {
+ if (filteredPds == null) {
+ filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
+ }
+ checkDependencies(beanName, mbd, filteredPds, pvs);
+ }
+
+ if (pvs != null) { //把以前处理好的PropertyValues给bean里面设置一下。主要是上面步骤没有给bean里面设置的属性
+ applyPropertyValues(beanName, mbd, bw, pvs); //xml版的所有配置会来到这里给属性赋值
+ }
+ }
+```
+
+
+
+
+
+AutowiredAnnotationBeanPostProcessor（处理@Autowire）也在这里,但是直接返回了true，相当于没做事。
+
+#### BeanWrapperImpl#setValue()
+
+`applyPropertyValues(beanName, mbd, bw, pvs);`最终也是用下面的反射进行赋值
+
+```java
+@Override //利用set方法反射赋值
+public void setValue(@Nullable Object value) throws Exception { //name setName
+ Method writeMethod = (this.pd instanceof GenericTypeAwarePropertyDescriptor ?
+ ((GenericTypeAwarePropertyDescriptor) this.pd).getWriteMethodForActualAccess() :
+ this.pd.getWriteMethod());
+ if (System.getSecurityManager() != null) {
+ AccessController.doPrivileged((PrivilegedAction