spring~2、源码解读-BeanFactory之bean 的生命周期

一、一起走过 bean 的生命周期

一）、bean的生命周期

bean生命周期在BeanFactory 中有定义

二）demo测试结果流程

1、bean生命周期流程图

2、辅助了解bean生命周期流程图

1 ）、自定义一个bean的后处理器，用来增强bean

首先自定义一个bean的后处理器MyProcessor，通过实现接口beanPostProcessor，并重写初始化前和初始化后者两个方法，由容器监听并在初始化bean前后分别调用，这是spring提供的一个可扩展的接口，你可以添加一些操作来增强bean

2）、 类关系图

三）、bean生命周期demo实例

如果你想具体跟着走一下测试流程，可以参看下面代码：

1、定义注册bean信息GreetingService

package cn.dbet.spring.service;

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.BeanFactoryAware;
import org.springframework.beans.factory.BeanNameAware;
import org.springframework.beans.factory.InitializingBean;

/**
 * GreetingService
 */
public class GreetingService implements BeanNameAware , BeanFactoryAware,InitializingBean{
	private String greeting ;
	private String greeting2 ;
	private ByeService bs ;
	
	public GreetingService() {
		System.out.println("new GreetingService()");
	}

	public ByeService getBs() {
		return bs;
	}

	public void setBs(ByeService bs) {
		this.bs = bs;
		System.out.println("DI:setBs("+bs+")");
	}

	public String getGreeting2() {
		return greeting2;
	}

	public void setGreeting2(String greeting2) {
		this.greeting2 = greeting2;
		System.out.println("DI:setGreeting2("+greeting2+")");
	}

	public String getGreeting() {
		return greeting;
	}

	public void setGreeting(String greeting) {
		this.greeting = greeting;
		System.out.println("DI:setGreeting("+greeting+")");
	}
	
	public void sayGreeting(){
		System.out.println(greeting);
		bs.sayBye();
	}
	
	public void sayGreeting2(){
		System.out.println(greeting2);
	}

	/**
	 * BeanNameAware接口
	 */
	public void setBeanName(String name) {
		System.out.println("BeanNameAware:setBeanName("+name+")");
	}

	/**
	 * BeanFactoryAware
	 */
	public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
		System.out.println("BeanFactoryAware:setBeanFactory("+beanFactory+")");
	}
	
	public void ini(){
		System.out.println("ini");
	}

	/**
	 * 
	 */
	public void afterPropertiesSet() throws Exception {
		System.out.println("afterPropertiesSet");
	}
	
	public void release(){
		System.out.println("release");
	}
}

2、定义依赖bean信息ByeService

public class ByeService {
	private String bye ;

	public String getBye() {
		return bye;
	}

	public void setBye(String bye) {
		this.bye = bye;
	}
	
	public void sayBye(){
		System.out.println(bye);
	}
	public ByeService(){
		System.out.println("new ByeService()");
	}
}

3、自定义bean后处理器MyProcessor

public class MyProcessor implements BeanPostProcessor {

	/**
	 * before
	 */
	public Object postProcessBeforeInitialization(Object bean, String beanName)
			throws BeansException {
		System.out.println("before:" + bean + " : " + beanName);
		return bean;
	}

	/**
	 * after
	 */
	public Object postProcessAfterInitialization(Object bean, String beanName)
			throws BeansException {
		System.out.println("after:" + bean + " : " + beanName);
		return bean;
	}

4、ioc容器配置部分

<!-- greetingService -->
    <bean id="greetingService" class="com.spring.stu.service.impl.GreetingService" scope="singleton" init-method="ini" destroy-method="release">
        <property name="greeting">
            <value>hello world</value>
        </property>
        <property name="greeting2" value="tom" />
        <property name="bs" ref="byeService"/>
    </bean>

    <!-- byeService -->
    <bean id="byeService" class="com.spring.stu.service.impl.ByeService">
        <property name="bye" value="byebye" />
    </bean>

    <bean class="com.spring.stu.service.impl.MyProcessor" />

GreetingService greeting greeting2 byeService byeService MyProcessor

5、测试

 @Test  /**测试bean的生命周期*/
    public void testBeanLife(){
        ApplicationContext ac = new ClassPathXmlApplicationContext("ioc.xml");

        ByeService byeService = (ByeService)ac.getBean("byeService");
        System.out.println(byeService);
        System.out.println("================");
        GreetingService gs = (GreetingService)ac.getBean("greetingService");
        System.out.println(gs);
          
       ((ClassPathXmlApplicationContext)ac).destroy();
    }

执行结果

new GreetingService()
new ByeService()
before:com.spring.stu.service.impl.ByeService@1b7cc17c : byeService
after:com.spring.stu.service.impl.ByeService@1b7cc17c : byeService
DI:setGreeting(hello world)
DI:setGreeting2(tom)
DI:setBs(com.spring.stu.service.impl.ByeService@1b7cc17c)
BeanNameAware:setBeanName(greetingService)
BeanFactoryAware:setBeanFactory(org.springframework.beans.factory.support.DefaultListableBeanFactory@5ccddd20: defining beans [userDaoService,userDaoService2,apple1,appleInstanceFactory,apple2,myFactoryBean,greetingService,byeService,com.spring.stu.service.impl.MyProcessor#0]; root of factory hierarchy)
before:com.spring.stu.service.impl.GreetingService@1a482e36 : greetingService
afterPropertiesSet
ini
after:com.spring.stu.service.impl.GreetingService@1a482e36 : greetingService
com.spring.stu.service.impl.ByeService@1b7cc17c
================
com.spring.stu.service.impl.GreetingService@1a482e36
release

小结

从上面的测试结果，可以看出：
1 、实例化beanA
beanA在实例化的时候，依赖的beanB,就会先完成beanB的实例化和初始化，然后继续beanA的创建
2、完成beanA的注入
3、beanA实现的一系列aware接口，会将工厂以及容器等注入给beanA，beanA能使用它们做一些扩展操作。
4、自定义一个beanProcessor,实现spring的接口beanPostProcessor,然后注册自定义bean处理器，在调用初始化方法的前后分别会调用这个接口的两个方法，作用在所有bean的创建
【另外：无论bean是否是懒加载，或者是否单例，bean的后处理器都会调用初始化前后方法】
5、初始化方法有两种方式分别为：
① 实现接口InitializingBean
② 在xml中bean定义的地方添加属性init-method，然后自定义一个初始化方法

6、销毁也有两种方式：
①实现接口DisposableBean
②在xml中bean定义处添加属性destroy-method，然后自定义个一个销毁方法
销毁一次后，就没了，所以销毁方法只能调用一种。所以我只写了一种销毁实现方式。

bean的创建是根据xml文件自上而下创建的，实例化对象后如果发现遇到其他依赖的bean,就先构建依赖的bean,构建完成后继续构建本bean。
整个bean的生命周期都是围绕bean的实例化和初始化过程展开的，最后用完记得 gc掉bean对象 。