springboot控制quartz任务

1.pom.xml

<!-- 定时器任务 quartz需要导入的坐标 -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context-support</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-tx</artifactId>
        </dependency>
        <dependency>
            <groupId>org.quartz-scheduler</groupId>
            <artifactId>quartz</artifactId>
            <version>2.2.1</version>
        </dependency>

2.需要用到的数据表

/*
 Navicat Premium Data Transfer

 Source Server         : local
 Source Server Type    : MySQL
 Source Server Version : 50527
 Source Host           : localhost:3306
 Source Schema         : demo

 Target Server Type    : MySQL
 Target Server Version : 50527
 File Encoding         : 65001

 Date: 06/06/2018 19:43:17
*/

SET NAMES utf8mb4;
SET FOREIGN_KEY_CHECKS = 0;

-- ----------------------------
-- Table structure for qrtz_blob_triggers
-- ----------------------------
DROP TABLE IF EXISTS `qrtz_blob_triggers`;
CREATE TABLE `qrtz_blob_triggers`  (
  `SCHED_NAME` varchar(120) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL,
  `TRIGGER_NAME` varchar(200) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL,
  `TRIGGER_GROUP` varchar(200) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL,
  `BLOB_DATA` blob,
  PRIMARY KEY (`SCHED_NAME`, `TRIGGER_NAME`, `TRIGGER_GROUP`) USING BTREE,
  CONSTRAINT `qrtz_blob_triggers_ibfk_1` FOREIGN KEY (`SCHED_NAME`, `TRIGGER_NAME`, `TRIGGER_GROUP`) REFERENCES `qrtz_triggers` (`SCHED_NAME`, `TRIGGER_NAME`, `TRIGGER_GROUP`) ON DELETE RESTRICT ON UPDATE RESTRICT
) ENGINE = InnoDB CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Compact;

-- ----------------------------
-- Table structure for qrtz_calendars
-- ----------------------------
DROP TABLE IF EXISTS `qrtz_calendars`;
CREATE TABLE `qrtz_calendars`  (
  `SCHED_NAME` varchar(120) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL,
  `CALENDAR_NAME` varchar(200) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL,
  `CALENDAR` blob NOT NULL,
  PRIMARY KEY (`SCHED_NAME`, `CALENDAR_NAME`) USING BTREE
) ENGINE = InnoDB CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Compact;

-- ----------------------------
-- Table structure for qrtz_cron_triggers
-- ----------------------------
DROP TABLE IF EXISTS `qrtz_cron_triggers`;
CREATE TABLE `qrtz_cron_triggers`  (
  `SCHED_NAME` varchar(120) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL,
  `TRIGGER_NAME` varchar(200) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL,
  `TRIGGER_GROUP` varchar(200) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL,
  `CRON_EXPRESSION` varchar(200) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL,
  `TIME_ZONE_ID` varchar(80) CHARACTER SET utf8 COLLATE utf8_general_ci DEFAULT NULL,
  PRIMARY KEY (`SCHED_NAME`, `TRIGGER_NAME`, `TRIGGER_GROUP`) USING BTREE,
  CONSTRAINT `qrtz_cron_triggers_ibfk_1` FOREIGN KEY (`SCHED_NAME`, `TRIGGER_NAME`, `TRIGGER_GROUP`) REFERENCES `qrtz_triggers` (`SCHED_NAME`, `TRIGGER_NAME`, `TRIGGER_GROUP`) ON DELETE RESTRICT ON UPDATE RESTRICT
) ENGINE = InnoDB CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Compact;

-- ----------------------------
-- Table structure for qrtz_fired_triggers
-- ----------------------------
DROP TABLE IF EXISTS `qrtz_fired_triggers`;
CREATE TABLE `qrtz_fired_triggers`  (
  `SCHED_NAME` varchar(120) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL,
  `ENTRY_ID` varchar(95) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL,
  `TRIGGER_NAME` varchar(200) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL,
  `TRIGGER_GROUP` varchar(200) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL,
  `INSTANCE_NAME` varchar(200) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL,
  `FIRED_TIME` bigint(13) NOT NULL,
  `SCHED_TIME` bigint(13) NOT NULL,
  `PRIORITY` int(11) NOT NULL,
  `STATE` varchar(16) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL,
  `JOB_NAME` varchar(200) CHARACTER SET utf8 COLLATE utf8_general_ci DEFAULT NULL,
  `JOB_GROUP` varchar(200) CHARACTER SET utf8 COLLATE utf8_general_ci DEFAULT NULL,
  `IS_NONCONCURRENT` varchar(1) CHARACTER SET utf8 COLLATE utf8_general_ci DEFAULT NULL,
  `REQUESTS_RECOVERY` varchar(1) CHARACTER SET utf8 COLLATE utf8_general_ci DEFAULT NULL,
  PRIMARY KEY (`SCHED_NAME`, `ENTRY_ID`) USING BTREE
) ENGINE = InnoDB CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Compact;

-- ----------------------------
-- Table structure for qrtz_job_details
-- ----------------------------
DROP TABLE IF EXISTS `qrtz_job_details`;
CREATE TABLE `qrtz_job_details`  (
  `SCHED_NAME` varchar(120) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL,
  `JOB_NAME` varchar(200) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL,
  `JOB_GROUP` varchar(200) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL,
  `DESCRIPTION` varchar(250) CHARACTER SET utf8 COLLATE utf8_general_ci DEFAULT NULL,
  `JOB_CLASS_NAME` varchar(250) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL,
  `IS_DURABLE` varchar(1) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL,
  `IS_NONCONCURRENT` varchar(1) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL,
  `IS_UPDATE_DATA` varchar(1) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL,
  `REQUESTS_RECOVERY` varchar(1) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL,
  `JOB_DATA` blob,
  PRIMARY KEY (`SCHED_NAME`, `JOB_NAME`, `JOB_GROUP`) USING BTREE
) ENGINE = InnoDB CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Compact;

-- ----------------------------
-- Table structure for qrtz_locks
-- ----------------------------
DROP TABLE IF EXISTS `qrtz_locks`;
CREATE TABLE `qrtz_locks`  (
  `SCHED_NAME` varchar(120) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL,
  `LOCK_NAME` varchar(40) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL,
  PRIMARY KEY (`SCHED_NAME`, `LOCK_NAME`) USING BTREE
) ENGINE = InnoDB CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Compact;

-- ----------------------------
-- Table structure for qrtz_paused_trigger_grps
-- ----------------------------
DROP TABLE IF EXISTS `qrtz_paused_trigger_grps`;
CREATE TABLE `qrtz_paused_trigger_grps`  (
  `SCHED_NAME` varchar(120) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL,
  `TRIGGER_GROUP` varchar(200) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL,
  PRIMARY KEY (`SCHED_NAME`, `TRIGGER_GROUP`) USING BTREE
) ENGINE = InnoDB CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Compact;

-- ----------------------------
-- Table structure for qrtz_scheduler_state
-- ----------------------------
DROP TABLE IF EXISTS `qrtz_scheduler_state`;
CREATE TABLE `qrtz_scheduler_state`  (
  `SCHED_NAME` varchar(120) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL,
  `INSTANCE_NAME` varchar(200) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL,
  `LAST_CHECKIN_TIME` bigint(13) NOT NULL,
  `CHECKIN_INTERVAL` bigint(13) NOT NULL,
  PRIMARY KEY (`SCHED_NAME`, `INSTANCE_NAME`) USING BTREE
) ENGINE = InnoDB CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Compact;

-- ----------------------------
-- Table structure for qrtz_simple_triggers
-- ----------------------------
DROP TABLE IF EXISTS `qrtz_simple_triggers`;
CREATE TABLE `qrtz_simple_triggers`  (
  `SCHED_NAME` varchar(120) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL,
  `TRIGGER_NAME` varchar(200) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL,
  `TRIGGER_GROUP` varchar(200) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL,
  `REPEAT_COUNT` bigint(7) NOT NULL,
  `REPEAT_INTERVAL` bigint(12) NOT NULL,
  `TIMES_TRIGGERED` bigint(10) NOT NULL,
  PRIMARY KEY (`SCHED_NAME`, `TRIGGER_NAME`, `TRIGGER_GROUP`) USING BTREE,
  CONSTRAINT `qrtz_simple_triggers_ibfk_1` FOREIGN KEY (`SCHED_NAME`, `TRIGGER_NAME`, `TRIGGER_GROUP`) REFERENCES `qrtz_triggers` (`SCHED_NAME`, `TRIGGER_NAME`, `TRIGGER_GROUP`) ON DELETE RESTRICT ON UPDATE RESTRICT
) ENGINE = InnoDB CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Compact;

-- ----------------------------
-- Table structure for qrtz_simprop_triggers
-- ----------------------------
DROP TABLE IF EXISTS `qrtz_simprop_triggers`;
CREATE TABLE `qrtz_simprop_triggers`  (
  `SCHED_NAME` varchar(120) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL,
  `TRIGGER_NAME` varchar(200) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL,
  `TRIGGER_GROUP` varchar(200) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL,
  `STR_PROP_1` varchar(512) CHARACTER SET utf8 COLLATE utf8_general_ci DEFAULT NULL,
  `STR_PROP_2` varchar(512) CHARACTER SET utf8 COLLATE utf8_general_ci DEFAULT NULL,
  `STR_PROP_3` varchar(512) CHARACTER SET utf8 COLLATE utf8_general_ci DEFAULT NULL,
  `INT_PROP_1` int(11) DEFAULT NULL,
  `INT_PROP_2` int(11) DEFAULT NULL,
  `LONG_PROP_1` bigint(20) DEFAULT NULL,
  `LONG_PROP_2` bigint(20) DEFAULT NULL,
  `DEC_PROP_1` decimal(13, 4) DEFAULT NULL,
  `DEC_PROP_2` decimal(13, 4) DEFAULT NULL,
  `BOOL_PROP_1` varchar(1) CHARACTER SET utf8 COLLATE utf8_general_ci DEFAULT NULL,
  `BOOL_PROP_2` varchar(1) CHARACTER SET utf8 COLLATE utf8_general_ci DEFAULT NULL,
  PRIMARY KEY (`SCHED_NAME`, `TRIGGER_NAME`, `TRIGGER_GROUP`) USING BTREE,
  CONSTRAINT `qrtz_simprop_triggers_ibfk_1` FOREIGN KEY (`SCHED_NAME`, `TRIGGER_NAME`, `TRIGGER_GROUP`) REFERENCES `qrtz_triggers` (`SCHED_NAME`, `TRIGGER_NAME`, `TRIGGER_GROUP`) ON DELETE RESTRICT ON UPDATE RESTRICT
) ENGINE = InnoDB CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Compact;

-- ----------------------------
-- Table structure for qrtz_triggers
-- ----------------------------
DROP TABLE IF EXISTS `qrtz_triggers`;
CREATE TABLE `qrtz_triggers`  (
  `SCHED_NAME` varchar(120) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL,
  `TRIGGER_NAME` varchar(200) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL,
  `TRIGGER_GROUP` varchar(200) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL,
  `JOB_NAME` varchar(200) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL,
  `JOB_GROUP` varchar(200) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL,
  `DESCRIPTION` varchar(250) CHARACTER SET utf8 COLLATE utf8_general_ci DEFAULT NULL,
  `NEXT_FIRE_TIME` bigint(13) DEFAULT NULL,
  `PREV_FIRE_TIME` bigint(13) DEFAULT NULL,
  `PRIORITY` int(11) DEFAULT NULL,
  `TRIGGER_STATE` varchar(16) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL,
  `TRIGGER_TYPE` varchar(8) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL,
  `START_TIME` bigint(13) NOT NULL,
  `END_TIME` bigint(13) DEFAULT NULL,
  `CALENDAR_NAME` varchar(200) CHARACTER SET utf8 COLLATE utf8_general_ci DEFAULT NULL,
  `MISFIRE_INSTR` smallint(2) DEFAULT NULL,
  `JOB_DATA` blob,
  PRIMARY KEY (`SCHED_NAME`, `TRIGGER_NAME`, `TRIGGER_GROUP`) USING BTREE,
  INDEX `SCHED_NAME`(`SCHED_NAME`, `JOB_NAME`, `JOB_GROUP`) USING BTREE,
  CONSTRAINT `qrtz_triggers_ibfk_1` FOREIGN KEY (`SCHED_NAME`, `JOB_NAME`, `JOB_GROUP`) REFERENCES `qrtz_job_details` (`SCHED_NAME`, `JOB_NAME`, `JOB_GROUP`) ON DELETE RESTRICT ON UPDATE RESTRICT
) ENGINE = InnoDB CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Compact;

SET FOREIGN_KEY_CHECKS = 1;

3.quartz需要用到的类

quartz配置信息

package com.tnaot.recommendreckon.nearline.quartz.config;

import org.quartz.Scheduler;
import org.quartz.ee.servlet.QuartzInitializerListener;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.config.PropertiesFactoryBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.io.ClassPathResource;
import org.springframework.scheduling.quartz.SchedulerFactoryBean;

import java.io.IOException;
import java.util.Properties;

/**
 * Author: hezishan
 * Date: 2018/5/24.
 * Description: quartz配置
 **/
@Configuration
public class QuartzConfig {
    @Autowired
    private QuartzJobFactory jobFactory;

    /**
     * 定时任务初始化监听器
     *
     * @Title: initListener
     */
    @Bean
    public QuartzInitializerListener initListener() {
        return new QuartzInitializerListener();
    }

    /**
     * 任务调度器
     *
     * @Title: scheduler
     * @throws IOException
     */
    @Bean(name = "Scheduler")
    public Scheduler scheduler() throws IOException {
        return schedulerFactoryBean().getScheduler();
    }

    /**
     * 任务调度器工厂
     *
     * @Title: schedulerFactoryBean
     * @throws IOException
     */
    @Bean(name = "SchedulerFactory")
    public SchedulerFactoryBean schedulerFactoryBean() throws IOException {
        SchedulerFactoryBean factory = new SchedulerFactoryBean();
        factory.setQuartzProperties(quartzProperties());
        factory.setOverwriteExistingJobs(true);
        factory.setStartupDelay(0);
        factory.setJobFactory(jobFactory);
        return factory;
    }

    /**
     * 读取定时任务配置
     *
     * @throws IOException
     * @Title: quartzProperties
     */
    @Bean
    public Properties quartzProperties() throws IOException {
        PropertiesFactoryBean propertiesFactoryBean = new PropertiesFactoryBean();
        propertiesFactoryBean.setLocation(new ClassPathResource("/quartz.properties"));
        propertiesFactoryBean.afterPropertiesSet();
        return propertiesFactoryBean.getObject();
    }


}

把quartz交给spring管理

package com.tnaot.recommendreckon.nearline.quartz.config;

import org.quartz.spi.TriggerFiredBundle;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.config.AutowireCapableBeanFactory;
import org.springframework.scheduling.quartz.AdaptableJobFactory;
import org.springframework.stereotype.Component;

/**
 * Author: hezishan
 * Date: 2018/5/24.
 * Description: QuartzJobFactory
 **/
@Component
public class QuartzJobFactory extends AdaptableJobFactory {
    @Autowired
    private AutowireCapableBeanFactory autowireCapableBeanFactory;

    /**
     * @see org.springframework.scheduling.quartz.AdaptableJobFactory#createJobInstance(org.quartz.spi.TriggerFiredBundle)
     */
    @Override
    protected Object createJobInstance(TriggerFiredBundle bundle) throws Exception {
        Object jobInstance = super.createJobInstance(bundle);
        // 实现Job的IOC管理
        autowireCapableBeanFactory.autowireBean(jobInstance);
        return jobInstance;
    }
}

任务通用方法

package com.tnaot.recommendreckon.nearline.quartz.job;

import org.quartz.Job;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;

/**
 * Author: hezishan
 * Date: 2018/5/24.
 * Description: 通用任务类
 **/
public interface BaseQuartzJob extends Job {
    void execute(JobExecutionContext executionContext) throws JobExecutionException;
}

定义任务

package com.tnaot.recommendreckon.nearline.quartz.job;

import com.tnaot.recommendreckon.core.collect.service.NewsReadService;
import org.quartz.DisallowConcurrentExecution;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

/**
 * Author: hezishan
 * Date: 2018/5/24.
 * Description: 
 **/
@DisallowConcurrentExecution
@Component
public class NearlineJob implements BaseQuartzJob {

    private static Logger LOGGER = LoggerFactory.getLogger(NearlineJob.class);

    @Autowired
    private NewsReadService newsReadService;


    @Override
    public void execute(JobExecutionContext executionContext) throws JobExecutionException {
        System.out.println("test");
    }
}

service用于编写任务的逻辑控制

package com.tnaot.recommendreckon.nearline.quartz.service;

import com.tnaot.recommendreckon.base.exception.ServiceException;
import com.tnaot.recommendreckon.base.response.ResponseCode;
import com.tnaot.recommendreckon.base.response.ResponseEntity;
import com.tnaot.recommendreckon.nearline.quartz.entity.TaskInfo;
import org.quartz.*;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Component;

/**
 * Author: hezishan
 * Date: 2018/5/24.
 * Description: 任务管理逻辑层
 **/
@Component
public class QuartzService {

    private static Logger LOGGER = LoggerFactory.getLogger(QuartzService.class);


    @Autowired
    @Qualifier("Scheduler")
    private Scheduler scheduler;

    /**
     * 创建任务
     *
     * @param job
     * @return
     * @throws Exception
     */
    public ResponseEntity addJob(TaskInfo job) throws Exception {
        ResponseEntity responseEntity = new ResponseEntity();
        try {
            JobDetail jobDetail = JobBuilder.newJob(getClass(job.getJobClassName()).getClass())
                    .withIdentity(job.getJobClassName(), job.getJobGroupName()).requestRecovery().build();
            //创建表达式调度构建起
            CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(job.getCronExpression());
            //根据传入的cron表达式创建一个触发器
            CronTrigger trigger = TriggerBuilder.newTrigger().withIdentity(job.getJobClassName(), job.getJobGroupName())
                    .withSchedule(scheduleBuilder).build();
            scheduler.scheduleJob(jobDetail, trigger);
            responseEntity.setResponseCode(ResponseCode.SUCCESS);
            responseEntity.setReponseMsg("创建任务成功");
        } catch (Exception e) {
            responseEntity.setResponseCode(ResponseCode.ADD_JOB_ERROR);
            responseEntity.setReponseMsg("创建任务失败");
            throw new ServiceException("创建定时任务失败");
        }
        return responseEntity;
    }

    /**
     * 暂停任务
     *
     * @param job
     * @return
     * @throws Exception
     */
    public ResponseEntity pauseJob(TaskInfo job) {
        ResponseEntity responseEntity = new ResponseEntity();
        try {
            scheduler.pauseJob(JobKey.jobKey(job.getJobClassName(), job.getJobGroupName()));
            responseEntity.setResponseCode(ResponseCode.SUCCESS);
            responseEntity.setReponseMsg("暂停任务成功");
        } catch (Exception e) {
            responseEntity.setResponseCode(ResponseCode.PAUSE_JOB_ERROR);
            responseEntity.setReponseMsg("暂停任务失败");
            throw new ServiceException("暂停任务失败");
        }
        return responseEntity;
    }

    /**
     * 恢复任务
     *
     * @param job
     * @return
     * @throws Exception
     */
    public ResponseEntity resumeJob(TaskInfo job) throws Exception {
        ResponseEntity responseEntity = new ResponseEntity();
        try {
            scheduler.resumeJob(JobKey.jobKey(job.getJobClassName(), job.getJobGroupName()));
            responseEntity.setResponseCode(ResponseCode.SUCCESS);
            responseEntity.setReponseMsg("恢复任务成功");
        } catch (Exception e) {
            responseEntity.setResponseCode(ResponseCode.RESUME_JOB_ERROR);
            responseEntity.setReponseMsg("恢复任务失败");
            throw new ServiceException("恢复任务失败");
        }
        return responseEntity;
    }

    /**
     * 重设任务
     *
     * @param job
     * @return
     * @throws Exception
     */
    public ResponseEntity rescheduleJob(TaskInfo job) throws Exception {
        ResponseEntity responseEntity = new ResponseEntity();
        try {
            TriggerKey triggerKey = TriggerKey.triggerKey(job.getJobClassName(), job.getJobGroupName());
            CronTrigger trigger = (CronTrigger) scheduler.getTrigger(triggerKey);
            CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(job.getCronExpression());
            trigger = trigger.getTriggerBuilder().withIdentity(triggerKey).withSchedule(scheduleBuilder).build();
            scheduler.rescheduleJob(triggerKey, trigger);
            responseEntity.setResponseCode(ResponseCode.SUCCESS);
            responseEntity.setReponseMsg("重设任务成功");
        } catch (SchedulerException e) {
            responseEntity.setResponseCode(ResponseCode.RESET_JOB_ERROR);
            responseEntity.setReponseMsg("重设任务失败");
            throw new ServiceException("重设任务失败");
        }
        return responseEntity;
    }

    public ResponseEntity deleteJob(TaskInfo job) throws Exception {
        ResponseEntity responseEntity = new ResponseEntity();
        try {
            //暂停触发器
            scheduler.pauseTrigger(TriggerKey.triggerKey(job.getJobClassName(), job.getJobGroupName()));
            //暂停任务
            scheduler.unscheduleJob(TriggerKey.triggerKey(job.getJobClassName(), job.getJobGroupName()));
            //删除任务
            scheduler.deleteJob(JobKey.jobKey(job.getJobClassName(), job.getJobGroupName()));
            responseEntity.setResponseCode(ResponseCode.SUCCESS);
            responseEntity.setReponseMsg("刪除任务成功");
        } catch (SchedulerException e) {
            responseEntity.setResponseCode(ResponseCode.RESET_JOB_ERROR);
            responseEntity.setReponseMsg("刪除任务失败");
            throw new ServiceException("刪除任务失败");
        }
        return responseEntity;
    }

    /**
     * 根据class name获取class
     *
     * @param classname
     * @return
     * @throws Exception
     */
    private Job getClass(String classname) throws Exception {
        String packageName = "com.tnaot.recommendreckon.nearline.quartz.job.";
        classname = packageName.concat(classname);
        Class<?> class1 = Class.forName(classname);
        return (Job) class1.newInstance();
    }


}

controller层，用于接收请求

package com.tnaot.recommendreckon.nearline.quartz.controller;

import com.tnaot.recommendreckon.base.response.ResponseEntity;
import com.tnaot.recommendreckon.core.bz.dao.NewsDao;
import com.tnaot.recommendreckon.core.collect.dao.NewsReadDao;
import com.tnaot.recommendreckon.core.recommend.dao.RecommendNewsResultDao;
import com.tnaot.recommendreckon.nearline.quartz.entity.TaskInfo;
import com.tnaot.recommendreckon.nearline.quartz.service.QuartzService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.bind.annotation.RestController;

/**
 * Author: hezishan
 * Date: 2018/5/24.
 * Description: 任务管理Controller
 **/
@RestController
@RequestMapping(value = "/quartz")
public class QuartzController {

    @Autowired
    private QuartzService quartzService;

    @Autowired
    NewsReadDao newsReadDao;

    @Autowired
    RecommendNewsResultDao recomandNewsHistoryDao;

    @Autowired
    NewsDao newsDao;


    @ResponseBody
    @RequestMapping(value = "/addJob", method = RequestMethod.POST)
    public ResponseEntity addJob(TaskInfo job) throws Exception {
        return quartzService.addJob(job);
    }

    @ResponseBody
    @RequestMapping(value = "/pauseJob", method = RequestMethod.POST)
    public ResponseEntity pauseJob(TaskInfo job) throws Exception {
        return quartzService.pauseJob(job);
    }

    @ResponseBody
    @RequestMapping(value = "/resumeJob", method = RequestMethod.POST)
    public ResponseEntity resumeJob(TaskInfo job) throws Exception {
        return quartzService.resumeJob(job);
    }

    @ResponseBody
    @RequestMapping(value = "/rescheduleJob", method = RequestMethod.POST)
    public ResponseEntity rescheduleJob(TaskInfo job) throws Exception {
        return quartzService.rescheduleJob(job);
    }

    @ResponseBody
    @RequestMapping(value = "/deleteJob", method = RequestMethod.POST)
    public ResponseEntity deleteJob(TaskInfo job) throws Exception {
        return quartzService.deleteJob(job);
    }

    @ResponseBody
    @RequestMapping(value = "/test", method = RequestMethod.POST)
    public void test( ) throws Exception {
        System.out.println(newsReadDao.findById(1024));
        System.out.println(recomandNewsHistoryDao.findById(1024));
        System.out.println(newsDao.findById(245792));
        System.out.println();

    }


}

实体类，用于接收参数

package com.tnaot.recommendreckon.nearline.quartz.entity;

/**
 * Author: hezishan
 * Date: 2018/5/24.
 * Description:
 **/
public class TaskInfo {

    private String jobClassName;

    private String jobGroupName;

    private String cronExpression;

    public String getJobClassName() {
        return jobClassName;
    }

    public void setJobClassName(String jobClassName) {
        this.jobClassName = jobClassName;
    }

    public String getJobGroupName() {
        return jobGroupName;
    }

    public void setJobGroupName(String jobGroupName) {
        this.jobGroupName = jobGroupName;
    }

    public String getCronExpression() {
        return cronExpression;
    }

    public void setCronExpression(String cronExpression) {
        this.cronExpression = cronExpression;
    }
}

最后启动，就可以了