Quartz 持久化到MySQL 并创建触发器

已于 2022-04-26 10:31:48 修改
阅读量962 收藏
点赞数
分类专栏： java 文章标签： mysql 数据库 database
于 2021-12-15 10:53:57 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_39069718/article/details/121947208
版权

示例：

    pom.xml

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

   实现步骤：

    1. 


import cn.hutool.json.JSONUtil;
import com.alibaba.fastjson.JSONObject;
import lombok.extern.slf4j.Slf4j;
import org.example.config.ConfigurationJSON;
import org.example.config.quartz.DelQuartzJob;
import org.example.utils.QuartzCronDateUtils;
import org.example.config.quartz.AddQuartzJob;
import org.example.model.common.CommonResult;
import org.example.model.common.JsonTMSBean;
import org.example.model.entity.PersonnelAccessAuthority;
import org.example.service.PersonnelReceivingService;
import org.example.service.QuartzService;
import org.example.utils.HttpClientUtils;
import org.quartz.JobDetail;
import org.quartz.JobKey;
import org.quartz.Scheduler;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.text.SimpleDateFormat;
import java.util.*;

/**
 * @author 
 * @version 1.0
 * @PACKAGE_NAME: org.example.service.impl
 * @date 2021/11/29 14:41 周一
 */
@Slf4j
@Service
public class PersonnelReceivingServiceImpl  implements PersonnelReceivingService {

    
     @Autowired
     QuartzService quartzService;
     @Autowired
      Scheduler  scheduler;

    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

    Map map = new HashMap(2);

    @Override
    public String  receiveLeaveCancellation( ) {
             try {
                 String personCode1 ="4131231123";
                    String startTime = "2022-05-26 12:40:00";
                    String endTime ="2022-06-27 11:40:00";
                    //有效期开始时间
                    Date parse = sdf.parse(startTime);
                    long starTime = parse.getTime();
                    Calendar calendar= Calendar.getInstance();
                    Date time = calendar.getTime();
                    long newstarTime = time.getTime();
                    //有效期截止时间
                    Date endPresonTime = sdf.parse(endTime);
                    long endTimelong = endPresonTime.getTime();
                    Calendar calendarendTime= Calendar.getInstance();
                    Date timeendTime = calendarendTime.getTime();
                    long newendTimee = timeendTime.getTime();
                    //判断如果开始时间小于当前时间，就抛弃
                    if(starTime<=newstarTime&&endTimelong<=newendTimee){
                        log.error("判断如果开始和结束时间小于当前时间:"+JSONUtil.toJsonStr(personCode1));
                    }else {
                        Date startDate = new Date(starTime);
                        String startcron = QuartzCronDateUtils.getCron(startDate);
                        JobKey jobKey = JobKey.jobKey("addJob", "addGroup");
                        JobDetail jobDetail1 = scheduler.getJobDetail(jobKey);
                        if (jobDetail1 == null) {
                            quartzService.addJob(AddQuartzJob.class, "addJob", personCode1, startcron, personCode1);
                        } else {
                            // 获取触发器标识  如果有的话 更新时间就可以了
                            TriggerKey triggerKeys = TriggerKey.triggerKey(personCode1, "addGroup");
                            CronTrigger triggers = (CronTrigger) scheduler.getTrigger(triggerKeys);
                            if(triggers!=null){
                                // 表达式调度构建器
                                CronScheduleBuilder scheduleBuilder = CronScheduleBuilder
                                        .cronSchedule(startcron);
                                // Trigger已存在，更新相应的定时设置
                                // 按新的cronExpression表达式重新构建trigger
                                triggers = triggers.getTriggerBuilder()
                                        .forJob(JobKey.jobKey("addJob","addGroup"))
                                        .withIdentity(triggerKeys)
                                        .withSchedule(scheduleBuilder).build();
                                // 按新的trigger重新设置job执行
                                scheduler.rescheduleJob(triggerKeys, triggers);
                            }else {
                                quartzService.addTrigger(jobDetail1, personCode1, startcron);

                            }
                        }
                        //执行结束时间
                        Date endDate = new Date(endTimelong);
                        String endCron = QuartzCronDateUtils.getCron(endDate);
                        JobKey updatejobKey = JobKey.jobKey("updateJob", "updateGroup");
                        JobDetail jobDetailUpdate = scheduler.getJobDetail(updatejobKey);
                        if (jobDetailUpdate == null) {
                            quartzService.delJob(DelQuartzJob.class, "updateJob", "updateGroup", personCode1, endCron, personCode1);
                        } else {
                            // 获取触发器标识  如果有的话 更新时间就可以了
                            TriggerKey triggerKeys = TriggerKey.triggerKey(personCode1, "updateGroup");
                            CronTrigger triggers = (CronTrigger) scheduler.getTrigger(triggerKeys);
                            if(triggers!=null){
                                // 表达式调度构建器
                                CronScheduleBuilder scheduleBuilder = CronScheduleBuilder
                                        .cronSchedule(endCron);
                                // Trigger已存在，更新相应的定时设置
                                // 按新的cronExpression表达式重新构建trigger
                                triggers = triggers.getTriggerBuilder()
                                        .forJob(JobKey.jobKey("addJob","addGroup"))
                                        .withIdentity(triggerKeys)
                                        .withSchedule(scheduleBuilder).build();
                                // 按新的trigger重新设置job执行
                                scheduler.rescheduleJob(triggerKeys, triggers);
                            }else {
                                quartzService.delTrigger(jobDetailUpdate, personCode1, "updateGroup", endCron, personCode1);
                            }

                        }
                    }

        }catch (Exception ex){
              log.error(personnelAccessAuthority +"人员信息数据转换失败："+ex.getMessage());
        }
        return  null
    }

}

package org.example.service;

import org.example.config.quartz.AddQuartzJob;
import org.example.config.quartz.DelQuartzJob;
import org.quartz.JobDetail;

import java.util.Map;

/**
 * @author 
 * @version 1.0
 * @PACKAGE_NAME: org.example.service
 * @date 2021/12/8 14:53 周三
 */
public interface QuartzService {


    /**
     * 增加一个job
     * @param jobClass
     * 任务实现类
     * @param jobName
     *  任务名称(建议唯一)
     * @param jobGroupName
     *   任务组名
     * @param triggerName
     *   触发器名
     * @param jobTime
     *  时间表达式 （如：0/5 * * * * ? ）
     * @param personCode
     * @return
     */
    void addJob(Class<AddQuartzJob> jobClass, String jobName, String jobGroupName, String triggerName, String jobTime, String personCode);

    void addTrigger(JobDetail jobDetail, String personCodeTime, String jobGroupName, String cron, String personCode);

    void delJob(Class<DelQuartzJob> delQuartzJobClass, String updateJob, String updateGroup, String personCodeEndTime, String endCron, String personCode);

    void delTrigger(JobDetail jobDetailUpdate, String personCodeEndTime, String updateGroup, String endCron, String personCode);

    /**
     * 任务
     * @param delVisitorQuartzJobClass
     * @param visitorAddJob
     * @param visitorAddGroup
     * @param visitorStarttime
     * @param endCron
     * @param visitorData
     */
    void addVisitorJob(Class<AddVisitorQuartzJob> delVisitorQuartzJobClass, String visitorAddJob, String visitorAddGroup, String visitorStarttime, String endCron, VisitorData visitorData);

    /**
     * 添加触发器
     * @param jobDetail
     * @param visitorStarttime
     * @param visitorAddGroup
     * @param endCron
     * @param visitorData
     */
    void visitorTrigger(JobDetail jobDetail, String visitorStarttime, String visitorAddGroup, String endCron, VisitorData visitorData);

    void delVisitorJob(Class<DelVisitorQuartzJob> delVisitorQuartzJobClass, String updateVisitorJob, String updateVisitorGroup, String personCodeEndTime, String endCronVisitor, VisitorData visitorData);

}

package org.example.service.impl;


import lombok.extern.slf4j.Slf4j;
import org.example.config.quartz.AddQuartzJob;
import org.example.config.quartz.DelQuartzJob;
import org.example.service.QuartzService;
import org.quartz.*;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import javax.annotation.PostConstruct;
import java.util.*;

import static org.quartz.CronScheduleBuilder.cronSchedule;
import static org.quartz.TriggerBuilder.newTrigger;

/**
 * quartz逻辑
 * @author gourd
 */
@Slf4j
@Service
public class QuartzServiceImpl implements QuartzService {

    @Autowired
    private Scheduler scheduler;

    @PostConstruct
    public void startScheduler() {
        try {
            scheduler.start();
        } catch (SchedulerException e) {
            e.printStackTrace();
        }
    }

    /**
     * 添加出入权限任务
     *  @param jobClass
     *            任务实现类
     * @param jobName
     *            任务名称(建议唯一)
     * @param jobGroupName
 *            任务组名
     *            TriggerName  触发器名称
     * @param jobTime
*            时间表达式
     *
     * @param personCode
     */
    @Override
    public void addJob(Class<AddQuartzJob> jobClass,
                            String jobName,
                            String jobGroupName,
                            String triggerName,
                            String jobTime,
                            String personCode) {
        try {
            // 创建jobDetail实例，绑定Job实现类
            // 指明job的名称，所在组的名称，以及绑定job类
            // 任务名称和组构成任务key
            JobDetail  jobDetail = JobBuilder.newJob(jobClass).withIdentity(jobName, jobGroupName)
                    .build();
            // 设置job参数jobName
            if(StringUtils.isNotBlank(personCode)){
                jobDetail.getJobDataMap().put("personCode",personCode);
            }
            // 定义调度触发规则
            // 使用cornTrigger规则
            // 触发器key
            Trigger trigger = newTrigger().withIdentity(triggerName, jobGroupName)

                    .startAt(DateBuilder.futureDate(1, DateBuilder.IntervalUnit.SECOND))
                    .withSchedule(cronSchedule(jobTime)).build();
              trigger.getJobDataMap().put("personCode",personCode);
            // 把作业和触发器注册到任务调度中
            scheduler.scheduleJob(jobDetail, trigger);
        } catch (Exception e) {
            log.error("添加出入权限任务失败："+e.getMessage());
        }
    }

    /**
     * 添加出入权限触发器
     * @param jobDetail1
     * @param personCodeTime
     * @param jobGroupName
     * @param cron
     * @param jobData
     */
    @Override
    public void addTrigger(JobDetail jobDetail1, String personCodeTime, String jobGroupName, String cron, String jobData) {
        try {
            // 定义调度触发规则
            // 把作业和触发器注册到任务调度中
            scheduler.scheduleJob(newTrigger().withIdentity(new TriggerKey(personCodeTime, jobGroupName)).withSchedule(
                    cronSchedule(cron)).forJob(jobDetail1).usingJobData("personCode",jobData).build());
        } catch (Exception e) {
            log.error("添加出入权限触发器失败："+e.getMessage());
        }
    }

    /**
     * 新增修改权限job
     * @param jobClass
     * @param jobName
     * @param jobGroupName
     * @param triggerName
     * @param jobTime
     * @param jobData
     */
    @Override
    public void delJob(Class<DelQuartzJob> jobClass,
                       String jobName,
                       String jobGroupName,
                       String triggerName,
                       String jobTime,
                       String jobData) {
        try {
            // 创建jobDetail实例，绑定Job实现类
            // 指明job的名称，所在组的名称，以及绑定job类
            // 任务名称和组构成任务key
            JobDetail  jobDetail = JobBuilder.newJob(jobClass).withIdentity(jobName, jobGroupName)
                    .build();
            // 设置job参数jobName
            if(jobData!= null){
                jobDetail.getJobDataMap().put("personCode",jobData);
            }
            // 定义调度触发规则
            // 使用cornTrigger规则
            // 触发器key
            Trigger trigger = newTrigger().withIdentity(triggerName, jobGroupName)
                    .startAt(DateBuilder.futureDate(1, DateBuilder.IntervalUnit.SECOND))
                    .withSchedule(cronSchedule(jobTime)).build();
            trigger.getJobDataMap().put("personCode",jobData);

            // 把作业和触发器注册到任务调度中
            scheduler.scheduleJob(jobDetail, trigger);
        } catch (Exception e) {
            log.error("修改出入任务失败："+e.getMessage());
        }
    }

    /**
     * 添加修改出入权限触发器
     * @param jobDetail
     * @param personCodeEndTime
     * @param updateGroup
     * @param endCron
     * @param jobData
     */
    @Override
    public void delTrigger(JobDetail jobDetail, String personCodeEndTime, String updateGroup, String endCron, String jobData) {
        try {
            // 定义调度触发规则
            // 把作业和触发器注册到任务调度中
            scheduler.scheduleJob(newTrigger().withIdentity(new TriggerKey(personCodeEndTime, updateGroup)).withSchedule(
                            cronSchedule(endCron)).forJob(jobDetail).usingJobData("personCode",jobData).build());
        } catch (Exception e) {
            log.error("添加修改出入权限触发器失败：" + e.getMessage());
        }
       }

    /**
     * 任务信息
     * @param jobClass
     * @param jobName
     * @param jobGroupName
     * @param triggerName
     * @param jobTime
     * @param visitorData
     */
    @Override
    public void addVisitorJob(Class<AddVisitorQuartzJob> jobClass,
                              String jobName,
                              String jobGroupName,
                              String triggerName,
                              String jobTime,
                              VisitorData visitorData) {

        try {
            // 创建jobDetail实例，绑定Job实现类
            // 指明job的名称，所在组的名称，以及绑定job类
            // 任务名称和组构成任务key
            JobDetail  jobDetail = JobBuilder.newJob(jobClass).withIdentity(jobName, jobGroupName)
                    .build();
            // 定义调度触发规则
            // 使用cornTrigger规则
            String visitor = JSONObject.toJSONString(visitorData);
            // 触发器key
            Trigger trigger = newTrigger().withIdentity(triggerName, jobGroupName)

                    .startAt(DateBuilder.futureDate(1, DateBuilder.IntervalUnit.SECOND))
                    .withSchedule(cronSchedule(jobTime)).build();
            trigger.getJobDataMap().put("visitorData",visitor);
            // 把作业和触发器注册到任务调度中
            scheduler.scheduleJob(jobDetail, trigger);
        } catch (Exception e) {
            log.error("添加访客出入权限任务失败："+e.getMessage());
        }

    }

    /**
     * 出入触发器
     * @param jobDetail
     * @param visitorStarttime
     * @param visitorAddGroup
     * @param endCron
     * @param visitorData
     */
    @Override
    public void visitorTrigger(JobDetail jobDetail,
                                  String visitorStarttime,
                                  String visitorAddGroup,
                                  String endCron,
                                  VisitorData visitorData) {
        try {
            // 定义调度触发规则
            String visitor = JSONObject.toJSONString(visitorData);
            // 把作业和触发器注册到任务调度中
            scheduler.scheduleJob(newTrigger().withIdentity(new TriggerKey(visitorStarttime, visitorAddGroup)).withSchedule(
                    cronSchedule(endCron)).forJob(jobDetail).usingJobData("visitorData", visitor).build());
        } catch (Exception e) {
            log.error("出入权限触发器失败：" + e.getMessage());
        }
    }

    /**
     * 删除出入权限
     * @param jobClass
     * @param jobName
     * @param jobGroupName
     * @param triggerName
     * @param jobTime
     * @param visitorData
     */
    @Override
    public void delVisitorJob(Class<DelVisitorQuartzJob> jobClass,
                              String jobName,
                              String jobGroupName,
                              String triggerName,
                              String jobTime,
                              VisitorData visitorData) {

        try {
            // 创建jobDetail实例，绑定Job实现类
            // 指明job的名称，所在组的名称，以及绑定job类
            // 任务名称和组构成任务key
            JobDetail  jobDetail = JobBuilder.newJob(jobClass).withIdentity(jobName, jobGroupName)
                    .build();
            // 定义调度触发规则
            // 使用cornTrigger规则
            String visitor = JSONObject.toJSONString(visitorData);
            // 触发器key
            Trigger trigger = newTrigger().withIdentity(triggerName, jobGroupName)

                    .startAt(DateBuilder.futureDate(1, DateBuilder.IntervalUnit.SECOND))
                    .withSchedule(cronSchedule(jobTime)).build();
            trigger.getJobDataMap().put("visitorData",visitor);
            // 把作业和触发器注册到任务调度中
            scheduler.scheduleJob(jobDetail, trigger);
        } catch (Exception e) {
            log.error("删除出入权限任务失败："+e.getMessage());
        }

    }


package org.example.config.quartz;


import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import lombok.extern.slf4j.Slf4j;
import org.example.config.ConfigurationJSON;
import org.example.model.common.DataModel;
import org.example.model.common.JsonTMSBean;
import org.example.model.common.TmsLeaveCancelPerson;
import org.example.utils.HttpClientUtils;
import org.quartz.JobDataMap;
import org.quartz.JobExecutionContext;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.quartz.QuartzJobBean;
import org.springframework.stereotype.Component;

import java.util.Date;
import java.util.List;

/**
 * 业务处理
 * @author gourd
 */
@Component
public class AddQuartzJob extends QuartzJobBean {


    @Override
    protected void executeInternal(JobExecutionContext arg0)  {
            JsonTMSBean jsonTMSBean=null;
            //人员权限信息
            TmsLeaveCancelPerson tmsLeaveCancelPerson =null;
            // 获取参数
            JobDataMap jobDatQuartzCronDateUtilsaMap = arg0.getJobDetail().getJobDataMap();
            System.out.println(new Date() +"     新增执行的业务====="+JSON.toJSONString(jobDatQuartzCronDateUtilsaMap));
              // 获取参数
            JobDataMap jobDataMap = context.getTrigger().getJobDataMap();
            // 业务逻辑
            String visitorData = jobDataMap.getString("visitorData");


    }

}
package org.example.utils;
import java.text.SimpleDateFormat;
import java.util.Date;

/**
 * @author 
 * @version 1.0
 * @PACKAGE_NAME: org.example.config.quartz
 * @date 2021/12/8 14:52 周三
 */

public class QuartzCronDateUtils {
    /***
     *  日期转换cron表达式时间格式
     * @param date
     * @param dateFormat
     * @return
     */
    public static String formatDateByPattern(Date date,String dateFormat){
        SimpleDateFormat sdf = new SimpleDateFormat(dateFormat);
        String formatTimeStr = null;
        if (date != null) {
            formatTimeStr = sdf.format(date);
        }
        return formatTimeStr;
    }
    /***
     * convert Date to cron
     * @param date:时间
     * @return
     */
    public static String getCron(Date  date){
        String dateFormat="ss mm HH dd MM ? yyyy";
        return formatDateByPattern(date,dateFormat);
    }
}

南大白
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
四、持久化到Mysql中
heishuiloveyou的博客
02-21 110
复制代码//将上面配置好的 factoryBean 注入进来@Autowiredprivate SchedulerFactoryBean factoryBean;//2. 任务实例（JobDetail）JobDetailjobDetail= JobBuilder.newJob(HelloJob.class).build();//3. 触发器（Trigger）Triggertrigger= TriggerBuilder.newTrigger().build();复制代码。
quartz 2.0持久化到mysql_SpringBoot2.0整合Quartz定时任务（持久化到数据库，更为简单的方式）...
weixin_39923806的博客
02-03 242
1. pom文件添加依赖org.springframework.bootspring-boot-starterorg.springframework.bootspring-boot-starter-testtestorg.springframework.bootspring-boot-starter-weborg.springframework.bootspring-boot-starter-qu...
定时任务Quartz（二）-- 持久化定时任务
weixin_45272815的博客
05-25 917
在做持久化定时任务Quartz案例前，确保已经阅读过，之前文章，（简单、入门版本）。。本此实现基于之前版本进行更新，追加，实现与数据库交互，完成重启服务，定时任务不丢失。真正做到持久化定时任务至此，job 已经被我们成功持久化到数据库。我们来回顾下整体的一个流程。pom文件添加对应的依赖。mysql数据库对应表的初始化。配置对应的properties。将原来quartz控制的类的实例化交给spirng IOC控制。（对应的是核心QuartzConfiguration类和JobFactory类。
【发邮件】使用Java的定时任务库Quartz来定时获取MySQL数据并发送邮件
最新发布
qq_31532979的博客
04-24 410
使用Java的定时任务库Quartz来定时获取MySQL数据并发送邮件。欢迎关注微信公众号：数据科学与艺术 作者WX:superhe199。方法将会被执行，即获取数据库数据并发送邮件。对象来定义任务的触发时间。对象来定义要执行的任务，然后创建了一个。为你的SMTP服务器和邮箱地址。等为你的数据库信息，以及。此时，当定时任务触发时，方法中，我们创建了一个。，然后启动定时任务。
quartz 2.0持久化到mysql_springBoot使用quartz，单表持久化到数据库，
weixin_31727797的博客
02-03 149
Quartz定时任务持久化到数据库，单表1.表结构DAO层使用mybatis-generator自动生成2.pom.xml文件加入依赖org.quartz-schedulerquartz2.2.1org.quartz-schedulerquartz-jobs2.2.13.application.properties中配置quartz线程池的线程数量，避免造成不必要的开销spring.quartz....
quartz持久化定时任务到数据库
DonLex 的博客
05-09 1万+
之前的demo使用的quartz,是存储在内存中的,有可能会造成定时任务的丢失,现在来使用数据库,将定时任务存储在数据库中,这样可以在系统意外重新启动后,仍保留定时任务信息 步骤鸟瞰 创建MySQL存放任务的表 创建properties 修改监听文件 强烈建议预习或者复习一下之前的文章 Quartz整合web项目(不基于spring) ,因为这篇文章,是在之前的文...
quartz 持久化数据库表
05-13
在`dbTables`压缩包中，你应该能找到对应不同数据库的SQL脚本文件，这些文件用于创建上述提到的Quartz持久化表。根据你的数据库类型选择合适的脚本运行，即可完成Quartz与数据库的集成，从而实现任务的持久化存储。 ...
quartz 持久化数据库表结构sql
10-13
本篇将详细介绍Quartz如何实现数据库持久化，并提供各类型数据库的SQL创建语句。 Quartz的持久化机制依赖于一组特定的数据库表，这些表存储了Job（任务）和Trigger（触发器）的信息。以下是Quartz默认使用的数据库...
springboot2.3集成quartz定时任务持久化数据库,支持集群
07-13
在本文中，我们将深入探讨如何在Spring Boot 2.3版本中集成Quartz定时任务，并实现其持久化到数据库，以便支持集群环境。这个过程的关键在于配置Quartz Scheduler，设置数据库连接，以及确保任务在多节点环境中能够...
Quartz定时任务持久化数据表
09-21
Quartz的定时任务持久化是指将任务的相关信息（如触发器、作业详情）存储到数据库中，而不是仅仅保留在内存里。这样做的好处是，即使应用服务器重启，之前设定的任务也不会丢失，因为它们可以从数据库中重新加载。...
quartz持久化语句2021
12-15
在分布式系统中，为了保证任务的可靠性和持久性，Quartz提供了数据库持久化功能，即将作业（Jobs）和触发器（Triggers）的信息存储在数据库中。这样，即使应用程序重启或服务器故障，任务调度信息也不会丢失，能够...
quartz mysql 整合
07-10
quartz mysql 整合
quartz 2.0持久化到mysql_【Quartz】将定时任务持久化到数据库
weixin_35131453的博客
02-03 166
ll need to set # org.quartz.jobStore.driverDelegateClass = org.quartz.impl.jdbcjobstore.StdJDBCDelegate#DROP TABLE IF EXISTS QRTZ_FIRED_TRIGGERS;DROP TABLE IF EXISTS QRTZ_PAUSED_TRIGGER_GRPS;DROP TABL...
SpringBoot 集成 Quartz + MySQL
Java技术攻略的博客
04-18 706
实现方式参考：若依(RuoYi)，他是新建了一张中间表，通过 init() 方法，利用中心中间表进行定时任务的初始化。保存 QRTZ_JOB_DETAILS、QRTZ_TRIGGERS => QRTZ_CRON_TRIGGERS。字段，可以是一个对像，以执行定时任务时，会把该字段反序列化，根据前期设定的内容进行业务处理。暂停后，qrtz_triggers 表的 TRIGGER_STATE = PAUSED。将 job.getJobDataMap()，对像序列化后，存入。获取 Quartz Job 任务。
quartz动态增删改查
qq_39949910的博客
04-30 603
四、略微复杂的quartz的使用：动态添加修改定时任务 设想一个项目场景： 在一个项目中，我需要动态的向项目中添加或者修改定时任务，还有暂停和启动的操作，相当于动态的添加定时任务，如果有这种需求 的话呢？你打算怎么做？ 4.1、quartz的固化（本案例不使用，仅作为学习） 这样的话，我们就需要将定时任务集成到数据库中了，在这方面，quartz给我们做了固化，具体的操作很简单： 在项目的配置文件（application.yml）中加入如下配置； 其中，always，代表每次启动项目都会给数据库添加quart
任务调度开源框架Quartz动态添加、修改和删除定时任务
热门推荐
永无止境
07-09 8万+
Quartz 是个开源的作业调度框架，为在 Java 应用程序中进行作业调度提供了简单却强大的机制。Quartz框架包含了调度器监听、作业和触发器监听。你可以配置作业和触发器监听为全局监听或者是特定于作业和触发器的监听。Quartz 允许开发人员根据时间间隔（或天）来调度作业。它实现了作业和触发器的多对多关系，还能把多个作业与不同的触发器关联。整合了 Quartz 的应用程序可以重用来自不同事件的
quartz 定时任务动态增加删除更新
yxkong的专栏
12-13 568
packagecom.yxkong.core.utils; importstaticorg.quartz.CronScheduleBuilder.cronSchedule; importstaticorg.quartz.JobBuilder.newJob; importstaticorg.quartz.TriggerBuilder.newTrigger; impor...
任务调度的 Java 实现方法二：quartz
码农的田园
02-17 457
Quartz是OpenSymphony开源组织在Job scheduling领域又一个开源项目,它可以与J2EE与J2SE应用程序相结合也可以单独使用。Quartz可以用来创建简单或为运行十个，百个，甚至是好几万个Jobs这样复杂的日程序表。Jobs可以做成标准的Java组件或 EJBs。  Quartz框架是一个全功能、开源的任务调度服务，可以集成几乎任何的java应用程序—从小的单片机系统到
quartz持久化到数据库中
09-27
此外，Quartz还提供了相应的API和工具，使得将作业和触发器信息持久化到数据库中变得简单和方便。开发人员可以通过编写代码或者配置文件来实现持久化的相关功能。 总之，Quartz的持久化功能可以确保作业和调度信息...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

南大白

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值