由于Bean的生命周期经历的阶段比较多，下面将通过图形化的方式描述：
通过 getBean() 调用 某个Bean
具体过程如下：
（1），当调用者通过getBean(beanName) 请求某一个Bean 时，如果容器注册了 org.springframework.beans.factory.config.InstantiationAwareBeanPostProcessor 接口，则在实例化Bean 之前，将调用 postProcessBeforeInstantiation（）方法
（2），根据配置情况调用Bean构造函数 或工厂方法实例化Bean
（3），如果容器注册了InstantiationAwareBeanPostProcessor 接口，那么在实例化Bean 之后，调用该接口 的postProcessAfterInstantiation（）方法，可在这里对已经实例化的Bean 进行一些操作
（4），如果Bean配置了属性信息，那么容器在这一步着手将配置值设置到Bean 对应的属性中去，在设置每个属性值之前都会调用 InstantiationAwareBeanPostProcessor 接口的 postProcessPropertyValues 方法
（5），调用Bean 的属性设置方法 设置属性值
（6），如果Bean 实现了 BeanNameAware 接口 则将调用 setBeanName 接口方法，将配置文件中该Bean 的对应名称设置到Bean 中去
（7），如果Bean 实现了 BeanFactoryAware 接口 则将调用 setBeanFactory 接口方法，将BeanFactory容器实例设置到Bean 中去
（8），如果BeanFactory 装配了 org.springframework.beans.factory.config.BeanPostProcessor 后处理 ，则将调用postProcessBeforeInitialization(Object bean, String beanName) 方法 对Bean 进行加工操作，其中，入参Bean 是当前操作的Bean，而BeanName 是当前 Bean 的 配置名，返回对象加工后的Bean。
（9），如果Bean实现了 InitializingBean 接口，则将调用接口的afterPropertiesSet 方法
（10），如果在applicationContext 配置文件中通过init-method属性指定了初始化方法，则将执行这个方法
（11），如果BeanFactory 装配了 org.springframework.beans.factory.config.BeanPostProcessor 后处理 ，则将调用postProcessAfterInitialization(Object bean, String beanName) 方法 这个方法在此时调用，容器再次获得了对Bean 的加工机会
（12），如果在<Bean> 中指定了作用范围 scope = "prototype" 则将Bean返回给调用者 有调用者 管理 Bean 的生命周期，如果 scope = "singleton" ,则将Bean 放入 IOC容器的 缓存池中，由Spring 管理Bean 的生命周期
（13），如果Bean 实现了 DisposableBean 接口则将调用接口的 destroy（）方法
（14），如果<Bean> 的 destory-method 属性指定了Bean 的销毁方法，那么Spring 将执行 Bean 的这个方法，完成Bean的资源释放的工作
代码验证：
public class Car implements BeanFactoryAware,BeanNameAware,InitializingBean,DisposableBean{
private String brand;
private String color;
private Integer maxSpeed;
private String beanName;
private BeanFactory beanFactory;
public Car(){
System.out.println("Car() 构造器调用");
}
@Override
public void destroy() throws Exception {
System.out.println("调用 DisposableBean destroy 方法");
}
@Override
public void afterPropertiesSet() throws Exception {
System.out.println("调用 InitializingBean afterPropertiesSet 方法");
}
@Override
public void setBeanName(String beanName) {
System.out.println("调用 BeanNameAware setBeanName 方法");
this.beanName = beanName;
}
@Override
public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
System.out.println("调用 BeanFactoryAware setBeanFactory 方法");
this.beanFactory = beanFactory;
}
public void introduce(){
System.out.println("Car[brand : "+brand+",color:"+color+",maxSpeed:"+maxSpeed+"]");
}
@Override
public String toString() {
return "Car[brand : "+brand+",color:"+color+",maxSpeed:"+maxSpeed+"]";
}
public void myInit(){
System.out.println("调用 init-method 指定的myInit 方法");
}
public void myDestroy(){
System.out.println("调用 init-method 指定的myDestroy 方法");
}
//=====================================//
public String getBrand() {
return brand;
}
public String getColor() {
return color;
}
public Integer getMaxSpeed() {
return maxSpeed;
}
public BeanFactory getBeanFactory() {
return beanFactory;
}
public String getBeanName() {
return beanName;
}
public void setBrand(String brand) {
System.out.println("调用 setBrand 设置 属性");
this.brand = brand;
}
public void setColor(String color) {
System.out.println("调用 setColor 设置 属性");
this.color = color;
}
public void setMaxSpeed(Integer maxSpeed) {
System.out.println("调用 setMaxSpeed 设置 属性");
this.maxSpeed = maxSpeed;
}
}
public class MyInstantiationAwareBeanPostProcessor extends InstantiationAwareBeanPostProcessorAdapter{
public Object postProcessBeforeInstantiation(Class<?> beanClass,String beanName) throws BeansException {
if("car".equals(beanName)){
System.out.println("MyInstantiationAwareBeanPostProcessor.postProcessBeforeInstantiation 方法");
}
return super.postProcessBeforeInstantiation(beanClass, beanName);
}
public boolean postProcessAfterInstantiation(Object bean, String beanName)throws BeansException {
if("car".equals(beanName)){
System.out.println("MyInstantiationAwareBeanPostProcessor.postProcessAfterInstantiation 方法");
}
return super.postProcessAfterInstantiation(bean, beanName);
}
public PropertyValues postProcessPropertyValues(PropertyValues pvs,PropertyDescriptor[] pds, Object bean, String beanName)
throws BeansException {
if("car".equals(beanName)){
System.out.println("MyInstantiationAwareBeanPostProcessor.postProcessPropertyValues 方法");
}
return super.postProcessPropertyValues(pvs, pds, bean, beanName);
}
}
public class MyBeanPostProcess implements BeanPostProcessor{
@Override
public Object postProcessBeforeInitialization(Object bean, String beanName)throws BeansException {
if("car".equals(beanName)){
System.out.println("调用MyBeanPostProcess.postProcessBeforeInitialization 方法");
Car car = (Car)bean;
if(car.getColor() == null){
car.setColor("黑色");
}
}
return bean;
}
@Override
public Object postProcessAfterInitialization(Object bean, String beanName)throws BeansException {
if("car".equals(beanName)){
System.out.println("调用 MyBeanPostProcess.postProcessAfterInitialization 方法");
Car car = (Car)bean;
if(car.getMaxSpeed() > 100){
car.setMaxSpeed(100);
}
}
return bean;
}
}
public class BeanLifeCycle {
private static void beanLifeCycleInFactory(){
//配置文件并启动容器
Resource resource = new ClassPathResource("applicationContext.xml");
BeanFactory factory = new DefaultListableBeanFactory();
XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader((DefaultListableBeanFactory)factory);
reader.loadBeanDefinitions(resource);
//向容器中注册 MyBeanPostProcess 后处理器
((DefaultListableBeanFactory)factory).addBeanPostProcessor(new MyBeanPostProcess());
//向容器中注册 MyInstantiationAwareBeanPostProcessor 后处理器
((DefaultListableBeanFactory)factory).addBeanPostProcessor(new MyInstantiationAwareBeanPostProcessor());
//从容器中获取bean 将触发容器中实例化 bean 这将引发Bean 生命周期方法的调用
Car car1 = factory.getBean(Car.class);
car1.introduce();
//第二次获取bean 直接从缓存中读取
Car car2 = factory.getBean(Car.class);
//查看 car1 和 car2是否是同一个引用
System.out.println(car1 == car2);
//关闭容器
((DefaultListableBeanFactory)factory).destroySingletons();
//((ClassPathXmlApplicationContext)ctx).destroy();
}
public static void main(String[] args) {
BeanLifeCycle.beanLifeCycleInFactory();
}
}
输出的结果：
MyInstantiationAwareBeanPostProcessor.postProcessBeforeInstantiation 方法
Car() 构造器调用
MyInstantiationAwareBeanPostProcessor.postProcessAfterInstantiation 方法
MyInstantiationAwareBeanPostProcessor.postProcessPropertyValues 方法
调用 setBrand 设置 属性
调用 setMaxSpeed 设置 属性
调用 BeanNameAware setBeanName 方法
调用 BeanFactoryAware setBeanFactory 方法
调用MyBeanPostProcess.postProcessBeforeInitialization 方法
调用 setColor 设置 属性
调用 InitializingBean afterPropertiesSet 方法
调用 init-method 指定的myInit 方法
调用 MyBeanPostProcess.postProcessAfterInitialization 方法
调用 setMaxSpeed 设置 属性
Car[brand : BMW,color:黑色,maxSpeed:100]
true
调用 DisposableBean destroy 方法
调用 init-method 指定的myDestroy 方法
