• 【quartz】从数据库中读取配置实现动态定时任务

    前言

            在Java中定时任务是很常见的，使用@Scheduled注解即可实现定时，但是在生产环境中可能会遇到页面上自主配置定时任务的定时时间，这种情况下单独用@Scheduled注解很难实现定时任务，所以我们可以将定时任务存储在数据库中并通过quartz实现动态定时任务。

    配置依赖

    1. <dependency>
    2.     <groupId>org.quartz-scheduler</groupId>
    3.     <artifactId>quartz</artifactId>
    4.     <version>2.2.1</version>
    5. </dependency>
    6. <dependency>
    7.     <groupId>org.quartz-scheduler</groupId>
    8.     <artifactId>quartz-jobs</artifactId>
    9.     <version>2.2.1</version>
    10. </dependency>
    11. <dependency>
    12.     <groupId>org.springframework</groupId>
    13.     <artifactId>spring-context</artifactId>
    14. </dependency>
    15. <dependency>
    16.     <groupId>org.springframework</groupId>
    17.     <artifactId>spring-context-support</artifactId>
    18. </dependency>

    实现方式

    1、定时任务表实体

    1. @Data
    2. @TableName("SCHEDULE_JOB")
    3. public class ScheduleJob {
    4.  
    5.     /**
    6.      * 序号
    7.      */
    8.     @TableId(value = "ID", type = IdType.ID_WORKER_STR)
    9.     private String id;
    10.  
    11.     /**
    12.      * 任务名称
    13.      */
    14.     @TableField("JOB_NAME")
    15.     private String jobName;
    16.  
    17.     /**
    18.      * 任务分组
    19.      */
    20.     @TableField("JOB_GROUP")
    21.     private String jobGroup;
    22.  
    23.     /**
    24.      * 任务状态 是否启动任务,2：失效；1：有效
    25.      */
    26.     @TableField("JOB_STATUS")
    27.     private Integer jobStatus;
    28.  
    29.     /**
    30.      * cron表达式,推荐使用6域的
    31.      */
    32.     @TableField("CRON_EXPRESSION")
    33.     private String cronExpression;
    34.  
    35.     /**
    36.      * 描述
    37.      */
    38.     @TableField("DESCRIPTION")
    39.     private String description;
    40.  
    41.     /**
    42.      * 任务执行时调用哪个类的方法 包名+类名，全路径
    43.      */
    44.     @TableField("BEAN_CLASS")
    45.     private String beanClass;
    46.  
    47.     /**
    48.      * 任务是否有状态
    49.      */
    50.     @TableField("IS_CONCURRENT")
    51.     private Integer isConcurrent;
    52.  
    53.     /**
    54.      * spring bean 对应定时任务的类名，首字母小写
    55.      */
    56.     @TableField("SPRING_ID")
    57.     private String springId;
    58.  
    59.     /**
    60.      * 任务调用的方法名
    61.      */
    62.     @TableField("method_name")
    63.     private String methodName;
    64.  
    65.     @TableField("CREATE_TIME")
    66.     private Date createTime;
    67.  
    68.     @TableField("UPDATE_TIME")
    69.     private Date updateTime;
    70. }

    2、反射调用scheduleJob中定义的方法

    1. import com.saas.reptile.common.result.Result;
    2. import com.saas.reptile.entity.po.ScheduleJob;
    3. import com.saas.reptile.utils.LogUtils;
    4. import com.saas.reptile.utils.SpringUtils;
    5. import com.saas.reptile.utils.StringUtils;
    6. import org.springframework.beans.factory.annotation.Autowired;
    7. import org.springframework.context.ApplicationContext;
    8.  
    9. import java.lang.reflect.Method;
    10.  
    11. public class TaskUtils {
    12.  
    13.     @Autowired
    14.     private ApplicationContext applicationContext;
    15.     /**
    16.      * 通过反射调用scheduleJob中定义的方法
    17.      *
    18.      * @param scheduleJob
    19.      */
    20.     public static void invokMethod(ScheduleJob scheduleJob) {
    21.  
    22.         try {//添加最大的异常捕获
    23.             String springId = scheduleJob.getSpringId();
    24.             Object object = null;
    25.             Class clazz = null;
    26.  
    27.             //根据反射来进行
    28.             if (StringUtils.isNotBlank(springId)) {
    29.                 object = SpringUtils.getBean(springId);
    30.             }
    31.  
    32.             if (object == null && StringUtils.isNotBlank(scheduleJob.getBeanClass())) {
    33.                 String jobStr = "定时任务名称 = [" + scheduleJob.getJobName() + "]-在spring 中没有这个 springId, 通过 class type 获取中...";
    34.                 LogUtils.info(jobStr, scheduleJob.getBeanClass());
    35.                 try {
    36.                     clazz = Class.forName(scheduleJob.getBeanClass());
    37.                     object = SpringUtils.getBean(clazz);
    38.                     if(object == null){
    39.                         jobStr = "定时任务名称 = [" + scheduleJob.getJobName() + "]-在spring 中没有获得 bean, 调用 spring 方法再次构建中...";
    40.                         LogUtils.info(jobStr, scheduleJob.getBeanClass());
    41.                         object = SpringUtils.getBeanByType(clazz);
    42.                     }
    43.                     if (StringUtils.isNotBlank(springId)) {
    44.                         SpringUtils.setBean(springId, object);
    45.                         LogUtils.info("spring bean 构建完成并加入到容器中 ", scheduleJob.getBeanClass());
    46.                     }
    47.                     LogUtils.info("定时任务 spring bean 构建成功! ", scheduleJob.getBeanClass());
    48.                 } catch (Exception e) {
    49.                     LogUtils.error("定时任务 spring bean 构建失败了!!! ", scheduleJob.getBeanClass(), e);
    50.                     Result.fail(e);
    51.                     return;
    52.                 }
    53.             }
    54.  
    55.             clazz = object.getClass();
    56.             Method method = null;
    57.             try {
    58.                 method = clazz.getDeclaredMethod(scheduleJob.getMethodName());
    59.             } catch (NoSuchMethodException e) {
    60.                 String jobStr = "定时任务名称 = [" + scheduleJob.getJobName() + "] = 未启动成功，方法名设置错误！！！";
    61.                 LogUtils.error(jobStr, e);
    62.             } catch (SecurityException e) {
    63.                 LogUtils.error("TaskUtils发生异常", e);
    64.                 Result.fail(e);
    65.             }
    66.             if (method != null) {
    67.                 try {
    68.                     method.invoke(object);
    69.                     LogUtils.info("定时任务名称 = [" + scheduleJob.getJobName() + "] = 启动成功");
    70.                 } catch (Exception e) {
    71.                     Result.fail(e);
    72.                     LogUtils.error("定时任务名称 = [" + scheduleJob.getJobName() + "] = 启动失败了!!!", e);
    73.                     return;
    74.                 }
    75.             } else {
    76.                 String jobStr = "定时任务名称 = [" + scheduleJob.getJobName() + "] = 启动失败了!!!";
    77.                 LogUtils.error(jobStr, clazz.getName(), "not find method ");
    78.             }
    79.  
    80.         } catch (Exception e) {//添加最大的异常捕获
    81.             Result.fail(e);
    82.             LogUtils.error("定时任务名称 = [" + scheduleJob.getJobName() + "] = 启动失败了!!!", e);
    83.         }
    84.  
    85.     }
    86. }

    3、创建正常状态下的job执行工厂

    1. import com.saas.reptile.entity.po.ScheduleJob;
    2. import org.quartz.Job;
    3. import org.quartz.JobExecutionContext;
    4. import org.quartz.JobExecutionException;
    5.  
    6. public class QuartzJobFactory implements Job {
    7.  
    8.     @Override
    9.     public void execute(JobExecutionContext context) throws JobExecutionException {
    10.         ScheduleJob scheduleJob = (ScheduleJob) context.getMergedJobDataMap().get("scheduleJob");
    11.         TaskUtils.invokMethod(scheduleJob);
    12.     }
    13. }

    4、若一个方法一次执行不完下次轮转时则等待改方法执行完后才执行下一次操作

    1. import com.saas.reptile.entity.po.ScheduleJob;
    2. import org.quartz.DisallowConcurrentExecution;
    3. import org.quartz.Job;
    4. import org.quartz.JobExecutionContext;
    5. import org.quartz.JobExecutionException;
    6.  
    7. @DisallowConcurrentExecution
    8. public class QuartzJobFactoryDisallowConcurrentExecution implements Job {
    9.  
    10.     @Override
    11.     public void execute(JobExecutionContext context) throws JobExecutionException {
    12.         ScheduleJob scheduleJob = (ScheduleJob) context.getMergedJobDataMap().get("scheduleJob");
    13.         TaskUtils.invokMethod(scheduleJob);
    14.     }
    15. }

    5、创建需要运行的定时任务类

    1. @Component
    2. public class ClassAtmosphereTask {
    3.  
    4.     public void work(){
    5.         // do something
    6.     }
    7.  
    8. }

    6、SpringBean工厂工具类

    1. import org.springframework.beans.BeansException;
    2. import org.springframework.beans.factory.NoSuchBeanDefinitionException;
    3. import org.springframework.beans.factory.config.BeanFactoryPostProcessor;
    4. import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
    5. import org.springframework.stereotype.Component;
    6.  
    7. @Component
    8. public class SpringUtils implements BeanFactoryPostProcessor {
    9.  
    10.     // Spring应用上下文环境
    11.     private static ConfigurableListableBeanFactory beanFactory;
    12.  
    13.     @Override
    14.     public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
    15.         SpringUtils.beanFactory = beanFactory;
    16.     }
    17.  
    18.     /**
    19.      * 获取对象
    20.      *
    21.      * @param name
    22.      * @return Object 一个以所给名字注册的bean的实例
    23.      * @throws BeansException
    24.      */
    25.     @SuppressWarnings("unchecked")
    26.     public static <T> T getBean(String name) throws BeansException {
    27.         return (T) beanFactory.getBean(name);
    28.     }
    29.  
    30.     /**
    31.      * 获取对象
    32.      * @return Object 一个以所给名字注册的bean的实例
    33.      * @throws BeansException
    34.      */
    35.     @SuppressWarnings("unchecked")
    36.     public static <T> T getBeanByType(Class<T> clzee) throws BeansException {
    37.         try {
    38.             return beanFactory.createBean(clzee);
    39.         } catch (NoSuchBeanDefinitionException e) {
    40.             return null;
    41.         }
    42.  
    43.     }
    44.  
    45.     /**
    46.      * 注入一个对象
    47.      * @return Object 一个以所给名字注册的bean的实例
    48.      * @throws BeansException
    49.      */
    50.     @SuppressWarnings("unchecked")
    51.     public static void setBean(String springId, Object obj) throws BeansException {
    52.         beanFactory.registerSingleton(springId, obj);
    53.     }
    54.  
    55.     /**
    56.      * 获取类型为requiredType的对象
    57.      * @return
    58.      * @throws BeansException
    59.      */
    60.     public static <T> T getBean(Class<T> clz) throws BeansException {
    61.         try {
    62.             @SuppressWarnings("unchecked")
    63.             T result = (T) beanFactory.getBean(clz);
    64.             return result;
    65.         } catch (NoSuchBeanDefinitionException e) {
    66.             return null;
    67.         }
    68.     }
    69.  
    70.     /**
    71.      * 如果BeanFactory包含一个与所给名称匹配的bean定义，则返回true
    72.      *
    73.      * @param name
    74.      * @return boolean
    75.      */
    76.     public static boolean containsBean(String name) {
    77.         return beanFactory.containsBean(name);
    78.     }
    79.  
    80.     /**
    81.      * 判断以给定名字注册的bean定义是一个singleton还是一个prototype。
    82.      * 如果与给定名字相应的bean定义没有被找到，将会抛出一个异常（NoSuchBeanDefinitionException）
    83.      *
    84.      * @param name
    85.      * @return boolean
    86.      * @throws NoSuchBeanDefinitionException
    87.      */
    88.     public static boolean isSingleton(String name) throws NoSuchBeanDefinitionException {
    89.         return beanFactory.isSingleton(name);
    90.     }
    91.  
    92.     /**
    93.      * @param name
    94.      * @return Class 注册对象的类型
    95.      * @throws NoSuchBeanDefinitionException
    96.      */
    97.     public static Class<?> getType(String name) throws NoSuchBeanDefinitionException {
    98.         return beanFactory.getType(name);
    99.     }
    100.  
    101.     /**
    102.      * 如果给定的bean名字在bean定义中有别名，则返回这些别名
    103.      *
    104.      * @param name
    105.      * @return
    106.      * @throws NoSuchBeanDefinitionException
    107.      */
    108.     public static String[] getAliases(String name) throws NoSuchBeanDefinitionException {
    109.         return beanFactory.getAliases(name);
    110.     }
    111. }

    7、其他用到的工具类

    • 字符串工具类
    1. public class StringUtils {
    2.     public final static String REG_DIGIT = "[0-9]*";
    3.     public final static String REG_CHAR = "[a-zA-Z]*";
    4.     public final static String EMPTY = "";
    5.  
    6.     /**
    7.      * 判断是否为空
    8.      */
    9.     public static boolean isEmpty(Object... obj) {
    10.         if(obj == null)
    11.             return true;
    12.         for(Object object : obj) {
    13.             if (object == null)
    14.                 return true;
    15.             if (object.toString().trim().length() == 0)
    16.                 return true;
    17.         }
    18.  
    19.         return false;
    20.     }
    21.  
    22.     public static boolean isBlankEmpty(Object obj) {
    23.         if (obj == null || "".equals(obj) || "".equals(obj.toString().trim()) || "null".equalsIgnoreCase(obj.toString()))
    24.             return true;
    25.  
    26.         return false;
    27.     }
    28.  
    29.     /**
    30.      * 是否空,或者为空串,或者为"null"
    31.      * @author guoyu
    32.      */
    33.     public static boolean isBlankEmpty(Object... objs) {
    34.         if (objs == null || objs.length == 0)
    35.             return true;
    36.         for (Object obj : objs) {
    37.             if (isBlankEmpty(obj)) {
    38.                 return true;
    39.             }
    40.         }
    41.  
    42.         return false;
    43.     }
    44.  
    45.     public static boolean isNotBlank(String pattern) {
    46.         return !isBlankEmpty(pattern);
    47.     }
    48.  
    49.     public static boolean isBlank(String pattern) {
    50.         return isBlankEmpty(pattern);
    51.     }
    52.  
    53.     public static String formatCountNames(String nameList) {
    54.         String[] names = nameList.split(",");
    55.  
    56.         Map<String, Integer> nameCount = new HashMap<String, Integer>();
    57.         for(String name : names) {
    58.             if(StringUtils.isEmpty(name)) continue;
    59.             if(nameCount.containsKey(name)) {
    60.                 Integer count = nameCount.get(name) + 1;
    61.                 nameCount.put(name, count);
    62.             } else {
    63.                 nameCount.put(name, 1);
    64.             }
    65.         }
    66.  
    67.         StringBuilder newNames = new StringBuilder();
    68.         for(String key : nameCount.keySet()) {
    69.             if(StringUtils.isEmpty(key)) continue;
    70.             Integer count = nameCount.get(key);
    71.             String splitChar = newNames.length() > 0 ? "," : "";
    72.             newNames.append(splitChar).append(key).append("x").append(count);
    73.         }
    74.  
    75.         return newNames.toString();
    76.     }
    77.  
    78.  
    79.     public static boolean isDigit(String str){
    80.         return isNumeric(str);
    81.     }
    82.  
    83.     public static boolean isChar(String str){
    84.         return str.matches(REG_CHAR);
    85.     }
    86.  
    87.     public static Boolean isNotEmpty(Object... obj) {
    88.         Boolean r = StringUtils.isEmpty(obj);
    89.         return !r;
    90.     }
    91.  
    92.     public static boolean isNumeric(String str) {
    93.         if(isBlankEmpty(str)) return false;
    94.         for (int i = str.length(); --i >= 0;) {
    95.             if (!Character.isDigit(str.charAt(i))) {
    96.                 return false;
    97.             }
    98.         }
    99.  
    100.         return true;
    101.     }
    102.  
    103.     /**
    104.      * string 中的 str 在倒数 num 中的位置
    105.      * @author guoyu
    106.      */
    107.     public static int stringLastlndex(String string, String str, int num) {
    108.         int indexOf = string.lastIndexOf(str);
    109.         if(num > 1){
    110.             return stringLastlndex(string.substring(0, indexOf), str, num - 1);
    111.         } else {
    112.             return indexOf;
    113.         }
    114.     }
    115.  
    116.  
    117.     public static String getValue(Object val) {
    118.         return val == null ? "" : val.toString().replace("\n", "");
    119.     }
    120.  
    121.     public static String getFileName(boolean type, Date startDate, String tableName){
    122.         String dateString = dateFormat(startDate,"yyyyMMdd");
    123.         StringBuffer stringBuffer = new StringBuffer(dateString);
    124.         stringBuffer.append("_");
    125.         stringBuffer.append(tableName);
    126.         stringBuffer.append("_");
    127.         if (type) {
    128.             stringBuffer.append("insert&");
    129.         } else {
    130.             stringBuffer.append("update&");
    131.         }
    132.         return stringBuffer.toString();
    133.     }
    134.  
    135.     public static String getRefundNumber(Integer payRefundNum) {
    136.         if (payRefundNum == null) payRefundNum = 0;
    137.         payRefundNum = payRefundNum + 1;
    138.         String string = String.valueOf(payRefundNum);
    139.         if (string.length() == 1) {
    140.             return "0"+string;
    141.         }
    142.         return string;
    143.  
    144.     }
    145.  
    146.     private static String dateFormat(Date date, String datePattern) {
    147.         if(date == null) return "";
    148.         if(datePattern == null) datePattern = "yyyy-MM-dd";
    149.         SimpleDateFormat df = new SimpleDateFormat(datePattern, Locale.UK);
    150.         return df.format(date);
    151.     }
    152. }
    • 日志工具类
    1. import org.apache.commons.logging.LogFactory;
    2.  
    3.  
    4. public class LogUtils {
    5.     private static final org.apache.commons.logging.Log logger;
    6.     private static final Object lock = new Object();
    7.  
    8.     static {
    9.         synchronized (lock) {
    10.             logger = LogFactory.getLog(LogUtils.class);
    11.         }
    12.     }
    13.  
    14.     public static void info(Object... msgs) {
    15.         StringBuilder stringBuilder = new StringBuilder();
    16.         Throwable e = null;
    17.         for (Object msg : msgs) {
    18.             if (msg != null) {
    19.                 if (msg instanceof Throwable) {
    20.                     e = (Throwable) msg;
    21.                 } else {
    22.                     stringBuilder.append(msg).append(" ");
    23.                 }
    24.             }
    25.         }
    26.         logger.info(stringBuilder, e);
    27.     }
    28.  
    29.     public static void error(Object... msgs) {
    30.         StringBuilder stringBuilder = new StringBuilder();
    31.         Throwable e = null;
    32.         for (Object msg : msgs) {
    33.             if (msg != null) {
    34.                 if (msg instanceof Throwable) {
    35.                     e = (Throwable) msg;
    36.                 } else {
    37.                     stringBuilder.append(msg).append(" ");
    38.                 }
    39.             }
    40.         }
    41.         logger.error(stringBuilder, e);
    42.     }
    43.  
    44.     public static void warn(Object... msgs) {
    45.         StringBuilder stringBuilder = new StringBuilder();
    46.         Throwable e = null;
    47.         for (Object msg : msgs) {
    48.             if (msg != null) {
    49.                 if (msg instanceof Throwable) {
    50.                     e = (Throwable) msg;
    51.                 } else {
    52.                     stringBuilder.append(msg).append(" ");
    53.                 }
    54.             }
    55.         }
    56.         logger.warn(stringBuilder, e);
    57.     }
    58.  
    59.     public static void debug(Object... msgs) {
    60.         StringBuilder stringBuilder = new StringBuilder();
    61.         Throwable e = null;
    62.         for (Object msg : msgs) {
    63.             if (msg != null) {
    64.                 if (msg instanceof Throwable) {
    65.                     e = (Throwable) msg;
    66.                 } else {
    67.                     stringBuilder.append(msg).append(" ");
    68.                 }
    69.             }
    70.         }
    71.         logger.debug(stringBuilder, e);
    72.     }
    73. }
    • 数据分析常量类
    1. public final class Constant {
    2.  
    3.     private Constant() {
    4.     }
    5.  
    6.     // 定时任务运行状态：运行
    7.     public static final Integer STATUS_RUNNING = 1;
    8.  
    9.     // 定时任务运行状态：停止
    10.     public static final Integer STATUS_NOT_RUNNING = 2;
    11.  
    12.     // 定时任务是否有状态：有（默认为1，弃用）
    13.     public static final Integer CONCURRENT_IS = 1;
    14.  
    15.     // 定时任务是否有状态：无（默认为1，弃用）
    16.     public static final Integer CONCURRENT_NOT = 0;
    17. }
    • 接口返回参数类
    1. @Data
    2. public class Result<T> {
    3.  
    4.     private Integer code;
    5.  
    6.     private T data;
    7.  
    8.     private String msg;
    9.  
    10.     public Result() {
    11.         super();
    12.     }
    13.  
    14.     public Result(T data) {
    15.         this.data = data;
    16.     }
    17.  
    18.     public static Result success()
    19.     {
    20.         return success("");
    21.     }
    22.  
    23.     public static <T> Result success(T data) {
    24.         Result<T> result = new Result<>(ResultEnum.SUCCESS.getCode(), ResultEnum.SUCCESS.getName());
    25.         result.setData(data);
    26.         return result;
    27.     }
    28.  
    29.     public static <T> Result<T> fail(ResultEnum resultEnum) {
    30.         return createResult(null, resultEnum.getCode(), resultEnum.getName());
    31.     }
    32.  
    33.     public static <T> Result<T> fail(Integer code, String message) {
    34.         return createResult(null, code, message);
    35.     }
    36.  
    37.     public static <T> Result<T> fail(Throwable e) {
    38.         //打印异常栈信息到控制台
    39.         e.printStackTrace();
    40.         return createResult(null, 500, "服务器发生错误");
    41.     }
    42.  
    43.     private static <T> Result<T> createResult(T data, Integer code, String message) {
    44.         Result<T> r = new Result<>();
    45.         r.setCode(code);
    46.         r.setData(data);
    47.         r.setMsg(message);
    48.         return r;
    49.     }
    50.  
    51.     public Result(Integer code, String msg)
    52.     {
    53.         this.code = code;
    54.         this.msg = msg;
    55.     }
    56. }

    其中ResultEnum类如下：

    1. public enum ResultEnum {
    2.  
    3.     SUCCESS(200,"请求成功"),
    4.     UN_KNOWN_ERROR(-1, "未知错误"),
    5.  
    6.     PARAM_NULL_ERROR(10001,"参数为空"),
    7.  
    8.     PERMISSION_ACCESS_DENIED(50001, "permission access denied");
    9.  
    10.  
    11.     private int code;
    12.     private String name;
    13.  
    14.     private ResultEnum(int code, String name) {
    15.         this.code = code;
    16.         this.name = name;
    17.     }
    18.  
    19.     public int getCode() {
    20.         return this.code;
    21.     }
    22.  
    23.     public String getName() {
    24.         return this.name;
    25.     }
    26.  
    27.     public static ResultEnum getNameByCode(int code) {
    28.         for (ResultEnum resultEnum : ResultEnum.values()) {
    29.             if (code == resultEnum.getCode()) {
    30.                 return resultEnum;
    31.             }
    32.         }
    33.         return null;
    34.     }
    35. }

    8、sql语句

    1. SET NAMES utf8mb4;
    2. SET FOREIGN_KEY_CHECKS = 0;
    3.  
    4. -- ----------------------------
    5. -- Table structure for schedule_job
    6. -- ----------------------------
    7. DROP TABLE IF EXISTS `schedule_job`;
    8. CREATE TABLE `schedule_job`  (
    9.   `id` varchar(64) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NOT NULL COMMENT '主键',
    10.   `job_name` varchar(100) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci DEFAULT NULL COMMENT '任务名称',
    11.   `job_group` varchar(100) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci DEFAULT NULL COMMENT '任务分组',
    12.   `job_status` int(0) DEFAULT NULL COMMENT '任务状态 是否启动任务；1：有效；2：失效',
    13.   `cron_expression` varchar(200) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci DEFAULT NULL COMMENT 'cron表达式，推荐使用6域的',
    14.   `description` varchar(200) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci DEFAULT NULL COMMENT '定时任务描述',
    15.   `bean_class` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci DEFAULT NULL COMMENT '任务执行时调用哪个类的方法 包名+类名，全路径',
    16.   `is_concurrent` int(0) DEFAULT 1 COMMENT '任务是否有状态；0：没有；1：有',
    17.   `spring_id` varchar(100) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci DEFAULT NULL COMMENT '注册的Bean，所以与类名保持一致，首字母小写',
    18.   `method_name` varchar(100) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci DEFAULT NULL COMMENT '任务调用的方法名',
    19.   `create_time` datetime(0) DEFAULT NULL COMMENT '创建时间',
    20.   `update_time` datetime(0) DEFAULT NULL COMMENT '更新时间',
    21.   PRIMARY KEY (`id`) USING BTREE
    22. ) ENGINE = InnoDB CHARACTER SET = utf8mb4 COLLATE = utf8mb4_0900_ai_ci ROW_FORMAT = Dynamic;
    23.  
    24. -- ----------------------------
    25. -- Records of schedule_job
    26. -- ----------------------------
    27. INSERT INTO `schedule_job` VALUES ('1', 'ClassAtmosphereTask', 'ClassAtmosphereTask', 1, '0 30 23 * * ?', '班级氛围值定时任务', 'com.saas.reptile.task.ClassAtmosphereTask', 1, 'classAtmosphereTask', 'work', '2022-06-25 21:38:42', '2022-06-25 21:38:45');
    28.  
    29. SET FOREIGN_KEY_CHECKS = 1;

    注释的很详细，其中：

    job_name和job_group保持一致即可；

    is_concurrent默认为1；

    任务执行的类要全路径等等。

    9、方法实现

    写在service的实现类里

    1. package com.saas.reptile.service.impl;
    2.  
    3. import com.baomidou.mybatisplus.service.impl.ServiceImpl;
    4. import com.saas.reptile.common.quartz.QuartzJobFactory;
    5. import com.saas.reptile.common.quartz.QuartzJobFactoryDisallowConcurrentExecution;
    6. import com.saas.reptile.entity.po.ScheduleJob;
    7. import com.saas.reptile.mapper.ScheduleJobMapper;
    8. import com.saas.reptile.service.ScheduleJobService;
    9. import com.saas.reptile.utils.Constant;
    10. import com.saas.reptile.utils.LogUtils;
    11. import org.quartz.*;
    12. import org.quartz.impl.matchers.GroupMatcher;
    13. import org.springframework.beans.factory.annotation.Autowired;
    14. import org.springframework.stereotype.Service;
    15. import org.springframework.transaction.annotation.Propagation;
    16. import org.springframework.transaction.annotation.Transactional;
    17. import org.springframework.scheduling.quartz.SchedulerFactoryBean;
    18.  
    19. import javax.annotation.PostConstruct;
    20. import java.util.ArrayList;
    21. import java.util.List;
    22. import java.util.Set;
    23.  
    24.  
    25. @Service
    26. public class ScheduleJobServiceImpl extends ServiceImpl<ScheduleJobMapper, ScheduleJob>
    27.         implements ScheduleJobService {
    28.  
    29.     @Autowired
    30.     private SchedulerFactoryBean schedulerFactoryBean;
    31.  
    32.     /**
    33.      * 添加定时任务到数据库
    34.      * @param scheduleJob
    35.      */
    36.     @Override
    37.     @Transactional(propagation = Propagation.REQUIRED)
    38.     public void addTask(ScheduleJob scheduleJob) {
    39.         this.baseMapper.insert(scheduleJob);
    40.     }
    41.  
    42.     /**
    43.      * 改变定时任务状态
    44.      * @param id
    45.      * @param status
    46.      */
    47.     @Override
    48.     @Transactional(propagation = Propagation.REQUIRED)
    49.     public void changeJobStatus(String id, Integer status) throws SchedulerException {
    50. //        EntityWrapper<ScheduleJob> wrapper = new EntityWrapper<>();
    51. //        wrapper.eq("id",id);
    52. //        String setSql = "job_status = " + status;
    53. //        this.baseMapper.updateForSet(setSql, wrapper);
    54.         ScheduleJob job = selectById(id);
    55.         if (status == 1){
    56.             // 启动
    57.             job.setJobStatus(status);
    58.             addJob(job);
    59.         } else if (status == 2) {
    60.             // 停止
    61.             deleteJob(job);
    62.             job.setJobStatus(status);
    63.         }
    64.         // 更新定时任务
    65.         updateById(job);
    66.     }
    67.  
    68.     /**
    69.      * 更新定时任务cron表达式与运行状态
    70.      * @param jobId     定时任务主键ID
    71.      * @param cron      表达式
    72.      * @param status    定时状态
    73.      */
    74.     @Override
    75.     @Transactional(propagation = Propagation.REQUIRED)
    76.     public void updateCronStatus(String jobId, String cron, Integer status) throws SchedulerException {
    77.         ScheduleJob job = selectById(jobId);
    78.         if (status == 1){
    79.             // 启动
    80.             job.setJobStatus(status);
    81.             job.setCronExpression(cron);
    82.             addJob(job);
    83.         } else if (status == 2) {
    84.             // 停止
    85.             deleteJob(job);
    86.             job.setJobStatus(status);
    87.             job.setCronExpression(cron);
    88.         }
    89.         // 更新定时任务
    90.         updateById(job);
    91.     }
    92.  
    93.     /**
    94.      * 添加任务
    95.      *
    96.      * @param job
    97.      * @throws SchedulerException
    98.      */
    99.     @Transactional(propagation = Propagation.REQUIRED)
    100.     public void addJob(ScheduleJob job) throws SchedulerException {
    101.         // 定时任务运行状态为1则进入下一步
    102.         if (job == null || !Constant.STATUS_RUNNING.equals(job.getJobStatus())) {
    103.             return;
    104.         }
    105.         Scheduler scheduler = schedulerFactoryBean.getScheduler();
    106.         LogUtils.info(scheduler + ".......................................................................................add");
    107.         TriggerKey triggerKey = TriggerKey.triggerKey(job.getJobName(), job.getJobGroup());
    108.  
    109.         CronTrigger trigger = (CronTrigger) scheduler.getTrigger(triggerKey);
    110.  
    111.         // 不存在，创建一个
    112.         if (null == trigger) {
    113.             Class clazz = Constant.CONCURRENT_IS.equals(job.getIsConcurrent()) ? QuartzJobFactory.class : QuartzJobFactoryDisallowConcurrentExecution.class;
    114.  
    115.             JobDetail jobDetail = JobBuilder.newJob(clazz).withIdentity(job.getJobName(), job.getJobGroup()).build();
    116.  
    117.             jobDetail.getJobDataMap().put("scheduleJob", job);
    118.  
    119.             CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(job.getCronExpression());
    120.  
    121.             trigger = TriggerBuilder.newTrigger().withIdentity(job.getJobName(), job.getJobGroup()).withSchedule(scheduleBuilder).build();
    122.  
    123.             scheduler.scheduleJob(jobDetail, trigger);
    124.         } else {
    125.             // Trigger已存在，那么更新相应的定时设置
    126.             CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(job.getCronExpression());
    127.  
    128.             // 按新的cronExpression表达式重新构建trigger
    129.             trigger = trigger.getTriggerBuilder().withIdentity(triggerKey).withSchedule(scheduleBuilder).build();
    130.  
    131.             // 按新的trigger重新设置job执行
    132.             scheduler.rescheduleJob(triggerKey, trigger);
    133.         }
    134.     }
    135.  
    136.     @PostConstruct
    137.     public void init() throws Exception {
    138.         LogUtils.info("实例化List<ScheduleJob>,从数据库读取....",this);
    139.         // 这里获取任务信息数据
    140.         List<ScheduleJob> jobList = selectList(null);
    141.         for (ScheduleJob job : jobList) {
    142.             addJob(job);
    143.         }
    144.     }
    145.  
    146.     /**
    147.      * 获取所有计划中的任务列表
    148.      *
    149.      * @return
    150.      * @throws SchedulerException
    151.      */
    152.     public List<ScheduleJob> getAllJob() throws SchedulerException {
    153.         Scheduler scheduler = schedulerFactoryBean.getScheduler();
    154.         GroupMatcher<JobKey> matcher = GroupMatcher.anyJobGroup();
    155.         Set<JobKey> jobKeys = scheduler.getJobKeys(matcher);
    156.         List<ScheduleJob> jobList = new ArrayList<ScheduleJob>();
    157.         for (JobKey jobKey : jobKeys) {
    158.             List<? extends Trigger> triggers = scheduler.getTriggersOfJob(jobKey);
    159.             for (Trigger trigger : triggers) {
    160.                 ScheduleJob job = new ScheduleJob();
    161.                 job.setJobName(jobKey.getName());
    162.                 job.setJobGroup(jobKey.getGroup());
    163.                 job.setDescription("触发器:" + trigger.getKey());
    164.                 Trigger.TriggerState triggerState = scheduler.getTriggerState(trigger.getKey());
    165.                 job.setJobStatus(Integer.parseInt(triggerState.name()));
    166.                 if (trigger instanceof CronTrigger) {
    167.                     CronTrigger cronTrigger = (CronTrigger) trigger;
    168.                     String cronExpression = cronTrigger.getCronExpression();
    169.                     job.setCronExpression(cronExpression);
    170.                 }
    171.                 jobList.add(job);
    172.             }
    173.         }
    174.         return jobList;
    175.     }
    176.  
    177.     /**
    178.      * 所有正在运行的job
    179.      *
    180.      * @return
    181.      * @throws SchedulerException
    182.      */
    183.     public List<ScheduleJob> getRunningJob() throws SchedulerException {
    184.         Scheduler scheduler = schedulerFactoryBean.getScheduler();
    185.         List<JobExecutionContext> executingJobs = scheduler.getCurrentlyExecutingJobs();
    186.         List<ScheduleJob> jobList = new ArrayList<ScheduleJob>(executingJobs.size());
    187.         for (JobExecutionContext executingJob : executingJobs) {
    188.             ScheduleJob job = new ScheduleJob();
    189.             JobDetail jobDetail = executingJob.getJobDetail();
    190.             JobKey jobKey = jobDetail.getKey();
    191.             Trigger trigger = executingJob.getTrigger();
    192.             job.setJobName(jobKey.getName());
    193.             job.setJobGroup(jobKey.getGroup());
    194.             job.setDescription("触发器:" + trigger.getKey());
    195.             Trigger.TriggerState triggerState = scheduler.getTriggerState(trigger.getKey());
    196.             job.setJobStatus(Integer.parseInt(triggerState.name()));
    197.             if (trigger instanceof CronTrigger) {
    198.                 CronTrigger cronTrigger = (CronTrigger) trigger;
    199.                 String cronExpression = cronTrigger.getCronExpression();
    200.                 job.setCronExpression(cronExpression);
    201.             }
    202.             jobList.add(job);
    203.         }
    204.         return jobList;
    205.     }
    206.  
    207.     /**
    208.      * 暂停一个job
    209.      *
    210.      * @param scheduleJob
    211.      * @throws SchedulerException
    212.      */
    213.     public void pauseJob(ScheduleJob scheduleJob) throws SchedulerException {
    214.         Scheduler scheduler = schedulerFactoryBean.getScheduler();
    215.         JobKey jobKey = JobKey.jobKey(scheduleJob.getJobName(), scheduleJob.getJobGroup());
    216.         scheduler.pauseJob(jobKey);
    217.     }
    218.  
    219.     /**
    220.      * 恢复一个job
    221.      *
    222.      * @param scheduleJob
    223.      * @throws SchedulerException
    224.      */
    225.     public void resumeJob(ScheduleJob scheduleJob) throws SchedulerException {
    226.         Scheduler scheduler = schedulerFactoryBean.getScheduler();
    227.         JobKey jobKey = JobKey.jobKey(scheduleJob.getJobName(), scheduleJob.getJobGroup());
    228.         scheduler.resumeJob(jobKey);
    229.     }
    230.  
    231.     /**
    232.      * 删除一个job
    233.      *
    234.      * @param scheduleJob
    235.      * @throws SchedulerException
    236.      */
    237.     public void deleteJob(ScheduleJob scheduleJob) throws SchedulerException {
    238.         Scheduler scheduler = schedulerFactoryBean.getScheduler();
    239.         JobKey jobKey = JobKey.jobKey(scheduleJob.getJobName(), scheduleJob.getJobGroup());
    240.         scheduler.deleteJob(jobKey);
    241.  
    242.     }
    243.  
    244.     /**
    245.      * 立即执行job
    246.      *
    247.      * @param scheduleJob
    248.      * @throws SchedulerException
    249.      */
    250.     public void runAJobNow(ScheduleJob scheduleJob) throws SchedulerException {
    251.         Scheduler scheduler = schedulerFactoryBean.getScheduler();
    252.         JobKey jobKey = JobKey.jobKey(scheduleJob.getJobName(), scheduleJob.getJobGroup());
    253.         scheduler.triggerJob(jobKey);
    254.     }
    255.  
    256.     /**
    257.      * 更新job时间表达式
    258.      *
    259.      * @param scheduleJob
    260.      * @throws SchedulerException
    261.      */
    262.     public void updateJobCron(ScheduleJob scheduleJob) throws SchedulerException {
    263.         Scheduler scheduler = schedulerFactoryBean.getScheduler();
    264.  
    265.         TriggerKey triggerKey = TriggerKey.triggerKey(scheduleJob.getJobName(), scheduleJob.getJobGroup());
    266.  
    267.         CronTrigger trigger = (CronTrigger) scheduler.getTrigger(triggerKey);
    268.  
    269.         CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(scheduleJob.getCronExpression());
    270.  
    271.         trigger = trigger.getTriggerBuilder().withIdentity(triggerKey).withSchedule(scheduleBuilder).build();
    272.  
    273.         scheduler.rescheduleJob(triggerKey, trigger);
    274.     }
    275. }

    1、项目启动后首先运行上述方法里的init()方法，查询数据库表里的所有定时任务；

    2、然后到添加job方法【addJob】，将状态为1的定时任务推到Scheduler计划中

    3、还提供了获取所有计划中的任务列表、查询正在运行的job、暂停一个job等方法，不过暂时我没有用到。

    4、本项目是通过mybatis-plus进行数据库操作，当更新运行状态时，如果状态为1则启动job，如果状态为2则停止job。

    5、控制层方法省略，按实际生产环境来。

    参考资料：https://gitee.com/gangye/springboot_quartz_schedule

  • 相关阅读:
    vue中的生命周期有什么，怎么用
    Ubuntu20.04环境下编译MNN
    使用Django如何才能在浏览器页面中展示从摄像头中获取的画面opencv处理过的效果
    使用免费开源的Odoo CRM如何有效的获取潜在客户线索的经验分享
    Ajax,json
    机器学习笔记之高斯分布(五)推断任务之边缘概率分布与条件概率分布
    Go语言 和 Java语言对比理解系列一：函数参数传递
    #gStore-weekly | SPARQL 执行过程中高级查询函数的求值（上）
    【保姆级·创建对象】如何通过Supplier创建对象
    OpenCV的二值化处理函数threshold()详解
  • 原文地址：https://blog.csdn.net/qq_37634156/article/details/125465298