spring生命週期二轉載

####首先你需要知道的知識
在IoC容器啓動之後，並不會馬上就實例化相應的bean，此時容器僅僅擁有所有對象的BeanDefinition(BeanDefinition：是容器依賴某些工具加載的XML配置信息進行解析和分析，並將分析後的信息編組爲相應的BeanDefinition)。只有當getBean()調用時纔是有可能觸發Bean實例化階段的活動

#####爲什麼說有可能觸發Bean實例化階段？

因爲當對應某個bean定義的getBean()方法第一次被調用時，不管是顯示的還是隱式的，Bean實例化階段纔會被觸發，第二次被調用則會直接返回容器緩存的第一次實例化完的對象實例(因爲默認是singleton單例，當然，這裏的情況prototype類型的bean除外)

##該篇博客主要闡述
#####1、Bean的一生過程
#####2、Bean的後置處理器

###一、Bean的一生過程
####先來看以下的圖(Bean的一生)

####可以簡述爲以下九步

實例化bean對象(通過構造方法或者工廠方法)
設置對象屬性(setter等)（依賴注入）
如果Bean實現了BeanNameAware接口，工廠調用Bean的setBeanName()方法傳遞Bean的ID。（和下面的一條均屬於檢查Aware接口）
如果Bean實現了BeanFactoryAware接口，工廠調用setBeanFactory()方法傳入工廠自身
將Bean實例傳遞給Bean的前置處理器的postProcessBeforeInitialization(Object bean, String beanname)方法
調用Bean的初始化方法
將Bean實例傳遞給Bean的後置處理器的postProcessAfterInitialization(Object bean, String beanname)方法
使用Bean
容器關閉之前，調用Bean的銷燬方法
####先看一個最簡單的一生(沒有使用Bean的後置處理器)

Student.java

package com.linjie.cycle;

import org.springframework.beans.factory.BeanNameAware;

/**
* @author LinJie
* @Description:一個學生類(Bean)，能體現其生命週期的Bean
*/
public class Student implements BeanNameAware {
private String name;

   //無參構造方法
   public Student() {
       super();
   }

   /** 設置對象屬性
   * @param name the name to set
   */
   public void setName(String name) {
       System.out.println("設置對象屬性setName()..");
       this.name = name;
   }

   //Bean的初始化方法
   public void initStudent() {
       System.out.println("Student這個Bean：初始化");
   }

   //Bean的銷燬方法
   public void destroyStudent() {
       System.out.println("Student這個Bean：銷燬");
   }

   //Bean的使用
   public void play() {
       System.out.println("Student這個Bean：使用");
   }

   /* 重寫toString
   * @see java.lang.Object#toString()
   */
   @Override
   public String toString() {
       return "Student [name = " + name + "]";
   }

   //調用BeanNameAware的setBeanName()
   //傳遞Bean的ID。
   @Override
   public void setBeanName(String name) {
       System.out.println("調用BeanNameAware的setBeanName()..." );
   }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
測試類

package com.linjie.cycle;

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.AbstractApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
* 測試類
* @author LinJie
*
*/
public class CycleTest {
@Test
    public void test() {
       ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
       Student student = (Student) context.getBean("student");
       //Bean的使用
       student.play();
       System.out.println(student);
       //關閉容器
       ((AbstractApplicationContext) context).close();
   }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
applicationContext.xml

<?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">


       <bean id="student" class="com.linjie.cycle.Student" init-method="initStudent" destroy-method="destroyStudent">
       <property name="name" value="LINJIE"></property>
       </bean>
</beans>
1
2
3
4
5
6
7
8
9
10
11
12
控制檯顯示結果

可以在輸出結果看出bean的一生，完全與之前的一生過程圖相符(除了bean後置處理器部分)，這裏還需要提及的是在xml配置中的兩個屬性

init-method：指定初始化的方法
destroy-method：指定銷燬的方法
#####說到init-method和destroy-method，當然也要提及一下在< beans>的屬性

default-init-method：爲應用上下文中所有的Bean設置了共同的初始化方法
default-destroy-method：爲應用上下文中所有的Bean設置了共同的銷燬方法

###二、Bean的後置處理器

上面bean的一生其實已經算是對bean生命週期很完整的解釋了，然而bean的後置處理器，是爲了對bean的一個增強

####用法

分別在Bean的初始化前後對Bean對象提供自己的實例化邏輯

- 實現BeanPostProcessor接口
- postProcessBeforeInitialization方法
- postProcessAfterInitialization方法
1
2
3
####接上面的Student Demo

Student.java

package com.linjie.cycle;

import org.springframework.beans.factory.BeanNameAware;

/**
* @author LinJie
* @Description:一個學生類(Bean)，能體現其生命週期的Bean
*/
public class Student implements BeanNameAware {
private String name;

   //無參構造方法
   public Student() {
       super();
   }

   /* 重寫toString
   * @see java.lang.Object#toString()
   */
   @Override
   public String toString() {
       return "Student [name = " + name + "]";
   }

package com.linjie.cycle;

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

/**
* bean的後置處理器
* 分別在bean的初始化前後對bean對象提供自己的實例化邏輯
* postProcessAfterInitialization：初始化之後對bean進行增強處理
* postProcessBeforeInitialization：初始化之前對bean進行增強處理
* @author LinJie
*
*/
public class MyBeanPostProcessor implements BeanPostProcessor {

   //對初始化之後的Bean進行處理
   //參數：bean：即將初始化的bean
   //參數：beanname：bean的名稱
   //返回值：返回給用戶的那個bean,可以修改bean也可以返回一個新的bean
   @Override
   public Object postProcessAfterInitialization(Object bean, String beanname) throws BeansException {
       Student stu = null;
       System.out.println("對初始化之後的Bean進行處理,將Bean的成員變量的值修改了");
       if("name".equals(beanname) || bean instanceof Student) {
           stu = (Student) bean;
           stu.setName("Jack");
       }
       return stu;
   }

   //對初始化之前的Bean進行處理
   //參數：bean：即將初始化的bean
   //參數：beanname：bean的名稱
   //返回值：返回給用戶的那個bean,可以修改bean也可以返回一個新的bean
   @Override
   public Object postProcessBeforeInitialization(Object bean, String beanname) throws BeansException {
       System.out.println("對初始化之前的Bean進行處理,此時我的名字"+bean);
       return bean;
   }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
測試類

package com.linjie.cycle;

<?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">

       <bean id="student" class="com.linjie.cycle.Student" init-method="initStudent" destroy-method="destroyStudent">
       <property name="name" value="LINJIE"></property>
       </bean>

       
       <bean class="com.linjie.cycle.MyBeanPostProcessor"></bean>
</beans>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
控制檯顯示結果

可以在applicationContext.xml中看到配置Bean後置處理器，不需要ID，只需要其全類名，因爲IoC容器自動識別一個BeanPostProcessor

#####在控制檯顯示結果可以看出,Bean的後置處理器強大之處，可以對Bean實現自己想要做的事情，比如我這裏的Demo就是在postProcessAfterInitialization方法中將成員變量name偷偷修改了，最後輸出的就是偷偷修改之後的值

好了以上就是bean的一生，在控制檯下將bean的一生映射出來，對理解bean的一生(生命週期)更加直觀咯

####參考
《Spring揭祕》
《Spring IN ACTION》
---------------------
作者：淺然_
來源：CSDN
原文：https://blog.csdn.net/w_linux/article/details/80086950
版權聲明：本文爲博主原創文章，轉載請附上博文鏈接！

spring生命週期二轉載

mysql下載安裝配置詳細教程

集合比較

mysql數據庫鎖定機制

java中的遞歸方法(簡單實現)

MyEclipse2016的安裝破解

Mac下配置sublime實現LaTeX

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結