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

@SpringBootApplication
@EnableScheduling
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

@Service
public class OrderService {
    private static final Logger logger = LoggerFactory.getLogger(OrderService.class);
    // 模擬訂單存儲
    private Map<Long, Order> orderMap = new ConcurrentHashMap<>();
    private AtomicLong idGenerator = new AtomicLong(0);
    /**
     * 創(chuàng)建新訂單
     */
    public Order createOrder(Order order) {
        Long orderId = idGenerator.incrementAndGet();
        order.setId(orderId);
        order.setCreateTime(new Date());
        order.setStatus(OrderStatus.CREATED);
        orderMap.put(orderId, order);
        logger.info("創(chuàng)建訂單成功，訂單ID: {}", orderId);
        return order;
    }
    /**
     * 檢查并處理超時訂單
     */
    public void checkAndCloseTimeoutOrders() {
        Date now = new Date();
        int timeoutMinutes = 30;
        for (Order order : orderMap.values()) {
            if (OrderStatus.CREATED.equals(order.getStatus())) {
                long diffInMillis = now.getTime() - order.getCreateTime().getTime();
                long diffInMinutes = diffInMillis / (1000 * 60);
                if (diffInMinutes >= timeoutMinutes) {
                    order.setStatus(OrderStatus.CLOSED);
                    order.setCloseTime(now);
                    logger.info("訂單超時已關(guān)閉，訂單ID: {}", order.getId());
                }
            }
        }
    }
    /**
     * 獲取訂單狀態(tài)
     */
    public OrderStatus getOrderStatus(Long orderId) {
        Order order = orderMap.get(orderId);
        return order != null ? order.getStatus() : null;
    }
}
/**
 * 訂單狀態(tài)枚舉
 */
public enum OrderStatus {
    CREATED,     // 已創(chuàng)建
    PAID,        // 已支付
    CLOSED       // 已關(guān)閉
}
/**
 * 訂單實體類
 */
public class Order {
    private Long id;
    private String productName;
    private BigDecimal amount;
    private Date createTime;
    private Date closeTime;
    private OrderStatus status;
    // 省略getter和setter方法
}

@Component
public class OrderTimeoutScheduler {
    private static final Logger logger = LoggerFactory.getLogger(OrderTimeoutScheduler.class);
    @Autowired
    private OrderService orderService;
    /**
     * 每5分鐘檢查一次超時訂單
     * 使用cron表達式：每5分鐘執(zhí)行一次
     */
    @Scheduled(cron = "0 */5 * * * ?")
    public void checkOrderTimeout() {
        logger.info("開始執(zhí)行訂單超時檢查任務...");
        long startTime = System.currentTimeMillis();
        try {
            orderService.checkAndCloseTimeoutOrders();
        } catch (Exception e) {
            logger.error("訂單超時檢查任務執(zhí)行失敗", e);
        }
        long endTime = System.currentTimeMillis();
        logger.info("訂單超時檢查任務執(zhí)行完成，耗時：{}ms", (endTime - startTime));
    }
    /**
     * 另一種方式：固定延遲執(zhí)行
     * 上一次任務執(zhí)行完成后，延遲5分鐘再執(zhí)行
     */
    // @Scheduled(fixedDelay = 5 * 60 * 1000)
    // public void checkOrderTimeoutWithFixedDelay() {
    //     // 實現(xiàn)邏輯
    // }
    /**
     * 固定頻率執(zhí)行
     * 每5分鐘執(zhí)行一次，無論上一次任務是否完成
     */
    // @Scheduled(fixedRate = 5 * 60 * 1000)
    // public void checkOrderTimeoutWithFixedRate() {
    //     // 實現(xiàn)邏輯
    // }
}

@RestController
@RequestMapping("/orders")
public class OrderController {
    @Autowired
    private OrderService orderService;
    @PostMapping
    public ResponseEntity<Order> createOrder(@RequestBody Order order) {
        Order createdOrder = orderService.createOrder(order);
        return ResponseEntity.ok(createdOrder);
    }
    @GetMapping("/{orderId}/status")
    public ResponseEntity<OrderStatus> getOrderStatus(@PathVariable Long orderId) {
        OrderStatus status = orderService.getOrderStatus(orderId);
        return status != null ? 
            ResponseEntity.ok(status) : 
            ResponseEntity.notFound().build();
    }
}

@Configuration
public class SchedulerConfig {
    @Bean
    public TaskScheduler taskScheduler() {
        ThreadPoolTaskScheduler scheduler = new ThreadPoolTaskScheduler();
        scheduler.setPoolSize(10); // 線程池大小
        scheduler.setThreadNamePrefix("scheduled-task-");
        scheduler.setAwaitTerminationSeconds(60);
        scheduler.setWaitForTasksToCompleteOnShutdown(true);
        return scheduler;
    }
}

@Async
@Scheduled(fixedRate = 5000)
public void asyncScheduledTask() {
    // 這個任務會在單獨的線程中異步執(zhí)行
}

@Scheduled(cron = "${order.timeout.cron}")
public void checkOrderTimeout() {
    // ...
}