quartz 常规增删改查方法

1.controller封装

@RestController
@RequestMapping("/api")
public class SchedulerJobController {

    private Logger logger = LoggerFactory.getLogger(SchedulerJobController.class);

    @Autowired
    private SchedulerJobService schedulerJobService;

    /**
     * 获取所有任务
     * @param pageNum
     * @param pageSize
     * @return
     */
    @PostMapping("/getAllJobs")
    public Map<String, Object> getAllJobs(@RequestParam("pageNum") Integer pageNum, @RequestParam("pageSize") Integer pageSize){
        logger.info("getAllJobs：Request{pageNum：" + pageNum + ",pageSize：" + pageSize + "}");
        PageInfo<ScheduleJob> jobList = schedulerJobService.getAllScheduleJob(pageNum,pageSize);
        Map<String, Object> resultMap = new HashMap<String, Object>();
        resultMap.put("errCode",200);
        resultMap.put("errMsg","查询任务成功");
        resultMap.put("jobList", jobList.getList());
        resultMap.put("count", jobList.getTotal());
        resultMap.put("begin", pageNum);
        logger.info("getAllJobs：Response" + JSON.toJSONString(resultMap));
        return resultMap;
    }

    /**
     * 更新或者添加一个任务
     * @param scheduleJobStr
     * @return
     * @throws Exception
     */
    @PostMapping("/saveOrUpdate")
    public Map<String, Object> addOrUpdateJob(@RequestBody String scheduleJobStr) throws Exception {
        logger.info("addOrUpdateJob：Request" + scheduleJobStr);
        Map<String,Object> scheduleMap = JSON.parseObject(scheduleJobStr);
        String branchOrgInfo = scheduleMap.get("branchOrgInfo").toString();
        String settlement = scheduleMap.get("settlement").toString();
        Map<String,String> paramMap = new HashMap<>();
        paramMap.put("branchOrgCode",branchOrgInfo);
        paramMap.put("settlement",settlement);
        scheduleMap.put("params",JSON.toJSONString(paramMap));
        scheduleJobStr = JSON.toJSONString(scheduleMap);
        ScheduleJob scheduleJob = JSON.parseObject(scheduleJobStr,ScheduleJob.class);
        int flag = schedulerJobService.saveOrUpdate(scheduleJob);
        Map<String,Object> resultMap = new HashMap<String,Object>();
        if(flag == 1) {
            resultMap.put("errCode",200);
            resultMap.put("errMsg","添加任务成功");
        } else {
            resultMap.put("errCode",200);
            resultMap.put("errMsg","更新任务成功");
        }
        logger.info("addOrUpdateJob：success");
        logger.info("addOrUpdateJob：Response" + JSON.toJSONString(resultMap));
        return resultMap;
    }

    /**
     * 暂停任务
     * @param scheduleJobStr
     * @return
     * @throws SchedulerException
     */
    @PostMapping("/pausejob")
    public Map<String,Object> pauseJob(@RequestBody String scheduleJobStr) throws SchedulerException {
        logger.info("pausejob：Request" + scheduleJobStr);
        ScheduleJob scheduleJob = JSON.parseObject(scheduleJobStr,ScheduleJob.class);
        schedulerJobService.pauseJob(scheduleJob.getJobName(),scheduleJob.getJobGroup());
        Map<String,Object> resultMap = new HashMap<String,Object>();
        resultMap.put("errCode",200);
        resultMap.put("errMsg","暂停任务成功");
        logger.info("pauseJob：Response" + JSON.toJSONString(resultMap));
        return resultMap;
    }

    /**
     * 删除任务
     * @param scheduleJobStr
     * @return
     * @throws SchedulerException
     */
    @PostMapping("/deleteJob")
    public Map<String,Object> deleteJob(@RequestBody String scheduleJobStr) throws SchedulerException {
        logger.info("deleteJob：Request" + scheduleJobStr);
        ScheduleJob scheduleJob = JSON.parseObject(scheduleJobStr,ScheduleJob.class);
        schedulerJobService.deleteJob(scheduleJob.getJobName(),scheduleJob.getJobGroup());
        Map<String,Object> resultMap = new HashMap<String,Object>();
        resultMap.put("errCode",200);
        resultMap.put("errMsg","删除任务成功");
        logger.info("deleteJob：Response" + JSON.toJSONString(resultMap));
        return resultMap;
    }

    /**
     * 运行一次任务
     * @param scheduleJobStr
     * @return
     * @throws SchedulerException
     */
    @PostMapping("/runOneJob")
    public Map<String,Object> runJob(@RequestBody String scheduleJobStr) throws SchedulerException {
        logger.info("runOneJob：Request" + scheduleJobStr);
        ScheduleJob scheduleJob = JSON.parseObject(scheduleJobStr,ScheduleJob.class);
        schedulerJobService.runOneJob(scheduleJob.getJobName(),scheduleJob.getJobGroup());
        Map<String,Object> resultMap = new HashMap<String,Object>();
        resultMap.put("errCode",200);
        resultMap.put("errMsg","运行一次任务成功");
        logger.info("runOneJob：Response" + JSON.toJSONString(resultMap));
        return resultMap;
    }

    /**
     * 重启一个定时任务
     * @param scheduleJobStr
     * @return
     * @throws SchedulerException
     */
    @PostMapping("/resumeJob")
    public Object resumeJob(@RequestBody String scheduleJobStr) throws SchedulerException {
        logger.info("resumeJob：Request" + scheduleJobStr);
        ScheduleJob scheduleJob = JSON.parseObject(scheduleJobStr,ScheduleJob.class);
        schedulerJobService.resumeJob(scheduleJob.getJobName(),scheduleJob.getJobGroup());
        Map<String,Object> resultMap = new HashMap<String,Object>();
        resultMap.put("errCode",200);
        resultMap.put("errMsg","重启任务成功");
        logger.info("resumeJob：Response" + JSON.toJSONString(resultMap));
        return resultMap;
    }
}

2.service

public interface SchedulerJobService {

    PageInfo<ScheduleJob> getAllScheduleJob(Integer pageNum, Integer pageSize);

    int saveOrUpdate(ScheduleJob scheduleJob) throws Exception;

    public void pauseJob(String jobName, String jobGroup) throws SchedulerException;

    public void deleteJob(String jobName,String jobGroup) throws SchedulerException;

    public void runOneJob(String jobName, String jobGroup) throws SchedulerException;

    public void resumeJob(String jobName, String jobGroup) throws SchedulerException;

    void checkNotNull(ScheduleJob scheduleJob);
}

@Service
@Transactional
public class SchedulerJobServiceImpl implements SchedulerJobService {

    private Logger logger = LoggerFactory.getLogger(SchedulerJobServiceImpl.class);

    @Autowired
    private SchedulerJobInService schedulerJobInService;
    @Autowired
    private Scheduler scheduler;

    @Override
    public PageInfo<ScheduleJob> getAllScheduleJob(Integer pageNum, Integer pageSize) {
        PageHelper.startPage(pageNum,pageSize);
        List<ScheduleJob> scheduleJobs = schedulerJobInService.selectAllJobs();
        PageInfo<ScheduleJob> page = new PageInfo<ScheduleJob>(scheduleJobs);
        return page;
    }

    @Override
    public int saveOrUpdate(ScheduleJob scheduleJob) throws Exception {
        int flag = 0;
        TriggerKey triggerKey = TriggerKey.triggerKey(scheduleJob.getJobGroup(),scheduleJob.getJobGroup());
        CronTrigger cronTrigger = (CronTrigger) scheduler.getTrigger(triggerKey);
        if (cronTrigger==null){
            logger.info("添加任务----------------/addJob");
            addJob(scheduleJob);
            flag = 1;
        }else {
            logger.info("更新任务----------------/updateJob");
            updateJobSchedule(scheduleJob);
        }
        return flag;
    }

    @Override
    public void pauseJob(String jobName, String jobGroup) throws SchedulerException {
        logger.info("暂停任务----------------/pausejob");
        JobKey jobKey = JobKey.jobKey(jobGroup,jobGroup);
        ScheduleJob scheduleJob = schedulerJobInService.selectByJobNameAngJobGroup(jobName,jobGroup);
        scheduleJob.setJobStatus("0");
        scheduler.pauseJob(jobKey);
        schedulerJobInService.updateByPrimaryKeySelective(scheduleJob);
    }

    @Override
    public void deleteJob(String jobName, String jobGroup) throws SchedulerException {
        logger.info("删除任务----------------/deleteJob");
        ScheduleJob jobKey = new ScheduleJob();
        jobKey.setJobName(jobName);
        jobKey.setJobGroup(jobGroup);
        TriggerKey triggerKey = TriggerKey.triggerKey(jobGroup, jobGroup);
        // 停止触发器
        scheduler.pauseTrigger(triggerKey);
        // 移除触发器
        scheduler.unscheduleJob(triggerKey);
        // 删除任务
        scheduler.deleteJob(JobKey.jobKey(jobGroup, jobGroup));
        schedulerJobInService.deleteByJobNameAndJobGroup(jobKey);
        logger.info("deleteJob:" + JobKey.jobKey(jobName));
    }

    @Override
    public void runOneJob(String jobName, String jobGroup) throws SchedulerException {
        logger.info("运行一次任务----------------/runOneJob");
        JobKey jobKey = JobKey.jobKey(jobGroup, jobGroup);
        ScheduleJob scheduleJob = schedulerJobInService.selectByJobNameAngJobGroup(jobName, jobGroup);
        scheduler.triggerJob(jobKey);
        schedulerJobInService.updateByPrimaryKeySelective(scheduleJob);
    }

    @Override
    public void resumeJob(String jobName, String jobGroup) throws SchedulerException {
        logger.info("重启任务----------------/resumeJob");
        JobKey jobKey = JobKey.jobKey(jobGroup,jobGroup);
        ScheduleJob scheduleJob = schedulerJobInService.selectByJobNameAngJobGroup(jobName,jobGroup);
        scheduleJob.setJobStatus("1");
        scheduler.resumeJob(jobKey);
        schedulerJobInService.updateByPrimaryKeySelective(scheduleJob);
    }

    private void addJob(ScheduleJob scheduleJob) throws Exception{
        //校验参数
        checkNotNull(scheduleJob);
        String cronExpression = "";
        if (StringUtils.isBlank(scheduleJob.getNextSchedulTime())) {
            cronExpression = scheduleJob.getCronExpression();
        } else {
            String nextSchedulTime = scheduleJob.getNextSchedulTime();
            logger.info("调度时间----------------->" + nextSchedulTime);
            String now = DateUtil.formatDate(new Date());
            logger.info("当前时间----------------->" + now);
            int index = DateUtil.compareDate(now, nextSchedulTime);
            if (index == 1) {
                logger.info("----------------->调度时间不能小于当前时间");
                throw new BusinessException(9999,"调度时间不能小于当前时间");
            }
            cronExpression = DateUtil.getCron(nextSchedulTime);
        }
        logger.info("cron表达式：" + cronExpression);
        if (StringUtils.isBlank(cronExpression)){
            throw new BusinessException("CronExpression不能为空");
        }
        scheduleJob.setCronExpression(cronExpression);
        scheduleJob.setTriggerName("trigger" + scheduleJob.getJobName());
        scheduleJob.setTriggerGroup(scheduleJob.getJobGroup());
        scheduleJob.setJobStatus("1");
        scheduleJob.setJobRunState("0");
        //构建job信息
        JobDetail jobDetail = JobBuilder.newJob(getCls(scheduleJob.getJobClassName()).getClass())
                .withIdentity(scheduleJob.getJobGroup(),scheduleJob.getJobGroup())
                .withDescription(scheduleJob.getRemark())
                .build();
        jobDetail.getJobDataMap().put("scheduleJob",scheduleJob);
        //表达式调度构建器(即任务执行的时间)
        CronScheduleBuilder cronScheduleBuilder = CronScheduleBuilder.cronSchedule(cronExpression);
        //按新的cronExpression表达式构建一个新的trigger
        CronTrigger cronTrigger = TriggerBuilder.newTrigger()
                .withIdentity(scheduleJob.getJobGroup(),scheduleJob.getJobGroup())
                .withSchedule(cronScheduleBuilder).build();
        //传递的参数
        jobDetail.getJobDataMap().put("jobTaskType", "0");
        jobDetail.getJobDataMap().put("jobType", scheduleJob.getJobType());
        jobDetail.getJobDataMap().put("apiUrl", scheduleJob.getApiUrl());
        jobDetail.getJobDataMap().put("params", scheduleJob.getParams());
        //交由Scheduler安排触发
        scheduler.scheduleJob(jobDetail,cronTrigger);
        schedulerJobInService.insertSelective(scheduleJob);
        if("1".equals(scheduleJob.getIsNowRun())) { // 如果是立即运行则首先触发一次任务
            JobKey key = new JobKey(scheduleJob.getJobGroup(), scheduleJob.getJobGroup());
            scheduler.triggerJob(key, jobDetail.getJobDataMap());
        }
    }

    private void updateJobSchedule(ScheduleJob scheduleJob) throws Exception{
        //校验参数
        checkNotNull(scheduleJob);
        String cronExpression = "";
        if (StringUtils.isBlank(scheduleJob.getNextSchedulTime())) {
            cronExpression = scheduleJob.getCronExpression();
        } else {
            String nextSchedulTime = scheduleJob.getNextSchedulTime();
            logger.info("调度时间----------------->" + nextSchedulTime);
            String now = DateUtil.formatDate(new Date());
            logger.info("当前时间----------------->" + now);
            int index = DateUtil.compareDate(now, nextSchedulTime);
            if (index == 1) {
                logger.info("------------------>调度时间不能小于当前时间");
                throw new BusinessException(9999,"调度时间不能小于当前时间");
            }
            cronExpression = DateUtil.getCron(nextSchedulTime);
        }
        logger.info("cron表达式：" + cronExpression);
        if (StringUtils.isBlank(cronExpression)){
            throw new BusinessException("CronExpression不能为空");
        }
        scheduleJob.setCronExpression(cronExpression);
        String jobName = scheduleJob.getJobName();
        String jobGroup = scheduleJob.getJobGroup();
        ScheduleJob job = schedulerJobInService.selectByJobNameAngJobGroup(jobName,jobGroup);
        if(job == null || job.equals("")) {
            throw new BusinessException("null Job, please check it");
        }
        scheduleJob.setJobId(job.getJobId());
        //移除任务
        TriggerKey triggerKey = TriggerKey.triggerKey(jobGroup, jobGroup);
        // 停止触发器
        scheduler.pauseTrigger(triggerKey);
        // 移除触发器
        scheduler.unscheduleJob(triggerKey);
        // 删除任务
        scheduler.deleteJob(JobKey.jobKey(jobGroup, jobGroup));
        //构建job信息
        JobDetail jobDetail = JobBuilder.newJob(getCls(scheduleJob.getJobClassName()).getClass())
                .withIdentity(jobGroup,jobGroup)
                .withDescription(scheduleJob.getRemark())
                .build();
        jobDetail.getJobDataMap().put("scheduleJob",scheduleJob);
        //表达式调度构建器(即任务执行的时间)
        CronScheduleBuilder cronScheduleBuilder = CronScheduleBuilder.cronSchedule(cronExpression);
        //按新的cronExpression表达式构建一个新的trigger
        CronTrigger cronTrigger = TriggerBuilder.newTrigger()
                .withIdentity(jobGroup,jobGroup)
                .withSchedule(cronScheduleBuilder).build();
        //传递的参数
        jobDetail.getJobDataMap().put("jobTaskType", "0");
        jobDetail.getJobDataMap().put("jobType", scheduleJob.getJobType());
        jobDetail.getJobDataMap().put("apiUrl", scheduleJob.getApiUrl());
        jobDetail.getJobDataMap().put("params", scheduleJob.getParams());
        //交由Scheduler安排触发
        scheduler.scheduleJob(jobDetail,cronTrigger);
        scheduleJob.setJobStatus("1");
        scheduleJob.setJobRunState("0");
        schedulerJobInService.updateByPrimaryKeySelective(scheduleJob);
        if("1".equals(scheduleJob.getIsNowRun())) { // 如果是立即运行则首先触发一次任务
            JobKey key = new JobKey(jobGroup, jobGroup);
            scheduler.triggerJob(key, jobDetail.getJobDataMap());
        }
    }

    /**
     * 校验参数
     * @param scheduleJob
     */
    @Override
    public void checkNotNull(ScheduleJob scheduleJob) {
        if (scheduleJob==null){
            throw new BusinessException("scheduleJob is null,Please check it");
        }
        if (scheduleJob.getJobName()==null || scheduleJob.getJobName().equals("")){
            throw new BusinessException("the jobName of scheduleJob is null,Please check it");
        }
        if (scheduleJob.getJobGroup()==null || scheduleJob.getJobGroup().equals("")){
            throw new BusinessException("the jobGroup of scheduleJob is null,Please check it");
        }
    }

    /**
     * 根据类名称，通过反射得到该类，然后创建一个BaseJob的实例。
     * 由于NewJob和HelloJob都实现了BaseJob，
     * 所以这里不需要我们手动去判断。这里涉及到了一些java多态调用的机制
     *
     * @param classname
     * @return
     * @throws Exception
     */
    public static BaseJob getCls(String classname) throws Exception {
        Class<?> class1 = Class.forName(classname);
        return (BaseJob)class1.newInstance();
    }
}