2. 程式人生 > >spring中Bean的生命週期總結

spring中Bean的生命週期總結

阿新 • • 發佈：2019-02-01

spring中在ApplicationContext或在BeanFactory中Bean的生命週期總結

 Spring中Bean的生命週期,在學習spring的過程中bean的生命週期理解對學習spring有很大的幫助，下面我就分別介紹在ApplicationContext和BeanFactory中Bean的生命週期。

1、在ApplicationContext中Bean的生命週期

生命週期執行的過程如下：

1、需找所有的bean根據bean定義的資訊來例項化bean

2、使用依賴注入，spring按bean定義資訊配置bean的所有屬性

3、若bean實現了BeanNameAware介面，工廠呼叫Bean的setBeanName（）方法傳遞bean的ID。

4、若bean實現了BeanFactoryAware介面，工廠呼叫setBeanFactory（） 方法傳入工廠自身。

5、若bean實現了ApplicationContextAware()介面，setApplicationContext()方法會被呼叫

6、若BeanPostProcessor和bean關聯,

則它們的postProcessBeforeInitialization()方法被呼叫

7、若bean指定了init-method="init"方法、，它將被呼叫。

8、若有BeanPostProcessor和bean關聯，

則它們的postProcessAfterInitialization()方法被呼叫

    注意：通過已上操作,此時的Bean就可以被應用的系統使用，並講保留在BeanFactory工廠中直到不再需要為止.但我們也可以通過9或者10進行銷燬

9、若bean實現了DisposableBean介面,distroy()方法被呼叫

10、如果指定了destroy-method="close"定製的銷燬方法，就呼叫這個方法

案例分析：

   建立一個實體Bean程式碼如下：

[java] view plaincopyprint?
  1. package www.csdn.spring.dao;  
  2. import org.springframework.beans.BeansException;  
  3. import org.springframework.beans.factory.BeanFactory;  
  4. import org.springframework.beans.factory.BeanFactoryAware;  
  5. import org.springframework.beans.factory.BeanNameAware;  
  6. import org.springframework.beans.factory.DisposableBean;  
  7. import org.springframework.beans.factory.InitializingBean;  
  8. import org.springframework.context.ApplicationContext;  
  9. import org.springframework.context.ApplicationContextAware;  
  10. publicclass HelloDaoImpl implements BeanNameAware, BeanFactoryAware,  
  11. InitializingBean, ApplicationContextAware, DisposableBean {  
  12. private String content;  
  13. public HelloDaoImpl() {  
  14. System.out.println("----------HelloDaoImpl例項化");  
  15. }  
  16. publicvoid setContent(String content) {  
  17. System.out.println("----------通過依賴注入的內容是:" + content);  
  18. this.content = content;  
  19. }  
  20. @Override
  21. publicvoid setBeanName(String beanId) {  
  22. System.out.println("----------輸出BeanId:" + beanId);  
  23. }  
  24. @Override
  25. publicvoid setBeanFactory(BeanFactory factory) throws BeansException {  
  26. System.out.println("----------factory:" + factory.getClass());  
  27. }  
  28. @Override
  29. publicvoid setApplicationContext(ApplicationContext applicationContext)  
  30. throws BeansException {  
  31. System.out.println("----------" + applicationContext);  
  32. }  
  33. @Override
  34. publicvoid afterPropertiesSet() throws Exception {  
  35. System.out.println("----------afterPropertiesSet");  
  36. }  
  37. publicvoid init() {  
  38. System.out.println("----------初始化方法");  
  39. }  
  40. @Override
  41. publicvoid destroy() throws Exception {  
  42. System.out.println("----------bean被銷燬");  
  43. }  
  44. publicvoid close() {  
  45. System.out.println("----------close");  
  46. }  
  47. }  
package www.csdn.spring.dao;


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;

import org.springframework.context.ApplicationContext;

import org.springframework.context.ApplicationContextAware;


public class HelloDaoImpl implements BeanNameAware, BeanFactoryAware,

InitializingBean, ApplicationContextAware, DisposableBean {


private String content;


public HelloDaoImpl() {

System.out.println("----------HelloDaoImpl例項化");

}


public void setContent(String content) {

System.out.println("----------通過依賴注入的內容是:" + content);

this.content = content;

}


@Override

public void setBeanName(String beanId) {

System.out.println("----------輸出BeanId:" + beanId);

}


@Override

public void setBeanFactory(BeanFactory factory) throws BeansException {

System.out.println("----------factory:" + factory.getClass());


}


@Override

public void setApplicationContext(ApplicationContext applicationContext)

throws BeansException {

System.out.println("----------" + applicationContext);


}


@Override

public void afterPropertiesSet() throws Exception {

System.out.println("----------afterPropertiesSet");

}


public void init() {

System.out.println("----------初始化方法");

}


@Override

public void destroy() throws Exception {

System.out.println("----------bean被銷燬");


}


public void close() {

System.out.println("----------close");

}


}

建立BeanPostProcessor實現類

[java] view plaincopyprint?
  1. package www.csdn.spring.dao;  
  2. import org.springframework.beans.BeansException;  
  3. import org.springframework.beans.factory.config.BeanPostProcessor;  
  4. publicclass BeanPostProcessorImpl implements BeanPostProcessor {  
  5. @Override
  6. public Object postProcessBeforeInitialization(Object bean, String beanName)  
  7. throws BeansException {  
  8. System.out.println("我把:" + beanName + "例項化化之前的操作");  
  9. return bean;  
  10. }  
  11. @Override
  12. public Object postProcessAfterInitialization(Object bean, String beanName)  
  13. throws BeansException {  
  14. System.out.println("我把:" + beanName + "例項化化之後的操作");  
  15. return bean;  
  16. }  
  17. }  
package www.csdn.spring.dao;


import org.springframework.beans.BeansException;

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


public class BeanPostProcessorImpl implements BeanPostProcessor {

@Override

public Object postProcessBeforeInitialization(Object bean, String beanName)

throws BeansException {

System.out.println("我把:" + beanName + "例項化化之前的操作");

return bean;

}


@Override

public Object postProcessAfterInitialization(Object bean, String beanName)

throws BeansException {

System.out.println("我把:" + beanName + "例項化化之後的操作");

return bean;

}


}

在配置檔案中配置實體Bean和BeanPostProcessorImpl特殊的Bean

[html] view plaincopyprint?
  1. <?xmlversion="1.0"encoding="UTF-8"?>
  2. <beansxmlns="http://www.springframework.org/schema/beans"
  3. xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4. xsi:schemaLocation="http://www.springframework.org/schema/beans  
  5.            http://www.springframework.org/schema/beans/spring-beans.xsd">
  6. <!-- spring容器 就是負責建立、管理、維護Bean 並且能夠依賴注入到相應元件上 -->
  7. <beanid="helloDaoImpl"class="www.csdn.spring.dao.HelloDaoImpl"
  8. scope="singleton"lazy-init="false"init-method="init"destroy-method="close">
  9. <!-- 通過set方法注入 -->
  10. <propertyname="content"value="陳老師早上好！"/>
  11. </bean>
  12. <!-- BeanPostProcessor與當前的bean都進行關聯 -->
  13. <beanclass="www.csdn.spring.dao.BeanPostProcessorImpl"/>
  14. </beans>
<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns="http://www.springframework.org/schema/beans"

xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

xsi:schemaLocation="http://www.springframework.org/schema/beans

           http://www.springframework.org/schema/beans/spring-beans.xsd">



<!-- spring容器 就是負責建立、管理、維護Bean 並且能夠依賴注入到相應元件上 -->

<bean id="helloDaoImpl" class="www.csdn.spring.dao.HelloDaoImpl"

scope="singleton" lazy-init="false" init-method="init" destroy-method="close">

<!-- 通過set方法注入 -->

<property name="content" value="陳老師早上好！" />

</bean>


<!-- BeanPostProcessor與當前的bean都進行關聯 -->

<bean class="www.csdn.spring.dao.BeanPostProcessorImpl" />


</beans>

建立測試類BeanTest 

[java] view plaincopyprint?
  1. package www.csdn.spring.bean.cycle;  
  2. import org.junit.Test;  
  3. import org.springframework.context.ApplicationContext;  
  4. import org.springframework.context.ConfigurableApplicationContext;  
  5. import org.springframework.context.support.ClassPathXmlApplicationContext;  
  6. publicclass BeanTest {  
  7. @Test
  8. publicvoid test() {  
  9. ApplicationContext context = new ClassPathXmlApplicationContext(  
  10. "classpath:spring-dao.xml");  
  11. // 強制造型
  12. ConfigurableApplicationContext cont = (ConfigurableApplicationContext) context;  
  13. // 執行關閉 可以考到 destory-method的方法的執行
  14. cont.close();  
  15. }  
  16. }  
package www.csdn.spring.bean.cycle;


import org.junit.Test;

import org.springframework.context.ApplicationContext;

import org.springframework.context.ConfigurableApplicationContext;

import org.springframework.context.support.ClassPathXmlApplicationContext;


public class BeanTest {


@Test

public void test() {

ApplicationContext context = new ClassPathXmlApplicationContext(

"classpath:spring-dao.xml");

// 強制造型

ConfigurableApplicationContext cont = (ConfigurableApplicationContext) context;

// 執行關閉 可以考到 destory-method的方法的執行

cont.close();


}

}

執行結果如下：

總結：在ApplicationContext中Bean的生命週期

2、在 BeanFactory中Bean的生命週期

     在BeanFactory中Bean的生命週期與ApplicationContext中bean的生命週期唯一不同的是：若bean實現了ApplicationContextAware()介面，在ApplicationContext中bean的生命週期中setApplicationContext()方法會被呼叫,而在BeanFactory中Bean的生命週期此方法不會被呼叫。

案例採用上個案例：測試類中測試程式碼如下：

[java] view plaincopyprint?
  1. // 建立資源物件
  2. ClassPathResource resource = new ClassPathResource("spring-dao.xml");  
  3. // 採用BeanFactory初始化容器
  4. ConfigurableBeanFactory cbf = new XmlBeanFactory(resource);  
  5. // bean後置處理器必須通過addBeanPostProcessor(new BeanPostProcessorImpl())手動新增
  6. cbf.addBeanPostProcessor(new BeanPostProcessorImpl());  
  7. //在配置檔案中給BeanPostProcessorImpl的bean加上id="beanPostProcessorImpl" //cbf.addBeanPostProcessor(cbf.getBean("beanPostProcessorImpl", BeanPostProcessorImpl.class));
  8. // 獲取Bean物件
  9. cbf.getBean("helloDaoImpl", HelloDaoImpl.class);  
  10. // 銷燬
  11. cbf.destroySingletons();  
// 建立資源物件

ClassPathResource resource = new ClassPathResource("spring-dao.xml");

// 採用BeanFactory初始化容器

ConfigurableBeanFactory cbf = new XmlBeanFactory(resource);

// bean後置處理器必須通過addBeanPostProcessor(new BeanPostProcessorImpl())手動新增

cbf.addBeanPostProcessor(new BeanPostProcessorImpl());

//在配置檔案中給BeanPostProcessorImpl的bean加上id="beanPostProcessorImpl" //cbf.addBeanPostProcessor(cbf.getBean("beanPostProcessorImpl", BeanPostProcessorImpl.class));

// 獲取Bean物件

cbf.getBean("helloDaoImpl", HelloDaoImpl.class);

// 銷燬

cbf.destroySingletons();

執行結果：

總結：在BeanFactory中Bean的生命週期

另外說明：

     應用上下文與bean工廠的另一個重要區別是關於單例bean如何被載入。

bean工廠延遲載入所有bean，直到getBean()方法被呼叫。

應用上下文會在啟動後預載入所有單例bean.這樣可確保應用不需要等待他們被建立。

相關推薦

spring中bean生命週期

我們都知道servlet的生命週期是：例項化、初始化、接受處理請求、銷燬。 spring上下文中bean也是類似的： 我們的bean都是交給spring管理的，也就是我們將bean的建立、管理控制權都交給了spring容器也稱為IOC容器 當然IOC容器初始化時

Spring中bean生命週期（淺顯易懂）

1、網上下的圖，以供參考 2、/**  * 建立一個測試類的UserService  * @author lion  *  */ public class UserService {     private String username;//使用者名稱     pri

spring 中bean生命周期

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

2.Spring的Bean生命週期和組裝方式

1.Spring IoC容器概述    Spring IoC容器：      Spring容器即體現了IoC原理    Spring容器通過讀取配置元資料負責對Beans例項化、配置和裝配     配置元資

使用Spring的Bean生命週期特性釋放Redis連線池案例

簡介 寫這篇文章的初衷源於前幾天公司的Redis連線池溢位事件，後來是藉助SpringBean的生命週期特徵解決了連線池溢位問題。基礎稍微好點的人應該知道，spring管理的bean，可以自定義初始化方法init，和bean銷燬方法destroy，但是以前只是知道有這些特性

Spring的Bean生命週期內的callback方法和Spring容器啟動關閉時的callback方法

通過Spring管理的bean,在其生命週期內可以配置被Spring呼叫的callback方法一般有兩種:通過實現Spring提供的特點介面和通過配置callback方法.(如果bean是prototype的話,由於其銷燬不被Spring管理,其銷燬方法不會被呼叫) 1,通

總結Spring框架擴充套件點（二）bean生命週期中的擴充套件點（持續更新中...）

面向業務開發的時候，程式設計師需要明白業務的邏輯，並設計程式碼結構。而在進行中介軟體開發的時候，則需要明白框架的邏輯，進行開發。 所以要開發提供給spring的中介軟體，需要知道spring中有哪些擴充套件點，好在對應的地方插入我們的功能。 1. Spring容器初始化b

spring中Bean的生命週期總結

spring中在ApplicationContext或在BeanFactory中Bean的生命週期總結  Spring中Bean的生命週期,在學習spring的過程中bean的生命週期理解對學習spring有很大的幫助，下面我就分別介紹在ApplicationContext和BeanFactory中Bean

知識儲備：Spring中Bean的生命週期（基於註解版）

一：前言 在Spring專案中，通常配置Spring都是使用XML的形式進行配置，配置bean是通過<bean></bean>標籤將bean加入IOC容器中，但在Spring註解版中，可以通過Java程式碼進行配置，即建立一個java類在其類頭上標註@Configurat

spring中Bean的生命週期，具體再具體

今天在面試的時候，面試官提問到spring中Bean的生命週期,我的回答是： 1.例項化（為bean物件開闢空間） 2.初始化（對物件的屬性進行依賴注入，使用setter方法） 3.銷燬 我以為週期這裡

Spring中Bean的生命週期之[email protected]方法進行物件的初始化

方法：通過@Bean指定init-method和destroy-method； 注：單例項和原型模式物件的建立時間和初始化銷燬的時間順序不同。 一、單例項模式 1、建立Car例項物件，並建立初始化和銷燬方法 package com.atguigu.bean; imp

Spring AOP在Bean生命週期中的呼叫時機

之前有寫了一個生命週期的例子，直接拿來用，在每個生命週期方法中呼叫print方法。見上一篇 加上AOP的程式碼 package com.aspect; import org.aspectj.lang.ProceedingJoinPoint; import org.a

spring 中bean的作用域和生命週期

spring中bean的作用域: 生命週期(官方圖): spring 中bean例項化過程(不好意思,我盜圖了): 1:instantiate bean物件例項化 2:populate properties 封裝屬性 3:如果Bean實現BeanNameAwar

如果你每次面試前都要去背一篇Spring中Bean的生命週期，請看完這篇文章

# 前言 當你準備去複習Spring中Bean的生命週期的時候，這個時候你開始上網找資料，很大概率會看到下面這張圖： ![image-20200707094637369](https://gitee.com/wx_cc347be696/blogImage/raw/master/image-20200707

Spring中Bean的生命周期

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

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註解】2、Bean生命週期

1、初始化和銷燬 通過@Bean註解的initMethod和destroyMethod屬性 InitializingBean介面、DisposableBean介面 可以使用JSR250： @PostConstruct：在Bean建立完成並且屬性

5.Spring Bean生命週期.md

文章目錄 5.Spring Bean生命週期 生命週期流程圖 說明 總結 5.Spring Bean生命週期 生命週期流程圖 說明 *呼叫InstantitationAwareBeanP

Spring Bean生命週期回撥——初始化回撥(init-method）與銷燬回撥（destroy-method）

實現Bean初始化回撥和銷燬回撥各有三種方法，一是實現介面方法，二是在XML配置，三是使用註解 初始化回撥（init-method） 1、使用介面 org.springframework.beans.factory.InitializingBean介面類的作用是：在容器設定bean必

Spring 5 設計模式 - bean生命週期和使用的模式

Spring 5 設計模式 - bean生命週期和使用的模式 生命週期和階段 初始化階段 載入bean定義 初始化bean例項 使用BeanPostProcessor自定義bean 初始化擴充套件點