Quartz定时器定时执行业务程序

最新推荐文章于 2024-04-27 17:30:34 发布

苍海笛声

最新推荐文章于 2024-04-27 17:30:34 发布

阅读量606

点赞数 1

文章标签： java spring spring boot

本文链接：https://blog.csdn.net/qq_41946060/article/details/127512248

版权

1、导入相关依赖包

 <dependency>
     <groupId>org.springframework.boot</groupId>
     <artifactId>spring-boot-starter-quartz</artifactId>
     <version>2.2.6.RELEASE</version>
  </dependency>

    <dependency><!-- 该依赖必加，里面有sping对schedule的支持 -->
            <groupId>org.springframework</groupId>
            <artifactId>spring-context-support</artifactId>
        </dependency>
        <dependency>
            <groupId>org.quartz-scheduler</groupId>
            <artifactId>quartz</artifactId>
            <version>2.2.3</version>
        </dependency>
        <dependency>
            <groupId>org.quartz-scheduler</groupId>
            <artifactId>quartz-jobs</artifactId>
            <version>2.2.3</version>
        </dependency>

2、创建一个QuartzUtils工具类内容如下

public class QuartzUtils {
    /**
     * 创建定时任务 定时任务创建之后默认启动状态
     *
     * @param scheduler  调度器
     * @param quartzBean 定时任务信息类
     * @throws Exception
     */
    public static void createScheduleJob(Scheduler scheduler, QuartzBean quartzBean) {
        try {
            //获取到定时任务的执行类  必须是类的绝对路径名称
            //定时任务类需要是job类的具体实现 QuartzJobBean是job的抽象类。
            Class<? extends Job> jobClass = (Class<? extends Job>) Class.forName(quartzBean.getJobClass());
            // 构建定时任务信息->jobName就是QuartzBean类里面的变量，根据自己实际命明的来
            JobDetail jobDetail = JobBuilder.newJob(jobClass).withIdentity(quartzBean.getJobName()).usingJobData("jobName",quartzBean.getJobName()).build();
            // 设置定时任务执行方式
            CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(quartzBean.getCronExpression());
            // 构建触发器trigger
            CronTrigger trigger = TriggerBuilder.newTrigger().withIdentity(quartzBean.getJobName()).withSchedule(scheduleBuilder).build();
            scheduler.scheduleJob(jobDetail, trigger);
         } catch (ClassNotFoundException e) {
            System.out.println("定时任务类路径出错：请输入类的绝对路径");
        } catch (SchedulerException e) {
            System.out.println("创建定时任务出错：" + e.getMessage());
        }
    }

    /**
     * 根据任务名称暂停定时任务
     *
     * @param scheduler 调度器
     * @param jobName   定时任务名称
     * @throws SchedulerException
     */
    public static void pauseScheduleJob(Scheduler scheduler, String jobName) {
        JobKey jobKey = JobKey.jobKey(jobName);
        try {
            scheduler.pauseJob(jobKey);
        } catch (SchedulerException e) {
            System.out.println("暂停定时任务出错：" + e.getMessage());
        }
    }

    /**
     * 根据任务名称恢复定时任务
     *
     * @param scheduler 调度器
     * @param jobName   定时任务名称
     * @throws SchedulerException
     */
    public static void resumeScheduleJob(Scheduler scheduler, String jobName) {
        JobKey jobKey = JobKey.jobKey(jobName);
        try {
            scheduler.resumeJob(jobKey);
        } catch (SchedulerException e) {
            System.out.println("启动定时任务出错：" + e.getMessage());
        }
    }

    /**
     * 根据任务名称立即运行一次定时任务
     *
     * @param scheduler 调度器
     * @param jobName   定时任务名称
     * @throws SchedulerException
     */
    public static void runOnce(Scheduler scheduler, String jobName) {
        JobKey jobKey = JobKey.jobKey(jobName);
        try {
            scheduler.triggerJob(jobKey);
        } catch (SchedulerException e) {
            System.out.println("运行定时任务出错：" + e.getMessage());
        }
    }

    /**
     * 更新定时任务
     *
     * @param scheduler  调度器
     * @param quartzBean 定时任务信息类
     * @throws SchedulerException
     */
    public static void updateScheduleJob(Scheduler scheduler, QuartzBean quartzBean) {
        try {
            //获取到对应任务的触发器
            TriggerKey triggerKey = TriggerKey.triggerKey(quartzBean.getJobName());
            //设置定时任务执行方式
            CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(quartzBean.getCronExpression());
            //重新构建任务的触发器trigger
            CronTrigger trigger = (CronTrigger) scheduler.getTrigger(triggerKey);
            trigger = trigger.getTriggerBuilder().withIdentity(triggerKey).withSchedule(scheduleBuilder).build();
            //重置对应的job
            scheduler.rescheduleJob(triggerKey, trigger);
        } catch (SchedulerException e) {
            System.out.println("更新定时任务出错：" + e.getMessage());
        }
    }

    /**
     * 根据定时任务名称从调度器当中删除定时任务
     *
     * @param scheduler 调度器
     * @param jobName   定时任务名称
     * @throws SchedulerException
     */
    public static void deleteScheduleJob(Scheduler scheduler, String jobName) {
        JobKey jobKey = JobKey.jobKey(jobName);
        try {
            scheduler.deleteJob(jobKey);
        } catch (SchedulerException e) {
            System.out.println("删除定时任务出错：" + e.getMessage());
        }
    }

}

3、创建一个业务程序类TaskTest并继承QuartzJobBean类

@Configurable
@Component
public class TaskTest extends QuartzJobBean {
    @Override
    protected void executeInternal(JobExecutionContext jobExecutionContext) throws JobExecutionException {
        //TODO 这里写定时任务的执行逻辑
        JobDetail detail = jobExecutionContext.getJobDetail();//获取任务工具类里边传入的参数
        String jobName = detail.getJobDataMap().getString("jobName");//因为任务工具类里面写的 
        是jobName，所以保持一致
        System.out.println("动态的定时任务执行时间："+jobName);
    }
}

4、创建一个测试类，测试一下是否可以正常运行TaskTestController，并在启动类加上

@EnableScheduling注解

@RestController
@RequestMapping("/api/quartz/")
public class QuartzController {

    @Autowired
    private Scheduler scheduler;

    @Autowired
    private AreaInfoService areaInfoService;

    @RequestMapping("/createJob")
    @ResponseBody
    public String createJob(QuartzBean quartzBean) {
        try {
            //进行测试所以写死
            String classPath=TaskTest.class.toString();
            quartzBean.setJobClass(classPath.substring(6,classPath.length()));
            UUID uuid = UUID.randomUUID();
            quartzBean.setJobName(uuid.toString());
            String cron="*/5 * * * * ?";
            quartzBean.setCronExpression(cron);
            QuartzUtils.createScheduleJob(scheduler, quartzBean);
        } catch (Exception e) {
            return "创建失败";
        }
        return "创建成功";
    }

    @RequestMapping("/pauseJob")
    @ResponseBody
    public String pauseJob(String jobName) {
        try {
            QuartzUtils.pauseScheduleJob(scheduler, jobName);
        } catch (Exception e) {
            return "暂停失败";
        }
        return "暂停成功";
    }

    @RequestMapping("/runOnce")
    @ResponseBody
    public String runOnce(String jobName) {
        try {
            QuartzUtils.runOnce(scheduler, jobName);
        } catch (Exception e) {
            return "运行一次失败";
        }
        return "运行一次成功";
    }

    @RequestMapping("/resume")
    @ResponseBody
    public String resume(String jobName) {
        try {
            QuartzUtils.resumeScheduleJob(scheduler, jobName);
        } catch (Exception e) {
            return "启动失败";
        }
        return "启动成功";
    }

    @RequestMapping("/update")
    @ResponseBody
    public String update(QuartzBean quartzBean) {
        try {
            //进行测试所以写死
            String classPath=TaskTest.class.toString();
            quartzBean.setJobClass(classPath.substring(6,classPath.length()));
            quartzBean.setCronExpression("10 * * * * ?");
            QuartzUtils.updateScheduleJob(scheduler, quartzBean);
        } catch (Exception e) {
            return "启动失败";
        }
        return "启动成功";
    }
    @GetMapping("deleteScheduleJob")
    public String deleteScheduleJob(String jobName){
        try{
            QuartzUtils.deleteScheduleJob(scheduler,jobName);
        }catch (Exception e){
            e.printStackTrace();
            return "删除失败";
        }
        return "删除成功";
    }
}

5、运行结果

6、这里设置服务器重启或重新部署后，定时器自启

6.1、创建一个QuartzTask类并实现ServletContexeAware接口

@Component
public class QuartzTask implements ServletContextAware {
    private static final Logger logger = LoggerFactory.getLogger(DayScheduledTask.class);
    @Autowired
    private Scheduler scheduler;
    @Autowired
    private ImmuneReportMapper immuneReportMapper;

    /**
     * 服务重启自动调用定时器
     *
     * @param servletContext
     */
    @Override
    public void setServletContext(ServletContext servletContext) {//根据自己的实际业务场景去写，这是我写的一个样列
        logger.info("任务开始创建");
        ImmuneReport immuneReport = new ImmuneReport();
        List<ImmuneReport> list = immuneReportMapper.list(immuneReport);
        if (list.size() > 0) {
            ImmuneReport report = list.get(0);
            if (report.getReportStatus() == 1) {
                QuartzBean quartzBean = new QuartzBean();
                quartzBean.setJobName("test");
                quartzBean.setJobClass("com.airport.task.DayScheduledTask");
                List<String> days = Arrays.stream(report.getReportTime().split(":")).collect(Collectors.toList());
                StringBuilder builder = new StringBuilder();
                //设置定时器
                builder.append(days.get(2)).append(" ").append(days.get(1)).append(" ").append(days.get(0)).append(" * * ?");
                quartzBean.setCronExpression(builder.toString());
                QuartzUtils.createScheduleJob(scheduler, quartzBean);
                builder=null;
                quartzBean=null;
            }
        }
        immuneReport=null;
        logger.info("任务创建结束");
    }
}

到此关于Quartz定时器定时执行业务程序就结束了