2. 程式人生 > >spring原始碼分析：spring生命週期

spring原始碼分析：spring生命週期

阿新 • • 發佈：2018-12-19

最近在看springboot自動配置，看到了@Conditional,@ConditionalOnMissingBean等等。這些註解，一直研究他們是如何實現springboot的條件註解的。由他們回到了@Configuration,回到了ConfigurationClassPostProcessor。ConfigurationClassPostProcessor實現了BeanFactoryPostProcessor，在spring生命週期當中會存在某個地方執行實現了BeanFactoryPostProcessor的postProcessBeanFactory方法。由於以前看spring原始碼時做了比較，於是這裡再次總結一下加深自己的影響。

我會從spring生命週期分析，然後到spring如何實現註解，例如@Configuration,@Import等等，最後到@Conditional相關的註解如何實現。

先來看看spring核心程式碼：

@Override
    public void refresh() throws BeansException, IllegalStateException {
        synchronized (this.startupShutdownMonitor) {
            // Prepare this context for refreshing.
            prepareRefresh();

            // Tell the subclass to refresh the internal bean factory.
 

            ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

            // Prepare the bean factory for use in this context.
            prepareBeanFactory(beanFactory);

            try {
                // Allows post-processing of the bean factory in context subclasses.
                postProcessBeanFactory(beanFactory);

                // Invoke factory processors registered as beans in the context.
 

                invokeBeanFactoryPostProcessors(beanFactory);

                // Register bean processors that intercept bean creation.
                registerBeanPostProcessors(beanFactory);

                // Initialize message source for this context.
                initMessageSource();

                // Initialize event multicaster for this context.
                initApplicationEventMulticaster();

                // Initialize other special beans in specific context subclasses.
                onRefresh();

                // Check for listener beans and register them.
                registerListeners();

                // Instantiate all remaining (non-lazy-init) singletons.
                finishBeanFactoryInitialization(beanFactory);

                // Last step: publish corresponding event.
                finishRefresh();
            }

            catch (BeansException ex) {
                if (logger.isWarnEnabled()) {
                    logger.warn("Exception encountered during context initialization - " +
                            "cancelling refresh attempt: " + ex);
                }

                // Destroy already created singletons to avoid dangling resources.
                destroyBeans();

                // Reset 'active' flag.
                cancelRefresh(ex);

                // Propagate exception to caller.
                throw ex;
            }

            finally {
                // Reset common introspection caches in Spring's core, since we
                // might not ever need metadata for singleton beans anymore...
                resetCommonCaches();
            }
        }
    }

以下是我做的筆記:
這裡寫圖片描述

再來看看程式碼
App.Java

public class App {
    public static void main(String[] args) {
        System.out.println("====開始初始化容器===");

        ApplicationContext ctx = new AnnotationConfigApplicationContext(JavaConfig.class);
        System.out.println("====容器初始化成功!====");

        System.out.println("==========獲取person==============");
        Person person = (Person) ctx.getBean("person");

        person.say();
        System.out.println(person);

        System.out.println("==========獲取lazyPerson==============");
        LazyPerson lazyPerson = (LazyPerson) ctx.getBean("lazyPerson");

        System.out.println("===現在關閉容器===");

        ((ClassPathXmlApplicationContext)ctx).registerShutdownHook();
    }

}

JavaConfig

@Configuration
public class JavaConfig {


    @Bean
    @Lazy
    public LazyPerson lazyPerson(){
        return new LazyPerson();
    }

    @Bean
    public MyBeanFactoryPostProcessor myBeanFactoryPostProcessor(){
        return new MyBeanFactoryPostProcessor();
    }

    @Bean
    public MyBeanPostProcessor myBeanPostProcessor(){
        return  new MyBeanPostProcessor();
    }

    @Bean
    public MyInstantiationAwareBeanPostProcessor myInstantiationAwareBeanPostProcessor(){
        return new MyInstantiationAwareBeanPostProcessor();
    }

    @Bean
    public Person person(){
        return new Person();
    }
}

LazyPerson

public class LazyPerson {



    @PostConstruct
    public void init(){
        System.out.println("========LazyPerson init====================");
    }
    public LazyPerson(){
        System.out.println("==============LazyPerson()=========");
    }
}

MyBeanFactoryPostProcessor

public class MyBeanFactoryPostProcessor implements BeanDefinitionRegistryPostProcessor {

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

    public void postProcessBeanFactory(ConfigurableListableBeanFactory arg0)
            throws BeansException {
        System.out
                .println("MyBeanFactoryPostProcessor=====BeanFactoryPostProcessor呼叫postProcessBeanFactory方法");
        BeanDefinition bd = arg0.getBeanDefinition("person");
        bd.getPropertyValues().addPropertyValue("phone", "110");
    }
}
 public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException {
        System.out.println("==MyBeanFactoryPostProcessor==MyBeanFactoryPostProcessor呼叫=postProcessBeanDefinitionRegistry");
    }

MyBeanPostProcessor

public class MyBeanPostProcessor implements BeanPostProcessor {

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

    public Object postProcessAfterInitialization(Object arg0, String arg1)
            throws BeansException {
        System.out
                .println("MyBeanPostProcessor====BeanPostProcessor介面方法postProcessAfterInitialization對屬性進行更改！");
        return arg0;
    }

    public Object postProcessBeforeInitialization(Object arg0, String arg1)
            throws BeansException {
        System.out
                .println("MyBeanPostProcessor=====BeanPostProcessor介面方法postProcessBeforeInitialization對屬性進行更改！");
        return arg0;
    }
}

MyInstantiationAwareBeanPostProcessor

public class MyInstantiationAwareBeanPostProcessor extends
        InstantiationAwareBeanPostProcessorAdapter {

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

    // 介面方法、例項化Bean之前呼叫
    @Override
    public Object postProcessBeforeInstantiation(Class beanClass,
                                                 String beanName) throws BeansException {
        System.out
                .println("MyInstantiationAwareBeanPostProcessor=====InstantiationAwareBeanPostProcessor呼叫postProcessBeforeInstantiation方法");
        return null;
    }

    // 介面方法、例項化Bean之後呼叫
    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName)
            throws BeansException {
        System.out
                .println("MyInstantiationAwareBeanPostProcessor=====InstantiationAwareBeanPostProcessor呼叫postProcessAfterInitialization方法");
        return bean;
    }

    // 介面方法、設定某個屬性時呼叫
    @Override
    public PropertyValues postProcessPropertyValues(PropertyValues pvs,
                                                    PropertyDescriptor[] pds, Object bean, String beanName)
            throws BeansException {
        System.out
                .println("MyInstantiationAwareBeanPostProcessor======InstantiationAwareBeanPostProcessor呼叫postProcessPropertyValues方法");
        return pvs;
    }
}

Person

public class Person implements BeanFactoryAware, BeanNameAware,ApplicationContextAware,
        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;
    }

    public void say(){
        System.out.println("============say===============");
    }

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

    // 這是BeanFactoryAware介面方法

    public void setBeanFactory(BeanFactory arg0) throws BeansException {
        System.out
                .println("【BeanFactoryAware介面】呼叫BeanFactoryAware.setBeanFactory()");
        this.beanFactory = arg0;
    }

    // 這是BeanNameAware介面方法
    public void setBeanName(String arg0) {
        System.out.println("【BeanNameAware介面】呼叫BeanNameAware.setBeanName()");
        this.beanName = arg0;
    }

    // 這是InitializingBean介面方法
    public void afterPropertiesSet() throws Exception {
        System.out
                .println("【InitializingBean介面】呼叫InitializingBean.afterPropertiesSet()");
    }

    // 這是DiposibleBean介面方法
    public void destroy() throws Exception {
        System.out.println("【DiposibleBean介面】呼叫DiposibleBean.destory()");
    }

    // 通過<bean>的init-method屬性指定的初始化方法
    @PostConstruct
    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屬性指定的初始化方法");
    }

    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        System.out.println("ApplicationContextAware===================applicationContext======================");

    }
}

我們執行App的main方法得到結果

====開始初始化容器===

**********invokeBeanFactoryPostProcessors(beanFactory)**********
MyBeanFactoryPostProcessor=====這是BeanFactoryPostProcessor實現類構造器！！
==MyBeanFactoryPostProcessor==MyBeanFactoryPostProcessor呼叫=postProcessBeanDefinitionRegistry
MyBeanFactoryPostProcessor=====BeanFactoryPostProcessor呼叫postProcessBeanFactory方法
**********invokeBeanFactoryPostProcessors(beanFactory)**********


*****registerBeanPostProcessors(beanFactory);*****
MyBeanPostProcessor====這是BeanPostProcessor實現類構造器！！
MyInstantiationAwareBeanPostProcessor=====這是InstantiationAwareBeanPostProcessorAdapter實現類構造器！！
*****registerBeanPostProcessors(beanFactory);*****


***finishBeanFactoryInitialization(beanFactory);***

*******下面的一段是因為存在其他的類存在例項化，依賴注入所有你會看到重複的兩份*****
MyInstantiationAwareBeanPostProcessor=====InstantiationAwareBeanPostProcessor呼叫postProcessBeforeInstantiation方法
MyInstantiationAwareBeanPostProcessor======InstantiationAwareBeanPostProcessor呼叫postProcessPropertyValues方法
MyBeanPostProcessor=====BeanPostProcessor介面方法postProcessBeforeInitialization對屬性進行更改！
MyBeanPostProcessor====BeanPostProcessor介面方法postProcessAfterInitialization對屬性進行更改！
MyInstantiationAwareBeanPostProcessor=====InstantiationAwareBeanPostProcessor呼叫postProcessAfterInitialization方法
MyInstantiationAwareBeanPostProcessor=====InstantiationAwareBeanPostProcessor呼叫postProcessBeforeInstantiation方法
MyInstantiationAwareBeanPostProcessor======InstantiationAwareBeanPostProcessor呼叫postProcessPropertyValues方法
MyBeanPostProcessor=====BeanPostProcessor介面方法postProcessBeforeInitialization對屬性進行更改！
MyBeanPostProcessor====BeanPostProcessor介面方法postProcessAfterInitialization對屬性進行更改！
MyInstantiationAwareBeanPostProcessor=====InstantiationAwareBeanPostProcessor呼叫postProcessAfterInitialization方法
*******上面的一段是因為存在其他的類存在例項化，依賴注入所有你會看到重複的兩份*****

MyInstantiationAwareBeanPostProcessor=====InstantiationAwareBeanPostProcessor呼叫postProcessBeforeInstantiation方法
【構造器】呼叫Person的構造器例項化
MyInstantiationAwareBeanPostProcessor======InstantiationAwareBeanPostProcessor呼叫postProcessPropertyValues方法
【注入屬性】注入屬性phone
【BeanNameAware介面】呼叫BeanNameAware.setBeanName()
【BeanFactoryAware介面】呼叫BeanFactoryAware.setBeanFactory()
ApplicationContextAware===================applicationContext======================
MyBeanPostProcessor=====BeanPostProcessor介面方法postProcessBeforeInitialization對屬性進行更改！
【init-method】呼叫<bean>的init-method屬性指定的初始化方法
【InitializingBean介面】呼叫InitializingBean.afterPropertiesSet()
MyBeanPostProcessor====BeanPostProcessor介面方法postProcessAfterInitialization對屬性進行更改！
MyInstantiationAwareBeanPostProcessor=====InstantiationAwareBeanPostProcessor呼叫postProcessAfterInitialization方法
***finishBeanFactoryInitialization(beanFactory);****

====容器初始化成功!====




==========獲取person==============
============say===============
Person [address=null, name=null, phone=110]
==========獲取lazyPerson==============
MyInstantiationAwareBeanPostProcessor=====InstantiationAwareBeanPostProcessor呼叫postProcessBeforeInstantiation方法
==============LazyPerson()=========
MyInstantiationAwareBeanPostProcessor======InstantiationAwareBeanPostProcessor呼叫postProcessPropertyValues方法
MyBeanPostProcessor=====BeanPostProcessor介面方法postProcessBeforeInitialization對屬性進行更改！
========LazyPerson init====================
MyBeanPostProcessor====BeanPostProcessor介面方法postProcessAfterInitialization對屬性進行更改！
MyInstantiationAwareBeanPostProcessor=====InstantiationAwareBeanPostProcessor呼叫postProcessAfterInitialization方法
===現在關閉容器===

上面****標識的內容是我自己打上去方便你們知道refresh()哪個方法執行了什麼。我們看下我上面圖片中紅字的方法。

invokeBeanFactoryPostProcessors：
初始化BeanFactoryPostProcessor，只要是實現該介面的都會在此處初始化，MyBeanFactoryPostProcessor是實現了該介面的所以會在這裡例項化並且會呼叫它的postProcessBeanFactory方法。

registerBeanPostProcessors(beanFactory)：
初始化攔截Bean的BeanPostProcessors。只要是BeanPostProcessors的子類，在初始建構函式時，都會呼叫子類的前後方法
MyBeanPostProcessor和MyInstantiationAwareBeanPostProcessor都實現了該介面，會在這裡執行它的初始化方法。

finishBeanFactoryInitialization(beanFactory)：
這裡bean 如果不是抽象，不是懶載入，不是原型的就會在此處初始化。
bean在這裡執行getBean,此時會發生bean的初始化，和相應的依賴注入。
上面的結果中我註釋了，因為Spring容器中不止存在我們上面寫的那些bean還存在其他的。

這裡注入時：
構造器–>自動注入–>PostConstrut–>InitializingBean–>xml中配置init方法

從上面的結果中，我們可以總結出spring的生命週期。
1.初始化BeanFactoryPostProcessor。
2.執行BeanFactoryPostProcessor的postProcessBeanFactory。
3.初始化BeanPostProcessor。

發生getBean操作實現依賴注入:
4.執行InstantiationAwareBeanPostProcessor.postProcessBeforeInstantiation
5.執行bean的建構函式
6.執行
postProcessBeforeInstantiation.postProcessPropertyValues
7.為bean注入屬性
8.執行bean實現的有關Aware介面
9.執行BeanPostProcessor.postProcessBeforeInitialization
10.接下來根據具體情況：
PostConstrut–>InitializingBean–>xml中配置init方法
11.BeanPostProcessor.postProcessAfterInitialization
12.容器執行
13.DisposableBean.destroy

圖片:
這裡寫圖片描述
這裡寫圖片描述
這裡寫圖片描述

知道了spring生命週期，我們對Spring容器中bean的操作就很得心應手了。很多其他框架在使用spring時也利用了這些特性。

這裡我們就對spring的生命週期就非常熟悉了，下一講就講解下，具體是哪裡的程式碼執行了這些操作。

相關推薦

spring原始碼分析：spring生命週期二

接著上一篇我們看看具體是哪裡的程式碼執行了。 1.初始化BeanFactoryPostProcessor invokeBeanFactoryPostProcessors(beanFactory);--> PostProcessorRegistrationDelegate.

spring原始碼分析：spring生命週期

最近在看springboot自動配置，看到了@Conditional,@ConditionalOnMissingBean等等。這些註解，一直研究他們是如何實現springboot的條件註解的。由他們回到了@Configuration,回到了ConfigurationClassPostPr

Spring原始碼分析：Spring中的後置處理器BeanPostProcessor

BeanPostProcessor簡介 BeanPostProcessor是Spring IOC容器給我們提供的一個擴充套件介面，如果我們需要在容器完成Bean的例項、初始化方法前後新增一些自己的邏輯處理，那麼定義一個BeanPostProcessor介面的實現類。

Spring原始碼分析：AOP分析(三)

個人扯淡部落格：http://blog.ztgreat.cn 前言 在上篇部落格中，分析了Spring Aop的Advice的實現過程，其中Spring對Advice 使用了介面卡模式，將Advice包裝成了Interceptor，在最後，我們通過Spring提供的

Spring原始碼分析：BeanFactory (二)

前言 在前面我們簡單的分析了BeanFactory的結構，ListableBeanFactory，HierarchicalBeanFactory，AutowireCapableBeanFactory。主要核心類DefaultListableBeanFactor

spring原始碼分析：resource資源定位一

最近回過頭來，再次看spring原始碼，以前很多次都是隨意的一看，但是有了以前的基礎現在理解起來容易很多了，於是這次想要分析原始碼的過程中，想要始終帶著幾個疑問去看原始碼 1.spring原始碼這樣寫的好處？ 2.spring原始碼使用了哪些設計模式？ 3.自己該如何利用他的思想

spring原始碼分析：Aware介面讓你的bean對容器直接操作

相信大家都知道很多其他框架，比如mybatis，shiro等等，spring框架本身有些類會實現ApplicationContextAware，BeanFactoryAware或者等等其他XXXAware，這是用來幹嘛呢？ spring容器來管理bean。如果說bean需要知道容器的

Spring原始碼分析：AOP分析(一)

前言 Spring 的兩大核心，一是IOC，我們之前已經學習過，而另一個則是大名鼎鼎的 AOP，AOP的具體概念我就不介紹了，我們今天重點是要從原始碼層面去看看 spring 的 AOP 是如何實現的。 在Spring AOP實現中，使用的核心技術是動態代理，

深入理解Spring原始碼之bean的生命週期控制器BeanPostProcessor

 spring是藉助ioc容器進行bean的初始化的，ioc的概念如下： bean的生命週期：            bean建立---初始化----銷燬的過程   容器管理bean的生命週期；  我們可以自定義初始化和銷燬方法；容器在bean進行到當前生命週期

Spring原始碼分析4 — spring bean建立和初始化

1 介紹 建立並初始化spring容器中，refresh()方法中解析xml配置檔案，註冊容器後處理器，bean後處理器，初始化MessageSource，ApplicationEventMulticaster廣播器，註冊完ApplicationListene

spring原始碼分析之spring-jdbc模組詳解

0 概述 Spring將替我們完成所有使用JDBC API進行開發的單調乏味的、底層細節處理工作。下表描述了哪些是spring幫助我們做好的，哪些是我們要做的。 Action  Spring  You Define connection parameters.  X

Spring原始碼分析3 — spring XML配置檔案的解析流程

1 介紹 建立並初始化spring容器中，關鍵一步就是讀取並解析spring XML配置檔案。這個過程比較複雜，本文將詳細分析整個流程。先看涉及到的關鍵類。 XmlWebApplicationContext：web應用的預設Spring容器 XmlBean

Spring原始碼分析之Spring MVC之HanderMapping請求對映處理

AbstractHandlerMappig呼叫getHandler() /** * Look up a handler for the given request, falling back to the default * handler if no speci

React原始碼分析4 — React生命週期詳解

1 React生命週期流程 呼叫流程可以參看上圖。分為例項化，存在期和銷燬三個不同階段。介紹生命週期流程的文章很多，相信大部分同學也有所瞭解，我們就不詳細分析了。很多同學肯定有疑問，這些方法在React內部是在哪些方法中被呼叫的呢，他們觸發的時機又是什麼時

spring原始碼分析之spring-messaging模組詳解

0 概述 spring-messaging模組為整合messaging api和訊息協議提供支援。 其程式碼結構為： 其中base定義了訊息Message(MessageHeader和body)、訊息處理MessageHandler、傳送訊息MessageChann

spring原始碼分析系列5:ApplicationContext的初始化與Bean生命週期

回顧Bean與BeanDefinition的關係. BeanFactory容器. ApplicationContext上下文. 首先總結下: 開發人員定義Bean資訊：分為XML形式定義；註解式定義 ApplicationContext蒐集Bean的定義；儲存到BeabFactory容器的中。 BeanFa

spring原始碼閱讀筆記10：bean生命週期

　　前面的文章主要集中在分析Spring IOC容器部分的原理，這部分的核心邏輯是和bean建立及管理相關，對於單例bean的管理，從建立好到快取起來再到銷燬，其是有一個完整的生命週期，並且Spring也在整個bean的建立過程中提供了多處介面供使用者自己擴充套件，本文就來梳理一下Spring中的bean生命

Spring Developer Tools 原始碼分析：三、重啟自動配置'

接上文 Spring Developer Tools 原始碼分析：二、類路徑監控，接下來看看前面提到的這些類是如何配置，如何啟動的。 spring-boot-devtools 使用了 Spring Boot 的自動配置方式，我們先關注本地開發環境中自動重啟的部分。 在 LocalDevToolsAut

Spring 3.1新特性之二：@Enable*註解的原始碼,spring原始碼分析之定時任務Scheduled註解

分析SpringBoot的自動化配置原理的時候，可以觀察下這些@Enable*註解的原始碼，可以發現所有的註解都有一個@Import註解。@Import註解是用來匯入配置類的，這也就是說這些自動開啟的實現其實是匯入了一些自動配置的Bean。 如：freemarker的自動化配置類FreeMarkerAuto

【Spring學習21】Bean生命週期回撥：初始化回撥和銷燬回撥

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