spring Bean实例生命周期行为

    花了一下午的时间，整理测试了一下Bean的生命周期行为.

    首先排一个序。完整的测试代码后面贴出来。

1. 加载当前Bean的构造器    
   

2. 加载@Autowired注入的依赖关系的构造器。（也就是加载依赖的Bean）

3. 加载普通的依赖Bean构造器（<property name="person" ref="person"/>）

4. 注入依赖关系（<property name="person" ref="person"/>）

5. 执行@PostConstruct注解的方法

6. 执行afterPropertiesSet    

7. 执行 init-method

8. 执行 服务逻辑

9. 执行@PreDestroy注解（需要销毁Bean才会执行）

10. 执行destroy（需要销毁Bean才会执行）     

11. 执行destroy-method（需要销毁Bean才会执行）

    一般实际生产都采用零配置，为了测试通过XML加载指定Bean。

代码 :

Car.java 依赖Bean，通过@Autowired注入House实力

package com.peach.springtest.model;

public class Car {

    public Car() {
        System.out.println("Test car constructor");
    }

}

House.java 主Bean

package com.peach.springtest.model;

import org.springframework.beans.factory.DisposableBean;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.beans.factory.annotation.Autowired;
import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;


public class House implements InitializingBean, DisposableBean {

    private Person person;

    @Autowired
    private Car car;

    public House() {
        System.out.println("Test house Constructor");
    }

    public void status() {
        System.out.println("There is one person and one car");
    }

    @Autowired

    public void setPerson(Person person) {
        System.out.println("Test House setPerson");
        this.person = person;
    }

    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("Test house afterPropertiesSet");
    }

    @PostConstruct
    public void postConstruct() {
        System.out.println("Test house postConstruct");
    }

    public void initMethod() {
        System.out.println("Test house initMethod");
    }

    @PreDestroy
    public void preDestroy() {
        System.out.println("Test house preDestroy");
    }

    @Override
    public void destroy() throws Exception {
        System.out.println("Test house destroy");
    }

    public void destroyMethod() {
        System.out.println("Test house destroyMethod");
    }
}

Person.java 通过XML property ref 注入到House实力

package com.peach.springtest.model;

public class Person {

    public Person() {
        System.out.println("Test Person constructor");
    }

}

SpringDriver.java  加载spring 容器

package com.peach.springtest;

import com.peach.springtest.model.House;
import org.springframework.context.support.AbstractApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class SpringDriver {

    public static void main(String[] args) {
        AbstractApplicationContext context = new ClassPathXmlApplicationContext("ApplicationContext.xml");
        House house = (House) context.getBean("house");
        house.status();
        context.registerShutdownHook();
    }
}

ApplicationContext.xml  

<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns="http://www.springframework.org/schema/beans"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
           http://www.springframework.org/schema/beans/spring-beans-4.2.xsd
           http://www.springframework.org/schema/context
           http://www.springframework.org/schema/context/spring-context-4.2.xsd">

    <!--<context:component-scan base-package="com.peach.springtest.*"/>-->

    <context:annotation-config />
    <bean id="house" class="com.peach.springtest.model.House" init-method="initMethod" destroy-method="destroyMethod">
        <property name="person" ref="person"/>
    </bean>
    <bean id="person" class="com.peach.springtest.model.Person"/>
    <bean id="car" class="com.peach.springtest.model.Car"/>

</beans>

执行结果：