BeanFactory中Bean的生命周期

最新推荐文章于 2020-09-24 15:40:32 发布

_STH

最新推荐文章于 2020-09-24 15:40:32 发布

阅读量280

点赞数 1

分类专栏： spring 文章标签： java

本文链接：https://blog.youkuaiyun.com/u013088059/article/details/54235909

版权

spring 专栏收录该内容

2 篇文章

订阅专栏

BeanFactory中Bean的生命周期

这里写图片描述

当调用者通过getBean(beanName)向容器请求某一个Bean时，如果容器注册了InstantiationAwareBeanPostProcessor接口，在实例化Bean前，将调用该接口的POSTProcessBeforeInstantiation()方法；
根据配置信息调用Bean的构造函数或工程方法实例化Bean；
如果容器注册了InstantiationAwareBeanPostProcessor接口，在实例化bean之后，调用该接口的postProcessAfterInstantiation()方法，可在这里对已经实例化的对象进行一些“梳妆打扮”；
如果Bean配置了属性信息，容器在这一步着手将配置设置到Bean对应的属性中，不过在设置每个属性之前将先调用InstantiationAwareBeanPostProcessor接口的POSTProcessPropertyValue()方法；
调用Bean的属性设置方法设置属性值；
如果Bean实现了BeanNameAware接口，将调用setBeanName()接口方法，将配置文件中该Bean对应的名称设置到Bean中；
如果Bean实现了BeanFactoryAware接口，将调用setBeanFactory()接口方法，将BeanFactory容器实例设置到Bean中；
如果BeanFactory装配了BeanPostProcessor后处理器，将BeanPostProcessor的postProcessBeforeInitialization(object bean, String beanName)接口方法对Bean进行加工操作。其中入参bean是当前正在处理的Bean，而beanName是当前Bean的配置名，返回的对象为加工处理后的Bean。用户可以使用该方法对某些bean进行特殊的处理，甚至改变Bean的行为，BeanPostProcessor在Spring框架中占有重要地位，为容器提供Bean进行后续加工处理的切入点，Spring容器所提供的各种“神奇功能”（如AOP，动态代理等）都通过BeanPostProcessor实施；
如果Bean实现了InitializingBean的借口，将调用接口的afterPropertiesSet()方法；
如果在通过init-method属性定义了初始化方法，将执行这个方法；
BeanPostProcessor后处理器定义了两个方法：其一是postProcessBeforeInitialization()在第8步调用；其二是Object postProcessAfterInitialization(Object bean, String beanName)方法，这个方法在此时调用，容器再次获得对bean进行加工处理的机会；
如果在中指定Bean的作用范围为scope=“prototype”，将Bean返回给调用者，调用者负责Bean后续生命的管理，Spring不在管理这个Bean的生命周期。如果作用范围设置为scope=“singleton”，则将Bean进行后续的生命管理；
对于scope=“singleton”的bean，当容器关闭时，将处罚Spring对Bean的后续生命周期的管理工作，首先如果Bean实现了DisposableBean接口，则将调用接口的afterPropertiesSet()方法，可以在此编写释放资源、记录日志等操作；
对于scope=“singleton”的bean，如果通过的destroy-method属性指定了Bean的销毁方法，Spring将执行Bean的这个方法，完成Bean资源的释放等操作。

Bean的完整生命周期从Spring容器着手实例化Bean开始，知道最终销毁Bean，这当中经过了许多关键点，每个关键点都设计特定的方法调用，可以将这些方法大致划分为三类：

Bean自身的方法：如果调用Bean构造器函数实例化Bean，调用Setter设置Bean的属性值以及通过的init-method和destroy-method所指定的方法；
Bean级生命周期接口方法：如BeanNameAware、BeanFactoryAware、InitializingBean和DisposableBean，这些接口方法由Bean类直接实现；
容器级生命周期接口方法：在上如中在“★”的步骤是由InstantiationAwareBeanPostProcessor和BeanPostProcessor这两个接口实现，一般称它们的实现类为“后处理器”。后处理器接口一般不由Bean本身实现，它们独立于Bean，实现类以容器附加装置的形式注册到Spring容器中并通过接口反射未Spring容器预先识别。当Spring容器创建任何Bean的时候，这些后处理器都会方式作用，所以这些后处理器的影响是全局性的。当然，用户可以通过合理地编写后处理，让其仅对感兴趣Bean进行加工处理。

Bean级生命周期接口和容器机生命周期接口是个性和共性辩证统一思想的体现，前者解决bean个性化处理的问题；而后者解决容器中某些Bean共性化处理的问题。
Spring容器中可以注册多个后处理器，只要他们同事实现Ordered接口，容器将安特定的顺序依次调用这些后处理。

Demo实例
以下代码用来演示Bean生命周期
Car.java

package beanLifeCycleDemo;

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.*;

public class Car implements BeanFactoryAware, BeanNameAware, InitializingBean, DisposableBean {
   private String brand;
   private String color;
   private int maxSpeed;
   private String name;
   private BeanFactory beanFactory;
   private String beanName;

   public Car() {
      System.out.println("调用Car()构造函数。");
   }

   // BeanFactoryAware接口方法
   @Override
   public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
      System.out.println("调用BeanFactoryAware.setBeanFactory()。");
      this.beanFactory = beanFactory;
   }
   // BeanNameAware接口方法
   @Override
   public void setBeanName(String beanName) {
      System.out.println("调用BeanNameAware.setBeanName()。");
      this.beanName = beanName;
   }
   // InitializingBean接口方法
   @Override
   public void afterPropertiesSet() throws Exception {
      System.out.println("调用InitializingBean.afterPropertiesSet()。");
   }
   // DisposableBean接口方法
   @Override
   public void destroy() throws Exception {
      System.out.println("调用DisposableBean.destory()。");
   }

   public void myInit() {    
      System.out.println("调用myInit()，将maxSpeed设置为240。");
      this.maxSpeed = 240;
   }
   public void myDestory() {
      System.out.println("调用myDestroy()。");
   }
   public void introduce(){
      System.out.println("introduce:"+this.toString());
   }
   public String toString() {
      return "brand:" + brand + "/color:" + color + "/maxSpeed:"+ maxSpeed;
   }


   public String getBrand() {
      return brand;
   }
   public void setBrand(String brand) {
      System.out.println("调用setBrand()设置属性。");
      this.brand = brand;
   }
   public String getColor() {
      return color;
   }
   public void setColor(String color) {
      this.color = color;
   }
   public int getMaxSpeed() {
      return maxSpeed;
   }
   public void setMaxSpeed(int maxSpeed) {
      this.maxSpeed = maxSpeed;
   }
}

MyInstantiationAwareBeanPostProcessor.java

package beanLifeCycleDemo;

import org.springframework.beans.BeansException;
import org.springframework.beans.PropertyValues;
import org.springframework.beans.factory.config.InstantiationAwareBeanPostProcessorAdapter;

import java.beans.PropertyDescriptor;

public class MyInstantiationAwareBeanPostProcessor extends InstantiationAwareBeanPostProcessorAdapter{

   public Object postProcessBeforeInstantiation(Class beanClass, String beanName) throws BeansException {
      if("car".equals(beanName)){
         System.out.println("beanLifeCycleDemo.MyInstantiationAwareBeanPostProcessor.postProcessBeforeInstantiation");
      }     
      return null;
   }

   public boolean postProcessAfterInstantiation(Object bean, String beanName) throws BeansException {
      if("car".equals(beanName)){
         System.out.println("InstantiationAwareBeanPostProcessor.postProcessAfterInstantiation");
      }
      return true;
   }

   public PropertyValues postProcessPropertyValues(PropertyValues pvs, PropertyDescriptor[] pds, Object bean, String beanName) throws BeansException {
      if("car".equals(beanName)){
         System.out.println("InstantiationAwareBeanPostProcessor.postProcessPropertyValues");
      }
      return pvs;
   }

   public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
      return bean;
   }

   public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
      return bean;
   }
}

MyBeanPostProcessor.java

package beanLifeCycleDemo;

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

public class MyBeanPostProcessor implements BeanPostProcessor{
   public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {       
      if(beanName.equals("car")){
         Car car = (Car)bean;
         if(car.getColor() == null){
            System.out.println("调用MyBeanPostProcessor.postProcessBeforeInitialization()，color为空，设置为默认黑色。");
            car.setColor("黑色");
         }
      }
      return bean;
   }
   public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {    
      if(beanName.equals("car")){
         Car car = (Car)bean;
         if(car.getMaxSpeed() >= 200){
            System.out.println("调用MyBeanPostProcessor.postProcessAfterInitialization()，将maxSpeed调整为200。");
            car.setMaxSpeed(200);
         }
      }
      return bean;
   }
}

MyBeanFactoryPostProcessor.java

package beanLifeCycleDemo;

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanDefinition;
import org.springframework.beans.factory.config.BeanFactoryPostProcessor;
import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;

public class MyBeanFactoryPostProcessor implements BeanFactoryPostProcessor{

   @Override
   public void postProcessBeanFactory(ConfigurableListableBeanFactory bf) throws BeansException {
      BeanDefinition bd = bf.getBeanDefinition("car");
      bd.getPropertyValues().addPropertyValue("brand", "奇瑞QQ");
      System.out.println("调用MyBeanFactoryPostProcessor.postProcessBeanFactory()！");
   }

}

bean.xlm配置文件

<?xml version="1.0" encoding="UTF-8" ?>
<beans xmlns="http://www.springframework.org/schema/beans"
   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p"
   xsi:schemaLocation="http://www.springframework.org/schema/beans 
       http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">
   <bean id="car" class="beanLifeCycleDemo.Car"
       init-method="myInit"
       destroy-method="myDestory"
       p:brand="红旗CA72"
       p:maxSpeed="200" 
       />  
   <!-- bean id="car" class="com.baobaotao.beanfactory.Car" 
       init-method="myInit"
      destroy-method="myDestory"
      p:brand="红旗CA72"/ -->

</beans>

BeanLifeCycle.java

package beanLifeCycleDemo;

import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.config.ConfigurableBeanFactory;
import org.springframework.beans.factory.xml.XmlBeanFactory;
import org.springframework.core.io.ClassPathResource;
import org.springframework.core.io.Resource;

public class BeanLifeCycle {
    private static void LifeCycleInBeanFactory(){
      Resource res = new ClassPathResource("beanLifeCycleDemo/beans.xml");
       BeanFactory bf = new XmlBeanFactory(res);

       MyBeanFactoryPostProcessor beanFactoryPostProcessor = new MyBeanFactoryPostProcessor();
       beanFactoryPostProcessor.postProcessBeanFactory((XmlBeanFactory) bf);

       MyInstantiationAwareBeanPostProcessor instantiationAwareBeanPostProcessor = new MyInstantiationAwareBeanPostProcessor();
       ((ConfigurableBeanFactory)bf).addBeanPostProcessor(instantiationAwareBeanPostProcessor);

       MyBeanPostProcessor beanPostProcessor = new MyBeanPostProcessor();
       ((ConfigurableBeanFactory)bf).addBeanPostProcessor(beanPostProcessor);

       Car car1 = (Car)bf.getBean("car");
       car1.introduce();
       car1.setColor("红色");
       Car car2 = bf.getBean("car", Car.class);
       car2.introduce();
       ((XmlBeanFactory)bf).destroySingletons();
    }

   public static void main(String[] args) {
      LifeCycleInBeanFactory();
   }
}

运行结果

调用MyBeanFactoryPostProcessor.postProcessBeanFactory()！
beanLifeCycleDemo.MyInstantiationAwareBeanPostProcessor.postProcessBeforeInstantiation
调用Car()构造函数。
InstantiationAwareBeanPostProcessor.postProcessAfterInstantiation
InstantiationAwareBeanPostProcessor.postProcessPropertyValues
调用setBrand()设置属性。
调用BeanNameAware.setBeanName()。
调用BeanFactoryAware.setBeanFactory()。
调用MyBeanPostProcessor.postProcessBeforeInitialization()，color为空，设置为默认黑色。
调用InitializingBean.afterPropertiesSet()。
调用myInit()，将maxSpeed设置为240。
调用MyBeanPostProcessor.postProcessAfterInitialization()，将maxSpeed调整为200。
introduce:brand:奇瑞QQ/color:黑色/maxSpeed:200
introduce:brand:奇瑞QQ/color:红色/maxSpeed:200
调用DisposableBean.destory()。
调用myDestroy()。