Spring框架的核心是控制反转（IoC）容器，它负责管理应用程序中各个组件（称为Bean）的生命周期。理解Bean的生命周期以及容器和对象创建的时机，是深入掌握Spring的关键。下面将详细阐述这一过程。

Bean的生命周期概览

Spring Bean的生命周期通常包含配置解析、定义注册、实例化、依赖注入、初始化、使用以及销毁等多个阶段。下图展示了其主要流程：

一、Bean的定义阶段

1. 配置解析与BeanDefinition

Spring容器启动时，首先会读取应用程序的配置信息，这些配置可以是XML文件、Java注解或者Java配置类。例如，在一个XML配置文件中，我们可能会定义一个Bean：

<bean id="dataSourceConfig" class="com.example.DataSourceConfiguration" scope="singleton">
    <property name="url" value="jdbc:mysql://localhost:3306/mydb"/>
</bean>

Spring解析这些配置后，并不会立即创建对象，而是将每个Bean的元数据（如ID、类名、作用域、依赖关系等）封装成一个BeanDefinition对象。BeanDefinition可以看作是创建Bean实例的"蓝图"。

BeanDefinition中包含的关键信息包括：

• beanName：Bean的唯一标识符。
• className：Bean的全限定类名。
• scope：Bean的作用域，如singleton（单例）或prototype（原型）。
• constructorArguments / propertyValues：构造器参数或属性值，用于表示依赖信息。

2. BeanDefinition注册

解析并生成所有BeanDefinition后，Spring会将它们注册到一个内部的注册中心（通常是DefaultListableBeanFactory的beanDefinitionMap）。这一步仅是完成了Bean定义的备案，此时尚未有任何Bean的实例被创建。

Map<String, BeanDefinition> definitionRegistry = new ConcurrentHashMap<>();
definitionRegistry.put("dataSourceConfig", new BeanDefinition(/* ... */));

二、Bean的实例化与生命周期管理

1. 容器初始化差异：Bean创建时机

Bean实例的真正创建时机取决于所使用的Spring容器类型：

• ApplicationContext（预加载容器）：作为BeanFactory的子接口，ApplicationContext在启动（调用其refresh()方法）时，会默认完成所有单例Bean的实例化、依赖注入和初始化，这被称为"预加载"或"饿汉式"加载。
• BeanFactory（延迟加载容器）：这是Spring最基础的容器接口。它在启动时仅注册BeanDefinition，而不会立即实例化Bean。只有当首次调用getBean()方法请求某个Bean时，该Bean才会被创建，这被称为"延迟加载"或"懒汉式"加载。

尽管触发时机不同，但最终的Bean创建流程都遵循一套统一的内部机制。

2. Bean实例创建流程概览

当需要创建Bean实例时（无论是ApplicationContext的预加载还是BeanFactory的getBean()调用），Spring会执行以下核心步骤：

// 假设需要获取名为 "myService" 的Bean
Object serviceInstance = applicationContext.getBean("myService");

// 内部调用链（简化示意）
Object doGetBean(String beanName) {
    // 1. 尝试从缓存获取单例Bean (getSingleton())
    Object cachedInstance = getSingleton(beanName);
    if (cachedInstance != null) {
        return cachedInstance; // 存在则直接返回
    }

    // 2. 若缓存中不存在，则进入Bean创建流程 (createBean())
    Object newBean = createBean(beanName, getBeanDefinition(beanName));
    
    // 3. 将创建好的单例Bean放入缓存 (addSingleton())
    addSingleton(beanName, newBean);
    return newBean;
}

Object createBean(String beanName, BeanDefinition definition) {
    // a. 实例化Bean对象 (createBeanInstance())
    Object rawInstance = instantiate(definition);

    // b. 依赖注入 (populateBean())
    populateDependencies(rawInstance, definition);

    // c. 执行初始化方法 (initializeBean())
    Object fullyInitializedBean = initializeCallbacks(rawInstance, beanName);

    return fullyInitializedBean;
}

3. 步骤1：实例化对象 (Instantiate Bean)

Spring通过反射机制，根据BeanDefinition中的类名创建Bean的原始实例。通常是调用其无参构造函数，或者根据构造器参数调用特定构造函数。

// 伪代码：实例化过程
Class<?> targetClass = Class.forName(beanDefinition.getClassName());
Object beanInstance = targetClass.getConstructor().newInstance(); // 调用无参构造函数

4. 步骤2：依赖注入 (Populate Bean)

对象实例化后，Spring会根据BeanDefinition或注解信息（如@Autowired, @Resource）完成依赖注入。常见的注入方式有：

• 构造器注入：通过Bean的构造函数传入依赖。
• Setter注入：通过Bean的setter方法设置依赖属性。
• 字段注入：直接通过反射设置Bean的字段值。

示例（字段注入，使用Java配置）：

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
public class ReportService {
    private DataRepository dataRepository;

    @Autowired // 字段注入
    public void setDataRepository(DataRepository dataRepository) {
        this.dataRepository = dataRepository;
    }

    public void generateReport() {
        System.out.println("Generating report using data: " + dataRepository.fetchData());
    }
}

5. 步骤3：初始化回调 (Initialize Bean)

依赖注入完成后，Bean尚未完全就绪，Spring会执行一系列的初始化回调：

1. 执行各类Aware接口：如果Bean实现了BeanNameAware、ApplicationContextAware等接口，Spring会调用相应的方法，将Bean的名称、应用上下文等注入Bean。
2. 调用InitializingBean.afterPropertiesSet()：如果Bean实现了InitializingBean接口，其afterPropertiesSet()方法会被调用。
3. 执行自定义的init-method：如果Bean配置中指定了init-method（如XML配置中的<bean init-method="myInitMethod"/>），该方法会被调用。
4. 应用BeanPostProcessor：这是Spring扩展机制的核心。BeanPostProcessor接口允许在Bean初始化前后对Bean进行加工。例如，AOP代理的生成、对@Async等注解的处理，都是通过BeanPostProcessor实现的。

// 示例：自定义初始化方法
public class MyBean implements InitializingBean {
    private String setting;

    // ... 构造函数、setter方法

    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("MyBean: afterPropertiesSet() called. Setting: " + setting);
        // 执行自定义初始化逻辑
    }

    public void customInitMethod() {
        System.out.println("MyBean: customInitMethod() called.");
    }
}

6. 步骤4：注册到单例池 (Add to Singleton Cache)

经过上述所有步骤，一个完整的Bean实例就创建并初始化完成了。如果该Bean是单例作用域，Spring会将其放入一级缓存（通常是一个ConcurrentHashMap）中，以便后续请求可以直接从缓存中获取，避免重复创建。

// 伪代码：将Bean放入缓存
Map<String, Object> singletonCache = new ConcurrentHashMap<>();
singletonCache.put(beanName, fullyInitializedBean);

至此，Bean的实例化和初始化过程完成，它已准备好被应用程序使用。

三、Spring容器类型：BeanFactory与ApplicationContext

理解Spring IoC容器，必须区分BeanFactory和ApplicationContext。

1. 核心职责对比

• BeanFactory：是Spring容器的基础接口，提供最基本的IoC功能，主要职责是管理Bean的定义、注册和获取。它面向Spring自身，提供了一种简单工厂模式的实现。
• ApplicationContext：是BeanFactory的子接口，在BeanFactory的基础上提供了更多企业级的功能，面向应用程序开发者。它不仅包含BeanFactory的所有特性，还提供了资源加载、国际化支持、事件发布、AOP集成等高级功能。

2. 功能扩展

ApplicationContext通过继承和聚合其他接口，扩展了其功能：

• MessageSource：提供国际化（i18n）功能。
• ApplicationEventPublisher：支持事件发布与监听机制。
• ResourcePatternResolver：提供通用的资源加载能力，如从文件系统、Classpath或URL加载资源。
• 自动注册BeanPostProcessor和BeanFactoryPostProcessor：无需手动配置，ApplicationContext会自动检测并注册这些处理器。

3. 使用示例

BeanFactory 示例 (基础用法)

DefaultListableBeanFactory是BeanFactory接口的一个常用实现，通常与XmlBeanDefinitionReader等配合使用：

import org.springframework.beans.factory.support.DefaultListableBeanFactory;
import org.springframework.beans.factory.xml.XmlBeanDefinitionReader;
import org.springframework.core.io.ClassPathResource;

public class BasicBeanFactoryExample {
    public static void main(String[] args) {
        // 创建一个Bean工厂
        DefaultListableBeanFactory beanFactory = new DefaultListableBeanFactory();
        
        // 创建Bean定义读取器，并加载XML配置
        XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader(beanFactory);
        reader.loadBeanDefinitions(new ClassPathResource("simple-beans.xml"));

        // 第一次获取Bean时才实例化
        MyService myService = (MyService) beanFactory.getBean("myService");
        myService.execute();
    }
}

// simple-beans.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="myService" class="com.example.MyServiceImpl"/>

</beans>

ApplicationContext 示例 (常用推荐)

ApplicationContext的实现类如ClassPathXmlApplicationContext、AnnotationConfigApplicationContext等更常用：

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class AppContextExample {
    public static void main(String[] args) {
        // ApplicationContext启动时，会预加载并初始化所有单例Bean
        ApplicationContext context = new ClassPathXmlApplicationContext("application-context.xml");

        // 直接获取Bean
        ReportService reportService = context.getBean("reportService", ReportService.class);
        reportService.generateReport();

        // 关闭容器（对于非Web应用）
        if (context instanceof ClassPathXmlApplicationContext) {
            ((ClassPathXmlApplicationContext) context).close();
        }
    }
}

通常情况下，推荐在大多数应用程序中使用ApplicationContext，因为它提供了更丰富的功能集和更便捷的开发体验。