JAVA 如何优雅关闭 Spring Boot 应用？注册 shutdownHook 完成清理任务 - 智猿学院-前后端，数据库，人工智能，云计算等领域前沿技术讲座

优雅地关闭 Spring Boot 应用：使用 ShutdownHook 完成清理任务

大家好，今天我们来聊聊如何优雅地关闭 Spring Boot 应用。一个健壮的应用不仅要能稳定运行，也要能在退出时做好清理工作，释放资源，避免数据丢失或状态不一致。Spring Boot 提供了多种方式来处理应用关闭事件，其中一种常见且有效的方法就是注册 ShutdownHook。

1. 为什么需要优雅关闭？

想象一下，如果你的应用正在处理关键业务数据，突然被强制停止，可能会导致：

数据损坏或丢失： 未完成的数据库事务可能被回滚，部分数据可能未写入磁盘。
资源泄漏： 未关闭的连接池、文件句柄等资源会一直占用系统资源，最终导致系统性能下降。
状态不一致： 应用内部状态与外部系统状态不一致，导致后续业务流程出错。
不可预测的行为： 未处理的异常或中断可能导致应用行为变得不可预测。

因此，在应用关闭前执行必要的清理工作至关重要。优雅关闭的目标是确保应用在退出时能够完成所有未完成的任务，释放所有占用的资源，并保持数据和状态的一致性。

2. Spring Boot 关闭事件机制

Spring Boot 提供了一套完整的关闭事件机制，允许我们在应用关闭的不同阶段执行自定义逻辑。主要涉及以下几个组件：

ApplicationContextAware 接口： 实现此接口的 Bean 可以获取到 Spring 应用上下文，从而可以访问 Spring 管理的任何 Bean。
DisposableBean 接口： 实现此接口的 Bean 在销毁时会调用 destroy() 方法，可以在此方法中执行清理操作。
@PreDestroy 注解： 标注在方法上，该方法会在 Bean 销毁之前被调用。
ApplicationListener<ContextClosedEvent>： 监听 ContextClosedEvent 事件，该事件在 Spring 应用上下文关闭时发布。
ShutdownHook： Java 虚拟机 (JVM) 的 ShutdownHook 机制允许我们在 JVM 关闭前执行一段代码。

这些机制各有特点，适用场景也不同。ShutdownHook 是一种较为底层的方式，它能在 JVM 关闭的最后时刻执行，可以确保即使应用发生异常或被强制停止，清理逻辑也能得到执行。

3. 什么是 ShutdownHook？

ShutdownHook 是 JVM 提供的一种回调机制，允许我们在 JVM 关闭时执行一段代码。ShutdownHook 是一个线程，它会在以下情况发生时被触发：

用户调用 System.exit() 方法。
JVM 接收到操作系统的中断信号（例如，Ctrl+C）。
操作系统关闭。

ShutdownHook 的主要作用是在 JVM 关闭前执行一些清理工作，例如：

关闭数据库连接。
释放文件句柄。
保存应用状态。
发送告警信息。

4. 如何注册 ShutdownHook？

在 Java 中，我们可以使用 Runtime.getRuntime().addShutdownHook(Thread hook) 方法来注册 ShutdownHook。该方法接受一个 Thread 对象作为参数，该线程包含了 ShutdownHook 的执行逻辑。

下面是一个简单的 ShutdownHook 示例：

public class ShutdownHookExample {

    public static void main(String[] args) {
        // 注册 ShutdownHook
        Runtime.getRuntime().addShutdownHook(new Thread(() -> {
            System.out.println("ShutdownHook is running...");
            // 执行清理操作
            cleanupResources();
            System.out.println("ShutdownHook finished.");
        }));

        // 模拟应用运行
        System.out.println("Application is running...");
        try {
            Thread.sleep(5000); // 模拟应用运行 5 秒钟
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("Application is exiting...");
    }

    private static void cleanupResources() {
        // 在这里编写清理资源的代码
        System.out.println("Cleaning up resources...");
        // 例如：关闭数据库连接、释放文件句柄等
        try {
            Thread.sleep(2000); // 模拟清理资源需要 2 秒钟
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

在这个例子中，我们首先使用 Runtime.getRuntime().addShutdownHook() 方法注册了一个 ShutdownHook。该 ShutdownHook 的执行逻辑是打印一些信息，然后调用 cleanupResources() 方法来执行清理操作。在 cleanupResources() 方法中，我们可以编写清理资源的代码，例如关闭数据库连接、释放文件句柄等。

5. 在 Spring Boot 中使用 ShutdownHook

在 Spring Boot 中，我们可以利用 Spring 的 Bean 生命周期管理机制，结合 ShutdownHook 来实现优雅关闭。以下是一种常见的实现方式：

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.stereotype.Component;

import javax.annotation.PreDestroy;

@SpringBootApplication
public class ShutdownHookApplication {

    public static void main(String[] args) {
        SpringApplication.run(ShutdownHookApplication.class, args);
    }

    @Configuration
    public static class ShutdownHookConfig {

        @Bean
        public GracefulShutdown gracefulShutdown() {
            return new GracefulShutdown();
        }
    }

    @Component
    public static class GracefulShutdown {

        @PreDestroy
        public void onExit() {
            System.out.println("Spring Context is closing...");
            // 执行清理操作
            cleanupResources();
            System.out.println("Cleanup finished.");
        }

        private void cleanupResources() {
            // 在这里编写清理资源的代码
            System.out.println("Cleaning up resources...");
            // 例如：关闭数据库连接、释放文件句柄等
            try {
                Thread.sleep(2000); // 模拟清理资源需要 2 秒钟
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

在这个例子中，我们创建了一个名为 GracefulShutdown 的 Spring Bean，并使用 @PreDestroy 注解标注了 onExit() 方法。当 Spring 应用上下文关闭时，onExit() 方法会被调用，我们可以在该方法中执行清理操作。

但是，仅仅使用 @PreDestroy 并不能保证在所有情况下都能执行清理操作。例如，如果 JVM 被强制关闭，或者应用发生严重错误导致 JVM 崩溃，@PreDestroy 方法可能不会被调用。因此，我们需要结合 ShutdownHook 来确保清理操作能够执行。

以下是结合 ShutdownHook 的完整示例：

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.stereotype.Component;

import javax.annotation.PreDestroy;

@SpringBootApplication
public class ShutdownHookApplication {

    public static void main(String[] args) {
        SpringApplication.run(ShutdownHookApplication.class, args);
    }

    @Configuration
    public static class ShutdownHookConfig {

        @Bean
        public GracefulShutdown gracefulShutdown() {
            return new GracefulShutdown();
        }
    }

    @Component
    public static class GracefulShutdown {

        private volatile boolean shutdownInitiated = false;

        public GracefulShutdown() {
            // 注册 ShutdownHook
            Runtime.getRuntime().addShutdownHook(new Thread(() -> {
                System.out.println("ShutdownHook is running...");
                if (!shutdownInitiated) {
                    // 执行清理操作
                    cleanupResources();
                }
                System.out.println("ShutdownHook finished.");
            }));
        }

        @PreDestroy
        public void onExit() {
            System.out.println("Spring Context is closing...");
            shutdownInitiated = true;
            // 执行清理操作
            cleanupResources();
            System.out.println("Cleanup finished.");
        }

        private void cleanupResources() {
            // 在这里编写清理资源的代码
            System.out.println("Cleaning up resources...");
            // 例如：关闭数据库连接、释放文件句柄等
            try {
                Thread.sleep(2000); // 模拟清理资源需要 2 秒钟
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

在这个例子中，我们在 GracefulShutdown 类的构造函数中注册了一个 ShutdownHook。该 ShutdownHook 的执行逻辑是调用 cleanupResources() 方法来执行清理操作。同时，我们在 @PreDestroy 方法中也调用了 cleanupResources() 方法。

这里需要注意的是，我们使用了一个 shutdownInitiated 标志来避免重复执行清理操作。如果 @PreDestroy 方法先被调用，shutdownInitiated 标志会被设置为 true，ShutdownHook 在执行时会检查该标志，如果为 true，则不会重复执行清理操作。

6. 实际应用中的注意事项

在实际应用中，使用 ShutdownHook 需要注意以下几点：

ShutdownHook 的执行时间有限制： JVM 会为 ShutdownHook 的执行设置一个时间限制，如果 ShutdownHook 在规定的时间内没有执行完成，JVM 会强制关闭。因此，我们需要确保 ShutdownHook 的执行时间尽可能短，避免执行耗时的操作。
ShutdownHook 的执行顺序不确定： JVM 会按照不确定的顺序执行 ShutdownHook，因此，我们需要避免 ShutdownHook 之间存在依赖关系。
ShutdownHook 可能会被中断： 在 ShutdownHook 执行过程中，可能会接收到操作系统的中断信号，导致 ShutdownHook 被中断。因此，我们需要在 ShutdownHook 中处理中断异常，确保清理操作能够完成。
避免在 ShutdownHook 中使用 Spring 容器： 在 ShutdownHook 执行时，Spring 容器可能已经关闭，因此，我们需要避免在 ShutdownHook 中使用 Spring 容器。如果需要使用 Spring 容器，可以考虑在 @PreDestroy 方法中执行清理操作。
优雅关闭数据库连接池： 对于数据库连接池，例如 HikariCP、Druid 等，需要调用其 close() 方法来优雅关闭连接池，释放所有连接。
处理 InterruptedException： 在 ShutdownHook 中，由于线程随时可能被中断，因此需要妥善处理 InterruptedException，确保清理逻辑能够继续执行。

7. 代码示例：优雅关闭数据库连接池

以下是一个优雅关闭数据库连接池的示例：

import com.zaxxer.hikari.HikariDataSource;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import javax.annotation.PreDestroy;
import javax.sql.DataSource;
import java.sql.SQLException;

@Component
public class DatabaseCleanup {

    @Autowired
    private DataSource dataSource;

    @PreDestroy
    public void cleanup() {
        System.out.println("Closing database connection pool...");
        if (dataSource instanceof HikariDataSource) {
            HikariDataSource hikariDataSource = (HikariDataSource) dataSource;
            hikariDataSource.close();
            System.out.println("HikariCP connection pool closed.");
        } else {
            System.out.println("Unknown DataSource type. Cannot close connection pool.");
        }
    }
}

在这个例子中，我们首先注入了 DataSource 对象，然后在 @PreDestroy 方法中判断 DataSource 是否为 HikariDataSource 类型。如果是，则调用 hikariDataSource.close() 方法来关闭连接池。

8. ShutdownHook 和 Spring Boot Actuator

Spring Boot Actuator 提供了一个 /shutdown 端点，可以用来优雅地关闭应用。当我们调用该端点时，Spring Boot 会发布 ContextClosedEvent 事件，并执行所有注册的 @PreDestroy 方法。

使用 Actuator 关闭应用的优点是可以控制关闭过程，例如，可以设置关闭超时时间，或者在关闭前执行一些检查。

9. ShutdownHook 的替代方案

除了 ShutdownHook，还有一些其他的替代方案可以用来实现优雅关闭，例如：

DisposableBean 接口： 实现此接口的 Bean 在销毁时会调用 destroy() 方法，可以在此方法中执行清理操作。
ApplicationListener<ContextClosedEvent>： 监听 ContextClosedEvent 事件，该事件在 Spring 应用上下文关闭时发布。

这些替代方案各有特点，适用场景也不同。ShutdownHook 是一种较为底层的方式，它能在 JVM 关闭的最后时刻执行，可以确保即使应用发生异常或被强制停止，清理逻辑也能得到执行。

10. 总结

方法	优点	缺点	适用场景
`@PreDestroy`	简单易用，与 Spring 容器集成紧密。	无法保证在所有情况下都能执行，例如 JVM 被强制关闭。	大部分情况下的 Bean 销毁清理，例如关闭数据库连接。
`DisposableBean`	与 `@PreDestroy` 类似，但通过接口实现，更灵活。	同样无法保证在所有情况下都能执行。	与 `@PreDestroy` 类似，但需要实现接口。
`ApplicationListener`	可以监听 `ContextClosedEvent` 事件，在 Spring 上下文关闭时执行清理操作。	需要手动处理事件，代码相对复杂。	需要监听 Spring 上下文关闭事件的场景，例如发送告警信息。
ShutdownHook	保证在 JVM 关闭前执行，即使应用被强制停止。	执行时间有限制，执行顺序不确定，可能会被中断，避免使用 Spring 容器。	确保在所有情况下都能执行清理操作，例如释放关键资源。

总而言之，优雅关闭 Spring Boot 应用需要综合考虑各种因素，选择合适的方案。ShutdownHook 是一种可靠的底层机制，可以确保在 JVM 关闭前执行清理操作，结合 @PreDestroy 等 Spring 提供的机制，可以更好地管理应用生命周期，保证应用的健壮性和稳定性。记得妥善处理潜在的中断异常，并确保清理逻辑执行时间尽可能短。

11. 结语

优雅关闭，保证程序健壮运行

ShutdownHook，应对突发状况

多方考虑，选择最佳方案

优雅地关闭 Spring Boot 应用：使用 ShutdownHook 完成清理任务

发表回复 取消回复

发表回复取消回复