2. 程式人生 > >spring5 原始碼深度解析— IOC 之 bean 的初始化

spring5 原始碼深度解析— IOC 之 bean 的初始化

阿新 • • 發佈：2019-07-11

一個 bean 經歷了 createBeanInstance() 被創建出來，然後又經過一番屬性注入，依賴處理，歷經千辛萬苦，千錘百煉，終於有點兒 bean 例項的樣子，能堪大任了，只需要經歷最後一步就破繭成蝶了。這最後一步就是初始化，也就是 initializeBean()，所以這篇文章我們分析 doCreateBean() 中最後一步：初始化 bean。
我回到之前的doCreateBean方法中，如下

在populateBean方法下面有一個initializeBean(beanName, exposedObject, mbd)方法，這個就是用來執行使用者設定的初始化操作。我們看下方法體：

protected Object initializeBean(final String beanName, final Object bean, @Nullable RootBeanDefinition mbd) {
    if (System.getSecurityManager() != null) {
        AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
            // 啟用 Aware 方法
            invokeAwareMethods(beanName, bean);
            return null;
        }, getAccessControlContext());
    }
    else {
        // 對特殊的 bean 處理：Aware、BeanClassLoaderAware、BeanFactoryAware
        invokeAwareMethods(beanName, bean);
    }

    Object wrappedBean = bean;
    if (mbd == null || !mbd.isSynthetic()) {
        // 後處理器
        wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
    }

    try {
        // 啟用使用者自定義的 init 方法
        invokeInitMethods(beanName, wrappedBean, mbd);
    }
    catch (Throwable ex) {
        throw new BeanCreationException(
                (mbd != null ? mbd.getResourceDescription() : null),
                beanName, "Invocation of init method failed", ex);
    }
    if (mbd == null || !mbd.isSynthetic()) {
        // 後處理器
        wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
    }
    return wrappedBean;
}

初始化 bean 的方法其實就是三個步驟的處理，而這三個步驟主要還是根據使用者設定的來進行初始化，這三個過程為：

  1. 啟用 Aware 方法
  2. 後置處理器的應用
  3. 啟用自定義的 init 方法

激Aware方法 

我們先了解一下Aware方法的使用。Spring中提供了一些Aware介面，比如BeanFactoryAware,ApplicationContextAware,ResourceLoaderAware,ServletContextAware等，實現這些Aware介面的bean在被初始化後，可以取得一些相對應的資源，例如實現BeanFactoryAware的bean在初始化之後，Spring容器將會注入BeanFactory例項，而實現ApplicationContextAware的bean，在bean被初始化後，將會被注入ApplicationContext例項等。我們先通過示例方法瞭解下Aware的使用。

定義普通bean，如下程式碼：

public class HelloBean {
    public void say()
    {
        System.out.println("Hello");
    }
}

定義beanFactoryAware型別的bean

public class MyBeanAware implements BeanFactoryAware {
    private BeanFactory beanFactory;
    public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
        this.beanFactory = beanFactory;
    }
    public void testAware()
    {
        //通過hello這個bean id從beanFactory獲取例項  
        HelloBean hello = (HelloBean)beanFactory.getBean("hello");
        hello.say();
    }
}

進行測試

public class Test {
    public static void main(String[] args) {
        ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
        MyBeanAware test = (MyBeanAware)ctx.getBean("myBeanAware");
        test.testAware();
    }
}


<?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="myBeanAware" class="com.chenhao.spring.MyBeanAware">
    </bean>
    <bean id="hello" class="com.chenhao.spring.HelloBean">
    </bean>
</beans>

輸出

Hello

上面的方法我們獲取到Spring中BeanFactory，並且可以根據BeanFactory獲取所有的bean,以及進行相關設定。還有其他Aware的使用都是大同小異，看一下Spring的實現方式：

private void invokeAwareMethods(final String beanName, final Object bean) {  
    if (bean instanceof Aware) {  
        if (bean instanceof BeanNameAware) {  
            ((BeanNameAware) bean).setBeanName(beanName);  
        }  
        if (bean instanceof BeanClassLoaderAware) {  
            ((BeanClassLoaderAware) bean).setBeanClassLoader(getBeanClassLoader());  
        }  
        if (bean instanceof BeanFactoryAware) {  
            ((BeanFactoryAware) bean).setBeanFactory(AbstractAutowireCapableBeanFactory.this);  
        }  
    }
}

處理器的應用 

BeanPostPrecessor我們經常看到Spring中使用，這是Spring開放式架構的一個必不可少的亮點，給使用者充足的許可權去更改或者擴充套件Spring,而除了BeanPostProcessor外還有很多其他的PostProcessor，當然大部分都以此為基礎，整合自BeanPostProcessor。BeanPostProcessor在呼叫使用者自定義初始化方法前或者呼叫自定義初始化方法後分別會呼叫BeanPostProcessor的postProcessBeforeInitialization和postProcessAfterinitialization方法，使使用者可以根據自己的業務需求就行相應的處理。

public Object applyBeanPostProcessorsBeforeInitialization(Object existingBean, String beanName)  
        throws BeansException {  

    Object result = existingBean;  
    for (BeanPostProcessor beanProcessor : getBeanPostProcessors()) {  
        result = beanProcessor.postProcessBeforeInitialization(result, beanName);  
        if (result == null) {  
            return result;  
        }  
    }  
    return result;  
}

public Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName)  
        throws BeansException {  

    Object result = existingBean;  
    for (BeanPostProcessor beanProcessor : getBeanPostProcessors()) {  
        result = beanProcessor.postProcessAfterInitialization(result, beanName);  
        if (result == null) {  
            return result;  
        }  
    }  
    return result;  
}

啟用自定義的init方法 

客戶定製的初始化方法除了我們熟知的使用配置init-method外，還有使自定義的bean實現InitializingBean介面，並在afterPropertiesSet中實現自己的初始化業務邏輯。
init-method與afterPropertiesSet都是在初始化bean時執行，執行順序是afterPropertiesSet先執行，而init-method後執行。
在invokeInitMethods方法中就實現了這兩個步驟的初始化呼叫。

protected void invokeInitMethods(String beanName, final Object bean, @Nullable RootBeanDefinition mbd)
        throws Throwable {

    // 是否實現 InitializingBean
    // 如果實現了 InitializingBean 介面，則只掉呼叫bean的 afterPropertiesSet()
    boolean isInitializingBean = (bean instanceof InitializingBean);
    if (isInitializingBean && (mbd == null || !mbd.isExternallyManagedInitMethod("afterPropertiesSet"))) {
        if (logger.isDebugEnabled()) {
            logger.debug("Invoking afterPropertiesSet() on bean with name '" + beanName + "'");
        }
        if (System.getSecurityManager() != null) {
            try {
                AccessController.doPrivileged((PrivilegedExceptionAction<Object>) () -> {
                    ((InitializingBean) bean).afterPropertiesSet();
                    return null;
                }, getAccessControlContext());
            }
            catch (PrivilegedActionException pae) {
                throw pae.getException();
            }
        }
        else {
            // 直接呼叫 afterPropertiesSet()
            ((InitializingBean) bean).afterPropertiesSet();
        }
    }

    if (mbd != null && bean.getClass() != NullBean.class) {
        // 判斷是否指定了 init-method()，
        // 如果指定了 init-method()，則再呼叫制定的init-method
        String initMethodName = mbd.getInitMethodName();
        if (StringUtils.hasLength(initMethodName) &&
                !(isInitializingBean && "afterPropertiesSet".equals(initMethodName)) &&
                !mbd.isExternallyManagedInitMethod(initMethodName)) {
            // 利用反射機制執行
            invokeCustomInitMethod(beanName, bean, mbd);
        }
    }
}

首先檢測當前 bean 是否實現了 InitializingBean 介面，如果實現了則呼叫其 afterPropertiesSet()，然後再檢查是否也指定了 init-method()，如果指定了則通過反射機制呼叫指定的 init-method()。

init-method()

public class InitializingBeanTest {

    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public void setOtherName(){
        System.out.println("InitializingBeanTest setOtherName...");

        this.name = "chenhao";
    }
}

// 配置檔案
<bean id="initializingBeanTest" class="com.chenhao.spring.InitializingBeanTest"
        init-method="setOtherName">
    <property name="name" value="chenhao123"/>
</bean>

執行結果:

chenhao

我們可以使用 <beans> 標籤的 default-init-method 屬性來統一指定初始化方法，這樣就省了需要在每個 <bean> 標籤中都設定 init-method 這樣的繁瑣工作了。比如在 default-init-method 規定所有初始化操作全部以 initBean() 命名。如下：

我們看看 invokeCustomInitMethod 方法：

protected void invokeCustomInitMethod(String beanName, final Object bean, RootBeanDefinition mbd)
        throws Throwable {

    String initMethodName = mbd.getInitMethodName();
    Assert.state(initMethodName != null, "No init method set");
    Method initMethod = (mbd.isNonPublicAccessAllowed() ?
            BeanUtils.findMethod(bean.getClass(), initMethodName) :
            ClassUtils.getMethodIfAvailable(bean.getClass(), initMethodName));

    if (initMethod == null) {
        if (mbd.isEnforceInitMethod()) {
            throw new BeanDefinitionValidationException("Could not find an init method named '" +
                    initMethodName + "' on bean with name '" + beanName + "'");
        }
        else {
            if (logger.isTraceEnabled()) {
                logger.trace("No default init method named '" + initMethodName +
                        "' found on bean with name '" + beanName + "'");
            }
            // Ignore non-existent default lifecycle methods.
            return;
        }
    }

    if (logger.isTraceEnabled()) {
        logger.trace("Invoking init method  '" + initMethodName + "' on bean with name '" + beanName + "'");
    }
    Method methodToInvoke = ClassUtils.getInterfaceMethodIfPossible(initMethod);

    if (System.getSecurityManager() != null) {
        AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
            ReflectionUtils.makeAccessible(methodToInvoke);
            return null;
        });
        try {
            AccessController.doPrivileged((PrivilegedExceptionAction<Object>) () ->
                    methodToInvoke.invoke(bean), getAccessControlContext());
        }
        catch (PrivilegedActionException pae) {
            InvocationTargetException ex = (InvocationTargetException) pae.getException();
            throw ex.getTargetException();
        }
    }
    else {
        try {
            ReflectionUtils.makeAccessible(initMethod);
            initMethod.invoke(bean);
        }
        catch (InvocationTargetException ex) {
            throw ex.getTargetException();
        }
    }
}

我們看出最後是使用反射的方式來執行初始化方法。

&n

相關推薦

spring5 原始碼深度解析— IOC 之 bean 的初始化

一個 bean 經歷了 createBeanInstance() 被創建出來，然後又經過一番屬性注入，依賴處理，歷經千辛萬苦，千錘百煉，終於有點兒 bean 例項的樣子，能堪大任了，只需要經歷最後一步就破繭成蝶了。這最後一步就是初始化，也就是 initializeBean()，所

spring原始碼深度解析— IOC 之 bean 建立

在 Spring 中存在著不同的 scope，預設是 singleton ，還有 prototype、request 等等其他的 scope，他們的初始化步驟是怎樣的呢？這個答案在這篇部落格中給出。 singleton Spring 的 scope 預設為 singleton，第一部分分析了從快取中獲取單

spring原始碼深度解析— IOC 之 開啟 bean 的載入

概述 前面我們已經分析了spring對於xml配置檔案的解析，將分析的資訊組裝成 BeanDefinition，並將其儲存註冊到相應的 BeanDefinitionRegistry 中。至此，Spring IOC 的初始化工作完成。接下來我們將對bean的載入進行探索。 之前系列文章： spring原始

Spring5原始碼深度解析(一)之理解Configuration註解

程式碼地址：https://github.com/showkawa/spring-annotation/tree/master/src/main/java/com/brian 1.Spring體系結構 1.1、Spring Core：主要元件是BeanFactory，建立JavaBean的工廠，使用控制反

spring原始碼深度解析— IOC 之 容器的基本實現

概述 上一篇我們搭建完Spring原始碼閱讀環境，spring原始碼深度解析—Spring的整體架構和環境搭建 這篇我們開始真正的閱讀Spring的原始碼，分析spring的原始碼之前我們先來簡單回顧下spring核心功能的簡單使用 容器的基本用法 bean是spring最核心的東

spring原始碼深度解析— IOC 之 預設標籤解析（上）

概述 接前兩篇文章  spring原始碼深度解析—Spring的整體架構和環境搭建  和  spring原始碼深度解析— IOC 之 容器的基本實現 本文主要研究Spring標籤的解析，Spring的標籤中有預設標籤和自定義標籤，兩

spring原始碼深度解析— IOC 之 預設標籤解析（下）

在spring原始碼深度解析— IOC 之 預設標籤解析（上）中我們已經完成了從xml配置檔案到BeanDefinition的轉換，轉換後的例項是GenericBeanDefinition的例項。本文主要來看看標籤解析剩餘部分及BeanDefinition的註冊。 預設標籤中的自定義標籤解析

spring原始碼深度解析— IOC 之 自定義標籤解析

概述 之前我們已經介紹了spring中預設標籤的解析，解析來我們將分析自定義標籤的解析，我們先回顧下自定義標籤解析所使用的方法，如下圖所示：  我們看到自定義標籤的解析是通過BeanDefinitionParserDelegate.parseCustomElement(ele)進行的，解析來

spring原始碼深度解析— IOC 之 屬性填充

doCreateBean() 主要用於完成 bean 的建立和初始化工作，我們可以將其分為四個過程： createBeanInstance() 例項化 bean populateBean() 屬性填充 迴圈依賴的處理 initializeBean() 初始化

spring原始碼深度解析— IOC 之 迴圈依賴處理

什麼是迴圈依賴 迴圈依賴其實就是迴圈引用，也就是兩個或則兩個以上的bean互相持有對方，最終形成閉環。比如A依賴於B，B依賴於C，C又依賴於A。如下圖所示： 注意，這裡不是函式的迴圈呼叫，是物件的相互依賴關係。迴圈呼叫其實就是一個死迴圈，除非有終結條件。 Spring中迴圈依賴場景有： （1）構造

spring5 原始碼深度解析----- 建立AOP代理之獲取增強器

在上一篇的博文中我們講解了通過自定義配置完成了對AnnotationAwareAspectJAutoProxyCreator型別的自動註冊，那麼這個類到底做了什麼工作來完成AOP的操作呢？首先我們看看AnnotationAwareAspectJAutoProxyCreator的層次結構，如下圖所示： 

spring5 原始碼深度解析----- 被面試官給虐懵了，竟然是因為我不懂@Configuration配置類及@Bean的原理

@Configuration註解提供了全新的bean建立方式。最初spring通過xml配置檔案初始化bean並完成依賴注入工作。從spring3.0開始，在spring framework模組中提供了這個註解，搭配@Bean等註解，可以完全不依賴xml配置，在執行時完成bean的建立和初始化工作。例如：

Spring IOC容器bean初始化原始碼分析

上一篇分析對bean定義的解析原始碼進行了分析，這個過程的最終結果是把xml檔案中bean的定義解析成一個個的BeanDefinition物件並且註冊到容器中，在Spring IOC容器啟動簡介篇中分析，在容器啟動的最後會對容器中的所有bean進行初始化，利用之前解析出的B

RocketMQ原始碼深度解析三之Broker篇

（一）Broker的初始化 在初始化過程中，會呼叫 BrokerController 物件的 initialize 方法進行初始化工作，大致邏輯如下： （1）載入 topics.json、 consumerOffset.json、 subscriptionG

Spring5原始碼深度分析(二)之理解@Conditional,@Import註解

 程式碼地址：https://github.com/showkawa/spring-annotation/tree/master/src/main/java/com/brian 1.原始碼分析二主要分析的內容 1.使用@Condition多條件註冊bean物件2.@Import註解快速注入第三方

spring5 原始碼深度解析-----ApplicationContext容器refresh過程

在之前的博文中我們一直以BeanFactory介面以及它的預設實現類XmlBeanFactory為例進行分析，但是Spring中還提供了另一個介面ApplicationContext，用於擴充套件BeanFactory中現有的功能。 ApplicationContext和BeanFactory兩者都是用於載入

spring5 原始碼深度解析----- AOP的使用及AOP自定義標籤

我們知道在面向物件OOP程式設計存在一些弊端，當需要為多個不具有繼承關係的物件引入同一個公共行為時，例如日誌，安全檢測等，我們只有在每個物件裡引入公共行為，這樣程式中就產生了大量的重複程式碼，所以有了面向物件程式設計的補充，面向切面程式設計（AOP），AOP所關注的方向是橫向的，不同於OOP的縱向。接下來我們

spring5 原始碼深度解析----- AOP代理的生成

在獲取了所有對應bean的增強後，便可以進行代理的建立了。回到AbstractAutoProxyCreator的wrapIfNecessary方法中，如下所示：  1 protected static final Object[] DO_NOT_PROXY = null; 2 3

spring5 原始碼深度解析----- AOP目標方法和增強方法的執行（100%理解AOP）

上一篇博文中我們講了代理類的生成，這一篇主要講解剩下的部分，當代理類呼叫時，目標方法和代理方法是如何執行的,我們還是接著上篇的ReflectiveMethodInvocation類Proceed方法來看 public Object proceed() throws Throwable { //

spring5 原始碼深度解析----- Spring事務 是怎麼通過AOP實現的？（100%理解Spring事務）

此篇文章需要有SpringAOP基礎，知道AOP底層原理可以更好的理解Spring的事務處理。 自定義標籤 對於Spring中事務功能的程式碼分析，我們首先從配置檔案開始人手，在配置檔案中有這樣一個配置：<tx:annotation-driven/>。可以說此處配置是事務的開關，如果沒有此處配