Spring Boot应用优雅停机：确保数据持久化的最佳实践

// 示例：存在问题的@PreDestroy用法
@Component
public class MangaDataProvider {

  private static MangaService mangaService;

  @Autowired
  public MangaDataProvider(MangaService mangaService) {
    MangaDataProvider.mangaService = mangaService;
  }

  // 此处使用@PreDestroy标记静态方法，且可能无法保证数据完全保存
  @PreDestroy
  public static void onExit() {
    System.out.println("Attempting to save all data via static @PreDestroy...");
    // 实际的保存逻辑，可能因时间限制而中断
    mangaService.saveAll();
    System.out.println("Data save attempt completed.");
  }
}

@SpringBootApplication
public class Application extends SpringBootServletInitializer implements AppShellConfigurator {

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

  // 应用程序主类中的@PreDestroy，再次调用静态方法
  @PreDestroy
  public void onExit() {
    System.out.println("Application @PreDestroy triggered.");
    MangaDataProvider.onExit(); // 调用静态方法
  }
}

import org.springframework.context.ApplicationContext;
import org.springframework.boot.SpringApplication;
import org.springframework.stereotype.Service;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

// 假设MangaService负责实际的CRUD操作和数据保存
interface MangaService {
    void saveAll();
}

@Service
public class GracefulShutdownService {

    private final MangaService mangaService;
    private final ApplicationContext applicationContext;

    public GracefulShutdownService(MangaService mangaService, ApplicationContext applicationContext) {
        this.mangaService = mangaService;
        this.applicationContext = applicationContext;
    }

    /**
     * 执行所有需要在应用停机前完成的数据持久化和清理任务。
     */
    public void prepareForShutdown() {
        System.out.println("--- 收到优雅停机请求：开始执行数据持久化和清理任务 ---");
        try {
            // 示例：保存所有内存中的Manga实体到数据库
            mangaService.saveAll();
            System.out.println("Manga数据已成功持久化。");
            // 其他清理工作，例如：
            // - 关闭自定义连接池
            // - 清理临时文件
            // - 发送通知
        } catch (Exception e) {
            System.err.println("优雅停机过程中数据持久化失败: " + e.getMessage());
            // 记录错误，可能需要采取进一步措施，例如发送告警
        } finally {
            System.out.println("--- 数据持久化和清理任务完成 ---");
            // 可以在这里触发应用程序的实际关闭
            initiateApplicationExit();
        }
    }

    /**
     * 异步触发Spring Boot应用程序的关闭。
     * 为了确保HTTP响应能够先发送出去，通常会异步执行退出。
     */
    private void initiateApplicationExit() {
        new Thread(() -> {
            try {
                // 给予客户端足够的时间接收HTTP响应
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
            System.out.println("--- 正在关闭Spring Boot应用上下文 ---");
            // 通过SpringApplication.exit()安全关闭上下文
            SpringApplication.exit(applicationContext, () -> 0);
            // 或者使用System.exit(0)强制退出JVM，但SpringApplication.exit更优雅
            // System.exit(0);
        }).start();
    }
}

@RestController
@RequestMapping("/admin")
public class ShutdownController {

    private final GracefulShutdownService gracefulShutdownService;

    public ShutdownController(GracefulShutdownService gracefulShutdownService) {
        this.gracefulShutdownService = gracefulShutdownService;
    }

    /**
     * 接收外部系统发起的优雅停机请求。
     * 调用此端点后，应用程序将开始执行数据持久化，并最终关闭。
     * 例如：curl -X POST http://localhost:8080/admin/shutdown-prepare
     */
    @PostMapping("/shutdown-prepare")
    public String initiateGracefulShutdown() {
        gracefulShutdownService.prepareForShutdown();
        return "Application is preparing for shutdown and will terminate shortly.";
    }
}

import org.springframework.context.SmartLifecycle;
import org.springframework.stereotype.Component;

@Component
public class CustomShutdownLifecycle implements SmartLifecycle {

    private volatile boolean running = false;
    private final MangaService mangaService;

    public CustomShutdownLifecycle(MangaService mangaService) {
        this.mangaService = mangaService;
    }

    @Override
    public void start() {
        System.out.println("CustomShutdownLifecycle started.");
        this.running = true;
    }

    @Override
    public void stop() {
        // 默认的stop方法，不带回调
        System.out.println("CustomShutdownLifecycle stopping (default).");
        stop(() -> {}); // 调用带回调的stop方法
    }

    @Override
    public void stop(Runnable callback) {
        System.out.println("--- CustomShutdownLifecycle 收到停机通知：开始执行数据持久化 ---");
        try {
            mangaService.saveAll(); // 执行数据保存
            System.out.println("Manga数据通过SmartLifecycle持久化成功。");
        } catch (Exception e) {
            System.err.println("SmartLifecycle数据持久化失败: " + e.getMessage());
        } finally {
            this.running = false;
            callback.run(); // 务必调用callback.run()通知Spring容器此组件已停止
            System.out.println("--- CustomShutdownLifecycle 数据持久化完成 ---");
        }
    }

    @Override
    public boolean isRunning() {
        return this.running;
    }

    @Override
    public int getPhase() {
        // 返回一个负数，确保在其他组件（如数据库连接池）关闭之前执行
        return -Integer.MAX_VALUE;
    }

    @Override
    public boolean isAutoStartup() {
        return true; // 随Spring容器自动启动
    }
}