Spring Bean 生命周期管理完整指南

概述

Spring Bean 的生命周期是 Spring IoC 容器管理 Bean 的整个过程，从 Bean 的实例化、属性注入、初始化到销毁。理解这个生命周期对于掌握 Spring 框架的核心机制、进行自定义扩展以及排查问题至关重要。

---

完整生命周期流程图

┌─────────────────────────────────────────────────────────────────────────────┐
│                          Spring Bean 生命周期                                │
└─────────────────────────────────────────────────────────────────────────────┘

1. BeanDefinition 加载
   ↓
2. InstantiationAwareBeanPostProcessor.postProcessBeforeInstantiation()
      ├─ 返回非 null → 跳过后续步骤，直接执行步骤 8-9
      └─ 返回 null → 继续步骤 3
   ↓
3. 创建 Bean 实例 (构造函数/工厂方法)
   ↓
4. InstantiationAwareBeanPostProcessor.postProcessAfterInstantiation()
      ├─ 返回 false → 跳过属性填充，直接执行步骤 7
      └─ 返回 true → 继续步骤 5
   ↓
5. InstantiationAwareBeanPostProcessor.postProcessProperties()
   ↓
6. 属性填充 (populateBean)
      ├─ @Autowired/@Value 等依赖注入
      └─ InstantiationAwareBeanPostProcessor.postProcessPropertyValues()
   ↓
7. Aware 接口回调
      ├─ BeanNameAware.setBeanName()
      ├─ BeanClassLoaderAware.setBeanClassLoader()
      ├─ BeanFactoryAware.setBeanFactory()
      ├─ ApplicationContextAware.setApplicationContext()
      ├─ ResourceLoaderAware.setResourceLoader()
      └─ ApplicationEventPublisherAware.setApplicationEventPublisher()
   ↓
8. BeanPostProcessor.postProcessBeforeInitialization()
      └─ 所有 BPP 按顺序执行
   ↓
9. 初始化回调 (按顺序执行)
      9.1 @PostConstruct 注解方法
      9.2 InitializingBean.afterPropertiesSet()
      9.3 自定义 init-method
   ↓
10. BeanPostProcessor.postProcessAfterInitialization()
       ├─ AOP 代理在此处创建
       └─ 所有 BPP 按顺序执行
   ↓
11. SmartInitializingSingleton.afterSingletonsInstantiated()
       └─ 所有单例 Bean 创建完成后调用
   ↓
[Bean 就绪，可以使用]
   ↓
[容器关闭或 Bean 销毁时]
   ↓
12. 销毁回调 (按顺序执行)
       12.1 DestructionAwareBeanPostProcessor.postProcessBeforeDestruction()
       12.2 @PreDestroy 注解方法
       12.3 DisposableBean.destroy()
       12.4 自定义 destroy-method

---

详细阶段说明

阶段 1: BeanDefinition 加载

在容器启动时，Spring 会扫描并解析 Bean 的定义（XML、Java Config、组件扫描），将 Bean 的配置信息封装为 BeanDefinition 对象，存储在 DefaultListableBeanFactory中。这是生命周期的起点，但此时 Bean 还未被实例化。

// 示例：通过不同方式定义 Bean
@Configuration
public class AppConfig {
    @Bean
    public MyService myService() {
        return new MyService();
    }
}

@Component
public class MyComponent { }

@BeanDefinition // Spring 5.1+
public static MyBean myBean() { ... }

---

阶段 2: postProcessBeforeInstantiation (实例化前处理)

接口: InstantiationAwareBeanPostProcessor

方法签名:

@Nullable
Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException;

说明:

• 在 Bean 实例化之前调用
• 如果返回非 null 对象，Spring 将使用此对象作为 Bean 实例，跳过后续的实例化和属性填充步骤，直接进入 postProcessAfterInitialization
• 典型应用：CGLIB 早期代理、缓存优化

SmartInstantiationAwareBeanPostProcessor 扩展:

// 预测 Bean 类型（不实际创建实例）
@Nullable
default Class<?> predictBeanType(Class<?> beanClass, String beanName) {
    return null;
}

// 确定 Bean 类型（完全评估处理步骤）
default Class<?> determineBeanType(Class<?> beanClass, String beanName) {
    return beanClass;
}

示例 - AbstractAutoProxyCreator (AOP 代理创建):

public class AbstractAutoProxyCreator implements InstantiationAwareBeanPostProcessor, 
                                               SmartInstantiationAwareBeanPostProcessor {
    
    @Override
    public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) {
        // 检查是否需要创建代理
        if (isInfrastructureClass(beanClass)) {
            return null;
        }
        // 提前创建代理的逻辑...
    }
    
    @Override
    public Class<?> determineBeanType(Class<?> beanClass, String beanName) {
        // 确定代理后的类型
        return getAdvisees(beanName).isEmpty() ? beanClass : ProxyFactory.class;
    }
}

---

阶段 3: Bean 实例化

Spring 通过反射调用构造函数或工厂方法创建 Bean 实例：

实例化方式:

1. 构造函数实例化 (默认): new BeanClass()
2. 静态工厂方法: ClassName.createInstance()
3. 实例工厂方法: factoryBean.createInstance()

// XML 配置示例
<bean id="exampleBean" class="com.example.ExampleBean"/>
<bean id="staticFactory" class="com.example.Factory" factory-method="createStatic"/>
<bean id="instanceFactory" class="com.example.FactoryHolder" factory-bean="holder" factory-method="create"/>

循环依赖处理 (三级缓存):

// AbstractAutowireCapableBeanFactory 中的三级缓存

// 第一级：单例缓存 (完全初始化的 Bean)
private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);

// 第二级：正在创建的 Bean (早期引用)
private final Map<String, Object> singletonsCurrentlyInCreation = new HashSet<>();

// 第三级：早期引用 Factory(用于生成代理)
private final Map<String, ObjectFactory<?>> earlySingletonObjects = new HashMap<>(16);

// 放入第三级缓存 (允许提前获取，解决循环依赖)
protected void addSingletonFactory(String beanName, ObjectFactory<?> singletonFactory) {
    this.earlySingletonObjects.put(beanName, singletonFactory);
}

// 获取早期引用
protected Object getEarlyBeanReference(String beanName, RootBeanDefinition mbd, Object bean) {
    ObjectFactory<?> objectFactory = () -> postProcessAfterInstantiation(...) ? bean : createProxy(...);
    addSingletonFactory(beanName, objectFactory);
    return getRawEarlyReference(...);
}

---

阶段 4: postProcessAfterInstantiation (实例化后处理)

接口: InstantiationAwareBeanPostProcessor

方法签名:

default boolean postProcessAfterInstantiation(Object bean, String beanName) throws BeansException {
    return true; // 返回 true 继续属性填充，false 则跳过
}

说明:

• 在 Bean 实例化之后、属性填充之前调用
• 返回 false 可以跳过属性填充阶段
• 通常返回 true 继续正常流程

---

阶段 5: postProcessProperties (属性值处理)

接口: InstantiationAwareBeanPostProcessor

方法签名:

default PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName) throws BeansException {
    return pvs;
}

说明:

• 在属性填充之前修改属性值
• 典型应用：AutowiredAnnotationBeanPostProcessor 处理 @Autowired 和 @Value 注解

示例 - AutowiredAnnotationBeanPostProcessor:

public class AutowiredAnnotationBeanPostProcessor extends InjectedValuesBeanPostProcessor 
        implements InstantiationAwareBeanPostProcessor {
    
    @Override
    public PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName) {
        InjectedElement injectedElements = findAutowiredElements(bean, beanName);
        // 处理@Autowired 字段和方法
        injectAutowiredElements(injectedElements, bean, beanName);
        return pvs;
    }
}

---

阶段 6: 属性填充 (populateBean)

Spring 将定义的属性值注入到 Bean 中：

注入方式:

1. Setter 注入: 调用 setter 方法
2. 字段注入: @Autowired 直接注入字段
3. 构造器注入: 通过构造函数参数注入

public class UserService {
    @Autowired
    private UserRepository userRepository;  // 字段注入
    
    @Value("${app.name}")
    private String appName;  // @Value 注入
    
    private String description;
    
    public void setDescription(String description) {  // Setter 注入
        this.description = description;
    }
}

---

阶段 7: Aware 接口回调

实现 Aware 接口的 Bean 会在属性填充后收到容器基础设施的回调。注意: Aware 回调发生在 postProcessBeforeInitialization 之前。

接口	回调方法	说明
BeanNameAware	setBeanName(String name)	设置 Bean 的名称
BeanClassLoaderAware	setBeanClassLoader(ClassLoader cl)	设置类加载器
BeanFactoryAware	setBeanFactory(BeanFactory bf)	设置 BeanFactory 引用
ApplicationContextAware	setApplicationContext(ApplicationContext ctx)	设置 ApplicationContext 引用
ResourceLoaderAware	setResourceLoader(ResourceLoader rl)	设置资源加载器
ApplicationEventPublisherAware	setApplicationEventPublisher(ApplicationEventPublisher aep)	设置事件发布器
MessageSourceAware	setMessageSource(MessageSource ms)	设置消息源
EmbeddedValueResolverAware	setEmbeddedValueResolver(StringValueResolver svr)	设置值解析器

示例:

@Component
public class MyBean implements BeanNameAware, ApplicationContextAware {
    
    private String beanName;
    private ApplicationContext applicationContext;
    
    @Override
    public void setBeanName(String name) {
        this.beanName = name;
        System.out.println("Bean name is: " + name);
    }
    
    @Override
    public void setApplicationContext(ApplicationContext ctx) {
        this.applicationContext = ctx;
    }
    
    public void doSomething() {
        // 可以使用 beanName 和 applicationContext
        AnotherBean another = applicationContext.getBean(AnotherBean.class);
    }
}

---

阶段 8: postProcessBeforeInitialization (初始化前处理)

接口: BeanPostProcessor

方法签名:

@Nullable
Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException;

说明:

• 在 Bean 初始化方法调用之前执行
• 可以对 Bean 进行修改或包装
• 所有注册的 BeanPostProcessor 按顺序执行
• 可以返回 null 或其他对象（其他对象将被用作 Bean）

注册方式:

@Configuration
public class AppConfig {
    
    // 推荐：使用 static 避免配置类过早初始化
    @Bean
    public static MyBeanPostProcessor myBpp() {
        return new MyBeanPostProcessor();
    }
}

// 或通过组件扫描
@Component
public class MyBeanPostProcessor implements BeanPostProcessor {
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) {
        System.out.println("Before initialization: " + beanName);
        return bean;
    }
}

---

阶段 9: 初始化回调

初始化回调有三种方式，当多种方式同时存在时，执行顺序固定:

9.1 @PostConstruct (JSR-250)

public class MyBean {
    @PostConstruct
    public void init() {
        // 初始化逻辑
    }
}

要求: CommonAnnotationBeanPostProcessor 已注册 (Spring Boot 默认包含)

9.2 InitializingBean.afterPropertiesSet()

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

9.3 自定义 init-method

XML 配置:

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

Java Config:

@Bean(initMethod = "customInit")
public MyBean myBean() {
    return new MyBean();
}

完整示例 - 多种方式的执行顺序:

public class OrderedLifecycleBean implements InitializingBean {
    
    @PostConstruct
    public void postConstructInit() {
        System.out.println("1. @PostConstruct");
    }
    
    @Override
    public void afterPropertiesSet() {
        System.out.println("2. InitializingBean.afterPropertiesSet()");
    }
    
    public void customInit() {
        System.out.println("3. 自定义 init-method");
    }
}

@Configuration
public class Config {
    @Bean(initMethod = "customInit")
    public OrderedLifecycleBean bean() {
        return new OrderedLifecycleBean();
    }
}

输出:

1. @PostConstruct
2. InitializingBean.afterPropertiesSet()
3. 自定义 init-method

---

阶段 10: postProcessAfterInitialization (初始化后处理)

接口: BeanPostProcessor

方法签名:

@Nullable
Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException;

说明:

• 在 Bean 初始化方法调用之后执行
• AOP 代理在此阶段创建
• 可以返回包装后的对象 (如代理对象)
• 所有注册的 BeanPostProcessor 按顺序执行

典型应用:

1. AOP 代理创建: AnnotationAwareAspectJAutoProxyCreator
2. @Lazy 代理: LazyInitializationBeanPostProcessor
3. Scope 代理: ScopedProxyCreator

示例 - 自定义包装:

@Component
public class LoggingBeanPostProcessor implements BeanPostProcessor {
    
    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) {
        if (bean instanceof MyService) {
            // 返回包装后的对象
            return new LoggingProxy((MyService) bean);
        }
        return bean;
    }
}

---

阶段 11: SmartInitializingSingleton

接口: SmartInitializingSingleton

方法签名:

void afterSingletonsInstantiated();

说明:

• 在所有单例 Bean实例化完成后调用
• 保证此时可以通过 getBeansOfType() 获取所有单例 Bean
• 不适用于懒加载 Bean 和其他作用域 Bean

示例:

@Component
public class MyInitializer implements SmartInitializingSingleton {
    
    @Override
    public void afterSingletonsInstantiated() {
        // 所有单例 Bean 都已创建完成
        Map<String, MyService> services = 
            applicationContext.getBeansOfType(MyService.class);
        // 执行启动时的初始化逻辑
    }
}

---

[Bean 就绪]

此时 Bean 已经完全初始化，可以被应用程序使用。

---

销毁阶段

当容器关闭或 Bean 被显式销毁时，执行以下销毁回调，顺序固定:

12.1 DestructionAwareBeanPostProcessor.postProcessBeforeDestruction()

接口: DestructionAwareBeanPostProcessor (继承自 BeanPostProcessor)

void postProcessBeforeDestruction(Object bean, String beanName) throws BeansException;

12.2 @PreDestroy

public class MyBean {
    @PreDestroy
    public void cleanup() {
        // 清理资源
    }
}

12.3 DisposableBean.destroy()

public class MyBean implements DisposableBean {
    @Override
    public void destroy() throws Exception {
        // 清理资源
    }
}

12.4 自定义 destroy-method

XML 配置:

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

Java Config:

@Bean(destroyMethod = "cleanup")
public MyBean myBean() {
    return new MyBean();
}

销毁顺序示例:

public class OrderedDestroyBean implements DisposableBean {
    
    @PreDestroy
    public void preDestroy() {
        System.out.println("2. @PreDestroy");
    }
    
    @Override
    public void destroy() {
        System.out.println("3. DisposableBean.destroy()");
    }
    
    public void customDestroy() {
        System.out.println("4. 自定义 destroy-method");
    }
}

// DestructionAwareBeanPostProcessor 最先执行
// 输出顺序:
// 1. DestructionAwareBeanPostProcessor.postProcessBeforeDestruction()
// 2. @PreDestroy
// 3. DisposableBean.destroy()
// 4. 自定义 destroy-method

---

Lifecycle 和 SmartLifecycle

除了上述基本生命周期，Spring 还提供了 Lifecycle和SmartLifecycle 接口用于控制 Bean 的启动和停止。

Lifecycle 接口

public interface Lifecycle {
    void start();
    void stop();
    boolean isRunning();
}

SmartLifecycle 接口

public interface SmartLifecycle extends Lifecycle, Phased {
    boolean isAutoStartup();
    int getPhase();
    void stop(Runnable callback);
}

特性:

• isAutoStartup(): 是否在容器刷新时自动启动
• getPhase(): 相位值，决定启动/停止顺序
  • 值越小，越早启动，越晚停止
  • 值越大，越晚启动，越早停止

示例:

@Component
public class MyTaskScheduler implements SmartLifecycle {
    
    private volatile boolean running = false;
    private ScheduledExecutorService executor;
    
    @Override
    public void start() {
        if (!running) {
            executor = Executors.newScheduledThreadPool(4);
            running = true;
            // 启动定时任务
        }
    }
    
    @Override
    public void stop(Runnable callback) {
        if (running) {
            executor.shutdown();
            try {
                if (!executor.awaitTermination(5, TimeUnit.SECONDS)) {
                    executor.shutdownNow();
                }
            } catch (InterruptedException e) {
                executor.shutdownNow();
                Thread.currentThread().interrupt();
            }
            running = false;
        }
        callback.run();
    }
    
    @Override
    public boolean isRunning() {
        return running;
    }
    
    @Override
    public boolean isAutoStartup() {
        return true;
    }
    
    @Override
    public int getPhase() {
        return 0; // 默认相位
    }
}

停止通知与销毁的关系:

• 正常关闭时：先 stop() 所有 Lifecycle Bean，再执行 destroy 回调
• 热刷新时：直接执行 destroy 回调，不执行 stop

---

FactoryBean 特殊生命周期

FactoryBean是一个特殊的 Bean，它生产其他 Bean，有自己的生命周期规则。

FactoryBean 接口

public interface FactoryBean<T> {
    T getObject() throws Exception;           // 生产 Bean 实例
    boolean isSingleton();                    // 是否为单例
    @Nullable
    Class<?> getObjectType();                 // 返回类型
}

FactoryBean 生命周期特点

1. 容器获取 FactoryBean 本身: 使用 &beanName
2. 容器获取生产的 Bean: 直接使用 beanName
3. getObject() 调用时机: 在普通 Bean 的生命周期中，当需要该 Bean 时
4. 生产的 Bean 也会经历完整生命周期

示例:

@Component
public class MyFactoryBean implements FactoryBean<MyService> {
    
    @Override
    public MyService getObject() throws Exception {
        // 这里创建的是实际使用的 Bean
        // 这个 Bean 也会被容器管理生命周期
        return new MyServiceImpl();
    }
    
    @Override
    public Class<MyService> getObjectType() {
        return MyService.class;
    }
    
    @Override
    public boolean isSingleton() {
        return true;
    }
}

// 使用
@Service
public class ClientService {
    // 获取 FactoryBean 生产的 Bean
    @Autowired
    private MyService myService;
    
    // 获取 FactoryBean 本身 (需要加 &)
    @Autowired
    @Qualifier("&myFactoryBean")
    private FactoryBean<MyService> factoryBean;
}

---

关键 BeanPostProcessor 实现

Spring 内部提供了多个重要的 BeanPostProcessor 实现:

BPP 名称	主要功能
ConfigurationClassPostProcessor	处理@Configuration 类，优先级最高
AutowiredAnnotationBeanPostProcessor	处理@Autowired、@Value 注解
CommonAnnotationBeanPostProcessor	处理@PostConstruct、@PreDestroy、@Resource
AnnotationAwareAspectJAutoProxyCreator	AOP 代理创建
BeanExpressionVisitor	处理 SpEL 表达式
ScopedProxyCreator	处理 scoped proxy
ListenerAdapterProcessor	事件监听器适配

执行顺序:

// 可通过 @Order 或 Ordered 接口控制顺序
@Component
@Order(1)
public class FirstBeanPostProcessor implements BeanPostProcessor { ... }

@Component
@Order(2)
public class SecondBeanPostProcessor implements BeanPostProcessor { ... }

---

实战示例：完整的生命周期追踪

public class FullLifecycleBean 
        implements BeanNameAware, 
                   ApplicationContextAware, 
                   InitializingBean, 
                   DisposableBean,
                   SmartInitializingSingleton {
    
    private String beanName;
    private ApplicationContext context;
    
    // 1. 构造器
    public FullLifecycleBean() {
        System.out.println("[FullLifecycleBean] 1. 构造器");
    }
    
    // 2. Aware 接口回调
    @Override
    public void setBeanName(String name) {
        this.beanName = name;
        System.out.println("[FullLifecycleBean] 2. setBeanName: " + name);
    }
    
    @Override
    public void setApplicationContext(ApplicationContext ctx) {
        this.context = ctx;
        System.out.println("[FullLifecycleBean] 3. setApplicationContext");
    }
    
    // 4. @PostConstruct
    @PostConstruct
    public void postConstruct() {
        System.out.println("[FullLifecycleBean] 4. @PostConstruct");
    }
    
    // 5. InitializingBean
    @Override
    public void afterPropertiesSet() {
        System.out.println("[FullLifecycleBean] 5. afterPropertiesSet()");
    }
    
    // 6. 自定义 init-method
    public void customInit() {
        System.out.println("[FullLifecycleBean] 6. customInit()");
    }
    
    // 7. SmartInitializingSingleton (所有单例创建后)
    @Override
    public void afterSingletonsInstantiated() {
        System.out.println("[FullLifecycleBean] 7. afterSingletonsInstantiated()");
    }
    
    // 销毁阶段
    // 8. @PreDestroy
    @PreDestroy
    public void preDestroy() {
        System.out.println("[FullLifecycleBean] 8. @PreDestroy");
    }
    
    // 9. DisposableBean
    @Override
    public void destroy() {
        System.out.println("[FullLifecycleBean] 9. destroy()");
    }
    
    // 10. 自定义 destroy-method
    public void customDestroy() {
        System.out.println("[FullLifecycleBean] 10. customDestroy()");
    }
}

// 自定义 BeanPostProcessor 用于追踪
@Component
@Order(Integer.MIN_VALUE) // 最高优先级
public class LifecycleTracingBpp implements BeanPostProcessor, DestructionAwareBeanPostProcessor {
    
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) {
        if (bean instanceof FullLifecycleBean) {
            System.out.println("[BPP] postProcessBeforeInitialization: " + beanName);
        }
        return bean;
    }
    
    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) {
        if (bean instanceof FullLifecycleBean) {
            System.out.println("[BPP] postProcessAfterInitialization: " + beanName);
        }
        return bean;
    }
    
    @Override
    public void postProcessBeforeDestruction(Object bean, String beanName) {
        if (bean instanceof FullLifecycleBean) {
            System.out.println("[BPP] postProcessBeforeDestruction: " + beanName);
        }
    }
}

@Configuration
public class LifecycleConfig {
    
    @Bean(initMethod = "customInit", destroyMethod = "customDestroy")
    public FullLifecycleBean fullLifecycleBean() {
        return new FullLifecycleBean();
    }
}

完整输出顺序:

[FullLifecycleBean] 1. 构造器
[BPP] postProcessBeforeInitialization: fullLifecycleBean
[FullLifecycleBean] 2. setBeanName: fullLifecycleBean
[FullLifecycleBean] 3. setApplicationContext
[FullLifecycleBean] 4. @PostConstruct
[FullLifecycleBean] 5. afterPropertiesSet()
[FullLifecycleBean] 6. customInit()
[BPP] postProcessAfterInitialization: fullLifecycleBean
[FullLifecycleBean] 7. afterSingletonsInstantiated()

[容器关闭时]
[BPP] postProcessBeforeDestruction: fullLifecycleBean
[FullLifecycleBean] 8. @PreDestroy
[FullLifecycleBean] 9. destroy()
[FullLifecycleBean] 10. customDestroy()

---

常见应用场景

1. AOP 代理创建

AOP 在 postProcessAfterInitialization 阶段创建代理:

public class AnnotationAwareAspectJAutoProxyCreator 
        extends AbstractAutoProxyCreator 
        implements BeanPostProcessor {
    
    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) {
        // 检查是否需要代理
        if (isEligible(bean, beanName)) {
            // 创建 CGLIB 或 JDK 动态代理
            return createProxy(bean, beanName);
        }
        return bean;
    }
}

2. 事务管理

@Transactional 通过 AOP 代理实现:

@Transactional
public void transferMoney() {
    // 事务边界内的操作
}

实际执行时，代理对象会包装事务逻辑:

Client → TransactionProxy → TargetBean
     (开启事务)    (执行业务)    (提交/回滚)

3. 循环依赖解决

通过三级缓存和提前暴露工厂方法解决:

@Service
public class ServiceA {
    @Autowired
    private ServiceB serviceB;
}

@Service
public class ServiceB {
    @Autowired
    private ServiceA serviceA;  // 循环依赖
}

// Spring 解决流程:
// 1. 创建 ServiceA 实例，放入第三级缓存 (ObjectFactory)
// 2. 填充 ServiceA 属性时需要 ServiceB
// 3. 创建 ServiceB 实例，填充属性时需要 ServiceA
// 4. 从第三级缓存获取 ServiceA 的早期引用
// 5. 完成 ServiceB 初始化
// 6. 完成 ServiceA 初始化

4. 懒加载 (@Lazy)

@Service
public class ServiceA {
    @Autowired
    @Lazy  // 注入代理，延迟真实 Bean 的创建
    private ServiceB serviceB;
}

---

最佳实践

1. 选择合适的初始化方式

方式	优点	缺点	推荐使用场景
@PostConstruct	标准 JSR-250，解耦 Spring	需额外 BPP	通用场景
InitializingBean	明确标识	耦合 Spring	Spring 专用代码
init-method	灵活，可配置	易出错	第三方库集成

2. BeanPostProcessor 开发注意事项

// 正确：使用 static @Bean 注册
@Configuration
public class Config {
    @Bean
    public static MyBeanPostProcessor bpp() {
        return new MyBeanPostProcessor();
    }
}

// 错误：可能导致配置类过早初始化
@Bean
public MyBeanPostProcessor bpp() { ... }

3. 避免循环依赖

// 使用 @Lazy 打破循环
@Service
public class ServiceA {
    @Autowired
    @Lazy  // 延迟注入
    private ServiceB serviceB;
}

// 或使用 Setter 注入代替构造器注入
// 或重构代码消除循环依赖

4. 资源清理保证

// 推荐：同时使用多种方式确保清理
@Component
public class ResourceHolder implements DisposableBean {
    
    private Connection connection;
    
    @PreDestroy
    public void preDestroy() {
        cleanup();
    }
    
    @Override
    public void destroy() {
        cleanup();
    }
    
    private void cleanup() {
        if (connection != null) {
            try { connection.close(); } catch (SQLException e) { /* log */ }
        }
    }
}

---

参考链接

• Spring Framework Reference - Bean Lifecycle
• Spring Framework Reference - BeanPostProcessor
• Spring Javadoc API

---

本文档基于 Spring Framework 6.2 编写，适用于 Spring Boot 2.7+/3.x