一、具体的生命周期过程

二、创建类user 

package com.atguigu.spring.pojo;

public class User {
    private Integer id;
    private String username;
    private String password;
    private Integer age;

    public User() {
        System.out.println("生命周期：1、创建对象");
    }

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        System.out.println("生命周期：2、依赖注入");
        this.id = id;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public void initMethod() {
        System.out.println("生命周期：3、初始化");
    }

    public void destroyMethod() {
        System.out.println("生命周期：5、销毁");
    }

    public void use() {
        System.out.println("生命周期：4、使用");
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", username='" + username + '\'' +
                ", password='" + password + '\'' +
                ", age=" + age +
                '}';
    }
}

三、配置bean

在 spring-lifecycle.xml 中配置 User 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">

    <!-- 使用 init-method 属性指定初始化方法 -->
    <!-- 使用 destroy-method 属性指定销毁方法 -->
    <bean class="com.atguigu.spring.pojo.User" init-method="initMethod" destroy-method="destroyMethod">
        <property name="id" value="1001"></property>
        <property name="username" value="admin"></property>
        <property name="password" value="123456"></property>
        <property name="age" value="23"></property>
    </bean>

</beans>

四、测试

LifeCycleTest.Java测试代码

package com.atguigu.spring.test;

import com.atguigu.spring.pojo.User;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class LifeCycleTest {
    @Test
    public void testLife0(){
        ClassPathXmlApplicationContext ac = new ClassPathXmlApplicationContext("spring-lifecycle.xml");
        User bean = ac.getBean(User.class);
        System.out.println("生命周期：4、通过IOC容器获取bean并使用");
        ac.close();
    }

    @Test
    public void testLife(){
        //ConfigurableApplicationContext是ApplicatiionContext 的子接口，其中拓展了刷新和关闭容器的方法
        ConfigurableApplicationContext ioc = new ClassPathXmlApplicationContext("spring-lifecycle.xml");
        User user = ioc.getBean(User.class);
        user.use(); // 明确调用“使用”阶段
        System.out.println(user);
        ioc.close();
    }

}

输出结果

生命周期：1、创建对象
生命周期：2、依赖注入
生命周期：3、初始化
生命周期：4、使用
User{id=1001, username='admin', password='123456', age=23}
生命周期：5、销毁

进程已结束，退出代码为 0

五、bean的后置处理器实现步骤

Bean 后置处理器（BeanPostProcessor）是 Spring 提供的一个扩展点，允许我们在 Bean 初始化前后执行自定义逻辑。

1.实现 BeanPostProcessor

package com.atguigu.spring.process;

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor;

public class MyBeanProcessor implements BeanPostProcessor {
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("☆☆☆" + beanName + " = " + bean);
        System.out.println("MyBeanProcessor-->后置处理器postProcessBeforeInitialization");
        return bean;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("★★★" + beanName + " = " + bean);
        System.out.println("MyBeanProcessor-->后置处理器postProcessAfterInitialization");
        return bean;
    }
}

2.配置后置处理器

在 spring-lifecycle.xml 中配置后置处理器：

<bean class="com.atguigu.spring.process.MyBeanProcessor"/>

---

3. 测试代码

LifeCycleTest 类

package com.atguigu.spring.test;

import com.atguigu.spring.pojo.User;
import org.junit.Test;
import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class LifeCycleTest {
    @Test
    public void testLife(){
        // ConfigurableApplicationContext是ApplicationContext的子接口，其中拓展了刷新和关闭容器的方法
        ConfigurableApplicationContext ioc = new ClassPathXmlApplicationContext("spring-lifecycle.xml");
        User user = ioc.getBean(User.class);
        user.use(); // 明确调用“使用”阶段
        System.out.println(user);
        ioc.close(); // 关闭容器，触发销毁方法
    }
}

---

4. 输出结果

生命周期：1、创建对象
生命周期：2、依赖注入
☆☆☆com.atguigu.spring.pojo.User#0 = User{id=1001, username='admin', password='123456', age=23}
MyBeanProcessor-->后置处理器postProcessBeforeInitialization
生命周期：3、初始化
★★★com.atguigu.spring.pojo.User#0 = User{id=1001, username='admin', password='123456', age=23}
MyBeanProcessor-->后置处理器postProcessAfterInitialization
生命周期：4、使用
User{id=1001, username='admin', password='123456', age=23}
生命周期：5、销毁

---

5. 分析

1. Bean 后置处理器的作用：在 Bean 初始化前后执行自定义逻辑。适用于所有 Bean，而不是单独针对某一个 Bean。

2. 生命周期顺序：实例化 → 依赖注入 → postProcessBeforeInitialization → 初始化 → postProcessAfterInitialization → 使用 → 销毁。

3. 配置方式：通过实现 BeanPostProcessor 接口，并在 Spring 配置文件中注册。