源碼分析：Spring IOC 容器初始化過程

作者：猿java 2025-05-21 10:09:09

本文我們通過源碼深度分析了 Spring 5.x IOC容器的啟動流程，IOC是 Spring的核心，也是比較難懂的一部分，建議可以多去閱讀 Spring源碼，了解其精髓。?

這篇文章，我們將通過剖析 Spring 5.x源碼，深度分析 IOC 容器的初始化過程。

一、IOC 的基本概念

IOC，全稱Inversion of Control，翻譯為，它是一種設計原則，旨在通過減少對象之間的耦合度，提高系統的靈活性和可維護性。在傳統的編程方式中，對象通常負責自己依賴的創建和管理，這導致了高耦合度。而在 IOC 模式下，對象的創建和依賴管理交由外部容器控制，實現了對象之間的松耦合。

Spring 的 IOC 容器負責管理應用程序中的對象及其依賴關系。它通過配置元數據（如 XML、注解、Java 配置類等）來描述對象的創建、裝配和管理過程。IOC 容器在應用啟動時，根據配置元數據創建和裝配所有的 Bean，從而實現應用程序的依賴注入。

IOC 容器的核心接口包括：

BeanFactory：是 Spring IOC 容器的最基本接口，提供了獲取 Bean 的基本功能。它延遲加載 Bean，即在第一次調用 getBean 方法時才創建 Bean。
ApplicationContext：繼承自 BeanFactory，提供了更高級的功能，如國際化支持、事件傳播、AOP 集成等。ApplicationContext 通常在企業級應用中使用更為廣泛。

二、Spring IOC初始化流程

Spring 5.x 在 IOC 容器的初始化過程中，涵蓋了配置解析、Bean 定義加載與注冊、Bean 的實例化與裝配、初始化以及后期處理等多個階段。以下將對這些階段進行詳細解析。

1. 配置元數據的解析

在 Spring 應用中，配置元數據描述了應用中各個 Bean 及其依賴關系。配置元數據可以通過多種方式提供，包括 XML 配置文件、注解以及 Java 配置類（基于 @Configuration 的類）。

(1) XML 配置

傳統的 Spring 配置方式，通過 XML 文件定義 Bean 及其依賴關系。Spring 通過 XmlBeanDefinitionReader 將 XML 文件解析為 BeanDefinition 對象，并注冊到 BeanFactory 中。

示例 XML 配置：

<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="myBean" class="com.yuanjava.MyBean">
        <property name="dependency" ref="myDependency"/>
    </bean>

    <bean id="myDependency" class="com.yuanjava.MyDependency"/>
</beans>

(2) 注解配置

Spring 提供了多種注解，用于定義 Bean 和管理依賴關系，如 @Component、@Service、@Repository、@Controller、@Configuration 以及 @Autowired 等。通過 ComponentScan 掃描包路徑，容器自動檢測和注冊帶有特定注解的類為 Bean。

示例注解配置：

@Component
public class MyBean {
    @Autowired
    private MyDependency myDependency;
}

@Component
public class MyDependency { }

(3) Java 配置

基于 Java 的配置方式，通過 @Configuration 注解的類，使用 @Bean 方法定義 Bean。這種方式結合了類型安全和靈活性，受到越來越多開發者的青睞。

示例 Java 配置：

@Configuration
public class AppConfig {
    @Bean
    public MyBean myBean() {
        return new MyBean(myDependency());
    }

    @Bean
    public MyDependency myDependency() {
        return new MyDependency();
    }
}

2. Bean 定義的加載與注冊

配置元數據被解析后，Spring IOC 容器需要將其轉化為內部的 BeanDefinition 對象，并注冊到 BeanFactory 中。BeanDefinition 包含了 Bean 的類名、作用域、初始化方法、銷毀方法、依賴關系等信息。

在 Spring 5.x 中，具體步驟通常如下：

創建 BeanFactory 實例：常用的實現類是 DefaultListableBeanFactory。
使用 BeanDefinitionReader 讀取配置：如 XmlBeanDefinitionReader、AnnotatedBeanDefinitionReader、ConfigurationClassPostProcessor 等。
**解析并注冊 BeanDefinition**：將解析后的 Bean 定義注冊到 BeanFactory 中。

示例代碼：

// 創建 BeanFactory 實例
DefaultListableBeanFactory beanFactory = new DefaultListableBeanFactory();

// 創建 BeanDefinitionReader
XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader(beanFactory);

// 加載 XML 配置文件
reader.loadBeanDefinitions("classpath:applicationContext.xml");

// 或者使用注解配置
AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);

3. Bean 的實例化與裝配

在 Bean 定義加載并注冊后，IOC 容器根據需要實例化 Bean，并完成屬性的注入與依賴的裝配。Spring 提供了多種方式來完成 Bean 的實例化與裝配，如構造函數注入、Setter 方法注入、注解注入等。

(1) 實例化策略

Spring 提供了多種 Bean 的實例化策略，包括：

通過無參構造函數實例化：默認的實例化方式。
通過工廠方法實例化：可以通過靜態工廠方法或實例工廠方法來創建 Bean。
通過構造函數參數實例化：支持通過構造函數參數傳遞依賴。

(2) 依賴注入方式

依賴注入分為兩種主要方式：

構造函數注入：通過構造函數傳遞依賴對象。

public class MyBean {
    private final MyDependency myDependency;

    public MyBean(MyDependency myDependency) {
        this.myDependency = myDependency;
    }
}

Setter 方法注入：通過 Setter 方法注入依賴對象。

public class MyBean {
  private MyDependency myDependency;

  @Autowired
  public void setMyDependency(MyDependency myDependency) {
      this.myDependency = myDependency;
  }
}

在 Spring 5.x 中，推薦使用構造函數注入，因為它更符合不可變對象的設計理念，且有利于編寫可測試的代碼。

(3) 自動裝配

Spring 支持自動裝配，減少了顯式配置的工作量。自動裝配有以下幾種模式：

按類型自動裝配 (@Autowired)：根據 Bean 的類型進行裝配。
按名稱自動裝配 (@Qualifier)：結合 @Qualifier 注解指定 Bean 的名稱。
基于 Java 注解的裝配：如 @Primary、@Resource 等。
基于構造函數的自動裝配：通過構造函數參數進行裝配。

示例代碼：

@Component
public class MyService {
    private final MyRepository myRepository;

    @Autowired
    public MyService(MyRepository myRepository) {
        this.myRepository = myRepository;
    }
}

4. Bean 的初始化

在 Bean 被實例化并裝配完成后，還需要進行初始化工作。初始化過程包括執行自定義的初始化方法、BeanPostProcessor 的前置和后置處理等。

(1) InitializingBean 接口

Bean 可以通過實現 InitializingBean 接口，重寫 afterPropertiesSet 方法來自定義初始化邏輯。

public class MyBean implements InitializingBean {
    @Override
    public void afterPropertiesSet() throws Exception {
        // 初始化邏輯
    }
}

(2) 自定義初始化方法

在 Bean 配置中，可以通過 init-method 屬性指定自定義的初始化方法。

<bean id="myBean" class="com.yuanjava.MyBean" init-method="init"/>

或者通過注解 @PostConstruct 指定初始化方法：

public class MyBean {
    @PostConstruct
    public void init() {
        // 初始化邏輯
    }
}

(3) BeanPostProcessor

BeanPostProcessor 是 Spring 提供的擴展點，允許在 Bean 初始化前后進行自定義處理。常見的實現類有 AutowiredAnnotationBeanPostProcessor、CommonAnnotationBeanPostProcessor、ProxyPostProcessor 等。

BeanPostProcessor 提供兩個主要方法：

postProcessBeforeInitialization：在 Bean 初始化方法調用前執行。
postProcessAfterInitialization：在 Bean 初始化方法調用后執行。

示例代碼：

public class MyBeanPostProcessor implements BeanPostProcessor {
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        // 初始化前處理
        return bean;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        // 初始化后處理
        return bean;
    }
}

5. Bean 的后處理與銷毀

Bean 的生命周期不僅包括初始化，還包括銷毀過程。Spring 提供了多種機制來處理 Bean 的銷毀，如實現 DisposableBean 接口、指定銷毀方法、使用 @PreDestroy 注解等。

(1) DisposableBean 接口

通過實現 DisposableBean 接口，Bean 可以在銷毀前執行特定的邏輯。

public class MyBean implements DisposableBean {
    @Override
    public void destroy() throws Exception {
        // 銷毀邏輯
    }
}

(2) 自定義銷毀方法

在 Bean 配置中，可以通過 destroy-method 屬性指定自定義的銷毀方法。

<bean id="myBean" class="com.yuanjava.MyBean" destroy-method="cleanup"/>

或者使用 @PreDestroy 注解指定銷毀方法：

public class MyBean {
    @PreDestroy
    public void cleanup() {
        // 銷毀邏輯
    }
}

(3) DisposableBean 與 destroy-method 的優先級

當 Bean 同時實現了 DisposableBean 接口并指定了 destroy-method 時，Spring 會按照以下順序執行銷毀邏輯：

執行實現的 DisposableBean 接口的 destroy 方法。
執行 destroy-method 指定的方法。

這種方法確保了銷毀邏輯的有序執行，且用戶可以通過合理配置完成自定義的銷毀操作。

三、關鍵類與組件

在 Spring 5.x 中，IOC 容器的初始化過程涉及到多個關鍵類和組件，這些類和組件各司其職，共同完成容器的初始化與管理工作。以下將介紹其中幾個重要的類和組件。

1. ApplicationContext 接口及其實現

ApplicationContext 是 Spring IOC 容器的核心接口，繼承自 BeanFactory，提供了更強大的功能。常見的實現類包括：

ClassPathXmlApplicationContext：基于類路徑的 XML 配置文件創建 ApplicationContext。
FileSystemXmlApplicationContext：基于文件系統的 XML 配置文件創建 ApplicationContext。
AnnotationConfigApplicationContext：基于 Java 注解的配置類創建 ApplicationContext。
GenericWebApplicationContext：適用于 Web 應用的泛化 ApplicationContext。

示例代碼：

// 基于 XML 配置
ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");

// 基于注解配置
ApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);

2. DefaultListableBeanFactory

DefaultListableBeanFactory 是 BeanFactory 的默認實現，也是最常用的實現類之一。它支持 Bean 的定義注冊、依賴注入、Bean 后處理、作用域管理等功能。

DefaultListableBeanFactory beanFactory = new DefaultListableBeanFactory();

3. BeanDefinition 與 BeanDefinitionReader

BeanDefinition 是 Spring 內部用于描述 Bean 的核心類，包含了 Bean 的類名、作用域、依賴關系、初始化方法等信息。

BeanDefinitionReader 是用于讀取不同格式的配置元數據并注冊到 BeanFactory 中的接口，常見的實現類有：

XmlBeanDefinitionReader：讀取 XML 配置文件。
AnnotatedBeanDefinitionReader：讀取基于注解的配置。
PropertiesBeanDefinitionReader：讀取基于 properties 文件的配置。

示例代碼：

// 創建 BeanFactory
DefaultListableBeanFactory beanFactory = new DefaultListableBeanFactory();

// 創建 XML BeanDefinitionReader
XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader(beanFactory);

// 加載 XML 配置
reader.loadBeanDefinitions("classpath:applicationContext.xml");

4. InstantiationStrategy

InstantiationStrategy 接口定義了 Bean 實例化的策略。Spring 提供了兩種默認的實現：

SimpleInstantiationStrategy：簡單的實例化策略，適用于多數場景。
CglibSubclassingInstantiationStrategy：使用 CGLIB 生成子類進行實例化，常用于需要 AOP 代理的 Bean。

InstantiationStrategy strategy = new SimpleInstantiationStrategy();

5. AutowireCapableBeanFactory

AutowireCapableBeanFactory 是 BeanFactory 的子接口，提供了更高級別的功能，如支持自動裝配、Bean 后處理等。它在 Spring 的自動裝配和后處理機制中起到了關鍵作用。

AutowireCapableBeanFactory autowireCapableBeanFactory = context.getAutowireCapableBeanFactory();

6. BeanPostProcessor

BeanPostProcessor 是 Spring 提供的擴展點，用于在 Bean 的初始化前后進行自定義處理。常用的實現類包括：

AutowiredAnnotationBeanPostProcessor：處理 @Autowired 注解的裝配。
CommonAnnotationBeanPostProcessor：處理 @PostConstruct 和 @PreDestroy 注解。
ProxyPostProcessor：用于生成 AOP 代理等。

public class MyCustomBeanPostProcessor implements BeanPostProcessor {
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        // 自定義前置處理
        return bean;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        // 自定義后置處理
        return bean;
    }
}

四、總結

本文，我們通過源碼深度分析了 Spring 5.x IOC容器的啟動流程，IOC是 Spring的核心，也是比較難懂的一部分，建議可以多去閱讀 Spring源碼，了解其精髓。

責任編輯：趙寧寧來源：猿java