springboot整合quartz实现定时任务

一.引入依赖

 		 <dependency>
	         <groupId>org.springframework.boot</groupId>
	         <artifactId>spring-boot-starter-quartz</artifactId>
 		 </dependency>
   <!-- 该依赖必加，里面有spring对schedule的支持 -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context-support</artifactId>
         <version>4.1.6.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.quartz-scheduler</groupId>
            <artifactId>quartz</artifactId>
            <version>2.2.1</version>
        </dependency>

二.在resources目录下新建quartz.properties文件(命名必须这个)

内容如下:

# Default Properties file for use by StdSchedulerFactory
# to create a Quartz Scheduler Instance, if a different
# properties file is not explicitly specified.
#

#默认或是自己改名字都行
org.quartz.scheduler.instanceName: DefaultQuartzScheduler

#如果使用集群，instanceId必须唯一，设置成AUTO
org.quartz.scheduler.instanceId = AUTO

org.quartz.scheduler.rmi.export: false
org.quartz.scheduler.rmi.proxy: false
org.quartz.scheduler.wrapJobExecutionInUserTransaction: false

org.quartz.threadPool.class: org.quartz.simpl.SimpleThreadPool
org.quartz.threadPool.threadCount: 10
org.quartz.threadPool.threadPriority: 5
org.quartz.threadPool.threadsInheritContextClassLoaderOfInitializingThread: true

org.quartz.jobStore.misfireThreshold: 60000
#============================================================================
# Configure JobStore
#============================================================================

#内存方式
#org.quartz.jobStore.class: org.quartz.simpl.RAMJobStore

#存储方式使用JobStoreTX，也就是数据库
org.quartz.jobStore.class:org.quartz.impl.jdbcjobstore.JobStoreTX
org.quartz.jobStore.driverDelegateClass:org.quartz.impl.jdbcjobstore.StdJDBCDelegate
#使用自己的配置文件
org.quartz.jobStore.useProperties:true
#数据库中quartz表的表名前缀
org.quartz.jobStore.tablePrefix:qrtz_
org.quartz.jobStore.dataSource:qzDS
#是否使用集群（如果项目只部署到 一台服务器，就不用了）
org.quartz.jobStore.isClustered = true

#============================================================================
# Configure Datasources
#============================================================================
#配置数据源
org.quartz.dataSource.qzDS.driver:com.mysql.cj.jdbc.Driver
org.quartz.dataSource.qzDS.URL:jdbc:mysql://localhost:3306/quartz?useUnicode=true&characterEncoding=utf8&serverTimezone=Asia/Shanghai&autoReconnect=true&allowMultiQueries=true&useSSL=false
org.quartz.dataSource.qzDS.user:root
org.quartz.dataSource.qzDS.password:root
org.quartz.dataSource.qzDS.maxConnection:10

三.在项目中添加执行任务的内容

可以添加多个任务,

@Component
public class JobTest implements Job {
    @Autowired
    private MyQuartzJobController myQuartzJobController;

    public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
		//需要执行的内容体
        System.out.println("执行了");
    }
}

四.添加配置文件

第一个:

@Component
public class MyJobFactory extends AdaptableJobFactory {
    @Autowired
    private AutowireCapableBeanFactory capableBeanFactory;

    @Override
    protected Object createJobInstance(TriggerFiredBundle bundle) throws Exception {
        Object jobInstance = super.createJobInstance(bundle);
        capableBeanFactory.autowireBean(jobInstance); //这一步解决不能spring注入bean的问题
        return jobInstance;
    }
}

第二个:

@Configuration
public class QuartzConfigration {
    @Autowired
    private MyJobFactory myJobFactory;  //自定义的factory

    //指定quartz.properties
    @Bean
    public Properties quartzProperties() throws IOException {
        PropertiesFactoryBean propertiesFactoryBean = new PropertiesFactoryBean();
        propertiesFactoryBean.setLocation(new ClassPathResource("/quartz.properties"));
        propertiesFactoryBean.afterPropertiesSet();
        return propertiesFactoryBean.getObject();
    }



    //获取工厂bean
    @Bean
    public SchedulerFactoryBean schedulerFactoryBean() {
        SchedulerFactoryBean schedulerFactoryBean = new SchedulerFactoryBean();
        try {
            schedulerFactoryBean.setQuartzProperties(quartzProperties());
            schedulerFactoryBean.setJobFactory(myJobFactory);
        } catch (IOException e) {
            e.printStackTrace();
        }
        return schedulerFactoryBean;
    }

    //创建schedule
    @Bean(name = "scheduler")
    public Scheduler scheduler() {
        return schedulerFactoryBean().getScheduler();
    }
}

五.在项目所使用的数据库中执行以下sql文件,添加相应的表:

以mysql数据库为例,执行如下语句:

#
# In your Quartz properties file, you'll need to set 
# org.quartz.jobStore.driverDelegateClass = org.quartz.impl.jdbcjobstore.StdJDBCDelegate
#
#
# By: Ron Cordell - roncordell
#  I didn't see this anywhere, so I thought I'd post it here. This is the script from Quartz to create the tables in a MySQL database, modified to use INNODB instead of MYISAM.

DROP TABLE IF EXISTS QRTZ_FIRED_TRIGGERS;
DROP TABLE IF EXISTS QRTZ_PAUSED_TRIGGER_GRPS;
DROP TABLE IF EXISTS QRTZ_SCHEDULER_STATE;
DROP TABLE IF EXISTS QRTZ_LOCKS;
DROP TABLE IF EXISTS QRTZ_SIMPLE_TRIGGERS;
DROP TABLE IF EXISTS QRTZ_SIMPROP_TRIGGERS;
DROP TABLE IF EXISTS QRTZ_CRON_TRIGGERS;
DROP TABLE IF EXISTS QRTZ_BLOB_TRIGGERS;
DROP TABLE IF EXISTS QRTZ_TRIGGERS;
DROP TABLE IF EXISTS QRTZ_JOB_DETAILS;
DROP TABLE IF EXISTS QRTZ_CALENDARS;

CREATE TABLE QRTZ_JOB_DETAILS(
SCHED_NAME VARCHAR(120) NOT NULL,
JOB_NAME VARCHAR(200) NOT NULL,
JOB_GROUP VARCHAR(200) NOT NULL,
DESCRIPTION VARCHAR(250) NULL,
JOB_CLASS_NAME VARCHAR(250) NOT NULL,
IS_DURABLE VARCHAR(1) NOT NULL,
IS_NONCONCURRENT VARCHAR(1) NOT NULL,
IS_UPDATE_DATA VARCHAR(1) NOT NULL,
REQUESTS_RECOVERY VARCHAR(1) NOT NULL,
JOB_DATA BLOB NULL,
PRIMARY KEY (SCHED_NAME,JOB_NAME,JOB_GROUP))
ENGINE=InnoDB;

CREATE TABLE QRTZ_TRIGGERS (
SCHED_NAME VARCHAR(120) NOT NULL,
TRIGGER_NAME VARCHAR(200) NOT NULL,
TRIGGER_GROUP VARCHAR(200) NOT NULL,
JOB_NAME VARCHAR(200) NOT NULL,
JOB_GROUP VARCHAR(200) NOT NULL,
DESCRIPTION VARCHAR(250) NULL,
NEXT_FIRE_TIME BIGINT(13) NULL,
PREV_FIRE_TIME BIGINT(13) NULL,
PRIORITY INTEGER NULL,
TRIGGER_STATE VARCHAR(16) NOT NULL,
TRIGGER_TYPE VARCHAR(8) NOT NULL,
START_TIME BIGINT(13) NOT NULL,
END_TIME BIGINT(13) NULL,
CALENDAR_NAME VARCHAR(200) NULL,
MISFIRE_INSTR SMALLINT(2) NULL,
JOB_DATA BLOB NULL,
PRIMARY KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP),
FOREIGN KEY (SCHED_NAME,JOB_NAME,JOB_GROUP)
REFERENCES QRTZ_JOB_DETAILS(SCHED_NAME,JOB_NAME,JOB_GROUP))
ENGINE=InnoDB;

CREATE TABLE QRTZ_SIMPLE_TRIGGERS (
SCHED_NAME VARCHAR(120) NOT NULL,
TRIGGER_NAME VARCHAR(200) NOT NULL,
TRIGGER_GROUP VARCHAR(200) 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),
FOREIGN KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP)
REFERENCES QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP))
ENGINE=InnoDB;

CREATE TABLE QRTZ_CRON_TRIGGERS (
SCHED_NAME VARCHAR(120) NOT NULL,
TRIGGER_NAME VARCHAR(200) NOT NULL,
TRIGGER_GROUP VARCHAR(200) NOT NULL,
CRON_EXPRESSION VARCHAR(120) NOT NULL,
TIME_ZONE_ID VARCHAR(80),
PRIMARY KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP),
FOREIGN KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP)
REFERENCES QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP))
ENGINE=InnoDB;

CREATE TABLE QRTZ_SIMPROP_TRIGGERS
  (          
    SCHED_NAME VARCHAR(120) NOT NULL,
    TRIGGER_NAME VARCHAR(200) NOT NULL,
    TRIGGER_GROUP VARCHAR(200) NOT NULL,
    STR_PROP_1 VARCHAR(512) NULL,
    STR_PROP_2 VARCHAR(512) NULL,
    STR_PROP_3 VARCHAR(512) NULL,
    INT_PROP_1 INT NULL,
    INT_PROP_2 INT NULL,
    LONG_PROP_1 BIGINT NULL,
    LONG_PROP_2 BIGINT NULL,
    DEC_PROP_1 NUMERIC(13,4) NULL,
    DEC_PROP_2 NUMERIC(13,4) NULL,
    BOOL_PROP_1 VARCHAR(1) NULL,
    BOOL_PROP_2 VARCHAR(1) NULL,
    PRIMARY KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP),
    FOREIGN KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP) 
    REFERENCES QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP))
ENGINE=InnoDB;

CREATE TABLE QRTZ_BLOB_TRIGGERS (
SCHED_NAME VARCHAR(120) NOT NULL,
TRIGGER_NAME VARCHAR(200) NOT NULL,
TRIGGER_GROUP VARCHAR(200) NOT NULL,
BLOB_DATA BLOB NULL,
PRIMARY KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP),
INDEX (SCHED_NAME,TRIGGER_NAME, TRIGGER_GROUP),
FOREIGN KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP)
REFERENCES QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP))
ENGINE=InnoDB;

CREATE TABLE QRTZ_CALENDARS (
SCHED_NAME VARCHAR(120) NOT NULL,
CALENDAR_NAME VARCHAR(200) NOT NULL,
CALENDAR BLOB NOT NULL,
PRIMARY KEY (SCHED_NAME,CALENDAR_NAME))
ENGINE=InnoDB;

CREATE TABLE QRTZ_PAUSED_TRIGGER_GRPS (
SCHED_NAME VARCHAR(120) NOT NULL,
TRIGGER_GROUP VARCHAR(200) NOT NULL,
PRIMARY KEY (SCHED_NAME,TRIGGER_GROUP))
ENGINE=InnoDB;

CREATE TABLE QRTZ_FIRED_TRIGGERS (
SCHED_NAME VARCHAR(120) NOT NULL,
ENTRY_ID VARCHAR(95) NOT NULL,
TRIGGER_NAME VARCHAR(200) NOT NULL,
TRIGGER_GROUP VARCHAR(200) NOT NULL,
INSTANCE_NAME VARCHAR(200) NOT NULL,
FIRED_TIME BIGINT(13) NOT NULL,
SCHED_TIME BIGINT(13) NOT NULL,
PRIORITY INTEGER NOT NULL,
STATE VARCHAR(16) NOT NULL,
JOB_NAME VARCHAR(200) NULL,
JOB_GROUP VARCHAR(200) NULL,
IS_NONCONCURRENT VARCHAR(1) NULL,
REQUESTS_RECOVERY VARCHAR(1) NULL,
PRIMARY KEY (SCHED_NAME,ENTRY_ID))
ENGINE=InnoDB;

CREATE TABLE QRTZ_SCHEDULER_STATE (
SCHED_NAME VARCHAR(120) NOT NULL,
INSTANCE_NAME VARCHAR(200) NOT NULL,
LAST_CHECKIN_TIME BIGINT(13) NOT NULL,
CHECKIN_INTERVAL BIGINT(13) NOT NULL,
PRIMARY KEY (SCHED_NAME,INSTANCE_NAME))
ENGINE=InnoDB;

CREATE TABLE QRTZ_LOCKS (
SCHED_NAME VARCHAR(120) NOT NULL,
LOCK_NAME VARCHAR(40) NOT NULL,
PRIMARY KEY (SCHED_NAME,LOCK_NAME))
ENGINE=InnoDB;

CREATE INDEX IDX_QRTZ_J_REQ_RECOVERY ON QRTZ_JOB_DETAILS(SCHED_NAME,REQUESTS_RECOVERY);
CREATE INDEX IDX_QRTZ_J_GRP ON QRTZ_JOB_DETAILS(SCHED_NAME,JOB_GROUP);

CREATE INDEX IDX_QRTZ_T_J ON QRTZ_TRIGGERS(SCHED_NAME,JOB_NAME,JOB_GROUP);
CREATE INDEX IDX_QRTZ_T_JG ON QRTZ_TRIGGERS(SCHED_NAME,JOB_GROUP);
CREATE INDEX IDX_QRTZ_T_C ON QRTZ_TRIGGERS(SCHED_NAME,CALENDAR_NAME);
CREATE INDEX IDX_QRTZ_T_G ON QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_GROUP);
CREATE INDEX IDX_QRTZ_T_STATE ON QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_STATE);
CREATE INDEX IDX_QRTZ_T_N_STATE ON QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP,TRIGGER_STATE);
CREATE INDEX IDX_QRTZ_T_N_G_STATE ON QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_GROUP,TRIGGER_STATE);
CREATE INDEX IDX_QRTZ_T_NEXT_FIRE_TIME ON QRTZ_TRIGGERS(SCHED_NAME,NEXT_FIRE_TIME);
CREATE INDEX IDX_QRTZ_T_NFT_ST ON QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_STATE,NEXT_FIRE_TIME);
CREATE INDEX IDX_QRTZ_T_NFT_MISFIRE ON QRTZ_TRIGGERS(SCHED_NAME,MISFIRE_INSTR,NEXT_FIRE_TIME);
CREATE INDEX IDX_QRTZ_T_NFT_ST_MISFIRE ON QRTZ_TRIGGERS(SCHED_NAME,MISFIRE_INSTR,NEXT_FIRE_TIME,TRIGGER_STATE);
CREATE INDEX IDX_QRTZ_T_NFT_ST_MISFIRE_GRP ON QRTZ_TRIGGERS(SCHED_NAME,MISFIRE_INSTR,NEXT_FIRE_TIME,TRIGGER_GROUP,TRIGGER_STATE);

CREATE INDEX IDX_QRTZ_FT_TRIG_INST_NAME ON QRTZ_FIRED_TRIGGERS(SCHED_NAME,INSTANCE_NAME);
CREATE INDEX IDX_QRTZ_FT_INST_JOB_REQ_RCVRY ON QRTZ_FIRED_TRIGGERS(SCHED_NAME,INSTANCE_NAME,REQUESTS_RECOVERY);
CREATE INDEX IDX_QRTZ_FT_J_G ON QRTZ_FIRED_TRIGGERS(SCHED_NAME,JOB_NAME,JOB_GROUP);
CREATE INDEX IDX_QRTZ_FT_JG ON QRTZ_FIRED_TRIGGERS(SCHED_NAME,JOB_GROUP);
CREATE INDEX IDX_QRTZ_FT_T_G ON QRTZ_FIRED_TRIGGERS(SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP);
CREATE INDEX IDX_QRTZ_FT_TG ON QRTZ_FIRED_TRIGGERS(SCHED_NAME,TRIGGER_GROUP);

commit; 

六.编写实体类,用来接收前台传过来的相应参数和自定义的内容(对应的表结构也同样)

@Entity
@Table(name = "c_schedule_triggers")
@Data
public class MyQuartzJobPO {

    @Id
    @GenericGenerator(name = "mysqlNative", strategy = "native")
    @GeneratedValue(generator = "mysqlNative")
    private Integer id;

    @Column(columnDefinition = "varchar(50) NOT NULL comment '时间表达式'")
    private String cron;

    @Column(columnDefinition = "smallint(2) default 0 comment '使用状态 0：禁用   1：启用'")
    private Integer status;

    @Column(columnDefinition = "varchar(50) NOT NULL comment '任务名称'")
    private String jobName;

    @Column(columnDefinition = "varchar(50) NOT NULL comment '任务分组'")
    private String jobGroup;

七.编写controller,service,impl类代码:如下

controller:

@RestController
@RequestMapping(value = "/job")
@Api(value = "定时任务管理的API", description = "定时任务的CRUD操作")
public class MyQuartzJobController {

    @Autowired
    private QuartzService quartzService;

    @Autowired
    private MyQuartzJobRepository myQuartzJobRepository;

    @ApiOperation(value = "新增定时任务", notes = "新增定时任务 ", produces = MediaType.APPLICATION_JSON_UTF8_VALUE)
    @ApiImplicitParams({
            @ApiImplicitParam(name = "vo", value = "定时任务的vo", required = true, dataType = "MyQuartzJobRequestVO")
    })
    @ResponseBody
    @RequestMapping(value = "/add", method = RequestMethod.POST)
    public Map<String, Object> add(@RequestBody @Valid MyQuartzJobRequestVO vo){
        Map<String, Object> map = new HashMap<String, Object>();
        //判断重复
        //保存
        MyQuartzJobPO po = new MyQuartzJobPO();
        BeanUtils.copyProperties(vo, po);
        myQuartzJobRepository.save(po);
        map.put("msg","success");
        return map;
    }

    @ApiOperation(value = "刷新定时任务", notes = "刷新定时任务 ", produces = MediaType.APPLICATION_JSON_UTF8_VALUE)
    @ResponseBody
    @RequestMapping(value = "/refresh", method = RequestMethod.GET)
    public Map<String, Object> reflash(){
        Map<String, Object> map = new HashMap<String, Object>();
        quartzService.refreshJob();
        map.put("msg","success");
        return map;
    }

    @ApiOperation(value = "启动定时任务", notes = "启动定时任务 ", produces = MediaType.APPLICATION_JSON_UTF8_VALUE)
    @ApiImplicitParams({
            @ApiImplicitParam(name = "vo", value = "定时任务的vo", required = true, dataType = "MyQuartzJobRequestVO")
    })
    @ResponseBody
    @RequestMapping(value = "/start", method = RequestMethod.PUT)
    public Map<String, Object> start(@RequestBody MyQuartzJobRequestVO vo){
        Map<String, Object> map = new HashMap<String, Object>();
        //判断状态
        //保存
        MyQuartzJobPO po = new MyQuartzJobPO();
        BeanUtils.copyProperties(vo, po);
        myQuartzJobRepository.save(po);

        quartzService.start(vo.getJobName(), vo.getJobGroup(), vo.getCron());
        map.put("msg","success");
        return map;
    }

    @ApiOperation(value = "暂停定时任务", notes = "暂停定时任务 ", produces = MediaType.APPLICATION_JSON_UTF8_VALUE)
    @ApiImplicitParams({
            @ApiImplicitParam(name = "vo", value = "定时任务的vo", required = true, dataType = "MyQuartzJobRequestVO")
    })
    @ResponseBody
    @RequestMapping(value = "/stop", method = RequestMethod.PUT)
    public Map<String, Object> stop(@RequestBody MyQuartzJobRequestVO vo){
        Map<String, Object> map = new HashMap<String, Object>();
        //修改状态
        MyQuartzJobPO po = new MyQuartzJobPO();
        BeanUtils.copyProperties(vo, po);
        myQuartzJobRepository.save(po);
        quartzService.stop(vo.getJobName(), vo.getJobGroup());
        map.put("msg","success");
        return map;
    }

    @ApiOperation(value = "立即执行一次定时任务", notes = "立即执行一次定时任务 ", produces = MediaType.APPLICATION_JSON_UTF8_VALUE)
    @ApiImplicitParams({
            @ApiImplicitParam(name = "vo", value = "定时任务的vo", required = true, dataType = "MyQuartzJobRequestVO")
    })
    @ResponseBody
    @RequestMapping(value = "/execute", method = RequestMethod.PUT)
    public Map<String, Object> execute(@RequestBody MyQuartzJobRequestVO vo){
        Map<String, Object> map = new HashMap<String, Object>();
        quartzService.execute(vo.getJobName(), vo.getJobGroup());
        map.put("msg","success");
        return map;
    }

    @ApiOperation(value = "删除定时任务", notes = "删除定时任务 ", produces = MediaType.APPLICATION_JSON_UTF8_VALUE)
    @ApiImplicitParams({
            @ApiImplicitParam(name = "vo", value = "定时任务的vo", required = true, dataType = "MyQuartzJobRequestVO")
    })
    @ResponseBody
    @RequestMapping(value = "/delete", method = RequestMethod.DELETE)
    public Map<String, Object> delete(@RequestBody MyQuartzJobRequestVO vo){
        Map<String, Object> map = new HashMap<String, Object>();
        //删除
        MyQuartzJobPO po = new MyQuartzJobPO();
        BeanUtils.copyProperties(vo, po);
        myQuartzJobRepository.delete(po);
        quartzService.delete(vo.getJobName(), vo.getJobGroup());
        map.put("msg","success");
        return map;
    }
}

service:

public interface QuartzService {

    /**
     * @Author : maichaojiu
     * @Description : 刷新所有定时任务
     * Date : 2018/4/8 11:41
     */
    public void refreshJob();

    /**
     * @Author : maichaojiu
     * @Description : 添加定时任我游
     * Date : 2018/4/8 15:10
     */
    public boolean add(String name, String group, String cron);

    /**
     * @Author : maichaojiu
     * @Description : 启动定时任务
     * Date : 2018/4/8 11:45
     */
    public boolean start(String name, String group, String cron);

    /**
     * @Author : maichaojiu
     * @Description : 停止定时任务
     * Date : 2018/4/8 11:46
     */
    public boolean stop(String name, String group);

    /**
     * @Author : maichaojiu
     * @Description : 立即执行一次定时任务
     * Date : 2018/4/8 11:46
     */
    public boolean execute(String name, String group);

    /**
     * @Author : maichaojiu
     * @Description : 删除定时任务
     * Date : 2018/4/8 11:47
     */
    public boolean delete(String name, String group);

    /**
     * @Author : maichaojiu
     * @Description : 修改定时任务时间
     * Date : 2018/4/8 14:16
     */
    public boolean modify(String name, String group, String cron);
}

serviceImpl:

@Service
public class QuartzServiceImpl implements QuartzService {

    private static final Logger logger =  LoggerFactory.getLogger(QuartzServiceImpl.class);
    @Autowired
    private Scheduler scheduler;

    @Autowired
    private MyQuartzJobRepository myQuartzJobRepository;

    /**
     * @Author : maichaojiu
     * @Description : 刷新所有定时任务
     * Date : 2018/4/8 11:41
     */
    public void refreshJob() {
        try {
            //查询出数据库中所有的定时任务
            List<MyQuartzJobPO> jobList = myQuartzJobRepository.findAll();
            if(null != jobList && jobList.size() > 0){
                for(MyQuartzJobPO po : jobList){
                    Integer status = po.getStatus(); //该任务触发器目前的状态
                    TriggerKey triggerKey = TriggerKey.triggerKey(po.getJobName(), po.getJobGroup());
                    CronTrigger trigger = (CronTrigger) scheduler.getTrigger(triggerKey);
                    //说明本条任务还没有添加到quartz中
                    if (null == trigger) {
                        if(0 == status){ //如果是禁用，则不用创建触发器
                            continue;
                        }

                        this.add(po.getJobName(), po.getJobGroup(), po.getCron());

                    } else {  //说明查出来的这条任务，已经设置到quartz中了
                        // Trigger已存在，先判断是否需要删除，如果不需要，再判定是否时间有变化
                        if(0 == status){ //如果是禁用，从quartz中删除这条任务
                            JobKey jobKey = JobKey.jobKey(po.getJobName(), po.getJobGroup());
                            scheduler.deleteJob(jobKey);
                            continue;
                        }
                        String searchCron = po.getCron(); //获取数据库的
                        String currentCron = trigger.getCronExpression();
                        if(!searchCron.equals(currentCron)){  //说明该任务有变化，需要更新quartz中的对应的记录
                            //表达式调度构建器
                            CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(searchCron);

                            //按新的cronExpression表达式重新构建trigger
                            trigger = trigger.getTriggerBuilder().withIdentity(triggerKey)
                                    .withSchedule(scheduleBuilder).build();

                            //按新的trigger重新设置job执行
                            scheduler.rescheduleJob(triggerKey, trigger);
                        }
                    }
                }
            }
        } catch (Exception e) {
            logger.error("定时任务每日刷新触发器任务异常，在ScheduleTriggerServiceImpl的方法refreshTrigger中，异常信息：",e);
        }
    }

    /**
     * @Author : maichaojiu
     * @Description : 添加定时任务
     * Date : 2018/4/8 15:11
     */
    public boolean add(String name, String group, String cron){
        try {
            JobDetail jobDetail = JobBuilder.newJob((Class<? extends Job>) Class.forName(name))
                    .withIdentity(name, group).build();

            jobDetail.getJobDataMap().put("abc","123");

            //表达式调度构建器
            CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(cron);

            //按新的cronExpression表达式构建一个新的trigger
            CronTrigger trigger = TriggerBuilder.newTrigger().withIdentity(name, group).withSchedule(scheduleBuilder).build();

            //把trigger和jobDetail注入到调度器
            scheduler.scheduleJob(jobDetail, trigger);
        } catch (Exception e){
            System.out.println(e);
        }
        return true;
    }

    /**
     * @Author : maichaojiu
     * @Description : 启动定时任务
     * Date : 2018/4/8 11:45
     */
    public boolean start(String name, String group, String cron) {
        try {
            TriggerKey triggerKey = TriggerKey.triggerKey(name, group);
            CronTrigger trigger = (CronTrigger) scheduler.getTrigger(triggerKey);
            if(null == trigger){
                this.add(name, group, cron);
            }else{
                this.modify(name, group, cron);
            }
        } catch (Exception e){
            System.out.println(e);
        }
        return true;
    }

    /**
     * @Author : maichaojiu
     * @Description : 停止定时任务
     * Date : 2018/4/8 11:46
     */
    public boolean stop(String name, String group) {
        try {
            TriggerKey triggerKey = TriggerKey.triggerKey(name, group);
            boolean b = scheduler.unscheduleJob(triggerKey);//移除触发器
        } catch (Exception e){
            System.out.println(e);
        }
        return true;
    }

    /**
     * @Author : maichaojiu
     * @Description : 立即执行一次定时任务
     * Date : 2018/4/8 11:46
     */
    public boolean execute(String name, String group) {
        try {
            JobKey jobKey = JobKey.jobKey(name, group);
            //判断任务调度器中否存在该任务
            TriggerKey triggerKey = TriggerKey.triggerKey(name, group);
            CronTrigger trigger = (CronTrigger) scheduler.getTrigger(triggerKey);
            if(null != trigger){
                scheduler.triggerJob(jobKey);
            }else{
                //利用反射来执行方法
                Class<?> class1 = Class.forName(name);
                Object obj = class1.newInstance();
                Job job = (Job) obj;
                job.execute(null);
            }
        } catch (Exception e){
            System.out.println(e);
        }
        return true;
    }

    /**
     * @Author : maichaojiu
     * @Description : 删除定时任务
     * Date : 2018/4/8 11:47
     */
    public boolean delete(String name, String group)  {
        try {
            TriggerKey triggerKey = TriggerKey.triggerKey(name, group); //通过触发器名和组名获取TriggerKey
            JobKey jobKey = JobKey.jobKey(name, group);//通过任务名和组名获取JobKey
            scheduler.pauseTrigger(triggerKey); // 停止触发器
            scheduler.unscheduleJob(triggerKey);// 移除触发器
            scheduler.deleteJob(jobKey); // 删除任务
        } catch (Exception e){
            System.out.println(e);
        }
        return true;
    }

    /**
     * @Author : maichaojiu
     * @Description : 修改定时任务时间
     * Date : 2018/4/8 14:33
     */
    public boolean modify(String name, String group, String cron) {
        try {
            TriggerKey triggerKey = TriggerKey.triggerKey(name, group);//通过触发器名和组名获取TriggerKey
            CronTrigger trigger = (CronTrigger)scheduler.getTrigger(triggerKey);//通过TriggerKey获取CronTrigger
            if (trigger == null)  return true;
            String oldTime = trigger.getCronExpression();
            if (!oldTime.equalsIgnoreCase(cron)) {
                CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(trigger.getCronExpression());
                trigger = (CronTrigger)trigger.getTriggerBuilder()//重新构建trigger
                        .withIdentity(triggerKey)
                        .withSchedule(scheduleBuilder)
                        .withSchedule(CronScheduleBuilder.cronSchedule(cron))
                        .build();
                scheduler.rescheduleJob(triggerKey, trigger);//按新的trigger重新设置job执行
            }
        } catch (Exception e){
            System.out.println(e);
        }

        return true;
    }
}