Spring - Bean的实例化流程及生命周期

男娘i 2024-03-16 14:17 167阅读 0赞

#### 文章目录 ####

*  Bean的实例化流程及生命周期
 *  一、Bean实例化基本流程
 *   *  1.1 Bean实例化基本流程
     *  1.2 总结
 *  二、 Bean 后处理器
 *   *  2.1 介绍
     *  2.2 BeanFactoryPostProcessor Bean工厂后处理器
     *   *  2.2.1 入门
         *  2.2.2 Bean工厂后处理器注册BeanDefinition
         *  2.2.3 BeanDefinitionRegistryPostProcessor专门注册BeanDefinition操作
         *  2.2.4 完善实例化基本流程图
     *  2.3 BeanPostProcessor Bean后处理器
     *   *  2.3.1 入门
         *  2.3.2 before 与 after执行时机
         *  2.3.3 对Bean方法进行执行时间日志增强
         *  2.3.4 完善实例化基本流程图
 *  三、SpringBean 生命周期
 *   *  3.1 初始化过程
     *   *  3.1.1 Bean实例的属性注入
         *  3.1.2 三级缓存设计原理
     *  3.2 常用的Aware接口
 *  四、Spring IOC整体流程总结

## Bean的实例化流程及生命周期 ##

## 一、Bean实例化基本流程 ##

### 1.1 Bean实例化基本流程 ###

**从标签的配置到对象进入容器中，是怎么样的一个过程？**

*  **Spring容器在进行初始化时，会将xml配置的<bean>的信息封装成一个BeanDefinition对象**
    
    比如下面两段配置，会封装成两个BeanDefinition对象，因为这个信息在内存中也需要存储（并不是userService、userDao对象）

*  **所有的BeanDefinition对象存储到一个名为beanDefinitionMap的集合中去，Spring框架再对该Map进行遍历，使用反射创建Bean实例对象**
    
    beanDefinitionMap集合就是在BeanFactory中进行维护，如下所示
    
    beanDefinitionMap的Value就是对当前配置的这个Bean的信息进行封装的

![image-20230605135938405][]

我们随意点开一个看一看，它的**Value并不是一个userDao对象**，而是一个，而是一个GenericBeanDefinition，说白了就**是一个Bean标签信息**

![image-20230605140333446][]

> **只要将BeanDefinition注册到beanDefinitionMap这个Map中，Spring就会进行对应的Bean的实例化操作**

*  **创建好的Bean对象存储在一个名为singletonObjects的Map集合中，当调用getBean方法时，则最终从该Map集合中取出Bean实例对象返回**。
    
    singletonObjects就是一个单例池 ，也是一个Map集合
    
    当我们调用getBean的时候，就是根据getBean方法参数去Map集合中取出对应的Value值

![image-20230605140037210][]

> 当前的beanFactory是DefaultListableBeanFactory工厂对象，此对象中的各种属性，就是下图beanFactory下面的参数
> 
> ![image-20230605143319758][]
> 
> DefaultListableBeanFactory对象内部维护着一个Map用于存储封装好的BeanDefinitionMap（在上面已经说到过了）
> 
>     public class DefaultListableBeanFactory extends ... implements ... {
>          
>         //存储<bean>标签对应的BeanDefinition对象
>         //key:是Bean的beanName，value:是Bean定义对象BeanDefinition
>         private final Map<String, BeanDefinition> beanDefinitionMap;
>     }

### 1.2 总结 ###

*  加载xml配置文件，解析获取配置中的每个<bean>的信息，封装成一个个的BeanDefinition对象
 *  将BeanDefinition存储在一个名为beanDefinitionMap的Map<String,BeanDefinition>中
 *  ApplicationContext底层遍历beanDefinitionMap，创建Bean实例对象
 *  创建好的Bean实例对象，被存储到一个名为singletonObjects的Map<String,Object>中
 *  当执行applicationContext.getBean(beanName)时，从singletonObjects去匹配Bean实例返回

![image-20230605145506928][]

## 二、 Bean 后处理器 ##

### 2.1 介绍 ###

Spring的后处理器是Spring**对外开发的重要扩展点**，允许我们**介入到Bean的整个实例化流程**中来，以**达到动态注册BeanDefinition，动态修改BeanDefinition，以及动态修改Bean的作用**。

> 框架本身把一些功能封装好了，也有一些约定俗成的东西（按照他们的配置进行配置，最终就能完成响应的一些功能），但是有的时候我们需要自己介入到他的整个过程

**Spring主要有两种后处理器**：

*  **BeanFactoryPostProcessor**：**Bean工厂后处理器**，在BeanDefinitionMap填充完毕，**Bean实例化之前执行**
 *  **BeanPostProcessor**：**Bean后处理器，一般在Bean实例化之后，填充到单例池singletonObjects之前执行**

### 2.2 BeanFactoryPostProcessor Bean工厂后处理器 ###

**BeanFactoryPostProcessor**：**Bean工厂后处理器**，在BeanDefinitionMap填充完毕，**Bean实例化之前执行**

BeanFactoryPostProcessor是一个**接口规范，实现了该接口的类只要交由Spring容器管理的话，那么Spring就会回调该接口的方法，用于对BeanDefinition注册和修改的功能**。

@FunctionalInterface
    public interface BeanFactoryPostProcessor {
        
        void postProcessBeanFactory(ConfigurableListableBeanFactory var1) throws BeansException;
    }

#### 2.2.1 入门 ####

**定义类MyBeanFactoryPostProcessor并实现接口BeanFactoryPostProcessor**

**配置信息**

**测试类**

ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("beans.xml");

![image-20230605152809082][]

**那这个工厂后处理器有什么作用呢？看下面这个例子**

**配置文件**

注意看userService对应的全限定名

**工厂后处理器**

public class MyBeanFactoryPostProcessor implements BeanFactoryPostProcessor {
        
        //方法对应的参数就是BeanFactory
        public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
        
            System.out.println("beanDefinitionMap填充完毕后回调该方法...");
            //修改某一个beanDefinition
            // 说明：为了安全起见，并没有给我们提供getBeanDefinitionMap方法
            //      但是允许我们根据名字取获取某一个beanDefinition
            BeanDefinition beanDefinition = beanFactory.getBeanDefinition("userService");
            //userService全限定名是com.zhangjingqi.service.impl.UserServiceImpl
            //我们现在要改成com.zhangjingqi.dao.impl.UserDaoImpl
            beanDefinition.setBeanClassName("com.zhangjingqi.dao.impl.UserDaoImpl");
    
        }
    }

**测试**

发现已经不是UserServiceImpl，而是UserDaoImpl

//参数是一个xml配置文件
    ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("beans.xml");
    Object userService = applicationContext.getBean("userService");
    System.out.println(userService);

![image-20230605154146828][]

#### 2.2.2 Bean工厂后处理器注册BeanDefinition ####

之前我们创建Bean是在对应的xml文件中进行添加Bean标签

现在我们换一种方式，将Bean的注册放在工厂后处理器中

**Bean工厂后处理器注册BeanDefinition**

//方法对应的参数就是BeanFactory
        public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
        
            System.out.println("beanDefinitionMap填充完毕后回调该方法...");
    //      注册BeanDefinition
            BeanDefinition beanDefinition = new RootBeanDefinition();
            beanDefinition.setBeanClassName("com.zhangjingqi.dao.impl.PersonDaoImpl");
    
    //      ConfigurableListableBeanFactory内部没有注册BeanDefinition
    //      beanFactory.registerSingleton();此方法是其放入到单例池当中
    //      需要把ConfigurableListableBeanFactory类型强转为子类DefaultListableBeanFactory
            DefaultListableBeanFactory defaultListableBeanFactory = (DefaultListableBeanFactory)beanFactory;
            defaultListableBeanFactory.registerBeanDefinition("personDao",beanDefinition);
        }

**测试**

ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("beans.xml");
    Object personDao = applicationContext.getBean("personDao");
    System.out.println(personDao);

![image-20230605160422799][]

#### 2.2.3 BeanDefinitionRegistryPostProcessor专门注册BeanDefinition操作 ####

Spring 提供了一个BeanFactoryPostProcessor的子接口**BeanDefinitionRegistryPostProcessor专门用于注册BeanDefinition操作**，不再需要强转参数，比较方便

public class MyBeanFactoryPostProcessor2 implements BeanDefinitionRegistryPostProcessor {
        
    
    //  之前接口的方法
        public void postProcessBeanFactory(ConfigurableListableBeanFactory configurableListableBeanFactory) throws BeansException {
        
            System.out.println("MyBeanFactoryPostProcessor2的postProcessBeanFactory方法");
        }
    
    //   BeanDefinitionRegistryPostProcessor接口的方法，专门用于注册BeanDefinition操作
        public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry beanDefinitionRegistry)
                throws BeansException {
        
            System.out.println("MyBeanFactoryPostProcessor2的postProcessBeanDefinitionRegistry");
    
            BeanDefinition beanDefinition = new RootBeanDefinition();
    
            beanDefinition.setBeanClassName("com.zhangjingqi.dao.impl.UserDaoImpl");
    
            beanDefinitionRegistry.registerBeanDefinition("userDao2", beanDefinition);
        }
    }

**执行顺序**

![image-20230605162953015][]

#### 2.2.4 完善实例化基本流程图 ####

BeanDefinitionRegistryPostProcessor接口的实现类执行顺序要比其父类接口BeanFactoryPostProcessor的实现类的执行顺序靠前，如下图所示

![image-20230605163304002][]

### 2.3 BeanPostProcessor Bean后处理器 ###

**BeanPostProcessor**：**Bean后处理器，一般在Bean实例化之后，填充到单例池singletonObjects之前执行**

> Bean被实例化后，到最终缓存到名为singletonObjects单例池之前，**中间会经过Bean的初始化过程**
> 
> 例如：属性的填充、初始方法init的执行等，其中有一个对外进行扩展的点BeanPostProcessor，我们称为Bean后处理。跟上面的Bean工厂后处理器相似，它也是一个接口，实现了该接口并被容器管理的BeanPostProcessor，会在流程节点上被Spring自动调用。

#### 2.3.1 入门 ####

**BeanPostProcessor接口实现类代码**

Bean实例化之后才执行下面的两个方法

> 参数： bean是当前被实例化的Bean\*\*，\*\*beanName是当前Bean实例在容器中的名称
> 
> *返回值：当前**Bean**实例对象*

public class MyBeanPostProcessor implements BeanPostProcessor {
        
    //  先执行
        public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        
            System.out.println(bean+":postProcessBeforeInitialization:"+beanName);
            return bean;
        }
    
    //  后执行
        public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        
            System.out.println(bean+":postProcessAfterInitialization:"+beanName);
            return bean;
        }
    }

**配置文件信息**

然后我们再随便配置一个bean，否则没有效果

**测试信息**

ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("beans.xml");

![image-20230605202459396][]

#### 2.3.2 before 与 after执行时机 ####

由下图可得，执行顺序肯定是先before再after

![image-20230605202459396][image-20230605202459396 1]

**那在before与after方法中间有哪些操作呢？**

对应Bean的一些初始化方法

**顺序**：

**①Bean先创建**

**②执行before方法**

**③执行Bean初始化操作**

> 需要再Bean创建时指定 init-method="init"参数与参数值
> 
> 或者是实现InitializingBean接口并重写afterPropertiesSet方法
> 
> 如果都有的话，先执行afterPropertiesSet方法再执行init-method

public class UserDaoImpl implements UserDao, InitializingBean {
        
        public UserDaoImpl() {
        
            System.out.println("userDao实例化");
        }
    
        public void init() {
        
            System.out.println("init 初始化方法开始执行");
        }
    
        public void afterPropertiesSet() throws Exception {
        
            System.out.println("afterPropertiesSet");
        }
    }

![image-20230605204450140][]

**④执行after方法**

#### 2.3.3 对Bean方法进行执行时间日志增强 ####

**要求**

*  **Bean的方法执行之前控制台打印当前时间**
 *  **Bean的方法执行之后控制台打印当前时间**

>  *  对方法进行增强主要就是代理设计模式和包装设计模式；
>  *  由于Bean方法不确定，所以使用动态代理在运行期间执行增强操作；
>  *  在Bean实例创建完毕后，进入到单例池之前，使用Proxy代替真是的目标Bean

public class TimeLogBeanPostProcessor implements BeanPostProcessor {
        
        public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        
            //     使用动态代理对目标Bean进行增强，返回proxy对象，进而存储到单例池当中
            Object proxyBean = Proxy.newProxyInstance(bean.getClass().getClassLoader(),
                    bean.getClass().getInterfaces(),
                    (Object proxy, Method method, Object[] args) -> {
        
                        long start = System.currentTimeMillis();
                        System.out.println("开始时间：" + new Date(start));
                        //执行目标方法
                        Object result = method.invoke(bean, args);
                        long end = System.currentTimeMillis();
                        System.out.println("结束时间：" + new Date(end));
                        return result;
                    });
            //返回代理对象
            return proxyBean;
    
        }
    }

其实我感觉这个地方是有点难度的，但是在SpringBoot当中时非常简单的，可以看一下下面这篇文章[SpringBoot——IOC与AOP\_][SpringBoot_IOC_AOP]

#### 2.3.4 完善实例化基本流程图 ####

![image-20230605211520347][]

## 三、SpringBean 生命周期 ##

**生命周期**：从 Bean 实例化之后，即通过反射创建出对象之后，到Bean成为一个完整对象，最终存储到单例池中

**Spring Bean的生命周期大体上分为三个阶段**

*  **Bean的实例化阶段**

Spring框架会取出BeanDefinition的信息进行判断当前Bean的范围是否是singleton的，是否不是延迟加载的，是否不是FactoryBean等，最终将一个普通的singleton的Bean通过反射进行实例化

*  **Bean的初始化阶段**

Bean创建之后还仅仅是个"半成品"，还需要对Bean实例的属性进行填充、执行一些Aware接口方法、执行BeanPostProcessor方法、执行InitializingBean接口的初始化方法、执行自定义初始化init方法等。该阶段是Spring最具技术含量和复杂度的阶段，Aop增强功能，后面要学习的Spring的注解功能等、spring高频面试题Bean的循环引用问题都是在这个阶段体现的；

*  **Bean的完成阶段**

经过初始化阶段，Bean就成为了一个完整的Spring Bean，被存储到单例池singletonObjects中去了，即完成了Spring Bean的整个生命周期。

### 3.1 初始化过程 ###

*  **Bean实例的属性填充**
 *  **Aware接口属性注入**
    
    这一步的前提是实现Aware接口。
    
    实现框架提供好的一些扩展Aware接口，然后需要什么框架就通过Aware接口规定的一些方法给注入进去
 *  **BeanPostProcessor的before()方法回调**
 *  **InitializingBean接口的初始化方法回调**
 *  **自定义初始化方法init回调**
 *  **BeanPostProcessor的after()方法回调**

> 后四步顺序我们在上面的代码中已经演示过了

#### 3.1.1 Bean实例的属性注入 ####

BeanDefinition中有对当前Bean实体的注入信息通过属性propertyValues进行了存储

例如UserService的属性信息，如下所示

类中设置两个属性

public class UserServiceImpl implements UserService  {
        
    
        private UserDao userDao;
        public void setUserDao(UserDao userDao) {
        
            this.userDao =userDao;
        }
    
        private String username;
    
        public void setUsername(String username) {
        
            this.username = username;
        }
    
    }

如下图所示

![image-20230606100900921][]

**Spring在进行属性注入时，会分为如下几种情况**：

*  **注入普通属性**，String、int或存储基本类型的集合时，直接通过set方法的反射设置进去
 *  **注入单向对象引用属性**时，从容器中getBean获取后通过set方法反射设置进去，如果容器中没有，则先创建被注入对象Bean实例（完成整个生命周期）后，在进行注入操作

>     比如我们上面的程序中UserServiceImpl类创建依赖UserDao类，但是UserDao类不依赖UserServiceImpl类，这就是单项的
>     
>     假如说我们创建UserServiceImpl的时候发现内部需要UserDao，但是我们从容器中并没有找到UserDao，那我们此时UserServiceImpl创建Bean的操作停止，开始创建UserDao的Bean，直到UserDao完全创建完成再开始UserServiceImpl的创建Bean的操作

*  **注入双向对象引用属性**时，就比较复杂了，涉及了循环引用（循环依赖）问
    
    > **循环引用**：多个实体之间相互依赖并形成闭环的情况叫做“循环依赖”，也叫做“循环引用”
    > 
    > 比如说
    > 
    > 我们创建UserService接口的实例Bean，首先实例化Service，再初始化Service，但是UserService属性的填充需要UserDao，但是此时容器没有UserDao对象，所以我们要先创建一个UserDao对象
    > 
    > UserDao实例化依然是UserDao初始化属性填充，但是此时需要UserService对象，但是我们的UserService对象并没有创建完毕，所以容器又去创建UserService对象，此时进入了死循环
    > 
    > ![image-20230606104841879][]
    > 
    > 如下图所示，循环引用：
    > 
    > ![image-20230606104445215][]

为了解决循环依赖的问题，Spring提供了三级缓存

#### 3.1.2 三级缓存设计原理 ####

Spring提供了三级缓存存储完整Bean实例和半成品Bean实例，用于解决循环依赖的问题

singletonObjects 单例池存储完整Bean

earlySingletonObjects 存储半成品对象，且当前对象已经被其他对象引用

singletonFactories 存储半成品对象，对象未被引用

public class DefaultSingletonBeanRegistry ... {
        
        //1、最终存储单例Bean成品的容器，即实例化和初始化都完成的Bean，称之为"一级缓存"
        Map<String, Object> singletonObjects = new ConcurrentHashMap(256);
        
        //2、早期Bean单例池，缓存半成品对象，且当前对象已经被其他对象引用了，称之为"二级缓存"
        Map<String, Object> earlySingletonObjects = new ConcurrentHashMap(16);
        
        //3、单例Bean的工厂池，缓存半成品对象，对象未被引用，使用时在通过工厂创建Bean，称之为"三级缓存"
        Map<String, ObjectFactory<?>> singletonFactories = new HashMap(16);
    }

结合这张图，理由三级缓存原理再来看一下

*  **创建UserServiceBean把UserService的引用存储到第三级缓存singletonFactories当中**

![image-20230606142605246][]

> 但是在存储三级缓存的时候，并不是直接把创建好的UserService对象存进去，而是为UserService外面包一层（为UserService创建一个对应的ObjectFactory），并且在ObjectFactory类中的getObject方法中再return返回刚才创建好的UserService（只不过不是一个完整的Bean）
> 
> ![image-20230606112512833][]
> 
> String是Key，我们定义的BeanName，而Value是ObjectFactory，不再是Bean了（包了一层ObjectFactory），真正用到UserService的时候，再调用ObjectFactory.getObject方法返回UserService对象
> 
>     Map<String, ObjectFactory<?>> singletonFactories = new HashMap(16);
> 
> 三级缓存singletonFactories当中的Bean实际是未被别人引用的（创建完就扔进去了，别人还没有注入）

*  此时到了第二步但是**在Service初始化的时候，需要判断容器中是否有UserDao对象**

![image-20230606104841879][image-20230606104841879 1]

**如今判断方式和之前不一样了**，现在找的时候可以从第一级到三级缓存中寻找，挨个找，一级缓存没找找二级，二级没有找三级，然后发现都没有UserDao对象，所以就**创建UserDao对象**

> 此时创建的UserDao对象也向三级缓存中存放

![77245e2136bdac5ba9bdb50a194eeea5.png][]

*  此时我们就**创建UserDao对象，但是需要注入属性UserService，此时需要从容器中寻找**
    
    找的时候可以从第一级到三级缓存中寻找，挨个找，一级缓存没有找二级，二级没有找三级，最终在第三级缓存中找到UserService对象，调用ObjectFactory的getObject方法，最终把UserService的引用注入给UserDao
    
    与此同时再把Service从三级缓存当中移除掉，把其放入到二级缓存当中
    
    ![image-20230606142956749][]
 *  **之后再执行UserDao之后的生命之后，生成完整的UserDao的Bean**
    
    此时UserDao的Bean要存储到一级缓存，将三级缓存中的UserDao进行删除

![image-20230606144227122][]

*  **UserDao完成之后回溯到UserService初始化注入UserDao操作，执行一些列操作后成为完整Bean**

此时UserService填充完整的UserDao，从一级缓存中找到的

成为完整的Bean后，从二级缓存中删除UserService，将其加入到一级缓存之中

![image-20230606144633447][]

**总结**

*  UserService 实例化对象，但尚未初始化，将UserService存储到三级缓存
 *  UserService 属性注入，需要UserDao，从缓存中获取，没有UserDao
 *  UserDao实例化对象，但尚未初始化，将UserDao存储到到三级缓存
 *  UserDao属性注入，需要UserService，从三级缓存获取UserService，UserService从三级缓存移入二级缓存
 *  UserDao执行其他生命周期过程，最终成为一个完成Bean，存储到一级缓存，删除二三级缓存
 *  UserService 注入UserDao
 *  UserService执行其他生命周期过程，最终成为一个完成Bean，存储到一级缓存，删除二三级缓存

![image-20230606140138311][]

![image-20230606114607735][]

### 3.2 常用的Aware接口 ###

Aware接口是一种框架辅助属性注入的一种思想，其他框架中也可以看到类似的接口

框架具备高度封装性，我们接触到的一般都是业务代码，一个底层功能API不能轻易的获取到，但是这不意味着永远用不到这些对象，如果用到了，就可以使用框架提供的类似Aware的接口，让框架给我们注入该对象。

<table> 
 <thead> 
  <tr> 
   <th>Aware接口</th> 
   <th>回调方法</th> 
   <th>作用</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>ServletContextAware</td> 
   <td>setServletContext(ServletContext context)</td> 
   <td>Spring框架回调方法注入ServletContext对象，web环境下才生效</td> 
  </tr> 
  <tr> 
   <td>BeanFactoryAware</td> 
   <td>setBeanFactory(BeanFactory factory)</td> 
   <td>Spring框架回调方法注入beanFactory对象</td> 
  </tr> 
  <tr> 
   <td>BeanNameAware</td> 
   <td>setBeanName(String beanName)</td> 
   <td>Spring框架回调方法注入当前Bean在容器中的beanName</td> 
  </tr> 
  <tr> 
   <td>ApplicationContextAware</td> 
   <td>setApplicationContext(ApplicationContext applicationContext)</td> 
   <td>Spring框架回调方法注入applicationContext对象</td> 
  </tr> 
 </tbody> 
</table>

**下面来测试一下**

**导包**

<dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-web</artifactId>
                <version>5.3.7</version>
            </dependency>
    
            <dependency>
                <groupId>javax.servlet</groupId>
                <artifactId>javax.servlet-api</artifactId>
                <version>4.0.1</version>
            </dependency>

## 四、Spring IOC整体流程总结 ##

> 这张图很重要，最终流程图

![image-20230606153750630][]

**从头到尾看一遍**

*  **第一张图**
    
    > 此图流程具体详情在1.1与1.1中有详细说明
    
    **Bean标签怎么变成Bean对象的呢？**
    
    BeanDefinition Reader会读取xml文件中的Bean标签，每一个Bean标签的信息都抽取到外面封装成BeanDefinition对象（Bean定义对象），在此对象中存储的是Bean对象的一些信息，并不是我们要创建的Bean对象
    
    所有的BeanDefinition对象存储到beanDefinitionMap集合之中
    
    存完之后Spring会把此Map全部遍历一遍，取出每一个Definition，再从Definition中取出一些Bean相关信息，取出后通过反射创建对象
    
    把反射创建的对象存储到singletonObjects单例池之中
    
    我们最终getBean时就是从单例池中获取Bean

![image-20230605145506928][image-20230605145506928 1]

*  **第二张图**
    
    > 具体详情可以查看2.2
    
    之后我们讲了BeanFactory后处理器

BeanFactory后处理器是在beanDefinitionMap封装完毕之后，创建对象之前执行的

在这里我们可以进行BeanDefinition的修改，也可以进行BeanDefinition的注册

![image-20230606155018885][]

*  **第三张图**

> 具体详情可以查看 2.3
> 
> **BeanPostProcessor**：**Bean后处理器，一般在Bean实例化之后，填充到单例池singletonObjects之前执行**

Bean后处理器也是对功能的进行扩展

有两个方法before与after

![image-20230606155353947][]

*  **最后一张图**
    
    比之前多了一个bean的生命周期

![image-20230606153750630][image-20230606153750630 1]

[image-20230605135938405]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/16/9b11718f32804c2488d8fae1cfefd768.png
[image-20230605140333446]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/16/76cc460c14054ef4b59522b5567f11eb.png
[image-20230605140037210]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/16/2ef63e08991b445c9cdf776c3b2cccfe.png
[image-20230605143319758]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/16/cff77ef058b347ebbafb259fb8c6bba7.png
[image-20230605145506928]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/16/0ce3f181b8194c71a1ed8359868d9ec0.png
[image-20230605152809082]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/16/d14e9eccafe344528c34a9a5e530df2f.png
[image-20230605154146828]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/16/81fb06de2fb34b8e85a82ec4ec7cf5f2.png
[image-20230605160422799]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/16/e8fab2561e1e4916b32fe2aa6096e241.png
[image-20230605162953015]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/16/f72001175b9b4a88aa06950b54c3bec0.png
[image-20230605163304002]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/16/43aff46377d34d5bb4c390dc822d90e2.png
[image-20230605202459396]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/16/e4eb5ab36b2d4d9fa0207616ac581738.png
[image-20230605202459396 1]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/16/6a780424fd1b4befaa1c3e252025e35b.png
[image-20230605204450140]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/16/59ac2d292e8446468426532703a7b6ea.png
[SpringBoot_IOC_AOP]: https://blog.csdn.net/weixin_51351637/article/details/130779252
[image-20230605211520347]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/16/f9416122f0d046f38e98ea944f2ed4d0.png
[image-20230606100900921]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/16/e3838774b46c46579c3ab77eca91be79.png
[image-20230606104841879]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/16/b4c65d4d2b2246a9b668400842f22937.png
[image-20230606104445215]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/16/527baa48bf824d66b91bd64d9212267c.png
[image-20230606142605246]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/16/7577ad1047994054b17d2b026adafc4d.png
[image-20230606112512833]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/16/9a7bfb8f42e94bedab6afd7bcb8afea1.png
[image-20230606104841879 1]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/16/0e0ddc9f48a3434e96d769c6674646e7.png
[77245e2136bdac5ba9bdb50a194eeea5.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/16/470b5d0365f54ee497adc2be8c2dbef3.png
[image-20230606142956749]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/16/fb4f094a08a44004a7da7d26353f4d72.png
[image-20230606144227122]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/16/6b56e73865fb4498a4e366dd5840ce1f.png
[image-20230606144633447]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/16/45fe65e915a34a4ba6ba0b1f7243e56b.png
[image-20230606140138311]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/16/51da583183da46f9ba5023cb60970d36.png
[image-20230606114607735]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/16/87292ab579064e8c983f386ab383ae1f.png
[image-20230606153750630]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/16/328e8a3fc7ae428cbe9f39163966b3a6.png
[image-20230605145506928 1]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/16/a0892cff339a4280831e56c79704b82c.png
[image-20230606155018885]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/16/93e16698719e42bf95082f7f8b3d335d.png
[image-20230606155353947]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/16/06bfb97886134af7b8aa557e438b25e6.png
[image-20230606153750630 1]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/16/8b2a33cffaa746a08f31ceace4739fa3.png