Quartz:(2)Springboot集成Quartz框架，并实现自定义开启，关闭定时任务

一、导入依赖

 <!--quartz集成springboot-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-quartz</artifactId>
        </dependency>

二、书写配置文件

spring:
    quartz:
        jdbc:
        #这个第一次启动设置成always，就可以自动生成时间任务持久化所需的数据库的表
          initialize-schema: never 
        job-store-type: jdbc
        properties:
          org:
            quartz:
              scheduler:
                instanceName: clusteredScheduler
                instanceId: AUTO
                dataSource:
                  qzDS:
                  #Oracl数据源
                    driver: oracle.jdbc.driver.OracleDriver
                    URL: jdbc:oracle:thin:@127.0.0.1:1521/orcl
                    user: TYLERYUE
                    password: 2fk786267kf
                    maxConnections: 10
                    provider: hikaricp
              jobStore:
                class: org.quartz.impl.jdbcjobstore.JobStoreTX
                driverDelegateClass: org.quartz.impl.jdbcjobstore.oracle.OracleDelegate
                tablePrefix: QRTZ_
                isClustered: true
                clusterCheckinInterval: 10000
                useProperties: true
                #持久化的数据源
                dataSource: qzDS
              threadPool:
                class: org.quartz.simpl.SimpleThreadPool
                threadCount: 10
                threadPriority: 5
                threadsInheritContextClassLoaderOfInitializingThread: true

三、创建一个定时任务的服务类

/**
 * 时间作业服务实现类
 */
@Component
@Slf4j
public class TimeTaskServiceImpl implements TimeTaskService {
    //这里集成了springboot，触发器自动注入就好了
    @Autowired
    public Scheduler scheduler;
    
    /**
     * 结束并删除定时任务
     */
    @Override
    public void deleteTimeTask(String jobName,String jobGroup,String triggerName,String triggerGrouop) {
        try {
            scheduler.pauseTrigger(TriggerKey.triggerKey(triggerName,triggerGrouop));//暂停触发器
            scheduler.unscheduleJob(TriggerKey.triggerKey(triggerName,triggerGrouop));//移除触发器
            scheduler.deleteJob(JobKey.jobKey(jobName,jobGroup));//删除Job
            log.info("====================定时任务成功删除");
        } catch (SchedulerException e) {
            e.printStackTrace();
        }
    }




    /**
     * 开始一个自定义Cron定时任务
     * 自定义了一个TaskCondition类，
     * 可以设置我们执行自定义定时任务设置的参数，如：			 *	jobName,想要执行的job对象等参数
     */
    @Override
    public void startTimeTask(TaskCondition taskCondition) {
        //创建一个job
        try {
            //获取时间任务类全类名
            String className = taskCondition.getJobObject().getClass().getName();
            Date timeCorn = taskCondition.getTimeCorn();
            String cron = DFUtils.dateToCron(timeCorn);//时间转换为Cron表达式
            String id=taskCondition.getId();


            log.info("=====================创建了一个JOb");
            log.info("job全类名"+className);
            JobDetail job=JobBuilder.newJob(((Job)Class.forName(className).newInstance()).getClass())
                    .withIdentity(taskCondition.getJobName(),taskCondition.getJobGroup())
                    .usingJobData("id", id)//时间任务会用到的id参数
                    .build();

            log.info("=====================创建了一个触发器");
            CronTrigger  cronTrigger = TriggerBuilder.newTrigger()
                    .withIdentity(taskCondition.getTriggerName(),taskCondition.getTriggerGroup())
                    .startNow()
                    .withSchedule(CronScheduleBuilder.cronSchedule(cron))
                    .build();
            //进行调度
            log.info("调度的时间"+timeCorn);
            scheduler.scheduleJob(job,cronTrigger);
            if (!scheduler.isShutdown()) {

                scheduler.start();
                log.info("===================时间任务已开始运行");
            }

        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

四、创建时间任务设置参数对象

/**
 * 时间任务设置参数对象
 */
@Data
public class TaskCondition {
    //必选条件
    private String jobName;
    private String jobGroup;
    private String triggerName;
    private String triggerGroup;
    private Object jobObject;//job对象
    private Date timeCorn;//时间条件
    //以上是必备的变量
    //以下是根据实际业务定义的变量
    //这个是job对象从定时任务JobDetail中接受的要参数变量
    private String id;//id



    /**
     * 链式调用
     * @return
     */
    public TaskCondition jobName(String jobName){
        this.setJobName(jobName);
        return this;
    }
    public TaskCondition jobGroup(String jobGroup){
        this.setJobGroup(jobGroup);
        return this;
    }
    public TaskCondition triggerName(String triggerName){
        this.setTriggerName(triggerName);
        return this;
    }
    public TaskCondition triggerGroup(String triggerGroup){
        this.setTriggerGroup(triggerGroup);
        return this;
    }
    public TaskCondition jobObject(Object jobObject){
        this.setJobObject(jobObject);
        return this;
    }
    public TaskCondition timeCorn(Date timeCorn){
        this.setTimeCorn(timeCorn);
        return this;
    }


}

五、创建一个测试的job

/**
 * 测试的时间任务
 */
public class TestJob extends QuartzJobBean {
    @Override
    protected void executeInternal(JobExecutionContext context) throws JobExecutionException {
        //业务逻辑写在这里面
        StringJoiner outStr=new StringJoiner("")
                .add("helloe EX====")
                .add(DFUtils.format(new Date())+">>>>线程名：")
                .add(Thread.currentThread().getName()+">>>>触发器名：")
                .add(context.getTrigger().getKey().getName());
        System.out.println(outStr);
    }
}

六、在需要启动定时任务的地方，调用刚才定义好的启动方法

 //时间任务设置参数对象
 TaskCondition taskCondition=new TaskCondition();
        
taskCondition.jobName("myjob")//设置jobDetail相关
                .jobGroup("my")                
    			.triggerName("myTrigger")//设置触发器
                .triggerGroup("my")
             .timeCorn(new Date())//任务执行时间
                .jobObject(new TestJob())//job对象
                .setId(reserves.getId());//一些业务上的参数，根据需求来设置
//调用开始定时任务方法，传入时间任务设置参数对象
        timeTaskService.startTimeTask(taskCondition);

如果测试成功，则集成完成！