SpringBoot整合quartz實現動態啟動，停止定時任務功能

 

 

 注意：這個方法當程序重啟之后會失效，所以必須將定時任務持久化到數據庫，然后程序啟動的時候重新把數據庫的定時任務加載到quartz中

springboot程序啟動初始化代碼參考：https://www.cnblogs.com/pxblog/p/14995261.html

 

 

引入maven

  <!-- https://mvnrepository.com/artifact/org.quartz-scheduler/quartz -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-quartz</artifactId>
        </dependency>

 

 

TaskJob.java   任務執行類

package com.test.cms.task;

import com.test.cms.service.TaskService;
import org.quartz.*;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.util.Date;

/**
 * @PersistJobDataAfterExecution 和 @DisallowConcurrentExecution
 * 表示不讓某個定時任務並發執行保證上一個任務執行完后，再去執行下一個任務
 */
@PersistJobDataAfterExecution
@DisallowConcurrentExecution
@Component
public class TaskJob implements Job {

    /**
     * 可以直接注入service層。這里只是演示，沒有這個類
     */
    @Autowired
    private TaskService taskService;


    @Override
    public void execute(JobExecutionContext context)  {
        JobDataMap jobDataMap=context.getJobDetail().getJobDataMap();
        System.out.println("11"+new Date()+"    "+jobDataMap.getString("value")+"  "+context.getJobDetail().getKey());
    }


}

 

 

控制器

TaskController.java

package com.test.cms.controller;

import com.test.cms.task.TaskJob;
import org.quartz.JobDataMap;
import org.quartz.JobKey;
import org.quartz.Scheduler;
import org.quartz.SchedulerException;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.quartz.CronTriggerFactoryBean;
import org.springframework.scheduling.quartz.JobDetailFactoryBean;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.*;

@RestController
public class TaskController {

    /**
     * 啟動任務 需要自己完善邏輯，這里我用uuid作為taskCode 保證唯一
     * 啟動之前要通過數據庫查詢是否任務已經啟動，如果啟動了就不能啟動了
     * 啟動成功了 要把數據庫的任務狀態改為啟動中
     */
    @RequestMapping(value = "/task/start")
    public void start() {
        String uuid = UUID.randomUUID().toString();
        System.out.println(uuid);
        startTask(uuid);

    }

    /**
     * 停止任務 需要自己完善邏輯
     * @param taskCode 傳入啟動任務時設置的taskCode參數
     */
    @RequestMapping(value = "/task/stop")
    public void stop(String taskCode) {
        endTask(taskCode);
    }

    /**
     * 開始任務調度
     *
     * @param taskCode 任務名稱 需要唯一標識，停止任務時需要用到
     */
    private void startTask(String taskCode){
        //任務開始的corn表達式
        String cronExpress = "*/5 * * * * ?";
        if (cronExpress.indexOf("null") == -1) {
            try {
                JobDetailFactoryBean jobDetailFactoryBean = new JobDetailFactoryBean();
                jobDetailFactoryBean.setName(taskCode);
                jobDetailFactoryBean.setGroup(Scheduler.DEFAULT_GROUP);
                //TaskJob.class 是任務所要執行操作的類
                jobDetailFactoryBean.setJobClass(TaskJob.class);
                //任務需要的參數可以通過map方法傳遞，
                Map map = new HashMap();
                map.put("value", "我在傳遞參數");
                jobDetailFactoryBean.setJobDataMap(getJobDataMap(map));
                jobDetailFactoryBean.afterPropertiesSet();
                CronTriggerFactoryBean cronTriggerFactoryBean = new CronTriggerFactoryBean();
                cronTriggerFactoryBean.setBeanName(taskCode);
                cronTriggerFactoryBean.setCronExpression(cronExpress);
                cronTriggerFactoryBean.setGroup(Scheduler.DEFAULT_GROUP);
                cronTriggerFactoryBean.setName("cron_" + taskCode);
                cronTriggerFactoryBean.afterPropertiesSet();
                scheduler.scheduleJob(jobDetailFactoryBean.getObject(), cronTriggerFactoryBean.getObject());
                System.out.println(taskCode+"任務啟動成功");
            } catch (Exception e) {
                e.printStackTrace();
                System.out.println(taskCode+"任務啟動失敗");
            }
        }
    }


    /**
     * 結束任務調度
     *
     * @param taskCode
     */
    private void endTask(String taskCode)  {
        try {
            scheduler.deleteJob(JobKey.jobKey(taskCode, Scheduler.DEFAULT_GROUP));
            System.out.println(taskCode+"任務停止成功");
        } catch (SchedulerException e) {
            e.printStackTrace();
            System.out.println(taskCode+"任務停止失敗");
        }
    }


    /**
     * 將HashMap轉為JobDataMap
     * @param params
     * @return
     */
    private JobDataMap getJobDataMap(Map<String, String> params) {
        JobDataMap jdm = new JobDataMap();
        Set<String> keySet = params.keySet();
        Iterator<String> it = keySet.iterator();
        while (it.hasNext()) {
            String key = it.next();
            jdm.put(key, params.get(key));
        }
        return jdm;
    }



    @Autowired
    private Scheduler scheduler;
}

 

 

啟動類要加上注解@EnableScheduling

package com.test.cms;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.scheduling.annotation.EnableScheduling;

@SpringBootApplication
@EnableScheduling   //要加上開啟定時任務的注解
public class CmsApplication {

    public static void main(String[] args) {
        SpringApplication.run(CmsApplication.class, args);
    }

}

 

 

JAVA日期Date格式轉corn表達式：https://www.cnblogs.com/pxblog/p/14992923.html