bean裝載到Spring應用上下文的生命周期

在基於Spring的應用中，應用對象生存於Spring容器中，Spring容器負責創建對象，裝配對象，配置對象，並管理對象的整個生命周期，從生存到死亡。

bean裝載到Spring應用上下文中的生命周期過程如圖所示：

過程解釋：
1. Spring對bean進行實例化；

2. Spring將值和bean的引用注入到bean對應的屬性中；

3. 如果bean實現了BeanNameAware接口，Spring將bean的ID傳遞給setBeanName()方法；

4. 如果bean實現了BeanFactoryAware接口，Spring將調用setBeanFactory()方法，將BeanFactory容器實例傳入；

5. 如果bean實現了ApplicationContextAware接口，Spring將調用setApplicationContext()方法，將bean所在的應用上下文的引用傳入進來；

6. 如果bean實現了BeanPostProcessor接口，Spring將調用它們的postProcessBeforeIniitialization()方法；

7. 如果bean實現了InitializingBean接口，Spring將調用它們的afterPropertiesSet()方法。

8. 如果bean使用initMethod聲明了初始化方法，該方法也會被調用；

9. 如果bean實現了BeanPostProcessor接口，Spring將調用的postProcessAfterInitialization()方法；

10. 此時，bean已經准備就緒，可以被應用程序使用了，它們將一直駐留在應用上下文中，直到該應用上下文被銷毀；

11. 如果bean實現了DisposableBean接口，Spring將調用它的destroy()接口方法。

12. 如果bean使用destroy-method聲明了銷毀方法，該方法也會被調用。

 

測試代碼：

package beanlifecycle;

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.*;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;

/**
 * bean的定義
 */
public class MySpringBeanLifeCycle implements
        BeanNameAware,
        BeanFactoryAware,
        ApplicationContextAware,
        InitializingBean,
        DisposableBean {

    private ApplicationContext applicationContext;

    public MySpringBeanLifeCycle() {
        System.out.println("實例化 MySpringBeanLifeCycle ...");
    }

    @Override
    public void setBeanName(String s) {
        System.out.println("BeanNameAware -> setBeanName ...");
    }

    @Override
    public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
        System.out.println("BeanFactoryAware --> setBeanFactory ...");
    }

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        System.out.println("ApplicationContextAware -> setApplicationContext ...");
    }

    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("InitializingBean -> afterPropertiesSet ...");
    }

    @Override
    public void destroy() throws Exception {
        System.out.println("DisposableBean -> destroy...");
    }

    public void customInit() {
        System.out.println("自定義初始化方法...");
    }

    public void customDestroy() {
        System.out.println("自定義銷毀方法...");
    }
}

 

package beanlifecycle;

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

/**
 * 實現BeanPostProcessor接口
 */
public class MySpringBeanPostProcessor implements BeanPostProcessor {

    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        if (bean instanceof MySpringBeanLifeCycle) {
            System.out.println("BeanPostProcessor -> postProcessBeforeInitialization ...");
        }
        return bean;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        if (bean instanceof MySpringBeanLifeCycle) {
            System.out.println("BeanPostProcessor -> postProcessAfterInitialization ...");
        }
        return bean;
    }
}

 

package beanlifecycle;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * bean配置類
 */
@Configuration
public class BeanLifeCycleConfig {

    @Bean(initMethod = "customInit", destroyMethod = "customDestroy")
    public MySpringBeanLifeCycle mySpringBeanLifeCycle() {
        return new MySpringBeanLifeCycle();
    }

    @Bean
    public MySpringBeanPostProcessor mySpringBeanPostProcessor() {
        return new MySpringBeanPostProcessor();
    }
}

 

package beanlifecycle;

import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class Main {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(BeanLifeCycleConfig.class);
        context.getBean(MySpringBeanLifeCycle.class);
        context.destroy();
    }
}

 

運行結果

實例化 MySpringBeanLifeCycle ...
BeanNameAware -> setBeanName ...
BeanFactoryAware --> setBeanFactory ...
ApplicationContextAware -> setApplicationContext ...
BeanPostProcessor -> postProcessBeforeInitialization ...
InitializingBean -> afterPropertiesSet ...
自定義初始化方法...
BeanPostProcessor -> postProcessAfterInitialization ...
DisposableBean -> destroy...
自定義銷毀方法...

 

參考《Spring實戰（第4版）》