Spring Bean完整生命周期流程总结

纳就这样吧
56 阅读6分钟

Spring Bean完整生命周期与主流框架整合详解

📋 概述

Spring Bean的生命周期是Spring框架的核心概念之一，它描述了从Bean的创建、初始化、使用到销毁的整个过程。Spring提供了丰富的扩展点，允许开发者在Bean生命周期的不同阶段插入自定义逻辑。本文档将详细阐述Spring与主流框架（如MyBatis、Hibernate、Spring MVC、Spring Cloud Alibaba、Spring Cloud OpenFeign等）整合时对这些扩展点的具体应用。

🔄 Spring Bean生命周期核心阶段

Spring Bean的生命周期主要包括以下核心阶段：

  1. 实例化阶段：Spring容器根据Bean定义创建Bean实例
  2. 属性注入阶段：将Bean的属性值和依赖注入到Bean实例中
  3. Aware接口回调阶段：调用各种Aware接口方法，注入容器相关信息
  4. 初始化阶段：执行BeanPostProcessor处理、@PostConstruct注解方法、InitializingBean接口和自定义初始化方法
  5. 使用阶段：Bean已准备就绪，可以被应用程序使用
  6. 销毁阶段：容器关闭时执行销毁逻辑，包括@PreDestroy注解方法、DisposableBean接口和自定义销毁方法

⚙️ Spring Bean生命周期核心接口和扩展点

核心生命周期接口

1. BeanPostProcessor
  • 作用域：全局扩展点，对所有Bean生效
  • 核心方法：
    • postProcessBeforeInitialization(Object bean, String beanName)：在初始化之前调用
    • postProcessAfterInitialization(Object bean, String beanName)：在初始化之后调用
  • 典型应用场景：AOP代理创建、自定义包装处理
2. InitializingBean
  • 核心方法：afterPropertiesSet()
  • 调用时机：属性设置完成后，但在自定义init-method之前
  • 典型应用场景：资源初始化、连接建立等
3. DisposableBean
  • 核心方法：destroy()
  • 调用时机：容器关闭时，在自定义destroy-method之前
  • 典型应用场景：资源释放、连接关闭等
4. FactoryBean
  • 核心方法：
    • getObject()：返回由该工厂创建的对象实例
    • getObjectType()：返回对象类型
    • isSingleton()：判断是否为单例
  • 典型应用场景：复杂对象的创建封装
5. Aware系列接口
  • BeanNameAware：获取Bean在容器中的名称
  • BeanFactoryAware：获取BeanFactory容器引用
  • ApplicationContextAware：获取ApplicationContext容器引用
  • EnvironmentAware：获取Environment对象
  • ResourceLoaderAware：获取ResourceLoader对象

注解形式的生命周期回调

1. @PostConstruct
  • 作用：标记初始化方法，在依赖注入完成后执行
  • 调用顺序：最先执行，早于InitializingBean.afterPropertiesSet()
2. @PreDestroy
  • 作用：标记销毁方法，在Bean销毁前执行
  • 调用顺序：最先执行，早于DisposableBean.destroy()

🧩 主流框架整合中的生命周期应用

1. MyBatis与Spring整合

基于对MyBatis-Spring整合机制的理解，其主要通过以下方式应用生命周期扩展点：

SqlSessionFactoryBean实现的关键接口：
  • FactoryBean：用于创建SqlSessionFactory实例
  • InitializingBean：在afterPropertiesSet()方法中完成SqlSessionFactory的构建
  • ApplicationListener：监听上下文刷新事件，进行后续处理
生命周期应用示例：
public class SqlSessionFactoryBean implements FactoryBean<SqlSessionFactory>, InitializingBean, ApplicationListener<ContextRefreshedEvent> {
    
    @Override
    public void afterPropertiesSet() throws Exception {
        // 构建SqlSessionFactory
        this.sqlSessionFactory = buildSqlSessionFactory();
    }
    
    @Override
    public SqlSessionFactory getObject() throws Exception {
        // 返回SqlSessionFactory实例
        return this.sqlSessionFactory;
    }
    
    @Override
    public void onApplicationEvent(ContextRefreshedEvent event) {
        // 上下文刷新后的处理逻辑
    }
}

2. Hibernate与Spring整合

LocalSessionFactoryBean实现的关键接口：
  • FactoryBean：用于创建SessionFactory实例
  • InitializingBean：在afterPropertiesSet()方法中完成SessionFactory的构建
  • DisposableBean：在destroy()方法中释放SessionFactory资源
  • BeanFactoryAware：获取BeanFactory引用
  • ResourceLoaderAware：获取ResourceLoader引用
  • SmartInitializingSingleton：在所有单例Bean实例化完成后执行特定逻辑
生命周期应用示例：
public class LocalSessionFactoryBean extends HibernateExceptionTranslator
        implements FactoryBean<SessionFactory>, ResourceLoaderAware, BeanFactoryAware,
        InitializingBean, SmartInitializingSingleton, DisposableBean {
    
    @Override
    public void setBeanFactory(BeanFactory beanFactory) {
        // 注入BeanFactory引用
        this.beanFactory = beanFactory;
    }
    
    @Override
    public void setResourceLoader(ResourceLoader resourceLoader) {
        // 注入ResourceLoader引用
        this.resourceLoader = resourceLoader;
    }
    
    @Override
    public void afterPropertiesSet() throws Exception {
        // 属性设置完成后，构建SessionFactory
        this.sessionFactory = buildSessionFactory();
    }
    
    @Override
    public void afterSingletonsInstantiated() {
        // 所有单例Bean实例化完成后执行
    }
    
    @Override
    public SessionFactory getObject() throws Exception {
        // 返回SessionFactory实例
        return this.sessionFactory;
    }
    
    @Override
    public void destroy() throws Exception {
        // 销毁资源，关闭SessionFactory
        if (this.sessionFactory instanceof DisposableBean) {
            ((DisposableBean) this.sessionFactory).destroy();
        }
    }
}

3. Spring MVC与Spring整合

DispatcherServlet实现的关键接口：
  • ApplicationContextAware：获取ApplicationContext引用
  • EnvironmentCapable：获取Environment引用
  • HttpServletBean：继承自HttpServlet，实现了BeanWrapper和EnvironmentAware
生命周期应用示例：
public class DispatcherServlet extends FrameworkServlet {
    
    @Override
    protected void onRefresh(ApplicationContext context) {
        // 初始化各种策略组件
        initStrategies(context);
    }
    
    protected void initStrategies(ApplicationContext context) {
        // 初始化处理器映射器、处理器适配器、视图解析器等
        initMultipartResolver(context);
        initLocaleResolver(context);
        initThemeResolver(context);
        initHandlerMappings(context);
        initHandlerAdapters(context);
        initHandlerExceptionResolvers(context);
        initRequestToViewNameTranslator(context);
        initViewResolvers(context);
        initFlashMapManager(context);
    }
}

// 拦截器中的生命周期方法
public interface HandlerInterceptor {
    default boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)
            throws Exception {
        // 请求处理前执行
        return true;
    }

    default void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler,
            ModelAndView modelAndView) throws Exception {
        // 请求处理后、视图渲染前执行
    }

    default void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler,
            Exception ex) throws Exception {
        // 视图渲染完成后执行
    }
}

4. Spring Boot中的生命周期扩展

SmartLifecycle接口：
  • 核心方法：
    • isAutoStartup()：是否自动启动
    • getPhase()：启动阶段
    • start()/stop()：启动/停止方法
DefaultLifecycleProcessor实现：
  • 管理Lifecycle和SmartLifecycle beans的分组启动/停止
  • 支持按phase顺序处理及并发启动配置
生命周期应用示例：
public interface SmartLifecycle extends Lifecycle, Phased {
    boolean isAutoStartup();
    
    default void stop(Runnable callback) {
        stop();
        callback.run();
    }
}

public class DefaultLifecycleProcessor implements LifecycleProcessor, BeanFactoryAware {
    @Override
    public void onRefresh() {
        // 启动所有符合条件的Lifecycle beans
        startBeans(true);
    }
    
    @Override
    public void onClose() {
        // 停止所有Lifecycle beans
        stopBeans();
    }
}

5. Spring Cloud Alibaba整合

虽然在本次分析中未找到Spring Cloud Alibaba源码，但基于对其架构的理解，其主要通过以下方式应用生命周期扩展点：

Nacos相关组件：
  • NacosDiscoveryClient：实现DisposableBean接口，在destroy()方法中注销服务
  • NacosServiceRegistry：实现InitializingBean接口，在afterPropertiesSet()方法中初始化注册中心客户端
Sentinel相关组件：
  • SentinelBeanPostProcessor：实现BeanPostProcessor接口，对Bean进行增强处理
  • SentinelWebAutoConfiguration：通过@PostConstruct注解初始化Web相关的Sentinel规则

6. Spring Cloud OpenFeign整合

虽然在本次分析中未找到Spring Cloud OpenFeign源码，但基于对其架构的理解，其主要通过以下方式应用生命周期扩展点：

FeignClient相关组件：
  • FeignClientFactoryBean：实现FactoryBean接口，用于创建Feign客户端代理实例
  • FeignContext：实现InitializingBean接口，在afterPropertiesSet()方法中初始化Feign上下文
生命周期应用示例：
class FeignClientFactoryBean implements FactoryBean<Object> {
    
    @Override
    public Object getObject() throws Exception {
        // 创建Feign客户端代理实例
        return getTarget();
    }
    
    @Override
    public Class<?> getObjectType() {
        return targetType;
    }
    
    @Override
    public boolean isSingleton() {
        return true;
    }
}

📊 整合点对比分析

框架核心类实现接口主要用途
MyBatisSqlSessionFactoryBeanFactoryBean, InitializingBean创建SqlSessionFactory
HibernateLocalSessionFactoryBeanFactoryBean, InitializingBean, DisposableBean创建SessionFactory
Spring MVCDispatcherServletApplicationContextAware初始化Web组件
Spring Cloud AlibabaNacosDiscoveryClientDisposableBean服务注销
Spring Cloud OpenFeignFeignClientFactoryBeanFactoryBean创建Feign客户端

📝 总结

Spring Bean的生命周期机制为框架整合提供了强大的扩展能力。各个主流框架都充分利用了Spring提供的各种扩展点：

  1. FactoryBean：用于复杂对象的创建，如SessionFactory、SqlSessionFactory等
  2. InitializingBean/DisposableBean：用于资源的初始化和销毁
  3. BeanPostProcessor：用于对象增强，如AOP代理
  4. Aware系列接口：用于获取容器相关信息
  5. 注解形式(@PostConstruct/@PreDestroy)：简化生命周期回调方法的定义

通过对这些扩展点的合理运用，各框架能够很好地融入Spring生态系统，既保持了自身的特性，又充分利用了Spring的强大功能。

avatar
文章
阅读
粉丝