Spring上下文关闭时已销毁Bean依赖问题及Tomcat拦截方案咨询

遇到这种Spring销毁顺序导致的依赖问题确实头疼，我来给你几个靠谱的解决方案，都是实际项目里验证过的：

方案一：利用Spring原生的SmartLifecycle控制销毁顺序 #

这是最推荐的Spring原生解决方案，既能解耦业务逻辑和缓存服务，又能精准控制任务执行时机，完全避开Bean销毁顺序的坑。

SmartLifecycle接口允许你自定义Bean的启动/停止逻辑，还能通过getPhase()方法指定执行优先级——销毁时，phase值越大的Bean会越先执行stop方法，刚好能满足我们“在缓存服务销毁前完成任务”的需求。

具体实现步骤：

1. 定义一个接口，让所有需要提前执行关闭逻辑的业务Bean实现它：

public interface ShutdownAware {
    void onShutdown(CacheService cacheService);
}

2. 实现SmartLifecycle的任务执行器，注入缓存服务和所有实现了ShutdownAware的Bean：

@Component
public class PreDestroyTaskExecutor implements SmartLifecycle {
    private boolean isRunning = false;
    private final CacheService cacheService;
    private final List<ShutdownAware> shutdownBeans;

    // 构造注入依赖
    public PreDestroyTaskExecutor(CacheService cacheService, List<ShutdownAware> shutdownBeans) {
        this.cacheService = cacheService;
        this.shutdownBeans = shutdownBeans;
    }

    @Override
    public void start() {
        isRunning = true;
    }

    @Override
    public void stop() {
        // 先执行所有业务Bean的关闭逻辑，此时缓存服务完全可用
        shutdownBeans.forEach(bean -> bean.onShutdown(cacheService));
        // 在这里添加邮件发送操作
        sendShutdownNotification();
    }

    @Override
    public boolean isRunning() {
        return isRunning;
    }

    @Override
    public int getPhase() {
        // 设置比缓存服务更高的phase值（默认Bean的phase是0）
        // 确保我们的任务在缓存服务销毁前执行
        return 100;
    }

    private void sendShutdownNotification() {
        // 你的邮件发送逻辑
    }
}

3. 让需要依赖缓存的业务Bean实现ShutdownAware接口，把原本的销毁逻辑移到onShutdown方法里即可。

这个方案的优点：

• 完全解耦：缓存服务不需要知道任何业务逻辑，业务Bean只需要实现统一接口
• 精准控制：通过phase值确保执行顺序，避免异步销毁带来的问题
• 原生支持：不需要依赖Tomcat等容器，换容器也能正常工作

方案二：拦截Tomcat停止信号，提前执行任务 #

如果你的场景必须在Spring上下文开始销毁之前完成所有任务，可以直接拦截Tomcat的停止事件，在Spring上下文完全可用时执行任务，再手动触发Spring的关闭流程。

实现步骤：

1. 编写Tomcat生命周期监听器，监听BEFORE_STOP_EVENT（Tomcat准备停止Web应用前的事件）：

public class TomcatPreShutdownListener implements LifecycleListener {
    @Override
    public void lifecycleEvent(LifecycleEvent event) {
        if (Lifecycle.BEFORE_STOP_EVENT.equals(event.getType())) {
            // 从Tomcat上下文获取Spring应用上下文
            StandardContext tomcatContext = (StandardContext) event.getLifecycle();
            ServletContext servletContext = tomcatContext.getServletContext();
            WebApplicationContext springContext = WebApplicationContextUtils.getWebApplicationContext(servletContext);
            
            if (springContext != null) {
                // 执行所有依赖缓存的关闭任务
                CacheService cacheService = springContext.getBean(CacheService.class);
                List<ShutdownAware> shutdownBeans = springContext.getBeansOfType(ShutdownAware.class).values().stream().toList();
                shutdownBeans.forEach(bean -> bean.onShutdown(cacheService));
                
                // 发送邮件通知
                sendShutdownNotification();
                
                // 手动关闭Spring上下文（可选，Tomcat后续也会自动关闭，但手动触发更可控）
                ((ConfigurableApplicationContext) springContext).close();
            }
        }
    }

    private void sendShutdownNotification() {
        // 邮件发送逻辑
    }
}

2. 注册这个监听器到Tomcat中：
   • 如果是Spring Boot项目，通过自定义TomcatServletWebServerFactory注册：

   @Configuration
   public class TomcatConfig {
       @Bean
       public TomcatServletWebServerFactory tomcatServerFactory() {
           return new TomcatServletWebServerFactory() {
               @Override
               protected void postProcessContext(Context context) {
                   context.addLifecycleListener(new TomcatPreShutdownListener());
               }
           };
       }
   }
   

   • 如果是传统Spring项目，可以在web.xml中配置，或者通过ServletContextListener动态添加。

这个方案的优点：

• 完全在Spring上下文销毁前执行任务，彻底避免Bean销毁带来的依赖问题
• 适合对执行时机要求极高的场景

对比与推荐 #

• 优先选方案一：它是Spring原生的解决方案，解耦性好，通用性强，不需要依赖容器，大部分场景都能满足需求
• 如果你的业务必须在Spring上下文完全未销毁时执行，再考虑方案二：它依赖Tomcat容器，但能做到最彻底的前置执行

内容的提问来源于stack exchange，提问作者jason