#优雅关闭（Graceful Shutdown）

@Component
@Slf4j
public class GracefulShutdownHandler implements ApplicationListener<ContextClosedEvent> {

    @Autowired
    private ExecutorService taskExecutor;

    @Autowired
    private OrderService orderService;

    @Autowired
    private KafkaConsumer consumer;

    @Override
    public void onApplicationEvent(ContextClosedEvent event) {
        log.info("开始优雅关闭...");

        // 1. 停止接收新请求（通过关闭入口）
        // Spring Boot 会自动停止新的 HTTP 请求

        // 2. 等待正在处理的任务完成
        log.info("等待任务完成...");
        taskExecutor.shutdown();
        try {
            if (!taskExecutor.awaitTermination(30, TimeUnit.SECONDS)) {
                log.warn("任务未能在 30 秒内完成，强制终止");
                taskExecutor.shutdownNow();
            }
        } catch (InterruptedException e) {
            taskExecutor.shutdownNow();
            Thread.currentThread().interrupt();
        }

        // 3. 提交清理任务
        log.info("执行清理任务...");

        // 4. 关闭 Kafka 消费者
        try {
            consumer.close();
            log.info("Kafka 消费者已关闭");
        } catch (Exception e) {
            log.error("关闭 Kafka 消费者失败", e);
        }

        // 5. 等待少量时间确保消息处理完成
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }

        log.info("优雅关闭完成");
    }
}

@Configuration
public class TomcatGracefulShutdown {

    @Bean
    public ConfigurableServletWebServerFactory webServerFactory() {
        TomcatServletWebServerFactory factory = new TomcatServletWebServerFactory();
        factory.addConnectorCustomizers(connector -> {
            // 禁用 NIO  acceptor 和 poller 线程的优雅关闭
            connector.setProperty("gracefulShutdownTimeout", "30000");
        });
        return factory;
    }
}

// 如果任务可以被中断，使用 Future.cancel(true)
Future<?> future = executor.submit(() -> {
    try {
        while (!Thread.currentThread().isInterrupted()) {
            process();
        }
    } catch (InterruptedException e) {
        // 正确处理中断
        Thread.currentThread().interrupt();
    }
});

// 取消任务
future.cancel(true);

// 如果任务不支持中断，使用带超时的任务
Future<?> futureWithTimeout = executor.submit(() -> {
    // 在任务内部检查超时
    long startTime = System.currentTimeMillis();
    while (System.currentTimeMillis() - startTime < MAX_DURATION) {
        processBatch();
    }
});

@Bean
public KafkaListenerContainerFactory<?> kafkaListenerContainerFactory(
        ConcurrentKafkaListenerContainerFactory<String, String> factory) {
    // 设置并发为 1，方便关闭
    factory.setConcurrency(1);

    // 设置监听器类型
    factory.getContainerProperties().setAckMode(AckMode.RECORD);

    return factory;
}

// 关闭时等待消息处理完成
@PreDestroy
public void shutdown() {
    kafkaListener.stop();
    log.info("Kafka 消费者已停止");
}

// 确保数据库连接池最后关闭
@PreDestroy
public void shutdown() {
    // 1. 先停止接收新请求
    server.shutdown();

    // 2. 等待处理中的请求完成
    executor.shutdown();
    try {
        executor.awaitTermination(30, TimeUnit.SECONDS);
    } catch (InterruptedException e) {
        executor.shutdownNow();
    }

    // 3. 最后关闭数据库连接池
    dataSource.close();
}