Spring中Bean的初始化過程

時間 2019-12-24

原文原文鏈接

在傳統的Java應用中，Bean的生命週期很是簡單。Java的關鍵詞new用來實例化Bean（或許他是非序列化的）。這樣就夠用了。相反，Bean 的生命週期在Spring容器中更加細緻。理解Spring Bean的生命週期很是重要，由於你或許要利用Spring提供的機會來訂製Bean的建立過程。

1. 容器尋找Bean的定義信息而且將其實例化。
2.受用依賴注入，Spring按照Bean定義信息配置Bean的全部屬性。
3.若是Bean實現了BeanNameAware接口，工廠調用Bean的setBeanName()方法傳遞Bean的ID。
4.若是Bean實現了BeanFactoryAware接口，工廠調用setBeanFactory()方法傳入工廠自身。
5.若是BeanPostProcessor和Bean關聯，那麼它們的postProcessBeforeInitialzation()方法將被調用。
6.若是Bean指定了init-method方法，它將被調用。
7.最後，若是有BeanPsotProcessor和Bean關聯，那麼它們的postProcessAfterInitialization()方法將被調用。
到這個時候，Bean已經能夠被應用系統使用了，而且將被保留在Bean Factory中知道它再也不須要。有兩種方法能夠把它從Bean Factory中刪除掉。
1.若是Bean實現了DisposableBean接口，destory()方法被調用。
2.若是指定了訂製的銷燬方法，就調用這個方法。
Bean在Spring應用上下文的生命週期與在Bean工廠中的生命週期只有一點不一樣，惟一不一樣的是，若是Bean實現了ApplicationContextAwre接口，setApplicationContext()方法被調用。

舉例：（這裏只是演示Bean工廠的例子）
我這裏用的是spring-1.2.6，因爲版本緣由吧，這裏演示的不是很好!
1.HelloWorld.java
java

Java代碼 spring

package com.spring.lifecycle; app
import org.springframework.beans.BeansException; post
import org.springframework.beans.factory.BeanFactory; 測試
import org.springframework.beans.factory.BeanFactoryAware; this
import org.springframework.beans.factory.BeanNameAware; spa
import org.springframework.beans.factory.DisposableBean; xml
import org.springframework.beans.factory.InitializingBean; 接口
import org.springframework.beans.factory.config.BeanPostProcessor; 生命週期
public class HelloWorld implements BeanNameAware,BeanFactoryAware, BeanPostProcessor,InitializingBean,DisposableBean{
private String hello;
public void setBeanName(String arg0) {
System.out.println("調用BeanNameAware的setBeanName()..." );
}
public String getHello() {
return hello;
}
public void setHello(String hello) {
this.hello = hello;
System.out.println("調用setHello()..." );
}
public void customInit() {
System.out.println("調用customInit()...");
}
public void customDestroy() {
System.out.println("調用customDestroy()...");
}
public Object postProcessAfterInitialization(Object arg0, String arg1)
throws BeansException {
System.out.println("調用BeanPostProcessor的postProcessAfterInitialization()...");
return null;
}
public Object postProcessBeforeInitialization(Object arg0, String arg1)
throws BeansException {
System.out.println("調用BeanPostProcessor的postProcessBeforeInitialization()...");
return null;
}
public void destroy() throws Exception {
System.out.println("調用DisposableBean的destory()...");
}
public void afterPropertiesSet() throws Exception {
System.out.println("調用InitializingBean的afterPropertiesSet()...");
}
public void setBeanFactory(BeanFactory arg0) throws BeansException {
System.out.println("調用BeanFactoryAware的setBeanFactory()...");
}
}

2.測試程序

Java代碼

package com.spring.springtest;
import junit.framework.TestCase;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import com.spring.lifecycle.HelloWorld;
public class TestLifeCycle extends TestCase {
private BeanFactory bf;
protected void setUp() throws Exception {
bf = new ClassPathXmlApplicationContext("applicationContext.xml");
}
public void testLifeCycle() throws Exception {
HelloWorld hello = (HelloWorld) bf.getBean("helloWorld");
assertEquals("hello world!", hello.getHello());
hello.destroy();
}
}

3.applicationContext.xml

Xml代碼

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd">
<beans>
<bean id="helloWorld" class="com.spring.lifecycle.HelloWorld"
init-method="customInit" destroy-method="customDestroy">
<property name="hello" value="hello world!"></property>
</bean>
</beans>

4.運行結果：

引用

調用setHello()... 調用BeanNameAware的setBeanName()... 調用BeanFactoryAware的setBeanFactory()... 調用InitializingBean的afterPropertiesSet()... 調用customInit()... 調用DisposableBean的destory()...