大廠高頻面試題Spring Bean生命周期最詳解

Spring作為目前Java最流行、最強大的輕量級架構。Spring Bean的生命周期也是面試高頻題，了解Spring Bean周期也能更好地幫助我們解決日常開發中的問題。程式員應該都知道Spring的基礎容器是ApplicationContext。應很多粉絲的強烈建議，本文我來分析分析 ApplicationContext中Bean的生命周期。ApplicationContext是頂層容器接口BeanFactory的實作類，是以，我們了解了ApplicationContext的生命周期邏輯，也基本上了解了其他類型容器的生命周期邏輯。

1 Spring生命周期流程圖

下面先來看一張Spring Bean完整的生命周期流程圖，下圖描述的是從Spring容器初始化Bean開始直到Spring容器銷毀Bean，所經曆的關鍵節點。

從上圖可以看出，Spring Bean的生命周期管理的基本思路是：在Bean出現之前，先準備操作Bean的BeanFactory，然後操作完Bean，所有的Bean也還會交給BeanFactory進行管理。在所有Bean操作準備BeanPostProcessor作為回調。在Bean的完整生命周期管理過程中，經曆了以下主要幾個步驟：

1.1 Bean建立前的準備階段

步驟1： Bean容器在配置檔案中找到Spring Bean的定義以及相關的配置，如init-method和destroy-method指定的方法。

步驟2：執行個體化回調相關的後置處理器如BeanFactoryPostProcessor、BeanPostProcessor、InstantiationAwareBeanPostProcessor等

1.2 建立Bean的執行個體

步驟3： Srping 容器使用Java反射API建立Bean的執行個體。

步驟4：掃描Bean聲明的屬性并解析。

1.3 開始依賴注入

步驟5：開始依賴注入，解析所有需要指派的屬性并指派。

步驟6：如果Bean類實作BeanNameAware接口，則将通過傳遞Bean的名稱來調用setBeanName()方法。

步驟7：如果Bean類實作BeanFactoryAware接口，則将通過傳遞BeanFactory對象的執行個體來調用setBeanFactory()方法。

步驟8：如果有任何與BeanFactory關聯的BeanPostProcessors對象已加載Bean，則将在設定Bean屬性之前調用postProcessBeforeInitialization()方法。

步驟9：如果Bean類實作了InitializingBean接口，則在設定了配置檔案中定義的所有Bean屬性後，将調用afterPropertiesSet()方法。

1.4 緩存到Spring容器

步驟10：如果配置檔案中的Bean定義包含init-method屬性，則該屬性的值将解析為Bean類中的方法名稱，并将調用該方法。

步驟11：如果為Bean Factory對象附加了任何Bean 後置處理器，則将調用postProcessAfterInitialization()方法。

1.5 銷毀Bean的執行個體

步驟12：如果Bean類實作DisposableBean接口，則當Application不再需要Bean引用時，将調用destroy()方法。

步驟13：如果配置檔案中的Bean定義包含destroy-method屬性，那麼将調用Bean類中的相應方法定義。

2 代碼實戰示範

下面我們用一個簡單的Bean來示範并觀察一下Spring Bean完整的生命周期。

2.1 準備Author類

1、首先是一個簡單的Bean，調用Bean自身的方法和Bean級生命周期接口方法，為了友善示範，它實作了BeanNameAware、BeanFactoryAware、InitializingBean和DiposableBean這4個接口，同時添加2個init-method和destory-method方法，對應配置檔案中的init-method和destroy-method。具體代碼如下：

package com.tom.lifecycle;

import lombok.Data;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.*;

@Slf4j
@Data
public class Author implements BeanFactoryAware, BeanNameAware, InitializingBean, DisposableBean {
    private String name;
    private String address;
    private int age;

    private BeanFactory beanFactory;

    private String beanName;

    public Author() {
        log.info("【構造器】調用Tom類的構造器執行個體化");
    }

    public void setName(String name) {
        log.info("【注入屬性】name");
        this.name = name;
    }

    public void setAddress(String address) {
        log.info("【注入屬性】address");
        this.address = address;
    }

    public void setAge(int age) {
        log.info("【注入屬性】age");
        this.age = age;
    }

    // 實作BeanFactoryAware接口的方法
    public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
        log.info("【BeanFactoryAware接口】調用setBeanFactory方法");
        this.beanFactory = beanFactory;
    }

    // 實作BeanNameAware接口的方法
    public void setBeanName(String beanName) {
        log.info("【BeanNameAware接口】調用setBeanName方法");
        this.beanName = beanName;
    }

    // 實作DiposibleBean接口的方法
    public void destroy() throws Exception {
        log.info("【DiposibleBean接口】調用destroy方法");
    }

    // 實作InitializingBean接口的方法
    public void afterPropertiesSet() throws Exception {
        log.info("【InitializingBean接口】調用afterPropertiesSet方法");
    }

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

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

在配置Spring配置檔案中加入如下内容：

<bean id="author" class="com.tom.lifecycle.Author"
          init-method="beanInit"
          destroy-method="beanDestory"
          scope="singleton"
          p:name="Tom" p:address="湖南長沙" p:age="18"/>

2.2 示範BeanFactoryPostProcessor的執行

1.建立GPBeanFactoryPostProcessor類，并實作BeanFactoryPostProcessor接口，具體代碼如下：

package com.tom.lifecycle;

import lombok.extern.slf4j.Slf4j;
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;

@Slf4j
public class GPBeanFactoryPostProcessor implements BeanFactoryPostProcessor{

    public GPBeanFactoryPostProcessor() {
        super();
        log.info("調用BeanFactoryPostProcessor實作類構造器！！");
    }

    public void postProcessBeanFactory(ConfigurableListableBeanFactory configurableListableBeanFactory) throws BeansException {
        log.info("BeanFactoryPostProcessor調用postProcessBeanFactory方法");
        BeanDefinition bd = configurableListableBeanFactory.getBeanDefinition("author");
        bd.getPropertyValues().addPropertyValue("age", "16");
    }
}

2.在配置Spring配置檔案中加入如下内容：

<bean id="beanFactoryPostProcessor" class="com.tom.lifecycle.GPBeanFactoryPostProcessor" />

3.編寫測試類BeanLifeCycleTest，具體代碼如下：

package com.tom.lifecycle;

import lombok.extern.slf4j.Slf4j;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

@Slf4j
public class BeanLifeCycleTest {

    public static void main(String[] args) {

        log.info("====== 開始初始化Spring容器 ========");

        ApplicationContext factory = new ClassPathXmlApplicationContext("application-beans.xml");

        log.info("====== 初始化Spring容器成功 ========");

        //擷取Author執行個體
        Author author = factory.getBean("author", Author.class);

        log.info(author.toString());

        log.info("====== 開始銷毀Spring容器 ========");

        ((ClassPathXmlApplicationContext) factory).registerShutdownHook();
    }

}

4.運作結果

運作結果如下：

15:49:12.477 [main] INFO com.tom.lifecycle.GPBeanPostProcessor - 調用BeanPostProcessor實作類構造器！！
15:49:12.494 [main] INFO com.tom.lifecycle.Author - 【構造器】調用Tom類的構造器執行個體化
15:49:12.527 [main] INFO com.tom.lifecycle.Author - 【注入屬性】address
15:49:12.528 [main] INFO com.tom.lifecycle.Author - 【注入屬性】age
15:49:12.528 [main] INFO com.tom.lifecycle.Author - 【注入屬性】name
15:49:12.528 [main] INFO com.tom.lifecycle.Author - 【BeanNameAware接口】調用setBeanName方法
15:49:12.528 [main] INFO com.tom.lifecycle.Author - 【BeanFactoryAware接口】調用setBeanFactory方法
15:49:12.528 [main] INFO com.tom.lifecycle.GPBeanPostProcessor - BeanPostProcessor接口方法postProcessBeforeInitialization對屬性進行更改
15:49:12.528 [main] INFO com.tom.lifecycle.Author - 【InitializingBean接口】調用afterPropertiesSet方法
15:49:12.528 [main] INFO com.tom.lifecycle.Author - 【init-method】調用<bean>的init-method屬性指定的初始化方法
15:49:12.528 [main] INFO com.tom.lifecycle.GPBeanPostProcessor - BeanPostProcessor接口方法postProcessAfterInitialization對屬性進行更改
15:49:12.531 [main] INFO com.tom.lifecycle.BeanLifeCycleTest - ====== 初始化Spring容器成功 ========
15:49:12.531 [main] INFO com.tom.lifecycle.BeanLifeCycleTest - Author(name=Tom, address=湖南長沙, age=18, beanFactory=org.springframework.beans.factory.support.DefaultListableBeanFactory@26653222: defining beans [beanPostProcessor,author]; root of factory hierarchy, beanName=author)
15:49:12.531 [main] INFO com.tom.lifecycle.BeanLifeCycleTest - ====== 開始銷毀Spring容器 ========
15:49:12.532 [Thread-0] INFO com.tom.lifecycle.Author - 【DiposibleBean接口】調用destroy方法
15:49:12.533 [Thread-0] INFO com.tom.lifecycle.Author - 【destroy-method】調用<bean>的destroy-method屬性指定的初始化方法

我們看到，整個執行和我們一開始繪制的流程圖一緻。但是為什麼我們要實作BeanFactoryPostProcessor接口呢？我們進入到BeanFactoryPostProcessor的源碼如下：

package org.springframework.beans.factory.config;

import org.springframework.beans.BeansException;

public interface BeanFactoryPostProcessor {
    void postProcessBeanFactory(ConfigurableListableBeanFactory var1) throws BeansException;
}

BeanFactoryPostProcessor接口隻有一個postProcessBeanFactory()方法，BeanFactoryPostProcessor：在BeanFactory标準初始化之後可以進行修改。将加載所有Bean定義，但是還沒有執行個體化Bean。這個方法允許重新覆寫或者添加屬性甚至快速的初始化bean。初次看到可能不知道postProcessBeanFactory()到底是幹嘛的。要想透徹了解這個方法的作用，下面來進入到BeanFactoryPostProcessor的源碼，了解一下postProcessBeanFactory()的參數，我們可以利用這些參數做一些操作。

通過參數來看，隻有一個ConfigurableListableBeanFactory類，這個類的可以提供分析、修改Bean定義和預先執行個體化單例的功能。我們再進入到ConfigurableListableBeanFactory的源碼中：

public interface ConfigurableListableBeanFactory extends ListableBeanFactory, AutowireCapableBeanFactory, ConfigurableBeanFactory {

        //忽略被給定注入依賴類型 ，例如String
    void ignoreDependencyType(Class<?> var1);

        //略被給定注入依賴接口 。這個通常被使用由ApplicationContext去注冊依賴，可以以多種方式實作。例如BeanFactory通過BeanFactoryAware，ApplicationContext 通過ApplicationContextAware。預設情況下，僅BeanFactoryAware接口是被忽略，需要忽略其他接口，調用此方法
    void ignoreDependencyInterface(Class<?> var1);

        //注冊一個特定類型依賴伴随着相應的Autowired值。這個是準備被用于應該可以Autowire而不是在這個工廠被定義的Bean的工廠/上下文引用。例如 将ApplicationContext類型的依賴項解析為Bean所在的ApplicationContext執行個體。注意~在普通的BeanFactory中沒有注冊這樣的預設類型，甚至連BeanFactory接口本身都沒有
    void registerResolvableDependency(Class<?> var1, Object var2);

        //确認這個被指定的Bean是否是一個Autowire候選，将被注入到其他聲明比對類型的依賴的Bean中
    boolean isAutowireCandidate(String var1, DependencyDescriptor var2) throws NoSuchBeanDefinitionException;

        //根據指定的beanName傳回被注冊的Bean定義，允許通路其屬性值和構造函數參數值（可以在BeanFactory後期處理期間被修改）。這個被傳回的BeanDefinition對象不應該是副本而是原始在工廠被注冊的。這意味着如果需要它可以被轉換為更具體的實作類型。注意這個方法隻能獲得本地工廠BeanDefinition
    BeanDefinition getBeanDefinition(String var1) throws NoSuchBeanDefinitionException;

        //當機全部Bean定義，給被注冊的Bean定義發信号告訴它們今後不再被修改和進一步後續處理。它允許Factory去積極緩存Bean定義中繼資料
    void freezeConfiguration();

        //傳回該工廠的BeanDefinnition是否被當機
    boolean isConfigurationFrozen();

        //確定所有非懶加載的單例Bean被執行個體化，包括FactoryBean
    void preInstantiateSingletons() throws BeansException;
}

通過以上示範和分析，我們應該大概能夠了解ConfigurableListableBeanFactory的作用，基本就都是對于Bean定義的操作。至此我們還沒有看到BeanPostProcessor 和InstantiationAwareBeanPostProcessor的調用。下面我們把BeanPostProcessor 和InstantiationAwareBeanPostProcessor的實作補充上來，再看完整的執行流程

2.3 實作BeanPostProcessor

建立GPBeanPostProcessor類，并實作BeanPostProcessor 接口，具體代碼如下：

package com.tom.lifecycle;

import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor;

@Slf4j
public class GPBeanPostProcessor implements BeanPostProcessor {

    public GPBeanPostProcessor(){
        log.info("調用BeanPostProcessor實作類構造器！！");
    }
    public Object postProcessBeforeInitialization(Object o, String s) throws BeansException {
        log.info("BeanPostProcessor接口方法postProcessBeforeInitialization對屬性進行更改");
        return o;
    }

    public Object postProcessAfterInitialization(Object o, String s) throws BeansException {
        log.info("BeanPostProcessor接口方法postProcessAfterInitialization對屬性進行更改");
        return o;
    }
}

ApplicationContext 可以在BeanDefinition中自動檢測到實作了BeanPostProcessor的Bean，并且把這些Bean應用于随後的Bean建立。普通的BeanFactory允許對後處理器進行程式化注冊，通過工廠應用于所有Bean建立。BeanPostProcessor接口中主要有兩個方法：

方法名	解釋
postProcessBeforeInitialization	在Bean執行個體化回調（例如InitializingBean的afterPropertiesSet 或者一個定制的init-method）之前應用此BeanPostProcessor
postProcessAfterInitialization	在bean執行個體化回調（例如InitializingBean的afterPropertiesSet 或者一個定制的init-method）之後應用此BeanPostProcessor

2.4 實作InstantiationAwareBeanPostProcessor

建立GPInstantiationAwareBeanPostProcessor類，并實作InstantiationAwareBeanPostProcessorAdapter接口，具體代碼如下：

package com.tom.lifecycle;

import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.BeansException;
import org.springframework.beans.PropertyValues;
import org.springframework.beans.factory.config.InstantiationAwareBeanPostProcessorAdapter;

import java.beans.PropertyDescriptor;

@Slf4j
public class GPInstantiationAwareBeanPostProcessor  extends InstantiationAwareBeanPostProcessorAdapter {

    public GPInstantiationAwareBeanPostProcessor() {
        super();
        log.info("調用InstantiationAwareBeanPostProcessorAdapter實作類構造器！！");
    }

    // 接口方法、執行個體化Bean之前調用
    @Override
    public Object postProcessBeforeInstantiation(Class beanClass,String beanName) throws BeansException {
        log.info("InstantiationAwareBeanPostProcessor調用postProcessBeforeInstantiation方法");
        return null;
    }

    // 接口方法、執行個體化Bean之後調用
    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        log.info("InstantiationAwareBeanPostProcessor調用postProcessAfterInitialization方法");
        return bean;
    }

    // 接口方法、設定某個屬性時調用
    @Override
    public PropertyValues postProcessPropertyValues(PropertyValues pvs, PropertyDescriptor[] pds, Object bean, String beanName) throws BeansException {
        log.info("InstantiationAwareBeanPostProcessor調用postProcessPropertyValues方法");
        return pvs;
    }
}

實作InstantiationAwareBeanPostProcessorAdapter的Bean之後，可以在執行個體化成功之後，做一些校驗或者補充些内容或者把Bean包裝代理注入。實作InstantiationAwareBeanPostProcessorAdapter的Bean之後，不會影響容器正常處理每一個執行個體化的Bean，其子類僅僅隻是根據需要覆寫父類的方法。

注意，隻有在實際需要 InstantiationAwareBeanPostProcessor 功能時才推薦此基類。如果我們所需要的隻是簡單的BeanPostProcessor功能，那麼直接實作更簡單的接口即可。

下面詳細介紹一下InstantiationAwareBeanPostProcessorAdapter接口中的所有方法：


postProcessBeforeInstantiation	在執行個體化目标Bean之前應用此BeanPostProcessor。這個傳回的Bean也許是一個代理代替目标Bean，有效地抑制目标Bean的預設執行個體化。如果此方法傳回一個非空對象，則Bean的建立過程将被短路。唯一的進一步處理被應用是BeanPostProcessor.postProcessAfterInitialization(java.lang.Object, java.lang.String)方法（改變了Bean的生命周期執行個體化之後直接進入BeanPostProcessor.postProcessAfterInitialization）回調來自于配置好的BeanPostProcessors。這個回調将僅被應用于有Bean Class的BeanDefintions。特别是，它不會應用于采用”factory-method“的Bean。後處理器可以實作擴充的SmartInstantiationAwareBeanPostProcessor接口，以便預測它們将傳回的Bean對象的類型
postProcessPropertyValues	在工廠将給定的屬性值應用到給定的Bean之前，對給定的屬性值進行後處理。允許檢查全部依賴是否已經全部滿足，例如基于一個@Required在Bean屬性的Setter方法上。還允許替換要應用的屬性值，通常通過基于原始的PropertyValues建立一個新的MutablePropertyValues執行個體，添加或删除特定的值
	在Bean初始化回調（如InitializingBean的afterPropertiesSet或者定制的init-method）之後，應用這個BeanPostProcessor去給一個新的Bean執行個體。Bean已經配置了屬性值，傳回的Bean執行個體可能已經被包裝。<br/>如果是FactoryBean，這個回調将為FactoryBean執行個體和其他被FactoryBean建立的對象所調用。這個post-processor可以通過相應的FactoryBean執行個體去檢查決定是否應用FactoryBean或者被建立的對象或者兩個都有。這個回調在一個由InstantiationAwareBeanPostProcessor短路的觸發之後将被調用

2.5 修改配置檔案

完整的配置檔案内容如下：

<?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="com.tom.lifecycle.GPBeanPostProcessor" />

        <bean id="beanFactoryPostProcessor" class="com.tom.lifecycle.GPBeanFactoryPostProcessor" />

        <bean id="instantiationAwareBeanPostProcessor" class="com.tom.lifecycle.GPInstantiationAwareBeanPostProcessor" />


        <bean id="author" class="com.tom.lifecycle.Author"
                init-method="beanInit"
                destroy-method="beanDestory"
                scope="singleton"
                p:name="Tom" p:address="湖南長沙" p:age="18"/>

</beans>

2.6 運作結果

最後，我們再次運作BeanLifeCycleTest測試類，看到如下運作結果：

15:56:20.030 [main] INFO com.tom.lifecycle.GPBeanFactoryPostProcessor - 調用BeanFactoryPostProcessor實作類構造器！！
15:56:20.045 [main] INFO com.tom.lifecycle.GPBeanFactoryPostProcessor - BeanFactoryPostProcessor調用postProcessBeanFactory方法
15:56:20.046 [main] INFO com.tom.lifecycle.GPBeanPostProcessor - 調用BeanPostProcessor實作類構造器！！
15:56:20.047 [main] INFO com.tom.lifecycle.GPInstantiationAwareBeanPostProcessor - 調用InstantiationAwareBeanPostProcessorAdapter實作類構造器！！
15:56:20.051 [main] INFO com.tom.lifecycle.GPInstantiationAwareBeanPostProcessor - InstantiationAwareBeanPostProcessor調用postProcessBeforeInstantiation方法
15:56:20.052 [main] INFO com.tom.lifecycle.Author - 【構造器】調用Tom類的構造器執行個體化
15:56:20.069 [main] INFO com.tom.lifecycle.GPInstantiationAwareBeanPostProcessor - InstantiationAwareBeanPostProcessor調用postProcessPropertyValues方法
15:56:20.092 [main] INFO com.tom.lifecycle.Author - 【注入屬性】address
15:56:20.092 [main] INFO com.tom.lifecycle.Author - 【注入屬性】age
15:56:20.092 [main] INFO com.tom.lifecycle.Author - 【注入屬性】name
15:56:20.092 [main] INFO com.tom.lifecycle.Author - 【BeanNameAware接口】調用setBeanName方法
15:56:20.092 [main] INFO com.tom.lifecycle.Author - 【BeanFactoryAware接口】調用setBeanFactory方法
15:56:20.093 [main] INFO com.tom.lifecycle.GPBeanPostProcessor - BeanPostProcessor接口方法postProcessBeforeInitialization對屬性進行更改
15:56:20.093 [main] INFO com.tom.lifecycle.Author - 【InitializingBean接口】調用afterPropertiesSet方法
15:56:20.093 [main] INFO com.tom.lifecycle.Author - 【init-method】調用<bean>的init-method屬性指定的初始化方法
15:56:20.093 [main] INFO com.tom.lifecycle.GPBeanPostProcessor - BeanPostProcessor接口方法postProcessAfterInitialization對屬性進行更改
15:56:20.093 [main] INFO com.tom.lifecycle.GPInstantiationAwareBeanPostProcessor - InstantiationAwareBeanPostProcessor調用postProcessAfterInitialization方法
15:56:20.097 [main] INFO com.tom.lifecycle.BeanLifeCycleTest - ====== 初始化Spring容器成功 ========
15:56:20.098 [main] INFO com.tom.lifecycle.BeanLifeCycleTest - Author(name=Tom, address=湖南長沙, age=16, beanFactory=org.springframework.beans.factory.support.DefaultListableBeanFactory@26653222: defining beans [beanPostProcessor,beanFactoryPostProcessor,instantiationAwareBeanPostProcessor,author]; root of factory hierarchy, beanName=author)
15:56:20.098 [main] INFO com.tom.lifecycle.BeanLifeCycleTest - ====== 開始銷毀Spring容器 ========
15:56:20.099 [Thread-0] INFO com.tom.lifecycle.Author - 【DiposibleBean接口】調用destroy方法
15:56:20.100 [Thread-0] INFO com.tom.lifecycle.Author - 【destroy-method】調用<bean>的destroy-method屬性指定的初始化方法

3 Spring Bean生命周期運作時序圖

最後我們來看一下完整的執行時序圖：

關注微信公衆号『 Tom彈架構』回複“Spring”可擷取完整源碼。

本文為“Tom彈架構”原創，轉載請注明出處。技術在于分享，我分享我快樂！如果您有任何建議也可留言評論或私信，您的支援是我堅持創作的動力。關注微信公衆号『 Tom彈架構』可擷取更多技術幹貨！

原創不易，堅持很酷，都看到這裡了，小夥伴記得點贊、收藏、在看，一鍵三連加關注！如果你覺得内容太幹，可以分享轉發給朋友滋潤滋潤！

大廠高頻面試題Spring Bean生命周期最詳解

1 Spring生命周期流程圖

1.1 Bean建立前的準備階段

1.2 建立Bean的執行個體

1.3 開始依賴注入

1.4 緩存到Spring容器

1.5 銷毀Bean的執行個體

2 代碼實戰示範

2.1 準備Author類

2.2 示範BeanFactoryPostProcessor的執行

2.3 實作BeanPostProcessor

2.4 實作InstantiationAwareBeanPostProcessor

2.5 修改配置檔案

2.6 運作結果

3 Spring Bean生命周期運作時序圖

繼續閱讀

Java小案例——随機數猜測随機數猜測

nginx location中斜線的位置的重要性

27 Best Free Eclipse Plug-ins for Java Developer to be ProductiveCode Quality PluginsText Editor PluginsDependency ManagementVersion Control Integration PluginsFramework Development Continuous Integration Related PluginsOther Utility Plugins

Java String.format方法的簡單使用

neo4j之cypher使用文檔

GitHub連夜封殺！這份阿裡 10W 字内部 Java 字面試手冊到底有多強？

spark/scala關于【資源檔案】加載方法概述外部檔案加載方案測試資源檔案打包入jar包中小結

mybatis_入門程式Mybatis入門

AOP程式設計_Android優雅權限架構(1)概念基礎，2021金三銀四前言正文大綱正文

面試題解析：你接口測試是怎麼做的？

Effective Java 8:通用程式設計

OOM三種類型

工廠模式-三種類型

【遞歸】高效率求2的n次幂

win10本地scala和spark安裝安裝scala安裝spark

scala (3) Function 和 Method