Spring中Bean的生命周期使用解析

bean的生命周期

解释

（1）beanfactorypostprocessor的postprocessorbeanfactory()方法：若某个ioc容器内添加了实现了beanfactorypostprocessor接口的实现类bean，那么在该容器中实例化任何其他bean之前可以回调该bean中的postprcessorbeanfactory()方法来对bean的配置元数据进行更改，比如从xml配置文件中获取到的配置信息。

（2）bean的实例化：bean的实例化是使用反射实现的。

（3）bean属性注入：bean实例化完成后，利用反射技术实现属性及依赖bean的注入。

（4）beannameaware的setbeanname()方法：如果某个bean实现了beannameaware接口，那么spring将会将bean实例的id传递给setbeanname()方法，在bean类中新增一个beanname字段，并实现setbeanname()方法。

（5）beanfactoryaware的setbeanfactory()方法：如果某个bean实现了beanfactoryaware接口，那么spring将会将创建bean的beanfactory传递给setbeanfactory()方法，在bean类中新增了一个beanfactory字段用来保存beanfactory的值，并实现setbeanfactory()方法。

（6）applicationcontextaware的setapplicationcontext()方法：如果某个bean实现了applicationcontextaware接口，那么spring将会将该bean所在的上下文环境applicationcontext传递给setapplicationcontext()方法，在bean类中新增一个applicationcontext字段用来保存applicationcontext的值，并实现setapplicationcontext()方法。

（7）beanpostprocessor预初始化方法：如果某个ioc容器中增加的实现beanpostprocessor接口的实现类bean，那么在该容器中实例化bean之后，执行初始化之前会调用beanpostprocessor中的postprocessbeforeinitialization()方法执行预初始化处理。

（8）initializingbean的afterpropertiesset()方法：如果bean实现了initializingbean接口，那么bean在实例化完成后将会执行接口中的afterpropertiesset()方法来进行初始化。

（9）自定义的inti-method指定的方法：如果配置文件中使用init-method属性指定了初始化方法，那么bean在实例化完成后将会调用该属性指定的初始化方法进行bean的初始化。

（10）beanpostprocessor初始化后方法：如果某个ioc容器中增加的实现beanpostprocessor接口的实现类bean，那么在该容器中实例化bean之后并且完成初始化调用后执行该接口中的postprocessorafterinitialization()方法进行初始化后处理。

（11）使用bean：此时有关bean的所有准备工作均已完成，bean可以被程序使用了，它们将会一直驻留在应用上下文中，直到该上下文环境被销毁。

（12）disposablebean的destory()方法：如果bean实现了disposablebean接口，spring将会在bean实例销毁之前调用该接口的destory()方法，来完成一些销毁之前的处理工作。

（13）自定义的destory-method指定的方法：如果在配置文件中使用destory-method指定了销毁方法，那么在bean实例销毁之前会调用该指定的方法完成一些销毁之前的处理工作。

注意：

1、beanfactorypostprocessor接口与beanpostprocessor接口的作用范围是整个上下文环境中，使用方法是单独新增一个类来实现这些接口，那么在处理其他bean的某些时刻就会回调响应的接口中的方法。

2、beannameaware、beanfactoryaware、applicationcontextaware的作用范围的bean范围，即仅仅对实现了该接口的指定bean有效，所有其使用方法是在要使用该功能的bean自己来实现该接口。

3、第8点与第9点所述的两个初始化方法作用是一样的，我们完全可以使用其中的一种即可，一般情况我们使用第9点所述的方式，尽量少的去来bean中实现某些接口，保持其独立性，低耦合性，尽量不要与spring代码耦合在一起。第12和第13也是如此。

4、 在beafactoryaware's setbeanfactory()和pre-initialization beanpostprocessor之间还应该有一步：调用applicationcontextaware的setapplicationcontext()方法。
可以看到bean生命周期要经历很多阶段，但这些阶段大部分都是可选的。例如，某个bean如果实现了beanfactoryaware接口的setbeanfactory方法，那么该bean的生命就会经历这个阶段，如果不实现则没有。

使用

public class book implements beannameaware, beanfactoryaware,
    applicationcontextaware, initializingbean, disposablebean {
  private string bookname;
  public book(){
    system.out.println("book initializing ");
  }
  @override
  public void setbeanfactory(beanfactory beanfactory) throws beansexception {
    system.out.println("book.setbeanfactory invoke");
  }
  @override
  public void setbeanname(string name) {
    system.out.println("book.setbeanname invoke");
  }
  @override
  public void destroy() throws exception {
    system.out.println("book.destory invoke");
  }
  @override
  public void afterpropertiesset() throws exception {
    system.out.println("book.afterpropertiesset invoke");
  }
  @override
  public void setapplicationcontext(applicationcontext applicationcontext) throws beansexception {
    system.out.println("book.setapplicationcontext invoke");
  }
  public string getbookname() {
    return bookname;
  }
  public void setbookname(string bookname) {
    this.bookname = bookname;
    system.out.println("setbookname: book name has set.");
  }
  public void mypostconstruct(){
    system.out.println("book.mypostconstruct invoke");
  }
  // 自定义初始化方法
  @postconstruct
  public void springpostconstruct(){
    system.out.println("@postconstruct");
  }
  public void mypredestory(){
    system.out.println("book.mypredestory invoke");
    system.out.println("---------------destroy-----------------");
  }
  // 自定义销毁方法
  @predestroy
  public void springpredestory(){
    system.out.println("@predestory");
  }
  @override
  protected void finalize() throws throwable {
    system.out.println("------inside finalize-----");
  }
}
public class mybeanfactorypostprocessor implements beanfactorypostprocessor {
  public mybeanfactorypostprocessor() {
    super();
    system.out.println("这是beanfactorypostprocessor实现类构造器！！");
  }
  @override
  public void postprocessbeanfactory(configurablelistablebeanfactory arg0)
      throws beansexception {
    system.out
        .println("beanfactorypostprocessor调用postprocessbeanfactory方法");
    beandefinition bd = arg0.getbeandefinition("book");
    bd.getpropertyvalues().addpropertyvalue("bookname", "ddd");
  }
}
// 通过注入调用
@component
public class mybeanpostprocessor implements beanpostprocessor {
  @override
  public object postprocessbeforeinitialization(object bean, string beanname) throws beansexception {
    if(bean instanceof book){
      system.out.println("mybeanpostprocessor.postprocessbeforeinitialization");
    }
    return bean;
  }
  @override
  public object postprocessafterinitialization(object bean, string beanname) throws beansexception {
    if(bean instanceof book){
      system.out.println("mybeanpostprocessor.postprocessafterinitialization");
    }
    return bean;
  }
}

// classpathxmlapplicationcontext 这个类实例化就会调用这个类
public class mybeanfactorypostprocessor implements beanfactorypostprocessor {
  public mybeanfactorypostprocessor() {
    super();
    system.out.println("这是beanfactorypostprocessor实现类构造器！！");
  }
  @override
  public void postprocessbeanfactory(configurablelistablebeanfactory arg0)
      throws beansexception {
    system.out
        .println("beanfactorypostprocessor调用postprocessbeanfactory方法");
    beandefinition bd = arg0.getbeandefinition("book");
    bd.getpropertyvalues().addpropertyvalue("bookname", "ddd");
  }
}
// instantiationawarebeanpostprocessor 接口本质是beanpostprocessor的子接口，一般我们继承spring为其提供的适配器类instantiationawarebeanpostprocessor adapter来使用它，如下：
public class myinstantiationawarebeanpostprocessor extends
    instantiationawarebeanpostprocessoradapter {
  public myinstantiationawarebeanpostprocessor() {
    super();
    system.out
        .println("这是instantiationawarebeanpostprocessoradapter实现类构造器！！");
  }
  // 接口方法、实例化bean之前调用
  @override
  public object postprocessbeforeinstantiation(class beanclass,
                         string beanname) throws beansexception {
    system.out
        .println("instantiationawarebeanpostprocessor调用postprocessbeforeinstantiation方法");
    return null;
  }
// 接口方法、实例化bean之后调用
  @override
  public object postprocessafterinitialization(object bean, string beanname)
      throws beansexception {
    system.out
        .println("instantiationawarebeanpostprocessor调用postprocessafterinitialization方法");
    return bean;
  }
// 接口方法、设置某个属性时调用
  @override
  public propertyvalues postprocesspropertyvalues(propertyvalues pvs,
                          propertydescriptor[] pds, object bean, string beanname)
      throws beansexception {
    system.out
        .println("instantiationawarebeanpostprocessor调用postprocesspropertyvalues方法");
    return pvs;
  }
}
// bean配置
<?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"
    xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"
    xsi:schemalocation="
      http://www.springframework.org/schema/beans
      http://www.springframework.org/schema/beans/spring-beans-3.2.xsd">

  <bean id="beanpostprocessor" class="com.example.demo.mybeanpostprocessor">
  </bean>

  <bean id="instantiationawarebeanpostprocessor" class="com.example.demo.myinstantiationawarebeanpostprocessor">
  </bean>

  <bean id="beanfactorypostprocessor" class="com.example.demo.mybeanfactorypostprocessor">
  </bean>

  <bean id="book" class="com.example.demo.book" init-method="mypostconstruct" destroy-method="mypredestory">
    <!-- 注入bean 属性名称 -->
    <property name="bookname" value="thingking in java" />
  </bean>
</beans>
//调用
    applicationcontext context = new classpathxmlapplicationcontext("beanconfig.xml");
    book book = (book)context.getbean("book");
    system.out.println("book name = " + book.getbookname());
    ((classpathxmlapplicationcontext) context).destroy();

以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持。