server:
  shutdown: graceful

spring:
  lifecycle:
    timeout-per-shutdown-phase: 30s

@SpringBootApplication
public class GracefulShutdownApplication {

    private static final Logger logger = LoggerFactory.getLogger(GracefulShutdownApplication.class);

    public static void main(String[] args) {
        SpringApplication.run(GracefulShutdownApplication.class, args);
        logger.info("Application started");
    }
    
    @RestController
    @RequestMapping("/api")
    static class SampleController {
        
        @GetMapping("/quick")
        public String quickRequest() {
            return "Quick response";
        }
        
        @GetMapping("/slow")
        public String slowRequest() throws InterruptedException {
            // 模擬長時間處理的請求
            logger.info("Start processing slow request");
            Thread.sleep(10000); // 10秒
            logger.info("Finished processing slow request");
            return "Slow response completed";
        }
    }
    
    @Bean
    public ApplicationListener<ContextClosedEvent> contextClosedEventListener() {
        return event -> logger.info("Received spring context closed event - shutting down");
    }
}

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-actuator</artifactId>
</dependency>

management:
  endpoint:
    shutdown:
      enabled: true
  endpoints:
    web:
      exposure:
        include: shutdown
      base-path: /management
  server:
    port: 8081  # 可選：為管理端點設(shè)置單獨端口

curl -X POST http://localhost:8081/management/shutdown

{
  "message": "Shutting down, bye..."
}

spring:
  security:
    user:
      name: admin
      password: secure_password
      roles: ACTUATOR

management:
  endpoints:
    web:
      exposure:
        include: shutdown
  endpoint:
    shutdown:
      enabled: true

# 配置端點安全
management.endpoints.web.base-path: /management

curl -X POST http://admin:secure_password@localhost:8080/management/shutdown

@SpringBootApplication
@EnableWebSecurity
public class ActuatorShutdownApplication {

    private static final Logger logger = LoggerFactory.getLogger(ActuatorShutdownApplication.class);

    public static void main(String[] args) {
        SpringApplication.run(ActuatorShutdownApplication.class, args);
        logger.info("Application started with Actuator shutdown enabled");
    }
    
    @Bean
    public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
        http.csrf().disable()
            .authorizeHttpRequests()
            .requestMatchers("/management/**").hasRole("ACTUATOR")
            .anyRequest().permitAll()
            .and()
            .httpBasic();
        
        return http.build();
    }
    
    @RestController
    static class ApiController {
        
        @GetMapping("/api/hello")
        public String hello() {
            return "Hello, world!";
        }
    }
    
    @Bean
    public ApplicationListener<ContextClosedEvent> shutdownListener() {
        return event -> {
            logger.info("Received shutdown signal via Actuator");
            
            // 等待活躍請求完成
            logger.info("Waiting for active requests to complete...");
            try {
                Thread.sleep(5000); // 簡化示例，實際應(yīng)監(jiān)控活躍請求
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
            
            logger.info("All requests completed, shutting down");
        };
    }
}

@SpringBootApplication
public class CustomShutdownHookApplication {

    private static final Logger logger = LoggerFactory.getLogger(CustomShutdownHookApplication.class);

    public static void main(String[] args) {
        ConfigurableApplicationContext context = SpringApplication.run(CustomShutdownHookApplication.class, args);
        
        // 注冊自定義ShutdownHook
        registerShutdownHook(context);
        
        logger.info("Application started with custom shutdown hook");
    }
    
    private static void registerShutdownHook(ConfigurableApplicationContext context) {
        Runtime.getRuntime().addShutdownHook(new Thread(() -> {
            logger.info("Executing custom shutdown hook");
            try {
                // 1. 停止接收新請求（如果是Web應(yīng)用）
                if (context.containsBean("tomcatServletWebServerFactory")) {
                    TomcatServletWebServerFactory server = context.getBean(TomcatServletWebServerFactory.class);
                    logger.info("Stopping web server to reject new requests");
                    // 注意: 實際應(yīng)用中需要找到正確方式停止特定Web服務(wù)器
                }
                
                // 2. 等待活躍請求處理完成
                logger.info("Waiting for active requests to complete");
                // 這里可以添加自定義等待邏輯，如檢查活躍連接數(shù)或線程狀態(tài)
                Thread.sleep(5000); // 簡化示例
                
                // 3. 關(guān)閉自定義線程池
                shutdownThreadPools(context);
                
                // 4. 關(guān)閉消息隊列連接
                closeMessageQueueConnections(context);
                
                // 5. 關(guān)閉數(shù)據(jù)庫連接池
                closeDataSourceConnections(context);
                
                // 6. 執(zhí)行其他自定義清理邏輯
                performCustomCleanup(context);
                
                // 7. 最后關(guān)閉Spring上下文
                logger.info("Closing Spring application context");
                context.close();
                
                logger.info("Graceful shutdown completed");
            } catch (Exception e) {
                logger.error("Error during graceful shutdown", e);
            }
        }, "GracefulShutdownHook"));
    }
    
    private static void shutdownThreadPools(ApplicationContext context) {
        logger.info("Shutting down thread pools");
        
        // 獲取所有ExecutorService類型的Bean
        Map<String, ExecutorService> executors = context.getBeansOfType(ExecutorService.class);
        
        executors.forEach((name, executor) -> {
            logger.info("Shutting down executor: {}", name);
            executor.shutdown();
            try {
                // 等待任務(wù)完成
                if (!executor.awaitTermination(15, TimeUnit.SECONDS)) {
                    logger.warn("Executor did not terminate in time, forcing shutdown: {}", name);
                    executor.shutdownNow();
                }
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                logger.warn("Interrupted while waiting for executor shutdown: {}", name);
                executor.shutdownNow();
            }
        });
    }
    
    private static void closeMessageQueueConnections(ApplicationContext context) {
        logger.info("Closing message queue connections");
        
        // 示例：關(guān)閉RabbitMQ連接
        if (context.containsBean("rabbitConnectionFactory")) {
            try {
                ConnectionFactory rabbitFactory = context.getBean(ConnectionFactory.class);
                // 適當?shù)仃P(guān)閉連接
                logger.info("Closed RabbitMQ connections");
            } catch (Exception e) {
                logger.error("Error closing RabbitMQ connections", e);
            }
        }
        
        // 示例：關(guān)閉Kafka連接
        if (context.containsBean("kafkaConsumerFactory")) {
            try {
                // 關(guān)閉Kafka連接的代碼
                logger.info("Closed Kafka connections");
            } catch (Exception e) {
                logger.error("Error closing Kafka connections", e);
            }
        }
    }
    
    private static void closeDataSourceConnections(ApplicationContext context) {
        logger.info("Closing datasource connections");
        
        // 獲取所有DataSource類型的Bean
        Map<String, DataSource> dataSources = context.getBeansOfType(DataSource.class);
        
        dataSources.forEach((name, dataSource) -> {
            try {
                // 對于HikariCP連接池
                if (dataSource instanceof HikariDataSource) {
                    ((HikariDataSource) dataSource).close();
                    logger.info("Closed HikariCP datasource: {}", name);
                }
                // 可以添加其他類型連接池的關(guān)閉邏輯
                else {
                    // 嘗試通過反射調(diào)用close方法
                    Method closeMethod = dataSource.getClass().getMethod("close");
                    closeMethod.invoke(dataSource);
                    logger.info("Closed datasource: {}", name);
                }
            } catch (Exception e) {
                logger.error("Error closing datasource: {}", name, e);
            }
        });
    }
    
    private static void performCustomCleanup(ApplicationContext context) {
        // 這里可以添加應(yīng)用特有的清理邏輯
        logger.info("Performing custom cleanup tasks");
        
        // 例如：保存應(yīng)用狀態(tài)
        // 例如：釋放本地資源
        // 例如：發(fā)送關(guān)閉通知給其他系統(tǒng)
    }
    
    @Bean
    public ExecutorService applicationTaskExecutor() {
        return Executors.newFixedThreadPool(10);
    }
    
    @RestController
    @RequestMapping("/api")
    static class ApiController {
        
        @Autowired
        private ExecutorService applicationTaskExecutor;
        
        @GetMapping("/task")
        public String submitTask() {
            applicationTaskExecutor.submit(() -> {
                try {
                    logger.info("Task started, will run for 30 seconds");
                    Thread.sleep(30000);
                    logger.info("Task completed");
                } catch (InterruptedException e) {
                    logger.info("Task interrupted");
                    Thread.currentThread().interrupt();
                }
            });
            return "Task submitted";
        }
    }
}