使用Quartz定时器设置支付订单有效期，并且解决Job类中无法注入Bean的问题

一、支付流程说明

微信小程序支付前后端支付流程实现可看我上一篇文章 微信小程序支付流程及代码实现

在订单支付过程当中，一般会给订单设置一个支付有效期，超过时间未支付则需要关闭此订单。在支付有效期内完成了支付则需要关闭对应的定时器任务，防止触发未支付的处理业务。

 二、Quartz定时器具体实现方式

此处使用Quartz定时器来实现，将订单编号作为参数放入定时器中，并且创建一个在设定时间只执行一次的定时任务。

package com.ruoyi.system.task;

import lombok.extern.slf4j.Slf4j;
import org.quartz.*;

import static org.quartz.JobBuilder.newJob;
import static org.quartz.TriggerBuilder.newTrigger;

/**
 * 定时器创建及销毁
 */
@Slf4j
public class OrderScheduler {

    /**
     * 创建定时任务
     * @param orderNum 支付订单编号
     * @param secondTime 订单支付超时时间（秒）
     * @throws SchedulerException
     */
    public static void scheduleOrderJob(String orderNum, Integer secondTime) throws SchedulerException {
        // 创建Scheduler工厂
        SchedulerFactory schedulerFactory = new org.quartz.impl.StdSchedulerFactory();
        Scheduler scheduler = schedulerFactory.getScheduler();

        // 创建JobDetail，并将订单ID传递给Job
        JobDetail jobDetail = newJob(OrderJob.class)
                .withIdentity(orderNum + "_job", "group1")
                .usingJobData("orderNum", orderNum)
                .build();

        // 创建Trigger，定义任务执行的时间规则
        Trigger trigger = newTrigger()
                .withIdentity(orderNum + "_trigger", "group1")
//                .startNow() // 创建任务之后立即执行一次
                .startAt(DateBuilder.futureDate(secondTime, DateBuilder.IntervalUnit.SECOND)) // 300秒后开始执行，只执行一次会自动删除
//                .withSchedule(cronSchedule("*/10 * * * * ?")) // 每10秒钟执行一次，周期性触发，一直循环，直到手动删除
                .build();

        // 将Job和Trigger关联到Scheduler
        scheduler.scheduleJob(jobDetail, trigger);

        // 启动Scheduler
        scheduler.start();
    }

    /**
     * 销毁定时任务
     * @param orderNum
     * @throws SchedulerException
     */
    public static void unscheduleOrderJob(String orderNum) throws SchedulerException {
        log.info("销毁定时任务[{}]",orderNum + "_job");
        // 创建Scheduler工厂
        SchedulerFactory schedulerFactory = new org.quartz.impl.StdSchedulerFactory();
        Scheduler scheduler = schedulerFactory.getScheduler();

        // 根据订单ID创建JobKey
        JobKey jobKey = new JobKey(orderNum + "_job", "group1");

        // 删除Job和Trigger
        scheduler.deleteJob(jobKey);
    }
}

另外还需要一个处理定时器执行的类，当到达指定时间之后就会执行这个类，来处理后续业务。

package com.ruoyi.system.task;

import com.ruoyi.system.service.impl.FPayOrderServiceImpl;
import lombok.extern.slf4j.Slf4j;
import org.quartz.Job;
import org.quartz.JobDataMap;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.springframework.stereotype.Component;

@Slf4j
@Component
public class OrderJob implements Job {

    @Override
    public void execute(JobExecutionContext context) throws JobExecutionException {

        // 从JobExecutionContext中获取JobDataMap
        JobDataMap jobDataMap = context.getJobDetail().getJobDataMap();
        // 获取订单ID
        String orderNum = jobDataMap.getString("orderNum");
        log.warn("处理超时未支付的订单编号：{}",orderNum);
        //处理超时未支付的订单
        //此方法可以用了解决Job类无法注入Bean的问题
        FPayOrderServiceImpl fPayOrderService1 = AppContextUtil.getBean(FPayOrderServiceImpl.class);
        fPayOrderService1.handleTimeoutPayOrder(orderNum);
    }


}

在实现了quartz的Job类之后，使用常规的 @Autowired 注入是获取不到Bean的，会报空指针异常，所以需要写一个静态工具类，用来解决quartz的Job类无法注入Bean的问题。

package com.ruoyi.system.task;

import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.BeansException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.stereotype.Component;
 
/**
 * 自定义静态工具类，用来解决quartz的Job类无法注入Bean的问题
 * @author kun
 * {@code @date} 2024/1/30
 */
@Component
@Slf4j
public class AppContextUtil implements ApplicationContextAware {
 
    //定义静态ApplicationContext
    private static ApplicationContext applicationContext = null;
 
    /**
     * 重写接口方法，该方法的参数为框架自动加载的IOC容器对象
     * 该方法在启动项目的时候会自动执行，前提是该类上有IOC相关注解，例如@Component
     * @param applicationContext IOC容器
     * @throws BeansException e
     */
    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        //将框架加载的IOC赋值给全局静态IOC
        AppContextUtil.applicationContext = applicationContext;
        log.info("==================ApplicationContext加载-----------------");
    }
 
    //获取 applicationContext
    public static ApplicationContext getApplicationContext(){
        return  applicationContext;
    }
 
    //通过name获取Bean
    public static Object getBean(String name){
        return  applicationContext.getBean(name);
    }
 
    //通过class获取Bean
    public static <T> T getBean(Class<T> clazz){
        return  applicationContext.getBean(clazz);
    }
 
    //通过name、Clazz返回指定Bean
    public static <T> T getBean(String name,Class<T> clazz){
        return  applicationContext.getBean(name,clazz);
    }
}

此时在实现了Job类的方法中使用 AppContextUtil.getBean(需要注入的Bean.class); 就可以获取到这个Bean了

当使用 .startAt（） 方法时，定时器执行一次会自动删除，可以不用调用销毁方法。如果用户在有效期内完成了支付则需要手动销毁定时任务

        try {
            // 销毁定时任务，避免触发定时器
            OrderScheduler.unscheduleOrderJob(queryReturnInfo.getOut_trade_no());
        } catch (Exception e) {
            log.error("销毁定时任务失败");
        }