参考文章

Spring生命周期描述

Bean 容器找到配置文件中 Spring Bean 的定义。
Bean 容器利用 Java Reflection API 创建一个Bean的实例。
如果涉及到一些属性值利用 set()方法设置一些属性值。
如果 Bean 实现了 BeanNameAware 接口，调用 setBeanName()方法，传入Bean的名字。
如果 Bean 实现了 BeanClassLoaderAware 接口，调用 setBeanClassLoader()方法，传入 ClassLoader对象的实例。
与上面的类似，如果实现了其他 *.Aware接口，就调用相应的方法。
如果有和加载这个 Bean 的 Spring 容器相关的 BeanPostProcessor 对象，执行postProcessBeforeInitialization() 方法
如果Bean实现了InitializingBean接口，执行afterPropertiesSet()方法。
如果 Bean 在配置文件中的定义包含 init-method 属性，执行指定的方法。
如果有和加载这个 Bean的 Spring 容器相关的 BeanPostProcessor 对象，执行postProcessAfterInitialization() 方法
当要销毁 Bean 的时候，如果 Bean 实现了 DisposableBean 接口，执行 destroy() 方法。
当要销毁 Bean 的时候，如果 Bean 在配置文件中的定义包含 destroy-method 属性，执行指定的方法。

图示

image.png

Spring生命周期测试代码

Spring生命周期Bean目标类

/**
 * @ClassName Book
 * @Description Spring生命周期Bean目标类
 * @Author Edison_Lv
 * @Version 1.0
 * @Date 2020/5/18 21:53
 */
public class Book implements BeanNameAware, BeanFactoryAware, ApplicationContextAware, InitializingBean, DisposableBean {
    private String bookName;

    public String getBookName() {
        return bookName;
    }

    public void setBookName(String bookName) {
        System.out.println("Book.setBookName invoke====from bean的属性值的一些set()方法");
        this.bookName = bookName;
    }

    public Book() {
        System.out.println("Book Contructor====from 构造方法");
    }

    public Book(String bookName) {
        this.bookName = bookName;
    }

    @Override
    public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
        System.out.println("Book.setBeanFactory invoke====from BeanNameAware");
    }
 
    @Override
    public void setBeanName(String s) {
        System.out.println("Book.setBeanName invoke====from BeanNameAware");
    }

    @Override
    public void destroy() throws Exception {
        System.out.println("Book.destory invoke====from DisposableBean");
    }

    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("Book.afterPropertiesSet invoke====from InitializingBean");
    }
 
    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        System.out.println("Book.setApplicationContext invoke====from ApplicationContextAware");
    }

    public void myPostConstruct(){
        System.out.println("Book.myPostConstruct invoke====from XX.xml的init-method");
    }

    // 自定义初始化方法
    @PostConstruct
    public void springPostConstruct(){
        System.out.println("@PostConstruct Method invoke  ====from @PostConstruct");
    }

    public void myPreDestory(){
        System.out.println("Book.myPreDestory invoke====from XX.xml的destroy-method");
        System.out.println("---------------destroy-----------------");
    }


    // 自定义销毁方法
    @PreDestroy
    public void springPreDestory(){
        System.out.println("@PreDestory Method invoke====from @PreDestroy");
    }

    @Override
    protected void finalize() throws Throwable {
        System.out.println("------inside finalize-----from Object.finalize()");
    }
}

自定义实现BeanPostProcessor 的MyBeanPostProcessor

/**
 * @ClassName MyBeanPostProcessor
 * @Description 自定义实现BeanPostProcessor 的MyBeanPostProcessor：
 * @Author Edison_Lv
 * @Version 1.0
 * @Date 2020/5/18 22:05
 */
public class MyBeanPostProcessor implements BeanPostProcessor {

    /**
     * @description 容器加载的时候会加载一些其他的bean，会调用初始化前和初始化后方法
     * 这次只关注book(bean)的生命周期
     * @date  2020/5/18 22:06
     * @param bean
     * @param beanName
     * @return {@link Object}
     * @author Edison_Lv
     **/
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        if(bean instanceof Book){
            System.out.println("MyBeanPostProcessor.postProcessBeforeInitialization====from BeanPostProcessor 所有spring Bean");
        }
        return bean;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        if(bean instanceof Book){
            System.out.println("MyBeanPostProcessor.postProcessAfterInitialization====from BeanPostProcessor 所有spring Bean");
        }
        return bean;
    }
}

SpringBeanLifecycleApplication Spring Bean生命周期测试启动类

/**
 * @ClassName SpringBeanLifecycleApplication
 * @Description Spring Bean生命周期测试类
 * @Author Edison_Lv
 * @Version 1.0
 * @Date 2020/5/18 22:09
 */
public class SpringBeanLifecycleApplication {

    public static void main(String[] args) {
        // Bean生命周期加载过程
        ApplicationContext context = new ClassPathXmlApplicationContext("classpath:Bean-Lifecycle.xml");
        Book book = (Book)context.getBean("book");
        System.out.println("Book name = " + book.getBookName()+" from 使用bean");
        ((ClassPathXmlApplicationContext) context).destroy();
    }
}

对应xml文件 Bean-Lifecycle.xml

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-2.5.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">
    <!-- 扫描bean -->
    <context:component-scan base-package="com.lvcr.demo.spring.beanlifecycle"/>
    <!-- 实现了用户自定义初始化和销毁方法 -->
    <bean id="book" class="com.lvcr.demo.spring.beanlifecycle.Book" init-method="myPostConstruct" destroy-method="myPreDestory">
        <!-- 注入bean 属性名称 -->
        <property name="bookName" value="thingking in java" />
    </bean>
    <!--引入自定义的BeanPostProcessor-->
    <bean class="com.lvcr.demo.spring.beanlifecycle.MyBeanPostProcessor"/>
</beans>