SpringBean的生命周期

秒速五厘米 2023-10-09 15:32 49阅读 0赞

#### SpringBean的生命周期 ####

*  一：前言
 *  二：什么是SpringBean的生命周期
 *  三：SpringBean与普通java对象的生命周期的不同
 *   *  3.1 普通java对象
     *  3.2 springBean对象
 *  四：springBean对象生命周期分析
 *   *  4.1宏观：
     *  4.2微观：
 *  五：SpringBean生命周期具体实例
 *   *  5.1 项目结构
     *  5.2 具体代码
     *   *  5.2.1 PersonBean
         *   *  5.2.1.1 代码解释
         *  5.2.2 定制处理器类
         *   *  5.2.2.1 代码解释
         *  5.2.3 springBean配置文件
 *  六：总结&提升

## 一：前言 ##

下文要讲的均是spring的默认作用域singleton的bean的生命周期，对spring作用域不了解的可以参考我的这篇文章  
[springbean的作用域][springbean]

## 二：什么是SpringBean的生命周期 ##

springBean的生命周期，指的是spring里一个**bean对象**从出生到死亡的整个过程。解 Spring 生命周期的之后，可以利用 Bean 在其存活期间的指定时刻完成一些相关操作。这种时刻可能有很多，但一般情况下，会在 Bean 被初始化后和被销毁前执行一些相关操作。

## 三：SpringBean与普通java对象的生命周期的不同 ##

### 3.1 普通java对象 ###

1.  new的时候创建对象
2.  对象不再使用，java自动进行垃圾回收

### 3.2 springBean对象 ###

1.  实例化
2.  属性赋值
3.  初始化
4.  使用
5.  销毁

## 四：springBean对象生命周期分析 ##

### 4.1宏观： ###

![在这里插入图片描述][63f522b8018c4bf2a2f3afbf381a1ec2.png]

### 4.2微观： ###

![在这里插入图片描述][64bf6a34a8c34a95858795a0764e7a3f.png]  
在上面两个图片中，我将springBean的生命周期分别从宏观和微观进行了表示，下面用一个例子来给大家看一下各个不同的生命周期

## 五：SpringBean生命周期具体实例 ##

### 5.1 项目结构 ###

此项目结构与[springBean作用域][springbean]项目结构一致，在这里就不多进行赘述  
![在这里插入图片描述][da7dd037baed4e2282d54a92809b13c9.png]

### 5.2 具体代码 ###

#### 5.2.1 PersonBean ####

PersonBean类，此类为我们**要展示的bean对象**

package com.tfjy.test2;
    
    import org.springframework.beans.BeansException;
    import org.springframework.beans.factory.*;
    
    /**
     * @BelongsProject: demo
     * @BelongsPackage: com.tfjy.test2
     * @Author: haolizhuo
     * @Description: Bean的生命周期
     * @CreateTime: 2023-01-29 20:53
     * @Version: 1.0
     */
    public class PersonBean implements InitializingBean, BeanFactoryAware, BeanNameAware, DisposableBean {
        
    
        /**
         * 身份证号
         */
        private Integer no;
    
        /**
         * 姓名
         */
        private String name;
    
        //最先走的方法就是调用构造函数，创建具体对象
        public PersonBean() {
        
            System.out.println("1.调用构造方法：我出生了！");
        }
    
    
        public Integer getNo() {
        
            return no;
        }
    
        public void setNo(Integer no) {
        
            this.no = no;
        }
    
        public String getName() {
        
            return name;
        }
    
        public void setName(String name) {
        
            this.name = name;
            System.out.println("2.设置属性：我的名字叫" + name);
        }
    
        //BeanNameAware接口，通过这个接口设置bean的id
        @Override
        public void setBeanName(String s) {
        
            System.out.println("3.调用BeanNameAware#setBeanName方法:我的bean的名字叫做" + s);
        }
    
    
        //    BeanFactoryAware 用于注入BeanFactory对象，能访问创建对象的BeanFactory。
        @Override
        public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
        
            System.out.println("4.调用BeanFactoryAware#setBeanFactory方法：注入BeanFactory对象");
        }
    
        //    InitializingBean 接口
        @Override
        public void afterPropertiesSet() throws Exception {
        
            System.out.println("6.InitializingBean#afterPropertiesSet方法：开始初始化");
        }
    
        //在创建bean的时候，会走这个对应的初始化方法
        public void init() {
        
            System.out.println("7.自定义init方法：自定义初始化");
        }
    
    
        //销毁一个bean对象
        @Override
        public void destroy() throws Exception {
        
            System.out.println("9.DisposableBean#destroy方法：开始销毁");
        }
    
        public void destroyMethod() {
        
            System.out.println("10.自定义destroy方法:自定义销毁");
        }
    
        public void work() {
        
            System.out.println("Bean使用中~~~~");
        }
    
    }

##### 5.2.1.1 代码解释 #####

这是一个 Java 类的代码，名为 PersonBean，它实现了 Spring 框架中的几个接口：InitializingBean、BeanFactoryAware、BeanNameAware、DisposableBean。下面是这个类的详细解释：

*  PersonBean()：这是 PersonBean 的构造函数，它在对象创建时被调用，并打印一条消息：「1.调用构造方法：我出生了！」。
 *  getNo() 和 setNo(Integer no)：这两个方法是 no 属性的 getter 和 setter，用于获取和设置对象的身份证号。
 *  getName() 和 setName(String name)：这两个方法是 name 属性的 getter 和 setter，用于获取和设置对象的姓名。当 name 属性被设置时，会打印一条消息：「2.设置属性：我的名字叫 xxx」。
 *  setBeanName(String s)：这个方法是 BeanNameAware 接口中的方法，用于设置对象的名称。当对象被创建时，Spring 容器会调用这个方法，并打印一条消息：「3.调用BeanNameAware\#setBeanName方法:我的bean的名字叫做 xxx」。
 *  setBeanFactory(BeanFactory beanFactory)：这个方法是 BeanFactoryAware 接口中的方法，用于设置对象所在的 BeanFactory。当对象被创建时，Spring 容器会调用这个方法，并打印一条消息：「4.调用BeanFactoryAware\#setBeanFactory方法：注入BeanFactory对象」。
 *  afterPropertiesSet()：这个方法是 InitializingBean 接口中的方法，用于在对象初始化完成后执行。当对象被创建时，Spring 容器会调用这个方法，并打印一条消息：「6.InitializingBean\#afterPropertiesSet方法：开始初始化」。
 *  init()：这是一个自定义的初始化方法，它在对象初始化完成后被调用，并打印一条消息：「7.自定义init方法：自定义初始化」。
 *  destroy()：这个方法是 DisposableBean 接口中的方法，用于在对象销毁时执行。当对象被销毁时，Spring 容器会调用这个方法，并打印一条消息：「9.DisposableBean\#destroy方法：开始销毁」。
 *  destroyMethod()：这是一个自定义的销毁方法，它在对象销毁时被调用，并打印一条消息：「10.自定义destroy方法:自定义销毁」。
 *  work()：这是一个自定义的方法，用于表示对象正在使用中，它会打印一条消息：「Bean使用中~~~~」。

#### 5.2.2 定制处理器类 ####

package com.tfjy.test2;
    
    import org.springframework.beans.BeansException;
    import org.springframework.beans.factory.config.BeanPostProcessor;
    
    /**
     * @BelongsProject: demo
     * @BelongsPackage: com.tfjy.test2
     * @Author: haolizhuo
     * @Description: 自定义的后处理器
     * @CreateTime: 2023-01-29 20:54
     * @Version: 1.0
     */
    public class MyBeanPostProcessor implements BeanPostProcessor {
        
    
        //前置处理器，bean对象初始化前的动作
        @Override
        public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        
            System.out.println("5.BeanPostProcessor.postProcessBeforeInitialization方法：bean对象初始化之前的动作");
            return bean;
        }
    
    
        //后置处理器，创建bean对象结束后走这里
        @Override
        public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        
            System.out.println("8.BeanPostProcessor#postProcessAfterInitialization方法：bean对象初始化之后的动作");
            return bean;
        }
    }

##### 5.2.2.1 代码解释 #####

这段代码定义了一个自定义的Bean后处理器类 MyBeanPostProcessor 实现了 Spring 框架中的 BeanPostProcessor 接口，可以用于在 Bean 的初始化前后进行一些定制化的处理。

*  该类实现了 postProcessBeforeInitialization 和 postProcessAfterInitialization 方法，分别用于在 Bean 初始化前和初始化后进行定制化的处理。这些方法都需要返回一个对象，表示处理后的 Bean 对象。
 *  在 postProcessBeforeInitialization 方法中，该后处理器对 Bean 进行一些初始化前的处理操作，例如对 Bean 进行属性设置、修改等。
 *  在 postProcessAfterInitialization 方法中，该后处理器对 Bean 进行一些初始化后的处理操作，例如对 Bean 进行额外的操作、修改等。
 *  这些后处理器可以在 Spring 容器启动时通过配置文件或者注解等方式指定，并会在 Bean 的创建过程中被自动调用。

#### 5.2.3 springBean配置文件 ####

在配置文件中通过。 init-method=“init” destroy-method="destroyMethod"分别为personBean对象配置初始化和销毁两个生命周期。

<?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 name="myBeanPostProcessor" class="com.tfjy.test2.MyBeanPostProcessor" />
        <bean name="personBean" class="com.tfjy.test2.PersonBean"
              init-method="init" destroy-method="destroyMethod">
            <property name="no" value= "80669865"/>
            <property name="name" value="张铁钢" />
        </bean>
    
    </beans>

通过springBean对象生命周期的学习，我们可以更好的了解spring里，Bean从出生到销毁的过程，并且可以利用一些操作，进行特殊处理。

## 六：总结&提升 ##

此篇文章我们进行了springBean的生命周期进行了分享，并且与普通的java对象进行了对比。通过这篇文章我们能更好的认识到SpringBean 的生命周期，更好的使用好spring这个开发者的春天。

[springbean]: https://blog.csdn.net/hlzdbk/article/details/128811271?spm=1001.2014.3001.5502
[63f522b8018c4bf2a2f3afbf381a1ec2.png]: https://img-blog.csdnimg.cn/63f522b8018c4bf2a2f3afbf381a1ec2.png
[64bf6a34a8c34a95858795a0764e7a3f.png]: https://img-blog.csdnimg.cn/64bf6a34a8c34a95858795a0764e7a3f.png
[da7dd037baed4e2282d54a92809b13c9.png]: https://img-blog.csdnimg.cn/da7dd037baed4e2282d54a92809b13c9.png