【Spring6】| Bean的生命周期（五步、七步、十步法剖析）

港控/mmm° 2024-03-29 15:42 41阅读 0赞

**目录**

一：Bean的生命周期

1. 什么是Bean的生命周期

2. Bean的生命周期之五步分析法

3. Bean生命周期之七步分析法

4. Bean生命周期之十步分析法

5. Bean的scop（作用域）不同，管理方式不同

6. 自己new的对象如何让Spring管理

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

## 一：Bean的生命周期 ##

#### 1. 什么是Bean的生命周期 ####

> （1）**Spring其实就是一个管理Bean对象的工厂，它负责对象的创建，对象的销毁等。**
> 
> （2）所谓的**生命周期**就是：**对象从创建开始到最终销毁的整个过程。**
> 
> （3）为什么要知道Bean的生命周期？
> 
> **生命周期的本质是：在哪个时间节点上调用了哪个类的哪个方法？**我们需要充分的了解在这个生命线上，都有哪些特殊的时间节点！只有我们知道了特殊的时间节点都在哪，到时我们才可以确定代码写到哪。我们可能需要在某个特殊的时间点上执行一段特定的代码，这段代码就可以放到这个节点上；当生命线走到这里的时候，自然会被调用。
> 
> （4）**下面我会按照由浅入深，按照5步、7步、10步法，讲解Bean的生命周期！**

####  ####

#### 2. Bean的生命周期之五步分析法 ####

> （1）Bean生命周期的管理，可以参考Spring的源码：**AbstractAutowireCapableBeanFactory类的doCreateBean()方法****。**
> 
> （2）**Bean生命周期可以粗略的划分为五大步：**
> 
>  *  第一步：实例化Bean
>  *  第二步：Bean属性赋值
>  *  第三步：初始化Bean
>  *  第四步：使用Bean
>  *  第五步：销毁Bean

![439deaea784b0feb27579fd75f5e9fb5.png][]

**编写测试程序：**

**Bean的生命周期按照粗略的五步的话：**

第一步：实例化Bean（调用无参数构造方法）  
第二步：给Bean属性赋值（调用set方法）  
第三步：初始化Bean（会调用Bean的init方法。注意：这个init方法需要自己写）  
第四步：使用Bean  
第五步：销毁Bean（会调用Bean的destroy方法。注意：这个destroy方法需要自己写）

定义一个Bean

package com.bjpowernode.spring.bean;
    
    public class User {
        private String username;
    
        public void setUsername(String username) {
            System.out.println("第二步：给对象的属性赋值");
            this.username = username;
        }
    
        public User() {
            System.out.println("第一步：实例化Bean，无参数构造方法执行了");
        }
    
        // 初始化Bean，需要自己写，自己配，方法名随意
        public void initBean(){
            System.out.println("第三步：初始化Bean");
        }
    
        // 销毁Bean，需要自己写，自己配，方法名随意
        public void destroyBean(){
            System.out.println("第五步：销毁Bean");
        }
    
        @Override
        public String toString() {
            return "User{" +
                    "username='" + username + '\'' +
                    '}';
        }
    }

spring.xml配置

> 需要在**<bean>标签中**调用**init-method**和**destroy-method**属性，手动指定初始化方法和销毁方法！

<?xml version="1.0" encoding="UTF-8"?>
    <beans xmlns="http://www.springframework.org/schema/beans"
           xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
           xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
    
        <bean id="user" class="com.bjpowernode.spring.bean.User"
              init-method="initBean" destroy-method="destroyBean">
              
             <property name="username" value="张三"/>
        </bean>
    </beans>

测试程序

> ①需要**手动关闭Spring容器（调用close方法）**，这样Spring容器才会销毁Bean，**才会去调用我们定义的destroyBean方法**！  
> ② 注意：只有ApplicationContext的实现类**ClassPathXmlApplicationContext有close方法**，**ApplicationContext没有**，所以**需要强制类型转换**；然后**调用close方法！**

package com.bjpowernode.spring.test;
    
    import com.bjpowernode.spring.bean.User;
    import org.junit.Test;
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    
    public class BeanLifecycleTest {
        @Test
        public void testBeanLifeCycleFive(){
            ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring.xml");
            User user = applicationContext.getBean("user", User.class);
            System.out.println("第四步：使用Bean"+user);
    
            // 需要手动关闭Spring容器
            ClassPathXmlApplicationContext context = (ClassPathXmlApplicationContext) applicationContext;
            context.close();
        }
    }

执行结果：从这里我们也可看出执行的顺序

![57cdf265b0d84f61a3acb43bd101c61c.png][]

**总结要点：**

**第一：只有正常关闭spring容器(调用close方法)，bean的销毁方法才会被调用。**

**第二：ClassPathXmlApplicationContext类才有close()方法，ApplicationContext中没有。**

**第三：配置文件中的init-method指定初始化方法，destroy-method指定销毁方法。**

#### 3. Bean生命周期之七步分析法 ####

> （1）在以上的5步中，**第3步是初始化Bean**，如果你还想在**初始化前**和**初始化后**添加代码，**可以加入“Bean后处理器”****；**需要编写一个类**实现BeanPostproccessor接口****，**并**重写里面的befor和after方法****。**
> 
> （2）**Bean生命周期可以细化为七大步：**
> 
>  *  第一步：实例化Bean
>  *  第二步：Bean属性赋值
>  *  第三步：**执行“Bean后处理器”的before方法**
>  *  第四步：初始化Bean
>  *  第五步：**执行“Bean后处理器”的after方法**
>  *  第六步：使用Bean
>  *  第七步：销毁Bean

![493a1201dd839499d7fd739bd2d1749e.png][]

编写一个类**实现BeanPostProcessor类**，并且重写before和after方法

**注意：方法中有两个参数：**

> ①第一个参数是创建的Bean对象！
> 
> ②第二个参数是Bean的名字！

package com.bjpowernode.spring.test;
    
    import org.springframework.beans.BeansException;
    import org.springframework.beans.factory.config.BeanPostProcessor;
    
    public class LogBeanPostProcessor implements BeanPostProcessor {
        @Override
        public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
            System.out.println("Bean后处理器的before方法执行，即将开始初始化");
            return BeanPostProcessor.super.postProcessBeforeInitialization(bean, beanName);
        }
    
        @Override
        public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
            System.out.println("Bean后处理器的after方法执行，已完成初始化");
            return BeanPostProcessor.super.postProcessAfterInitialization(bean, beanName);
        }
    }

在spring.xml文件中配置“Bean后处理器”

> **注意：在spring.xml文件中配置的Bean后处理器将作用于当前配置文件中所有的Bean！**

执行测试程序：

![c458a60802f7452eb5262d7295b6f7cb.png][]

#### 4. Bean生命周期之十步分析法 ####

**Bean生命周期十步：比七步添加的那三步在哪里？**

> （1）在“Bean后处理器”**before方法之前**干了什么事儿？  
> 检查Bean是否实现了**Aware相关的接口**，如果实现了接口则调用这些接口中的方法；调用这些方法的目的是为了给你传递一些数据，让你更加方便使用。
> 
> （2）在“Bean后处理器”**before方法之后**干了什么事儿？  
> 检查Bean是否实现了**InitializingBean接口**，如果实现了，则调用接口中的方法。
> 
> （3）**使用Bean之后**，**或者说销毁Bean之前**干了什么事儿？  
> 检查Bean是否实现了**DisposableBean接口**，如果实现了，则调用接口中的方法。
> 
> **总结：**添加的这三个点位的特点，都是在检查你这个Bean是否实现了某些特定的接口，如果实现了这些接口，则Spring容器会调用这个接口中的方法！

![3a15ca07491713fc878cdd3a88c968c6.png][]

> **Aware相关的接口包括：BeanNameAware、BeanClassLoaderAware、BeanFactoryAware**
> 
> ①当Bean实现了**BeanNameAware**，Spring会将Bean的**名字**传递给Bean。
> 
> ②当Bean实现了**BeanClassLoaderAware**，Spring会将加载该Bean的**类加载器**传递给Bean。
> 
> ③当Bean实现了**BeanFactoryAware**，Spring会将**Bean工厂对象**传递给Bean。
> 
> **测试以上10步，可以让User类实现5个接口，并实现所有方法：**
> 
> ①BeanNameAware
> 
> ②BeanClassLoaderAware
> 
> ③BeanFactoryAware
> 
> ④InitializingBean
> 
> ⑤DisposableBean

User类

package com.bjpowernode.spring.bean;
    
    import org.springframework.beans.BeansException;
    import org.springframework.beans.factory.*;
    
    
    public class User implements
            BeanNameAware, BeanClassLoaderAware, BeanFactoryAware,
            InitializingBean, DisposableBean{
        private String username;
    
        public void setUsername(String username) {
            System.out.println("第二步：给对象的属性赋值");
            this.username = username;
        }
    
        public User() {
            System.out.println("第一步：实例化Bean，无参数构造方法执行了");
        }
    
        // 初始化Bean，需要自己写，自己配，方法名随意
        public void initBean(){
            System.out.println("第四步：初始化Bean");
        }
    
        // 销毁Bean，需要自己写，自己配，方法名随意
        public void destroyBean(){
            System.out.println("第七步：销毁Bean");
        }
    
        @Override
        public String toString() {
            return "User{" +
                    "username='" + username + '\'' +
                    '}';
        }
    
        @Override
        public void setBeanClassLoader(ClassLoader classLoader) {
            System.out.println("类加载器：" + classLoader);
        }
    
        @Override
        public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
            System.out.println("Bean工厂：" + beanFactory);
        }
    
        @Override
        public void setBeanName(String name) {
            System.out.println("Bean的名字：" + name);
        }
    
        @Override
        public void destroy() throws Exception {
            System.out.println("DisposableBean destroy方法执行了");
        }
    
        @Override
        public void afterPropertiesSet() throws Exception {
            System.out.println("InitializingBean afterPropertiesSet方法执行了");
        }
    }

执行结果：

![23ec382ad70b4fcfbdb04d1a43ce5c2c.png][]

**总结：**

**①InitializingBean的方法早于init-method的执行。**

**②DisposableBean的方法早于destroy-method的执行。**

#### 5. Bean的scop（作用域）不同，管理方式不同 ####

**Spring 根据Bean的作用域来选择管理方式！**

> （1）对于**singleton（单例）作用域的Bean：**Spring 能够精确地知道该Bean何时被创建，何时初始化完成，以及何时被销毁。
> 
> （2）而对于 **prototype（多例/原型） 作用域的 Bean：**Spring 只负责创建，当容器创建了 Bean 的实例后，Bean 的实例就交给客户端代码管理，Spring 容器将不再跟踪其生命周期。

把spring.xml配置文件当中scop属性的singleton改成property

![90d2f7837ee74feeb710b284cd30fe83.png][]

再次执行测试程序：

> 当是多例的实际上只有前8步了，对于后两步的：检查Bean是否实现了DisposableBean接口 和 销毁Bean就不管了！

![21c32bc9d3ad466aa0bcabc449097af6.png][]

#### 6. 自己new的对象如何让Spring管理 ####

> 有些时候可能会遇到这样的需求，某个java对象是我们自己手动new的，然后我们希望这个对象被Spring容器管理，怎么实现呢？

Student类

package com.bjpowernode.spring.bean;
    
    public class Student {
    }

进行测试：

> **第一步：**创建**DefaultListableBeanFactory**对象！
> 
> **第二步：**注册Bean，调用这个对象的**registerSingleton()方法**，把自己创建的对象传进去，并起一个名字！
> 
> **第三步：**根据名字，调用**getBean**方法从Spring容器当中获取Bean对象！

package com.bjpowernode.spring.test;
    
    import com.bjpowernode.spring.bean.Student;
    import com.bjpowernode.spring.bean.User;
    import org.junit.Test;
    import org.springframework.beans.factory.support.DefaultListableBeanFactory;
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    
    public class BeanLifecycleTest {
    
        @Test
        public void testBeanRegister(){
            // 自己new的对象，没有被Spring管理
            Student student = new Student();
            System.out.println(student);
            // 创建DefaultListableBeanFactory对象
            DefaultListableBeanFactory factory = new DefaultListableBeanFactory();
            // 调用registerSingleton方法注册Bean
            factory.registerSingleton("studentBean",student);
            // 从Spring容器当中取出Bean
            Student studentBean = factory.getBean("studentBean", Student.class);
            System.out.println(studentBean);
    
        }
    }

执行结果：

> 获取到的是同一个Bean对象，说明确实是把我们创建的对象放到Spring容器当中进行管理！

![aa9fbb250d464270abba1d688e1299cc.png][]

[439deaea784b0feb27579fd75f5e9fb5.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/28/44948decd50f4fe68ed15bd626960438.png
[57cdf265b0d84f61a3acb43bd101c61c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/28/c41b18e2109341aa9dd6bca750433a5c.png
[493a1201dd839499d7fd739bd2d1749e.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/28/595a79c68809457fa04b4ac8fe9c709c.png
[c458a60802f7452eb5262d7295b6f7cb.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/28/006cdc988d8f4270afe62d1017da494a.png
[3a15ca07491713fc878cdd3a88c968c6.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/28/9febfc9192414b24a8d9a6ce7e4a4420.png
[23ec382ad70b4fcfbdb04d1a43ce5c2c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/28/3e4ea21217ec42c29da8e15b82effc5c.png
[90d2f7837ee74feeb710b284cd30fe83.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/28/982bf3a3055643c4bd4d3d01e736e331.png
[21c32bc9d3ad466aa0bcabc449097af6.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/28/45b5121421094faca6ac03bf3fe5b370.png
[aa9fbb250d464270abba1d688e1299cc.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/28/eafb99f0ded3497ebc17b02664e5ddcb.png