2. 程式人生 > >Spring-Bean生命周期

Spring-Bean生命周期

阿新 • • 發佈：2018-11-24
default anti fec aspectj inf getbean 不用 ans and

Spring作為當前Java最流行、最強大的輕量級框架，受到了程序員的熱烈歡迎。準確的了解Spring Bean的生命周期是非常必要的。我們通常使用ApplicationContext作為Spring容器。這裏，我們講的也是 ApplicationContext中Bean的生命周期。而實際上BeanFactory也是差不多的，只不過處理器需要手動註冊。

轉載請註明地址 http://www.cnblogs.com/zrtqsk/p/3735273.html，謝謝。

一、生命周期流程圖：

　　Spring Bean的完整生命周期從創建Spring容器開始，直到最終Spring容器銷毀Bean，這其中包含了一系列關鍵點。

技術分享圖片

技術分享圖片

　

若容器註冊了以上各種接口，程序那麽將會按照以上的流程進行。下面將仔細講解各接口作用。

二、各種接口方法分類

Bean的完整生命周期經歷了各種方法調用，這些方法可以劃分為以下幾類：

1、Bean自身的方法　　：　　這個包括了Bean本身調用的方法和通過配置文件中<bean>的init-method和destroy-method指定的方法

目標方法執行前後執行後，將進行初始化或銷毀。

<bean id="" class="" init-method="初始化方法名稱" destroy-method="銷毀的方法名稱">

2、Bean級生命周期接口方法　　：　　這個包括了BeanNameAware、BeanFactoryAware、InitializingBean和DiposableBean這些接口的方法

3、容器級生命周期接口方法　　：　　這個包括了InstantiationAwareBeanPostProcessor 和 BeanPostProcessor 這兩個接口實現，一般稱它們的實現類為“後處理器”。

4、工廠後處理器接口方法　　：　　這個包括了AspectJWeavingEnabler, ConfigurationClassPostProcessor, CustomAutowireConfigurer等等非常有用的工廠後處理器　　接口的方法。工廠後處理器也是容器級的。在應用上下文裝配配置文件之後立即調用。

　　

三、演示

我們用一個簡單的Spring Bean來演示一下Spring Bean的生命周期。

1、首先是一個簡單的Spring Bean，調用Bean自身的方法和Bean級生命周期接口方法，為了方便演示，它實現了BeanNameAware、BeanFactoryAware、InitializingBean和DiposableBean這4個接口，同時有2個方法，對應配置文件中<bean>的init-method和destroy-method。如下：

package springBeanTest;

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.DisposableBean;
import org.springframework.beans.factory.InitializingBean;

/**
 * @author qsk
 */
public class Person implements BeanFactoryAware, BeanNameAware,
        InitializingBean, DisposableBean {

    private String name;
    private String address;
    private int phone;

    private BeanFactory beanFactory;
    private String beanName;

    public Person() {
        System.out.println("【構造器】調用Person的構造器實例化");
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        System.out.println("【註入屬性】註入屬性name");
        this.name = name;
    }

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        System.out.println("【註入屬性】註入屬性address");
        this.address = address;
    }

    public int getPhone() {
        return phone;
    }

    public void setPhone(int phone) {
        System.out.println("【註入屬性】註入屬性phone");
        this.phone = phone;
    }

    @Override
    public String toString() {
        return "Person [address=" + address + ", name=" + name + ", phone="
                + phone + "]";
    }

    // 這是BeanFactoryAware接口方法
    @Override
    public void setBeanFactory(BeanFactory arg0) throws BeansException {
        System.out.println("【BeanFactoryAware接口】調用BeanFactoryAware.setBeanFactory()");
        this.beanFactory = arg0;
    }

    // 這是BeanNameAware接口方法
    @Override
    public void setBeanName(String arg0) {
        System.out.println("【BeanNameAware接口】調用BeanNameAware.setBeanName()");
        this.beanName = arg0;
    }

    // 這是InitializingBean接口方法
    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("【InitializingBean接口】調用InitializingBean.afterPropertiesSet()");
    }

    // 這是DiposibleBean接口方法
    @Override
    public void destroy() throws Exception {
        System.out.println("【DiposibleBean接口】調用DiposibleBean.destory()");
    }

    // 通過<bean>的init-method屬性指定的初始化方法
    public void myInit() {
        System.out.println("【init-method】調用<bean>的init-method屬性指定的初始化方法");
    }

    // 通過<bean>的destroy-method屬性指定的初始化方法
    public void myDestory() {
        System.out.println("【destroy-method】調用<bean>的destroy-method屬性指定的初始化方法");
    }
}

2、接下來是演示BeanPostProcessor接口的方法，如下：

package springBeanTest;

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

public class MyBeanPostProcessor implements BeanPostProcessor {

    public MyBeanPostProcessor() {
        super();
        System.out.println("這是BeanPostProcessor實現類構造器！！");
        // TODO Auto-generated constructor stub
    }

    @Override
    public Object postProcessAfterInitialization(Object arg0, String arg1)
            throws BeansException {
        System.out.println("BeanPostProcessor接口方法postProcessAfterInitialization對屬性進行更改！");
        return arg0;
    }

    @Override
    public Object postProcessBeforeInitialization(Object arg0, String arg1)
            throws BeansException {
        System.out
        .println("BeanPostProcessor接口方法postProcessBeforeInitialization對屬性進行更改！");
        return arg0;
    }
}

如上，BeanPostProcessor接口包括2個方法postProcessAfterInitialization和postProcessBeforeInitialization，這兩個方法的第一個參數都是要處理的Bean對象，第二個參數都是Bean的name。返回值也都是要處理的Bean對象。這裏要註意。

3、InstantiationAwareBeanPostProcessor 接口本質是BeanPostProcessor的子接口，一般我們繼承Spring為其提供的適配器類InstantiationAwareBeanPostProcessor Adapter來使用它，如下：

package springBeanTest;

import java.beans.PropertyDescriptor;

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

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;
    }
}

　　

這個有3個方法，其中第二個方法postProcessAfterInitialization就是重寫了BeanPostProcessor的方法。第三個方法postProcessPropertyValues用來操作屬性，返回值也應該是PropertyValues對象。

4、演示工廠後處理器接口方法，如下：

package springBeanTest;

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 {

    public MyBeanFactoryPostProcessor() {
        super();
        System.out.println("這是BeanFactoryPostProcessor實現類構造器！！");
    }

    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory arg0)
            throws BeansException {
        System.out
                .println("BeanFactoryPostProcessor調用postProcessBeanFactory方法");
        BeanDefinition bd = arg0.getBeanDefinition("person");
        bd.getPropertyValues().addPropertyValue("phone", "110");
    }

}

5、配置文件如下beans.xml，很簡單，使用ApplicationContext,處理器不用手動註冊：

<?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="springBeanTest.MyBeanPostProcessor">
    </bean>

    <bean id="instantiationAwareBeanPostProcessor" class="springBeanTest.MyInstantiationAwareBeanPostProcessor">
    </bean>

    <bean id="beanFactoryPostProcessor" class="springBeanTest.MyBeanFactoryPostProcessor">
    </bean>
    
    <bean id="person" class="springBeanTest.Person" init-method="myInit"
        destroy-method="myDestory" scope="singleton" p:name="張三" p:address="廣州"
        p:phone="15900000000" />

</beans>

6、下面測試一下：

package springBeanTest;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class BeanLifeCycle {

    public static void main(String[] args) {

        System.out.println("現在開始初始化容器");
        
        ApplicationContext factory = new ClassPathXmlApplicationContext("springBeanTest/beans.xml");
        System.out.println("容器初始化成功");    
        //得到Preson，並使用
        Person person = factory.getBean("person",Person.class);
        System.out.println(person);
        
        System.out.println("現在開始關閉容器！");
        ((ClassPathXmlApplicationContext)factory).registerShutdownHook();
    }
}

關閉容器使用的是實際是AbstractApplicationContext的鉤子方法。

我們來看一下結果：

現在開始初始化容器
2014-5-18 15:46:20 org.springframework.context.support.AbstractApplicationContext prepareRefresh
信息: Refreshing org.springframework.context.support.ClassPathXmlApplicationContext@19a0c7c: startup date [Sun May 18 15:46:20 CST 2014]; root of context hierarchy
2014-5-18 15:46:20 org.springframework.beans.factory.xml.XmlBeanDefinitionReader loadBeanDefinitions
信息: Loading XML bean definitions from class path resource [springBeanTest/beans.xml]
這是BeanFactoryPostProcessor實現類構造器！！
BeanFactoryPostProcessor調用postProcessBeanFactory方法
這是BeanPostProcessor實現類構造器！！
這是InstantiationAwareBeanPostProcessorAdapter實現類構造器！！
2014-5-18 15:46:20 org.springframework.beans.factory.support.DefaultListableBeanFactory preInstantiateSingletons
信息: Pre-instantiating singletons in org.springframework.beans.factory.support.DefaultListableBeanFactory@9934d4: defining beans [beanPostProcessor,instantiationAwareBeanPostProcessor,beanFactoryPostProcessor,person]; root of factory hierarchy
InstantiationAwareBeanPostProcessor調用postProcessBeforeInstantiation方法
【構造器】調用Person的構造器實例化
InstantiationAwareBeanPostProcessor調用postProcessPropertyValues方法
【註入屬性】註入屬性address
【註入屬性】註入屬性name
【註入屬性】註入屬性phone
【BeanNameAware接口】調用BeanNameAware.setBeanName()
【BeanFactoryAware接口】調用BeanFactoryAware.setBeanFactory()
BeanPostProcessor接口方法postProcessBeforeInitialization對屬性進行更改！
【InitializingBean接口】調用InitializingBean.afterPropertiesSet()
【init-method】調用<bean>的init-method屬性指定的初始化方法
BeanPostProcessor接口方法postProcessAfterInitialization對屬性進行更改！
InstantiationAwareBeanPostProcessor調用postProcessAfterInitialization方法
容器初始化成功
Person [address=廣州, name=張三, phone=110]
現在開始關閉容器！
【DiposibleBean接口】調用DiposibleBean.destory()
【destroy-method】調用<bean>的destroy-method屬性指定的初始化方法

Spring-Bean生命周期

相關推薦

Spring-Bean生命周期

default anti fec aspectj inf getbean 不用 ans and Spring作為當前Java最流行、最強大的輕量級框架，受到了程序員的熱烈歡迎。準確的了解Spring Bean的生命周期是非常必要的。我們通常使用ApplicationCont

Spring Bean生命周期

-i 有一個 自定義 factory actor prope width ava 對象銷毀 概述 對於普通的Java對象，當new的時候創建對象，當它沒有任何引用的時候被垃圾回收機制回收。而由Spring IoC容器托管的對象，它們的生命周期完全由容器控制。Spring中每

Spring Bean 生命周期測試

img const tco per ecan eth 註解配置 equals rop Bean類實現BeanNameAware ，DisposableBean, InitializingBean 接口 package com.bean.life.entity;

spring 中bean生命周期

encoding 學習 tostring true ice ava initial oid pan 從頭開始學習spring(一) 傳統編程中，依賴關系比較多的情況下，導致維護成本直線上升，spring 采用Ioc對bean進行管理，減少了開發人員的工作量 正確理解spri

Spring中Bean的生命周期

spring bean生命周期 Spring 容器中的 Bean 是有生命周期的，Spring 允許在 Bean 在初始化完成後以及 Bean 銷毀前執行特定的操作，常用的設定方式有以下三種： （1）通過 <bean> 元素的 init-method/destroy-

Spring《二》 Bean的生命周期

pro msg public sys ini text cto onf con Bean初始化 1、bean中實現public void init（）；方法，config.xml中增加init-method="init" 屬性。 2、bean實現接口Initializing

Spring Bean的生命周期（非常詳細）(轉載)

res 包含 初始 ini 文件 roc arc strac www Spring作為當前Java最流行、最強大的輕量級框架，受到了程序員的熱烈歡迎。準確的了解Spring Bean的生命周期是非常必要的。我們通常使用ApplicationContext作為Spring容

Spring Bean的生命周期

復制 第一個 except 處理器 演示 1.0 簡單的 schema 實現 轉自： http://www.cnblogs.com/zrtqsk/p/3735273.html Spring作為當前Java最流行、最強大的輕量級框架，受到了程序員的熱烈歡迎。準確的了解Spri

Spring bean的生命周期詳解

root bsp ram odi www rop ssp package etag bean的生命周期1.實例化bean 即new2.按照spring上下文對實例化的bean進行配置 即填充屬性，也就是IOC/DI（控制反轉，依賴註入）3.如果這個bean實現了BeanNa

Spring中Bean的生命周期討論

work cxf hello sys tex 操作 classpath system under 1、代碼和配置文件準備 1.1、測試類（user.java） 1 public class User { 2 private int id; 3 pri

Spring Bean的生命周期，《Spring 實戰》書中的官方說法

nco process 上下文 步驟 for 接口 prop sso 包括 連著兩天的面試 ，都問到了 Spring 的Bean的生命周期，其中還包括 昨晚一波阿裏的電話面試。這裏找到了Spring 實戰中的官方說法。希望各位要面試的小夥伴記住，以後有可能，或者是有時間 去

Spring之Bean的作用域與生命周期

src efi lin 控制 初始化 troy [] 分享 isp 在前面博客中提到容器啟動獲得BeanDefinition對象中有一個scope 屬性。該屬性控制著bean對象的作用域。本章節介紹Bean的作用域及生命周期，了解bean是怎麽來的又怎麽沒的。 一、Bean

Spring容器中Bean的生命周期

pub run down xsd 信息 ini exc rop throw Spring生命周期分為以下步驟： 1.instantiate bean 對象實例化 2.populate properties 封裝屬性 3.如果Bean實現BeanNameAware執行setB

Spring之Bean的生命周期

web nec connector start jasper dep oca cep table ---恢復內容開始--- Spring中關於Bean的生命周期，我總結的大致過程如下： 1、用戶調用BeanFactory接口的getBean()方法請求一個

spring ApplicationContext中Bean的生命周期

rabl tco finall 註冊 反射 定義 temp nfa eset AbstractApplicationContext Spring的AbstractApplicationContext是ApplicationContext的抽象實現類，該抽象類的refresh

學習 Spring (四) Bean 的生命周期

exce utf-8 schema 實現 row tar ring () 全局 Spring入門篇 學習筆記 定義 --> 初始化 --> 使用 --> 銷毀 初始化 實現 org.springframework.beans.factory.Init

spring Bean的完整生命周期

destroy pri 重要 processor 上下文對象 nts tro oid sso spring 容器中的bean的完整生命周期一共分為十一步完成。 1.bean對象的實例化 2.封裝屬性，也就是設置properties中的屬性值 3.如果bean實現了Be

Spring中Bean的作用域、生命周期

作用域 spring容器 分享 引用 多少 返回 portlet type 精確 Bean的作用域（scope） 　　Spring 3定義了五種作用域，分別為singleton（單例）、prototype（原型）、request、session、global sessio

Spring Bean的生命周期理解

object sdf erp println after 創建 img turn err 《Spring in action》 import org.springframework.beans.BeansException; impor

spring-bean的生命周期

div 繼續 end 是我 eve idt 系統路徑 contex 實現 參考： 作者：淺然_ https://blog.csdn.net/w_linux/article/details/80086950 spring就是一個能夠替你做很多事情的工廠，spring容