Spring框架——bean的生命週期

Spring 中 bean 的生命週期

bean 生命週期

​ bean 的生命週期大致流程如下，後面會爲大家解釋每個流程具體的作用

1. instantiate bean 對象實例化
2. populate properties 封裝屬性
3. 如果Bean實現 BeanNameAware 執行 setBeanName
4. 如果 Bean 實現 BeanFactoryAware 執行 setBeanFactory，獲取 Spring 容器
5. 如果存在類實現 BeanPostProcessor（後處理Bean），執行 postProcessBeforeInitialization
6. 如果 Bean 實現 InitializingBean 執行 afterPropertiesSet
7. 調用<bean init-method="init">指定初始化方法 init
8. 如果存在類實現 BeanPostProcessor（處理Bean），執行 postProcessAfterInitialization
9. 如果 Bean 實現 DisposableBean 執行 destroy
10. 調用<bean destroy-method="customerDestroy">指定銷燬方法 customerDestroy

對象實例化

​ bean 的生命週期從對象的實例化開始，當運行到下面的代碼時，就會實例化beans5.xml中bean標籤所定義的對象，並執行其構造方法

ApplicationContext context = new ClassPathXmlApplicationContext("beans5.xml");

封裝屬性

​ 接下來，Spring 會根據bean標籤下的property標籤來爲對象賦值，即依賴注入（封裝屬性），這時實際執行的是實現類中對應屬性的set方法，也就是說，想要通過這個方式爲對象封裝屬性，實現類中必須含有對應屬性的set方法

private String name;
private String password;

public String getName() {
    return name;
}

public void setName(String name) {
    this.name = name;
    System.out.println("set name");
}

public String getPassword() {
    return password;
}

public void setPassword(String password) {
    this.password = password;
    System.out.println("set password");
}

<bean id="user" class="com.lmh.model.User" init-method="myInit" destroy-method="myDestroy">
    <property name="name" value="lmh"></property>
    <property name="password" value="123"></property>
</bean>

BeanNameAware

​ 如果實現類中實現了BeanNameAware接口，那麼接下來對象就會執行重寫的setBeanName方法

@Override
public void setBeanName(String s) {
	// s：bean.xml 中的 bean id
	System.out.println("set Bean name: " + s);
}

​ 通過輸出我們知道，setBeanName函數的參數s爲bean標籤中的id屬性的值

BeanFactoryAware

​ 如果實現類中實現了BeanFactoryAware接口，接下來對象會執行重寫的setBeanFactory方法

@Override
public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
    // 工廠生產對象後放進容器中去
    System.out.println("Bean Factory: " + beanFactory);
}

​ 此時是 Bean 工廠生產的對象被放進 Spring 容器中的過程

BeanPostProcessor

​ BeanPostProcessor是 Spring IOC 容器提供的一種處理器接口，可以理解成一種對所有beans.xml中對象均有效的處理器

​ 使用時我們需要自定義處理器類，實現BeanPostProcessor接口，重寫其postProcessBeforeInitialization和postProcessAfterInitialization方法

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

public class MyBeanProcessor implements BeanPostProcessor {
    // 對所有對象有效
    @Override
    public Object postProcessBeforeInitialization(Object o, String s) throws BeansException {
        // 可用於多個對象的共同事情
        System.out.println("Before: " + s + " : " + o);
        return o;
    }

    @Override
    public Object postProcessAfterInitialization(Object o, String s) throws BeansException {
        System.out.println("After: " + s + " : " + o);
        return o;
    }
}

​ 其中o爲當前執行處理器的對象，s爲 bean 的id 屬性值，這裏postProcessBeforeInitialization方法在 bean 的生命週期中會在上一步後執行，而postProcessAfterInitialization圖中 Bean Is Ready To Use 之前執行

InitializingBean

​ 如果實現類中實現了InitializingBean接口，對象接下來會調用重寫的afterPropertiesSet方法

@Override
public void afterPropertiesSet() throws Exception {
    System.out.println("6.Pro is seted...");
}

自定義 Init 方法

​ 隨後，如果我們在實現類中自定義了 Init 方法，再bean標籤中設置了init-method="init"屬性後，自定義的 Init 方法會在這時執行

public void myInit() {
    System.out.println("7.My Init");
}

<bean id="user" class="com.lmh.model.User" init-method="myInit">
</bean>

DisposableBean

​ 以上週期執行完畢後，bean 就進入了可以被使用的狀態，當 bean 使用結束後，需要銷燬對象時，如果實現類中實現了DisposableBean接口，會執行從寫的destroy方法

@Override
public void destroy() throws Exception {
    System.out.println("9.Bean is Destroy");
}

自定義 Destroy 方法

​ 如果自定義了 Destroy 方法，會在這是執行，方式和自定義 Init 方法一致，實現類中定義 Destroy 方法，並在bean標籤中設置destroy-method="destroy"屬性

public void myDestroy() {
    System.out.println("my Destroy");
}

<bean id="user" class="com.lmh.model.User" destroy-method="myDestroy">
</bean>