Spring Scheduler定时任务实战指南(零基础入门任务调度)

<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);
    /**
     * 创建新订单
     */
    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("创建订单成功，订单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("订单超时已关闭，订单ID: {}", order.getId());
                }
            }
        }
    }
    /**
     * 获取订单状态
     */
    public OrderStatus getOrderStatus(Long orderId) {
        Order order = orderMap.get(orderId);
        return order != null ? order.getStatus() : null;
    }
}
/**
 * 订单状态枚举
 */
public enum OrderStatus {
    CREATED,     // 已创建
    PAID,        // 已支付
    CLOSED       // 已关闭
}
/**
 * 订单实体类
 */
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分钟执行一次
     */
    @Scheduled(cron = "0 */5 * * * ?")
    public void checkOrderTimeout() {
        logger.info("开始执行订单超时检查任务...");
        long startTime = System.currentTimeMillis();
        try {
            orderService.checkAndCloseTimeoutOrders();
        } catch (Exception e) {
            logger.error("订单超时检查任务执行失败", e);
        }
        long endTime = System.currentTimeMillis();
        logger.info("订单超时检查任务执行完成，耗时：{}ms", (endTime - startTime));
    }
    /**
     * 另一种方式：固定延迟执行
     * 上一次任务执行完成后，延迟5分钟再执行
     */
    // @Scheduled(fixedDelay = 5 * 60 * 1000)
    // public void checkOrderTimeoutWithFixedDelay() {
    //     // 实现逻辑
    // }
    /**
     * 固定频率执行
     * 每5分钟执行一次，无论上一次任务是否完成
     */
    // @Scheduled(fixedRate = 5 * 60 * 1000)
    // public void checkOrderTimeoutWithFixedRate() {
    //     // 实现逻辑
    // }
}

@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() {
    // 这个任务会在单独的线程中异步执行
}

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