Quartz动态添加,修改,删除任务(暂停,任务状态,恢复,最近触发时间)

Quartz动态添加,修改,删除任务(暂停,任务状态,恢复,最近触发时间)
Quartz动态添加,修改,删除任务(暂停,任务状态,恢复,最近触发时间)

关闭

  • quartz_Cron表达式一分钟教程

    09-05

  • quartz定时任务中常用的cron表达式

    05-08

  • Quartz2实现任务的临时启动/暂停/恢复

    05-17

  • quartz 获取正在执行的任务

    12-20

  • 在spring中实现quartz的动态调度(开始、暂停、停止等)

    09-04

  • SpringQuartz定时任务的cron表达式书写

    09-17

  • 定时任务Quartz_之_cron表达式(时间表达式)

    07-18

  • 查看Quartz 调度任务 job 的状态

    02-07

  • Quartz-基础

    06-25

  • spring quartz 根据开始时间 结束时间 动态设置任务

    08-28

  • Quartz任务调度原理简析

    05-30

  • Quartz_Cron表达式_每周、每月执行一次

    09-04

  • 得到quartz中Job的执行状态

    11-09

  • quartz定时:修改时间及时生效的定时任务

    08-16

  • Quartz任务调度的Cron表达式

    09-30

  • cron表达式(Quartz中的使用)

    01-03

  • quartz_时间表达式之Cron表达式详解

    08-16

  • quartz中cron表达式

    10-25

  • quartz任务停止最佳实践方式

    03-06

  • Spring+Quartz 实现任务动态管理监控

    12-20

  • Quartz-中断正在执行的任务

    11-15

  • spring-boot+quartz的CRUD动态任务管理系统

    04-03

  • Quartz_Cron表达式(定时任务)

    05-11

  • java时间操作

    05-31

  • TimeUtil工具类

    12-04

  • 随机生成日期

    12-11

  • quartz2.x的动态管理类

    12-07

  • 去除节假日,周末,获取当月的工作日

    06-05

  • java_日期的操作汇总

    11-03

  • DateUtil

    06-06

  • cron表达式获取上次执行时间和下次执行时间

    12-28

  • POI导出excel表格优化

    10-15

  • java_时间处理

    12-04

  • JAVA获取某段时间内的所有日期

    10-11

  • 逐页缓存查询(串行,避免OOM)导出Excel,zip压缩

    07-31

Quartz动态添加,修改,删除任务(暂停,任务状态,恢复,最近触发时间)

2018年05月25日 11:16:07 loveLifeLoveCoding 阅读数:2192
 

本案例采用quartz-2.2.3.jar

入门案例,执行比较简单的任务

QuartzManager.java  (任务的管理)

  1.  
    import java.text.ParseException;
  2.  
    import java.text.SimpleDateFormat;
  3.  
    import java.util.ArrayList;
  4.  
    import java.util.Date;
  5.  
    import java.util.List;
  6.  
     
  7.  
    import org.quartz.CronScheduleBuilder;
  8.  
    import org.quartz.CronTrigger;
  9.  
    import org.quartz.JobBuilder;
  10.  
    import org.quartz.JobDetail;
  11.  
    import org.quartz.JobKey;
  12.  
    import org.quartz.Scheduler;
  13.  
    import org.quartz.SchedulerException;
  14.  
    import org.quartz.SchedulerFactory;
  15.  
    import org.quartz.Trigger;
  16.  
    import org.quartz.Trigger.TriggerState;
  17.  
    import org.quartz.TriggerBuilder;
  18.  
    import org.quartz.TriggerKey;
  19.  
    import org.quartz.TriggerUtils;
  20.  
    import org.quartz.impl.StdSchedulerFactory;
  21.  
    import org.quartz.impl.triggers.CronTriggerImpl;
  22.  
     
  23.  
    public class QuartzManager {
  24.  
     
  25.  
    private static SchedulerFactory gSchedulerFactory = new StdSchedulerFactory();
  26.  
    private static String JOB_GROUP_NAME = "MY_JOBGROUP_NAME";
  27.  
    private static String TRIGGER_GROUP_NAME = "MY_TRIGGERGROUP_NAME";
  28.  
     
  29.  
    /**
  30.  
    * @Description: 添加一个定时任务,使用默认的任务组名,触发器名,触发器组名
  31.  
    * @param jobName
  32.  
    * 任务名
  33.  
    * @param cls
  34.  
    * 任务
  35.  
    * @param time
  36.  
    * 时间设置,参考quartz说明文档
  37.  
    */
  38.  
    @SuppressWarnings({ "rawtypes", "unchecked" })
  39.  
    public static void addJob(String jobName, Class cls, String cron) {
  40.  
    try {
  41.  
    Scheduler sched = gSchedulerFactory.getScheduler();
  42.  
    JobDetail job = JobBuilder.newJob(cls).withIdentity(jobName, JOB_GROUP_NAME).build();
  43.  
    // 表达式调度构建器
  44.  
    CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(cron);
  45.  
    // 按新的cronExpression表达式构建一个新的trigger
  46.  
    Trigger trigger = TriggerBuilder.newTrigger().withIdentity(jobName, TRIGGER_GROUP_NAME)
  47.  
    .withSchedule(scheduleBuilder).build();
  48.  
     
  49.  
    // 交给scheduler去调度
  50.  
    sched.scheduleJob(job, trigger);
  51.  
     
  52.  
    // 启动
  53.  
    if (!sched.isShutdown()) {
  54.  
    sched.start();
  55.  
    System.err.println("添加任务:"+jobName);
  56.  
    }
  57.  
    } catch (Exception e) {
  58.  
    throw new RuntimeException(e);
  59.  
    }
  60.  
    }
  61.  
     
  62.  
    /**
  63.  
    * @Description: 添加一个定时任务
  64.  
    * @param jobName
  65.  
    * 任务名
  66.  
    * @param jobGroupName
  67.  
    * 任务组名
  68.  
    * @param triggerName
  69.  
    * 触发器名
  70.  
    * @param triggerGroupName
  71.  
    * 触发器组名
  72.  
    * @param jobClass
  73.  
    * 任务
  74.  
    * @param time
  75.  
    * 时间设置,参考quartz说明文档
  76.  
    */
  77.  
    @SuppressWarnings({ "rawtypes", "unchecked" })
  78.  
    public static void addJob(String jobName, String jobGroupName, String triggerName, String triggerGroupName,
  79.  
    Class jobClass, String cron) {
  80.  
    try {
  81.  
    Scheduler sched = gSchedulerFactory.getScheduler();
  82.  
    JobDetail job = JobBuilder.newJob(jobClass).withIdentity(jobName, jobGroupName).build();
  83.  
    // 表达式调度构建器
  84.  
    CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(cron);
  85.  
    // 按新的cronExpression表达式构建一个新的trigger
  86.  
    Trigger trigger = TriggerBuilder.newTrigger().withIdentity(triggerName, triggerGroupName)
  87.  
    .withSchedule(scheduleBuilder).build();
  88.  
    sched.scheduleJob(job, trigger);
  89.  
    // 启动
  90.  
    if (!sched.isShutdown()) {
  91.  
    sched.start();
  92.  
    }
  93.  
    } catch (Exception e) {
  94.  
    throw new RuntimeException(e);
  95.  
    }
  96.  
    }
  97.  
     
  98.  
    /**
  99.  
    * @Description: 修改一个任务的触发时间(使用默认的任务组名,触发器名,触发器组名)
  100.  
    * @param jobName
  101.  
    * @param time
  102.  
    */
  103.  
    public static void modifyJobTime(String jobName, String cron) {
  104.  
    TriggerKey triggerKey = TriggerKey.triggerKey(jobName, TRIGGER_GROUP_NAME);
  105.  
     
  106.  
    try {
  107.  
    Scheduler sched = gSchedulerFactory.getScheduler();
  108.  
    CronTrigger trigger = (CronTrigger) sched.getTrigger(triggerKey);
  109.  
    if (trigger == null) {
  110.  
    return;
  111.  
    }
  112.  
    String oldTime = trigger.getCronExpression();
  113.  
    if (!oldTime.equalsIgnoreCase(cron)) {
  114.  
    CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(cron);
  115.  
    // 按新的cronExpression表达式重新构建trigger
  116.  
    trigger = trigger.getTriggerBuilder().withIdentity(triggerKey).withSchedule(scheduleBuilder).build();
  117.  
    // 按新的trigger重新设置job执行
  118.  
    sched.rescheduleJob(triggerKey, trigger);
  119.  
    }
  120.  
    } catch (Exception e) {
  121.  
    throw new RuntimeException(e);
  122.  
    }
  123.  
    }
  124.  
     
  125.  
     
  126.  
    /**
  127.  
    * @Description:修改任务,(可以修改任务名,任务类,触发时间)
  128.  
    * 原理:移除原来的任务,添加新的任务
  129.  
    * @param oldJobName :原任务名
  130.  
    * @param jobName
  131.  
    * @param jobclass
  132.  
    * @param cron
  133.  
    * @date 2018年5月23日 上午9:13:10
  134.  
    */
  135.  
    @SuppressWarnings({ "rawtypes", "unchecked" })
  136.  
    public static void modifyJob(String oldJobName, String jobName, Class jobclass, String cron) {
  137.  
    /*
  138.  
    * removeJob(oldJobName);
  139.  
    * addJob(jobName, jobclass, cron);
  140.  
    * System.err.println("修改任务"+oldJobName);
  141.  
    */
  142.  
    TriggerKey triggerKey = TriggerKey.triggerKey(oldJobName, TRIGGER_GROUP_NAME);
  143.  
    JobKey jobKey = JobKey.jobKey(oldJobName, JOB_GROUP_NAME);
  144.  
    try {
  145.  
    Scheduler sched = gSchedulerFactory.getScheduler();
  146.  
    Trigger trigger = (Trigger) sched.getTrigger(triggerKey);
  147.  
    if (trigger == null) {
  148.  
    return;
  149.  
    }
  150.  
    sched.pauseTrigger(triggerKey);// 停止触发器
  151.  
    sched.unscheduleJob(triggerKey);// 移除触发器
  152.  
    sched.deleteJob(jobKey);// 删除任务
  153.  
    System.err.println("移除任务:" + oldJobName);
  154.  
     
  155.  
    JobDetail job = JobBuilder.newJob(jobclass).withIdentity(jobName, JOB_GROUP_NAME).build();
  156.  
    // 表达式调度构建器
  157.  
    CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(cron);
  158.  
    // 按新的cronExpression表达式构建一个新的trigger
  159.  
    Trigger newTrigger = TriggerBuilder.newTrigger().withIdentity(jobName, TRIGGER_GROUP_NAME)
  160.  
    .withSchedule(scheduleBuilder).build();
  161.  
     
  162.  
    // 交给scheduler去调度
  163.  
    sched.scheduleJob(job, newTrigger);
  164.  
     
  165.  
    // 启动
  166.  
    if (!sched.isShutdown()) {
  167.  
    sched.start();
  168.  
    System.err.println("添加新任务:" + jobName);
  169.  
    }
  170.  
    System.err.println("修改任务【" + oldJobName + "】为:" + jobName);
  171.  
    } catch (Exception e) {
  172.  
    throw new RuntimeException(e);
  173.  
    }
  174.  
     
  175.  
    }
  176.  
     
  177.  
     
  178.  
    /**
  179.  
    * @Description: 修改一个任务的触发时间
  180.  
    * @param triggerName
  181.  
    * @param triggerGroupName
  182.  
    * @param time
  183.  
    */
  184.  
    public static void modifyJobTime(String triggerName, String triggerGroupName, String cron) {
  185.  
    TriggerKey triggerKey = TriggerKey.triggerKey(triggerName, triggerGroupName);
  186.  
    try {
  187.  
    Scheduler sched = gSchedulerFactory.getScheduler();
  188.  
    CronTrigger trigger = (CronTrigger) sched.getTrigger(triggerKey);
  189.  
    if (trigger == null) {
  190.  
    return;
  191.  
    }
  192.  
    String oldTime = trigger.getCronExpression();
  193.  
    if (!oldTime.equalsIgnoreCase(cron)) {
  194.  
    // trigger已存在,则更新相应的定时设置
  195.  
    CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(cron);
  196.  
    // 按新的cronExpression表达式重新构建trigger
  197.  
    trigger = trigger.getTriggerBuilder().withIdentity(triggerKey).withSchedule(scheduleBuilder).build();
  198.  
    // 按新的trigger重新设置job执行
  199.  
    sched.resumeTrigger(triggerKey);
  200.  
    }
  201.  
    } catch (Exception e) {
  202.  
    throw new RuntimeException(e);
  203.  
    }
  204.  
    }
  205.  
     
  206.  
    /**
  207.  
    * @Description 移除一个任务(使用默认的任务组名,触发器名,触发器组名)
  208.  
    * @param jobName
  209.  
    */
  210.  
    public static void removeJob(String jobName) {
  211.  
    TriggerKey triggerKey = TriggerKey.triggerKey(jobName, TRIGGER_GROUP_NAME);
  212.  
    JobKey jobKey = JobKey.jobKey(jobName, JOB_GROUP_NAME);
  213.  
    try {
  214.  
    Scheduler sched = gSchedulerFactory.getScheduler();
  215.  
    Trigger trigger = (Trigger) sched.getTrigger(triggerKey);
  216.  
    if (trigger == null) {
  217.  
    return;
  218.  
    }
  219.  
    sched.pauseTrigger(triggerKey);// 停止触发器
  220.  
    sched.unscheduleJob(triggerKey);// 移除触发器
  221.  
    sched.deleteJob(jobKey);// 删除任务
  222.  
    System.err.println("移除任务:"+jobName);
  223.  
    } catch (Exception e) {
  224.  
    throw new RuntimeException(e);
  225.  
    }
  226.  
    }
  227.  
     
  228.  
    /**
  229.  
    * @Description: 移除一个任务
  230.  
    * @param jobName
  231.  
    * @param jobGroupName
  232.  
    * @param triggerName
  233.  
    * @param triggerGroupName
  234.  
    */
  235.  
    public static void removeJob(String jobName, String jobGroupName, String triggerName, String triggerGroupName) {
  236.  
    TriggerKey triggerKey = TriggerKey.triggerKey(jobName, triggerGroupName);
  237.  
    JobKey jobKey = JobKey.jobKey(jobName, jobGroupName);
  238.  
    try {
  239.  
    Scheduler sched = gSchedulerFactory.getScheduler();
  240.  
    sched.pauseTrigger(triggerKey);// 停止触发器
  241.  
    sched.unscheduleJob(triggerKey);// 移除触发器
  242.  
    sched.deleteJob(jobKey);// 删除任务
  243.  
    } catch (Exception e) {
  244.  
    throw new RuntimeException(e);
  245.  
    }
  246.  
    }
  247.  
     
  248.  
    /**
  249.  
    * @Description:暂停一个任务(使用默认组名)
  250.  
    * @param jobName
  251.  
    */
  252.  
    public static void pauseJob(String jobName) {
  253.  
    JobKey jobKey = JobKey.jobKey(jobName, JOB_GROUP_NAME);
  254.  
    try {
  255.  
    Scheduler sched = gSchedulerFactory.getScheduler();
  256.  
    sched.pauseJob(jobKey);
  257.  
    } catch (SchedulerException e) {
  258.  
    e.printStackTrace();
  259.  
    }
  260.  
    }
  261.  
     
  262.  
    /**
  263.  
    * @Description:暂停一个任务
  264.  
    * @param jobName
  265.  
    * @param jobGroupName
  266.  
    */
  267.  
    public static void pauseJob(String jobName, String jobGroupName) {
  268.  
    JobKey jobKey = JobKey.jobKey(jobName, jobGroupName);
  269.  
    try {
  270.  
    Scheduler sched = gSchedulerFactory.getScheduler();
  271.  
    sched.pauseJob(jobKey);
  272.  
    } catch (SchedulerException e) {
  273.  
    e.printStackTrace();
  274.  
    }
  275.  
    }
  276.  
     
  277.  
    /**
  278.  
    * @Description:恢复一个任务(使用默认组名)
  279.  
    * @param jobName
  280.  
    */
  281.  
    public static void resumeJob(String jobName) {
  282.  
    JobKey jobKey = JobKey.jobKey(jobName, JOB_GROUP_NAME);
  283.  
    try {
  284.  
    Scheduler sched = gSchedulerFactory.getScheduler();
  285.  
    sched.resumeJob(jobKey);
  286.  
    } catch (SchedulerException e) {
  287.  
    e.printStackTrace();
  288.  
    }
  289.  
    }
  290.  
     
  291.  
    /**
  292.  
    * @Description:恢复一个任务
  293.  
    * @param jobName
  294.  
    * @param jobGroupName
  295.  
    * @date 2018年5月17日 上午9:56:09
  296.  
    */
  297.  
    public static void resumeJob(String jobName, String jobGroupName) {
  298.  
    JobKey jobKey = JobKey.jobKey(jobName, jobGroupName);
  299.  
    try {
  300.  
    Scheduler sched = gSchedulerFactory.getScheduler();
  301.  
    sched.resumeJob(jobKey);
  302.  
    } catch (SchedulerException e) {
  303.  
    e.printStackTrace();
  304.  
    }
  305.  
    }
  306.  
     
  307.  
    /**
  308.  
    * @Description:启动所有定时任务
  309.  
    */
  310.  
    public static void startJobs() {
  311.  
    try {
  312.  
    Scheduler sched = gSchedulerFactory.getScheduler();
  313.  
    sched.start();
  314.  
    } catch (Exception e) {
  315.  
    throw new RuntimeException(e);
  316.  
    }
  317.  
    }
  318.  
     
  319.  
    /**
  320.  
    * @Description 关闭所有定时任务
  321.  
    */
  322.  
    public static void shutdownJobs() {
  323.  
    try {
  324.  
    Scheduler sched = gSchedulerFactory.getScheduler();
  325.  
    if (!sched.isShutdown()) {
  326.  
    sched.shutdown();
  327.  
    }
  328.  
         } catch (Exception e) {
  329.  
    throw new RuntimeException(e);
  330.  
    }
  331.  
    }
  332.  
     
  333.  
    /**
  334.  
    * @Description: 立即运行任务,这里的立即运行,只会运行一次,方便测试时用。
  335.  
    * @param jobName
  336.  
    * @param jobGroupName
  337.  
    * @date 2018年5月17日 上午10:03:26
  338.  
    */
  339.  
    public static void triggerJob(String jobName) {
  340.  
    JobKey jobKey = JobKey.jobKey(jobName, JOB_GROUP_NAME);
  341.  
    try {
  342.  
    Scheduler sched = gSchedulerFactory.getScheduler();
  343.  
    sched.triggerJob(jobKey);
  344.  
    } catch (SchedulerException e) {
  345.  
    e.printStackTrace();
  346.  
    }
  347.  
    }
  348.  
     
  349.  
    /**
  350.  
    * @Description: 立即运行任务,这里的立即运行,只会运行一次,方便测试时用。
  351.  
    * @param jobName
  352.  
    * @param jobGroupName
  353.  
    * @date 2018年5月17日 上午10:03:26
  354.  
    */
  355.  
    public static void triggerJob(String jobName, String jobGroupName) {
  356.  
    JobKey jobKey = JobKey.jobKey(jobName, jobGroupName);
  357.  
    try {
  358.  
    Scheduler sched = gSchedulerFactory.getScheduler();
  359.  
    sched.triggerJob(jobKey);
  360.  
    } catch (SchedulerException e) {
  361.  
    e.printStackTrace();
  362.  
    }
  363.  
    }
  364.  
     
  365.  
    /**
  366.  
    * @Description: 获取任务状态
  367.  
    * NONE: 不存在
  368.  
    * NORMAL: 正常
  369.  
    * PAUSED: 暂停
  370.  
    * COMPLETE:完成
  371.  
    * ERROR : 错误
  372.  
    * BLOCKED : 阻塞
  373.  
    * @param jobName 触发器名
  374.  
    * @date 2018年5月21日 下午2:13:45
  375.  
    */
  376.  
    public static String getTriggerState(String jobName){
  377.  
    TriggerKey triggerKey = TriggerKey.triggerKey(jobName, TRIGGER_GROUP_NAME);
  378.  
    String name = null;
  379.  
    try {
  380.  
    Scheduler sched = gSchedulerFactory.getScheduler();
  381.  
    TriggerState triggerState = sched.getTriggerState(triggerKey);
  382.  
    name = triggerState.name();
  383.  
    } catch (SchedulerException e) {
  384.  
    e.printStackTrace();
  385.  
    }
  386.  
    return name;
  387.  
    }
  388.  
     
  389.  
    /**
  390.  
    * @Description:获取最近8次执行时间
  391.  
    * @param cron
  392.  
    * @date 2018年5月24日 下午5:13:03
  393.  
    */
  394.  
    public static List<String> getRecentTriggerTime(String cron) {
  395.  
    List<String> list = new ArrayList<String>();
  396.  
    try {
  397.  
    CronTriggerImpl cronTriggerImpl = new CronTriggerImpl();
  398.  
    cronTriggerImpl.setCronExpression(cron);
  399.  
    // 这个是重点,一行代码搞定
  400.  
    List<Date> dates = TriggerUtils.computeFireTimes(cronTriggerImpl, null, 8);
  401.  
    SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
  402.  
    for (Date date : dates) {
  403.  
    list.add(dateFormat.format(date));
  404.  
    }
  405.  
     
  406.  
    } catch (ParseException e) {
  407.  
    e.printStackTrace();
  408.  
    }
  409.  
    return list;
  410.  
    }
  411.  
     
  412.  
    }

MyJob.java  执行的任务

  1.  
     
  2.  
    import java.text.SimpleDateFormat;
  3.  
    import java.util.Calendar;
  4.  
     
  5.  
    import org.quartz.Job;
  6.  
    import org.quartz.JobExecutionContext;
  7.  
    import org.quartz.JobExecutionException;
  8.  
     
  9.  
    /**
  10.  
    * @Description:
  11.  
    * @date 2018年5月16日
  12.  
    */
  13.  
    public class MyJob implements Job {
  14.  
     
  15.  
    @Override
  16.  
    public void execute(JobExecutionContext context) throws JobExecutionException {
  17.  
     
  18.  
    System.err.println("任务运行开始-------- start --------");
  19.  
    try {
  20.  
    String jobName = context.getJobDetail().getKey().getName();
  21.  
    String jobGroup = context.getJobDetail().getKey().getGroup();
  22.  
    String triggerName = context.getTrigger().getKey().getName();
  23.  
    String triggerGroup = context.getTrigger().getKey().getGroup();
  24.  
     
  25.  
    SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy年MM月dd日 HH时mm分ss秒");
  26.  
    System.err.println("触发器Key:" + triggerName + ".." + triggerGroup + " 正在执行...");
  27.  
    System.err.println("任务Key:" + jobName + ".." + jobGroup + " 正在执行,执行时间: "
  28.  
    + dateFormat.format(Calendar.getInstance().getTime()));
  29.  
     
  30.  
    }catch (Exception e) {
  31.  
    System.err.println("捕获异常==="+e);
  32.  
    }
  33.  
    System.err.println("任务运行结束-------- end --------");
  34.  
    }
  35.  
     
  36.  
    }

测试类 LoadTask.java

  1.  
     
  2.  
    public class LoadTask {
  3.  
     
  4.  
    public static void main(String[] args) {
  5.  
    System.err.println("【系统启动】");
  6.  
    String corn = "0/5 * * * * ?";
  7.  
    //QuartzManager.addJob("job1", "jobGooup", "trigger1", "triggerGroup", MyJob.class, corn);
  8.  
    QuartzManager.addJob("job1", MyJob.class, corn);
  9.  
    System.err.println("添加任务一");
  10.  
    QuartzManager.getTriggerState("jobs");
  11.  
     
  12.  
    //睡眠一分钟
  13.  
    try {
  14.  
    Thread.sleep(60L * 1000L);
  15.  
    } catch (InterruptedException e) {
  16.  
    e.printStackTrace();
  17.  
    }
  18.  
     
  19.  
     
  20.  
    QuartzManager.modifyJobTime("job1", "0/3 * * * * ?");
  21.  
    System.out.println("修改触发时间");
  22.  
     
  23.  
    try {
  24.  
    Thread.sleep(15L * 1000L);
  25.  
    } catch (InterruptedException e) {
  26.  
    e.printStackTrace();
  27.  
    }
  28.  
     
  29.  
    QuartzManager.removeJob("job1");
  30.  
    //QuartzManager.removeJob("job1", "jobGooup", "trigger1", "triggerGroup");
  31.  
    System.out.println("删除任务");
  32.  
     
  33.  
    try {
  34.  
    Thread.sleep(5L * 1000L);
  35.  
    } catch (InterruptedException e) {
  36.  
    e.printStackTrace();
  37.  
    }
  38.  
     
  39.  
    System.out.println("【添加定时任务】");
  40.  
    QuartzManager.addJob("job1", MyJob.class, corn);
  41.  
    //QuartzManager.shutdownJobs();
  42.  
    //System.out.println("停止所有任务");
  43.  
    try {
  44.  
    Thread.sleep(5L * 1000L);
  45.  
    } catch (InterruptedException e) {
  46.  
    e.printStackTrace();
  47.  
    }
  48.  
     
  49.  
    System.out.println("【暂停定时任务】");
  50.  
    QuartzManager.pauseJob("job1");
  51.  
    System.out.println("【立即运行一次】");
  52.  
    QuartzManager.triggerJob("job1");
  53.  
    try {
  54.  
    Thread.sleep(5L * 1000L);
  55.  
    } catch (InterruptedException e) {
  56.  
    e.printStackTrace();
  57.  
    }
  58.  
     
  59.  
    System.out.println("【恢复定时任务】");
  60.  
    QuartzManager.resumeJob("job1");
  61.  
    try {
  62.  
    Thread.sleep(5L * 1000L);
  63.  
    } catch (InterruptedException e) {
  64.  
    e.printStackTrace();
  65.  
    }
  66.  
     
  67.  
    QuartzManager.shutdownJobs();
  68.  
    }
  69.  
    }
Quartz动态添加,修改,删除任务(暂停,任务状态,恢复,最近触发时间)
  • Quartz动态添加,修改,删除任务(暂停,任务状态,恢复,最近触发时间)
    溪雪: 你好,请问任务状态为什么会一直处在“不存在”的状态呢?(任务名和TRIGGER_GROUP_NAME没问题)(1个月前#1楼)

Quartz调度、终止执行的任务

08-07

使用Quartz调度任务,根据需要人为的终止某个任务,适用于很多常见的场景

下载

quartz定时任务执行一段时间停止了

09-01

-问答

原来除皮肤瘙痒这么简单?只有1%人知道的方法谷丰健康 · 猎媒

Spring+Quartz定时器使用方法(任务的添加删除修改暂停..._CSDN博客

11-2

Spring 内置了quartz框架,可以对方法上注解或者在配置文件里配置定时任务。但是如果...Quartz动态添加,修改,删除任务(暂停,任务状态,恢复,最近触发时间) 05-25 395...

quartz 定时任务的删除 恢复 已经暂停 - taizhen/blog - CSDN博客

4-10

在动态添加定时任务中其实已经涉及到了其中的一些代码,这里我们再来细化的理一理...Quartz动态添加,修改,删除任务(暂停,任务状态,恢复,最近触发时间) 05-25 阅读...

quartz配置动态任务,从数据库读取相应的类及方法,执行..._CSDN博客

11-23

步骤:首先创建一个javabean---》创建Quartz工厂---》xmlSchedulerFactoryBean--...Quartz动态添加,修改,删除任务(暂停,任务状态,恢复,最近触发时间) - loveLifeLove...

...Scheduler (Quartz) 动态添加,删除,修改任务的例子 ..._CSDN博客

10-30

标签:schdule quartz 定时任务 要求 根据任务清单执行不定数量,不定频率的定时任务。并且需要动态添加,删除,修改任务。 代码 public class JobExample { public ...

Spring3整合Quartz2实现定时任务及动态任务调整(添加删..._CSDN博客

10-26

最近工作中需要用到定时任务的功能,虽然Spring3也自带了一个轻量级的定时任务实现...Quartz动态添加,修改,删除任务(暂停,任务状态,恢复,最近触发时间) 05-25 345...

SpringBoot整合Quartz之动态控制任务(暂停,启动,修改执..._CSDN博客

4-10

SpringBoot整合 Quartz 篇请移步 https://blog.csdn.net/yali_aini/article...Quartz动态添加,修改,删除任务(暂停,任务状态,恢复,最近触发时间) 05-25 阅读...

任务调度开源框架Quartz动态添加、修改和删除定时任务 ..._CSDN博客

11-18

Quartz 是个开源的作业调度框架,为在 Java 应用...Quartz动态添加,修改,删除任务(暂停,任务状态,恢复,最近触发时间) - loveLifeLo...

Quartz1.7 动态添加、修改和删除定时任务(非spring集成..._CSDN博客

11-23

Quartz是一个由James House创立的开源项目,是一个功能强大的作业调度工具,可以计划...Quartz动态添加,修改,删除任务(暂停,任务状态,恢复,最近触发时间) - loveLifeLo...

晚上白开水+它,胖到160斤都能瘦,后悔没早知道道群 · 猎媒

关于quartz暂停恢复后,job执行多次的异常情况 - u01375..._CSDN博客

11-24

我的quartzjob使用的是jdbcstore方式。我需要设置我的job可以实现故障恢复,又因为...Quartz动态添加,修改,删除任务(暂停,任务状态,恢复,最近触发时间) - loveLifeLove...

quartz 暂停后重新启动,在暂停时 被暂停后的任务,在启动后会补偿执行即 会连续多次调用job中的execute方法。

阅读数 9795

调度(scheduleJob)或恢复调度(resumeTrigger,resumeJob)后不同的misfire对应的处理规则CronTrigger withMisfireHandlingInstru...博文来自: rabbit0708的专栏

白开水+它,喝完排出 巨便 !大肚子没了裕华 · 猎媒

Quartz的简化(只要一张表,动态启停任务)

阅读数 2763

spring-quartz,一张表配置、动态启停Job博文来自: 蒲公英的约定

Spring Quartz 动态暂停、恢复、修改定时任务

01-06

Spring Quartz 动态暂停、恢复、修改定时任务的一个demo,使用maven构建,框架采用spring springmvc jpa,数据库mysql,含数据库脚本,运行可用,页面访问地址ht

下载

肚子胖的像怀孕?白开水+它,1天瘦2斤!想胖都难宁龙商贸 · 猎媒

Quartz动态添加、修改和删除定时任务时间的方法以及日期转换cron表达式时间格式工具类

阅读数 9435

QuartzCronDateUtils博文来自: dengyu的专栏

码农必看:各大平台的推荐系统原来是靠它完成的,太牛了

第四范式先荐帮助客户从0到1搭建推荐系统,显著提升用户活跃,留存,观看时长等重要业务指标

Quartz动态添加,修改,删除任务(暂停,任务状态,恢复,最近触发时间)

Cron+Trigger+Quartz 任务 启动 暂停 恢复 修改 实例

阅读数 554

packagecom.xxl.job.admin.core.schedule;importcom.xxl.job.admin.core.jobbean.RemoteHttpJobBean;import...博文来自: z69183787的专栏

如何快速提升个性化推荐效果?

先荐推荐系统适合首页,信息流,内容详情页等场景,支持网页, APP,小程序,快应用,1分钟安装5分钟上线,支持人工干预推荐

Quartz动态添加,修改,删除任务(暂停,任务状态,恢复,最近触发时间)

第四范式发布先荐推荐系统,帮助300+媒体平台实现内容升级

先荐推荐系统由国际顶尖智能推荐团队研发,三步即可完成接入,毫秒级数据更新,支持PC,WAP, APP全平台接入

Quartz动态添加,修改,删除任务(暂停,任务状态,恢复,最近触发时间)

人脸检测工具face_recognition的安装与应用

阅读数 5万+

人脸检测工具face_recognition的安装与应用博文来自: roguesir的博客

原创
38
粉丝
4
喜欢
8
评论
3
等级:

访问:

2万+
积分:

581
排名:

11万+
勋章:
 

最新评论

 
上一篇:小程序动态添加class及调接口传递多个参数


下一篇:Android 动态添加Spinner(.java文件内实现) 实现 改变spinner 内文字属性