java实现定时任务

pom.xml

导入依赖配置，这里只是quartz的

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

service

package com.shengun.ssm.service;

public interface SystemSchedulerService {
    /**
     * 添加
     *
     * @param name
     * @param group
     * @param cron
     * @return
     */
    boolean addScheduler(String name, String group, String cron);

    /**
     * 修改
     *
     * @param jobDetailName
     * @param jobDetailGroup
     * @param cron
     * @return
     */
    boolean updateScheduler(String jobDetailName, String jobDetailGroup, String cron);

    /**
     * 删除
     *
     * @param jobDetailName
     * @param jobDetailGroup
     * @return
     */
    boolean deleteScheduler(String jobDetailName, String jobDetailGroup);

    /**
     * 暂停
     *
     * @param jobDetailName
     * @param jobDetailGroup
     * @return
     */
    boolean puaseScheduler(String jobDetailName, String jobDetailGroup);

    /**
     * 恢复
     *
     * @param jobDetailName
     * @param jobDetailGroup
     * @return
     */
    boolean resumeScheduler(String jobDetailName, String jobDetailGroup);
}

service实现类

package com.shengun.ssm.service.impl;

import com.shengun.ssm.job.QuartzSchedulerJob;
import com.shengun.ssm.service.SystemSchedulerService;
import org.quartz.*;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class SystemSchedulerServiceImpl implements SystemSchedulerService {

    @Autowired
    private Scheduler scheduler;

    @Override
    public boolean addScheduler(String name, String group, String cron) {
        try {
            JobDetail jobDetail = JobBuilder.newJob(QuartzSchedulerJob.class)//绑定一个具体工作类
                    .withIdentity(name, group) //设置一个标识，分组以及名字
                    .usingJobData("jobData", name) //传递到具体工作的数据，可以多个，获取根据dataKey获取即可
                    .usingJobData("executeData", "测试")
                    .build();
            Trigger trigger = TriggerBuilder.newTrigger()
                    .withIdentity(name, group)//设置一个触发器标识,这里设置了跟JobDetail使用一样的命名以及分组
                    .forJob(jobDetail)//绑定trigger到jobdetail
                    .withSchedule(CronScheduleBuilder.cronSchedule(cron))
                    .build();
            scheduler.scheduleJob(jobDetail, trigger);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    @Override
    public boolean updateScheduler(String jobDetailName, String jobDetailGroup, String cron) {
        try {
            JobKey jobKey = JobKey.jobKey(jobDetailName, jobDetailGroup);
            if (!CronExpression.isValidExpression(cron) || !scheduler.checkExists(jobKey)) {
                return false;
            }
            //triggerKey为添加定时任务时配置的name,group，这里是添加的时候设置的name跟group跟jobdetail是一样的
            TriggerKey triggerKey = TriggerKey.triggerKey(jobDetailName, jobDetailGroup);
            Trigger newTrigger = TriggerBuilder
                    .newTrigger()
                    .withIdentity(triggerKey)
                    .withSchedule(CronScheduleBuilder.cronSchedule(cron)).build();

//            CronTrigger newTrigger = (CronTrigger) scheduler.getTrigger(triggerKey);
//            CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(cron);
//            trigger = trigger.getTriggerBuilder().withIdentity(triggerKey).withSchedule(scheduleBuilder).build();

            scheduler.rescheduleJob(triggerKey, newTrigger);
            return true;
        } catch (SchedulerException e) {
            e.printStackTrace();
            return false;
        }
    }

    @Override
    public boolean deleteScheduler(String jobDetailName, String jobDetailGroup) {
        try {
            JobKey jobKey = JobKey.jobKey(jobDetailName, jobDetailGroup);
            if (!scheduler.checkExists(jobKey)) {
                return false;
            }
            scheduler.deleteJob(jobKey);
            return true;
        } catch (SchedulerException e) {
            e.printStackTrace();
            return false;
        }
    }

    @Override
    public boolean puaseScheduler(String jobDetailName, String jobDetailGroup) {
        try {
            JobKey jobKey = JobKey.jobKey(jobDetailName, jobDetailGroup);
            if (!scheduler.checkExists(jobKey)) {
                return false;
            }
            scheduler.pauseJob(jobKey);
            return true;
        } catch (SchedulerException e) {
            e.printStackTrace();
            return false;
        }
    }

    @Override
    public boolean resumeScheduler(String jobDetailName, String jobDetailGroup) {
        try {
            JobKey jobKey = JobKey.jobKey(jobDetailName, jobDetailGroup);
            if (!scheduler.checkExists(jobKey)) {
                return false;
            }
            scheduler.resumeJob(jobKey);
            return true;
        } catch (SchedulerException e) {
            e.printStackTrace();
            return false;
        }
    }
}

controller

package com.shengun.ssm.controller;

import com.shengun.annotation.OperationAnnotation;
import com.shengun.ssm.service.SystemSchedulerService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class SystemSchedulerController {

    @Autowired
    private SystemSchedulerService systemSchedulerService;

    @PostMapping("/add")
    @OperationAnnotation(content = "添加定时任务方法")
    public boolean add(@RequestParam String name, @RequestParam String group, @RequestParam String cron) {
        return systemSchedulerService.addScheduler(name, group, cron);
    }
    @PostMapping("/update")
    @OperationAnnotation(content = "修改定时任务方法")
    public boolean update(@RequestParam String name, @RequestParam String group, @RequestParam String cron) {
        return systemSchedulerService.updateScheduler(name, group, cron);
    }
    @PostMapping("/delete")
    @OperationAnnotation(content = "删除定时任务方法")
    public boolean delete(@RequestParam String name, @RequestParam String group) {
        return systemSchedulerService.deleteScheduler(name, group);
    }

    @PostMapping("/puase")
    @OperationAnnotation(content = "暂停定时任务方法")
    public boolean puase(@RequestParam String name, @RequestParam String group) {
        return systemSchedulerService.puaseScheduler(name, group);
    }

    @PostMapping("/resume")
    @OperationAnnotation(content = "恢复定时任务方法")
    public boolean resume(@RequestParam String name, @RequestParam String group) {
        return systemSchedulerService.resumeScheduler(name, group);
    }
}

SystemSchedulerInit配置文件

package com.shengun.ssm.config;

import com.shengun.ssm.service.SystemSchedulerService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.ApplicationArguments;
import org.springframework.boot.ApplicationRunner;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.annotation.EnableScheduling;

@Configuration
@EnableScheduling
public class SystemSchedulerInit implements ApplicationRunner {

    @Autowired
    private SystemSchedulerService systemSchedulerService;

    @Override
    public void run(ApplicationArguments args) throws Exception {
        systemSchedulerService.addScheduler("小猪佩奇", "动物组", "0/5 * * * * ?");
        systemSchedulerService.addScheduler("铁壁阿童木", "机器人组", "0/5 * * * * ?");
    }
}

QuartzSchedulerJob 定时任务

package com.shengun.ssm.job;

import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.springframework.scheduling.quartz.QuartzJobBean;

import java.time.LocalDateTime;

/**
 * 定时任务
 */
public class QuartzSchedulerJob extends QuartzJobBean {
    @Override
    protected void executeInternal(JobExecutionContext jobExecutionContext) throws JobExecutionException {
        String group = jobExecutionContext.getJobDetail().getKey().getGroup();
        switch (group) {
            case "动物组":
                System.out.println("定时任务动物组工作：" + jobExecutionContext.getJobDetail().getKey().getName()
                        + " 当前时间：" + LocalDateTime.now());
                break;
            case "机器人组":
                System.out.println("定时任务机器人组工作：" + jobExecutionContext.getJobDetail().getKey().getName()
                        + " 当前时间：" + LocalDateTime.now());
                break;
        }
    }
}