Spring Bean 生命周期

相关接口的分类

分类	接口	调用时间
工厂后处理器接口	BeanFactoryPostProcessor	容器创建完毕，装配Bean源后立即调用
容器后处理器接口	InstantiationAwareBeanPostProcessor	分别在调用构造之前，注入属性之前，实例化完成时调用
容器后处理器接口	BeanPostProcessor	分别在Bean的初始化方法调用前后执行
Bean级后置处理器接口	BeanNameAware	注入属性后调用
Bean级后置处理器接口	BeanFactoryAware	注入属性后调用
Bean级后置处理器接口	InitializingBean	在类本身的初始化方法之前调用其方法（本身也是初始化方法）
Bean级后置处理器接口	DiposableBean	在类本身的销毁方法执行之前调用其方法（本身也是销毁方法）
Bean本身方法	init方法	在注入属性之后调用初始化方法
Bean本身方法	destroy方法	在关闭容器的时候进行销毁

  实例

一、BeanFactoryPostProcessor接口：允许在 Spring 容器加载 Bean 定义之后，但是实例化 Bean 之前，对 Bean 的配置进行修改。

/**
 * BeanFactoryPostProcessor 接口允许在 Spring 容器加载 Bean 定义之后，但是实例化 Bean 之前，对 Bean 的配置进行修改。
 */
@Component
public class MyBeanFactoryPostProcessor implements BeanFactoryPostProcessor {
    public MyBeanFactoryPostProcessor() {
        super();
        System.out.println("【工厂构造】这是BeanFactoryPostProcessor实现类构造器！！");
    }

    /**
     * 这个类的主要作用是在 Spring 容器加载 Bean 定义后，通过实现 postProcessBeanFactory 方法来修改名为 "person" 的 Bean 的属性值。
     */
    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory configurableListableBeanFactory) throws BeansException {
        System.out.println("【工厂方法】BeanFactoryPostProcessor调用postProcessBeanFactory方法");
        BeanDefinition bd = configurableListableBeanFactory.getBeanDefinition("person");
        bd.getPropertyValues().addPropertyValue("name", "110");
    }
}

二、BeanPostProcessor接口：允许您在 Spring 容器实例化 Bean 之后，在特定的初始化方法调用的前/后阶段对 Bean 进行自定义处理

/**
 * BeanPostProcessor 接口允许您在 Spring 容器实例化 Bean 之后，在特定的初始化方法调用的前/后阶段对 Bean 进行自定义处理
 */
@Component
public class MyBeanPostProcessor implements BeanPostProcessor {

    public MyBeanPostProcessor() {
        super();
        System.out.println("【容器构造】这是BeanPostProcessor实现类构造器！！");
    }

    /**
     * 在 Bean 实例化后，但在初始化方法（如 @PostConstruct 或实现了 InitializingBean 接口的方法）调用之前调用，它允许您在 Bean 初始化之前进行一些自定义处理
     */
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("【容器方法】BeanPostProcessor接口方法postProcessBeforeInitialization对属性进行更改！");
        return bean;
    }

    /**
     * 在 Bean 初始化方法调用之后被调用。它允许您在 Bean 初始化之后进行一些自定义处理
     */
    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("【容器方法】BeanPostProcessor接口方法postProcessAfterInitialization对属性进行更改！");
        return bean;
    }
}

三、InstantiationAwareBeanPostProcessor 接口允许您在 Bean 实例化过程中的不同阶段进行自定义处理。

/**
 * InstantiationAwareBeanPostProcessor 接口允许您在 Bean 实例化过程中的不同阶段进行自定义处理。
 */
@Component
public class MyInstantiationAwareBeanPostProcessor extends InstantiationAwareBeanPostProcessorAdapter {
    public MyInstantiationAwareBeanPostProcessor() {
        super();
        System.out.println("【容器构造】这是InstantiationAwareBeanPostProcessorAdapter实现类构造器！！");
    }

    /**
     * 在实例化 Bean 之前被调用。这个方法允许您返回一个代替实际 Bean 实例的对象。
     */
    @Override
    public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException {
        System.out.println("【容器方法】InstantiationAwareBeanPostProcessor调用postProcessBeforeInstantiation方法");
        return null;
    }

    /**
     * 在 Bean 实例化后立即调用。这个方法返回一个布尔值，表示是否继续进行后续的属性填充。
     */
    @Override
    public boolean postProcessAfterInstantiation(Object bean, String beanName) throws BeansException {
        System.out.println("【容器方法】InstantiationAwareBeanPostProcessor调用postProcessAfterInitialization方法");
        return true;
    }

    /**
     * 在设置 Bean 的属性值之前被调用。这个方法允许您检查和修改属性值。
     */
    @Override
    public PropertyValues postProcessPropertyValues(PropertyValues pvs, PropertyDescriptor[] pds, Object bean, String beanName) throws BeansException {
        System.out.println("【容器方法】InstantiationAwareBeanPostProcessor调用postProcessPropertyValues方法");
        return pvs;
    }
}

四、定义了一个名为 Person 的类，它实现了一系列 Spring 框架的接口以及提供了一些自定义的初始化和销毁方法，这些接口和方法允许您在 Spring 容器中管理 Bean 的生命周期和属性注入。

/**
 * BeanFactoryAware：实现了这个接口，可以让该类获得对应的 BeanFactory，从而可以在类内部通过编程方式操作 Spring 容器。
 * BeanNameAware：实现了这个接口，可以让该类获得其在 Spring 容器中定义的 Bean 名称。
 * InitializingBean：实现了这个接口，可以在 Bean 的属性设置完毕后执行自定义的初始化逻辑。
 * DisposableBean：实现了这个接口，可以在 Bean 被销毁前执行一些清理工作。在 destroy 方法中，可以编写 Bean 销毁时的操作
 */
public class Person implements BeanFactoryAware, BeanNameAware, InitializingBean, DisposableBean {
    private BeanFactory beanFactory;
    private String beanName;

    // 这是BeanFactoryAware接口方法
    @Override
    public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
        System.out.println("【Bean方法：BeanFactoryAware接口】调用BeanFactoryAware.setBeanFactory()");
        this.beanFactory = beanFactory;
    }

    // 这是BeanNameAware接口方法
    @Override
    public void setBeanName(String s) {
        System.out.println("【Bean方法：BeanNameAware接口】调用BeanNameAware.setBeanName()");
        this.beanName = s;
    }

    // 这是InitializingBean接口方法
    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("【Bean方法：InitializingBean接口】调用InitializingBean.afterPropertiesSet()");
    }

    // 这是DiposibleBean接口方法
    @Override
    public void destroy() throws Exception {
        System.out.println("【Bean级别：DiposibleBean接口】调用DiposibleBean.destory()");
    }

    /**
     * 自定义的初始化方法，用于在 Bean 初始化时执行一些逻辑。这个方法可以在 Bean 的配置中通过 init-method 属性进行指定
     */
    public void myInit() {
        System.out.println("【自身方法：init-method】调用<bean>的init-method属性指定的初始化方法");
    }

    /**
     * 自定义的销毁方法，用于在 Bean 销毁时执行一些逻辑。这个方法可以在 Bean 的配置中通过 destroy-method 属性进行指定
     */
    public void myDestory() {
        System.out.println("【自身方法：destroy-method】调用<bean>的destroy-method属性指定的初始化方法");
    }

    private String name;
    private String address;

    public Person() {
        System.out.println("【类构造】调用Person的构造器实例化");
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        System.out.println("【类注入属性】注入属性name");
        this.name = name;
    }

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        System.out.println("【类注入属性】注入属性address");
        this.address = address;
    }

    @Override
    public String toString() {
        return "Person{" +
                "beanFactory=" + beanFactory +
                ", beanName='" + beanName + '\'' +
                ", name='" + name + '\'' +
                ", address='" + address + '\'' +
                '}';
    }
}

五、加载Person Bean，指定自定义初始化方法和销毁方法

@Configuration
public class PersonConfig {
    @Bean(initMethod = "myInit", destroyMethod = "myDestory")
    public Person person() {
        return new Person();
    }
}

六、启动后打印的日志

LOGGER测试：现在开始初始化容器
    【工厂构造】这是BeanFactoryPostProcessor实现类构造器！！
    【工厂方法】BeanFactoryPostProcessor调用postProcessBeanFactory方法
        【容器构造】这是BeanPostProcessor实现类构造器！！
        【容器构造】这是InstantiationAwareBeanPostProcessorAdapter实现类构造器！！
        【容器方法】InstantiationAwareBeanPostProcessor调用postProcessBeforeInstantiation方法
            【类构造】调用Person的构造器实例化
        【容器方法】InstantiationAwareBeanPostProcessor调用postProcessPropertyValues方法
                【类注入属性】注入属性address
                【类注入属性】注入属性name
                【类注入属性】注入属性phone
                【Bean方法：BeanNameAware接口】调用BeanNameAware.setBeanName()
                【Bean方法：BeanFactoryAware接口】调用BeanFactoryAware.setBeanFactory()
            【容器方法】BeanPostProcessor接口方法postProcessBeforeInitialization对属性进行更改！
                【Bean方法：InitializingBean接口】调用InitializingBean.afterPropertiesSet()
                【自身方法：init-method】调用<bean>的init-method属性指定的初始化方法
            【容器方法】BeanPostProcessor接口方法postProcessAfterInitialization对属性进行更改！
        【容器方法】InstantiationAwareBeanPostProcessor调用postProcessAfterInitialization方法
LOGGER测试：容器初始化成功
    Person [address=广州, name=张三, phone=110]
LOGGER测试：现在开始关闭容器！
                【Bean级别：DiposibleBean接口】调用DiposibleBean.destory()
                【自身方法：destroy-method】调用<bean>的destroy-method属性指定的初始化方法