【Spring】Spring的Bean的生命周期

痛定思痛。 2023-10-08 17:27 49阅读 0赞

![img][]

>  *  **作者简介：大家好，我是五度鱼，一个普通的Java领域博主，不停输出Java技术博客和干货**。
>  *  **座右铭：锲而不舍，金石可镂**。
>  *  **个人主页：[五度鱼学Java的主页][Java]**

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

*  前言
 *  1. 什么是Bean的生命周期？
 *  2. 为什么要知道Bean的生命周期？
 *  3. Bean的生命周期之5步
 *  4. Bean的生命周期之7步
 *  5. Bean的生命周期之10步
 *  6. Bean的作用域不同，管理方式不同
 *  7. 自己new的对象如何让Spring管理

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

## 前言 ##

在`Java`中，`Bean`是一个重要的概念，它代表了应用程序中的一个对象。在开发中，我们经常使用`Bean`来管理对象的生命周期。本文将介绍`Bean`的生命周期，并详细讲解如何在`Spring`框架中管理`Bean`的生命周期。

![在这里插入图片描述][2bfb23f4466c430e8b7284d8e63f9918.jpeg_pic_center]

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

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

`Spring`其实就是一个管理`Bean`对象的工厂。它负责对象的创建，对象的销毁等。

所谓的生命周期就是：对象从创建开始到最终销毁的整个过程。`Spring`为每个`Bean`定义了若干个回调方法，使得开发人员可以在某个特定的时间点对Bean进行特定的操作。

## 2. 为什么要知道Bean的生命周期？ ##

其实生命周期的本质是：在哪个时间节点上调用了哪个类的哪个方法。

我们需要充分的了解在这个生命线上，都有哪些特殊的时间节点。

只有我们知道了特殊的时间节点都在哪，到时我们才可以确定代码写到哪。

我们可能需要在某个特殊的时间点上执行一段特定的代码，这段代码就可以放到这个节点上。当生命线走到这里的时候，自然会被调用。

## 3. Bean的生命周期之5步 ##

`Bean`生命周期的管理，可以参考`Spring`的源码：**`AbstractAutowireCapableBeanFactory`类的`doCreateBean()`方法。**\`

Bean生命周期可以粗略的划分为五大步：

*  第一步：实例化`Bean`
 *  第二步：Bean属性赋值
 *  第三步：初始化`Bean`
 *  第四步：使用`Bean`
 *  第五步：销毁`Bean`

![img][img 1]

编写测试程序：

定义一个`Bean`

package com.powernode.spring6.bean;
    
    /**
     * @author 五度鱼
     * @version 1.0
     * @className User
     * @since 1.0
     **/
    public class User {
        
        private String name;
    
        public User() {
        
            System.out.println("1.实例化Bean");
        }
    
        public void setName(String name) {
        
            this.name = name;
            System.out.println("2.Bean属性赋值");
        }
    
        public void initBean(){
        
            System.out.println("3.初始化Bean");
        }
    
        public void destroyBean(){
        
            System.out.println("5.销毁Bean");
        }
    
    }
    <?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="userBean" class="com.powernode.spring6.bean.User" init-method="initBean" destroy-method="destroyBean">
            <property name="name" value="zhangsan"/>
        </bean>
    
    </beans>
    package com.powernode.spring6.test;
    
    import com.powernode.spring6.bean.User;
    import org.junit.Test;
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    
    /**
     * @author 五度鱼
     * @version 1.0
     * @className BeanLifecycleTest
     * @since 1.0
     **/
    public class BeanLifecycleTest {
        
        @Test
        public void testLifecycle(){
        
            ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring.xml");
            User userBean = applicationContext.getBean("userBean", User.class);
            System.out.println("4.使用Bean");
            // 只有正常关闭spring容器才会执行销毁方法
            ClassPathXmlApplicationContext context = (ClassPathXmlApplicationContext) applicationContext;
            context.close();
        }
    }

执行结果：

![img][img 2]

需要注意的：

*  第一：只有正常关闭spring容器，bean的销毁方法才会被调用。
 *  第二：`ClassPathXmlApplicationContext`类才有close()方法。
 *  第三：配置文件中的init-method指定初始化方法。`destroy-method`指定销毁方法。

## 4. Bean的生命周期之7步 ##

在以上的5步中，第3步是初始化Bean，如果你还想在初始化前和初始化后添加代码，可以加入“Bean后处理器”。

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

package com.powernode.spring6.bean;
    
    import org.springframework.beans.BeansException;
    import org.springframework.beans.factory.config.BeanPostProcessor;
    
    /**
     * @author 五度鱼
     * @version 1.0
     * @className LogBeanPostProcessor
     * @since 1.0
     **/
    public class LogBeanPostProcessor implements BeanPostProcessor {
        
        @Override
        public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        
            System.out.println("Bean后处理器的before方法执行，即将开始初始化");
            return bean;
        }
    
        @Override
        public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        
            System.out.println("Bean后处理器的after方法执行，已完成初始化");
            return bean;
        }
    }

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

<bean class="com.powernode.spring6.bean.LogBeanPostProcessor"/>

**一定要注意：在`spring.xml`文件中配置的`Bean`后处理器将作用于当前配置文件中所有的`Bean`。**

执行测试程序：

![img][img 3]

如果加上`Bean后处理器`的话，`Bean`的生命周期就是7步了：

![img][img 4]

## 5. Bean的生命周期之10步 ##

如果根据源码跟踪，可以划分更细粒度的步骤，10步：

![img][img 5]

上图中检查Bean是否实现了`Aware`的相关接口是什么意思？

`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`

代码如下：

package com.powernode.spring6.bean;
    
    import org.springframework.beans.BeansException;
    import org.springframework.beans.factory.*;
    
    /**
     * @author 五度鱼
     * @version 1.0
     * @className User
     * @since 1.0
     **/
    public class User implements BeanNameAware, BeanClassLoaderAware, BeanFactoryAware, InitializingBean, DisposableBean {
        
        private String name;
    
        public User() {
        
            System.out.println("1.实例化Bean");
        }
    
        public void setName(String name) {
        
            this.name = name;
            System.out.println("2.Bean属性赋值");
        }
    
        public void initBean(){
        
            System.out.println("6.初始化Bean");
        }
    
        public void destroyBean(){
        
            System.out.println("10.销毁Bean");
        }
    
        @Override
        public void setBeanClassLoader(ClassLoader classLoader) {
        
            System.out.println("3.类加载器：" + classLoader);
        }
    
        @Override
        public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
        
            System.out.println("3.Bean工厂：" + beanFactory);
        }
    
        @Override
        public void setBeanName(String name) {
        
            System.out.println("3.bean名字：" + name);
        }
    
        @Override
        public void destroy() throws Exception {
        
            System.out.println("9.DisposableBean destroy");
        }
    
        @Override
        public void afterPropertiesSet() throws Exception {
        
            System.out.println("5.afterPropertiesSet执行");
        }
    }
    package com.powernode.spring6.bean;
    
    import org.springframework.beans.BeansException;
    import org.springframework.beans.factory.config.BeanPostProcessor;
    
    /**
     * @author 五度鱼
     * @version 1.0
     * @className LogBeanPostProcessor
     * @since 1.0
     **/
    public class LogBeanPostProcessor implements BeanPostProcessor {
        
        @Override
        public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        
            System.out.println("4.Bean后处理器的before方法执行，即将开始初始化");
            return bean;
        }
    
        @Override
        public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        
            System.out.println("7.Bean后处理器的after方法执行，已完成初始化");
            return bean;
        }
    }

执行结果：

![img][img 6]

**通过测试可以看出来：**

*  **`InitializingBean`的方法早于`init-method`的执行。**
 *  **`DisposableBean`的方法早于`destroy-method`的执行。**

对于`SpringBean`的生命周期，掌握之前的7步即可。够用。

## 6. Bean的作用域不同，管理方式不同 ##

`Spring` 根据`Bean`的作用域来选择管理方式。

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

把之前`User`类的`spring.xml`文件中的配置`scope`设置为`prototype`：

<?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="userBean" class="com.powernode.spring6.bean.User" init-method="initBean" destroy-method="destroyBean" scope="prototype">
            <property name="name" value="zhangsan"/>
        </bean>
    
        
        <bean class="com.powernode.spring6.bean.LogBeanPostProcessor"/>
    
    </beans>

执行测试程序：

![img][img 7]

通过测试一目了然。只执行了前8步，第9和10都没有执行。

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

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

package com.powernode.spring6.bean;
    
    /**
     * @author 五度鱼
     * @version 1.0
     * @className User
     * @since 1.0
     **/
    public class User {
        
    }
    package com.powernode.spring6.test;
    
    import com.powernode.spring6.bean.User;
    import org.junit.Test;
    import org.springframework.beans.factory.support.DefaultListableBeanFactory;
    
    /**
     * @author 五度鱼
     * @version 1.0
     * @className RegisterBeanTest
     * @since 1.0
     **/
    public class RegisterBeanTest {
        
    
        @Test
        public void testBeanRegister(){
        
            // 自己new的对象
            User user = new User();
            System.out.println(user);
    
            // 创建 默认可列表BeanFactory 对象
            DefaultListableBeanFactory factory = new DefaultListableBeanFactory();
            // 注册Bean
            factory.registerSingleton("userBean", user);
            // 从spring容器中获取bean
            User userBean = factory.getBean("userBean", User.class);
            System.out.println(userBean);
        }
    }

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

**最后求个关注，点赞，收藏，谢谢！**

[img]: https://img-blog.csdnimg.cn/63748e72dc314943857316f3b1f6a386.gif#pic_center
[Java]: https://blog.csdn.net/qq_46096136?spm=1000.2115.3001.5343
[2bfb23f4466c430e8b7284d8e63f9918.jpeg_pic_center]: https://img-blog.csdnimg.cn/2bfb23f4466c430e8b7284d8e63f9918.jpeg#pic_center
[img 1]: https://img-blog.csdnimg.cn/img_convert/7912fabc6086df014899b9466b5a3ca8.png
[img 2]: https://img-blog.csdnimg.cn/img_convert/030f697032f365769ab83548ec742c16.png#pic_center
[img 3]: https://img-blog.csdnimg.cn/img_convert/ba01d3945261c2dbd5004d63728d9e40.png#pic_center
[img 4]: https://img-blog.csdnimg.cn/img_convert/7623b593fed56960588999e1af3c03d2.png
[img 5]: https://img-blog.csdnimg.cn/img_convert/fbed30541b207806336adc93abd7f107.png#pic_center
[img 6]: https://img-blog.csdnimg.cn/img_convert/c8b0c08a8b39c45a3646b871225bce01.png#pic_center
[img 7]: https://img-blog.csdnimg.cn/img_convert/7e19902ad05bba1b727154655835ba64.png#pic_center