Quartz 2.2.1版本单独使用实战

最新推荐文章于 2024-09-05 12:06:26 发布
最新推荐文章于 2024-09-05 12:06:26 发布
阅读量799 收藏
点赞数
分类专栏： quartz 定时调度
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u010077555/article/details/84104534
版权

Quartz 2.2.1版本单独使用实战

 

Maven依赖包

在Maven工程中添加Quartz2.2.1版本的依赖，如下

    <properties>
       <quartz.version>2.2.1</quartz.version>
    </properties> 

   <dependencies>
        <dependency>
            <groupId>org.quartz-scheduler</groupId>
            <artifactId>quartz</artifactId>
            <version>${quartz.version}</version>
        </dependency>
        <dependency>
            <groupId>org.quartz-scheduler</groupId>
            <artifactId>quartz-jobs</artifactId>
            <version>${quartz.version}</version>
        </dependency>
   </dependencies>

 

Quartz配置文件

quartz.properties配置如下：

# suppress inspection "UnusedProperty" for whole file

#ThreadPool 实现的类名
org.quartz.threadPool.class = org.quartz.simpl.SimpleThreadPool

# 线程数，最多可同时跑多少个定时任务,20
org.quartz.threadPool.threadCount = 20

#线程优先级
org.quartz.threadPool.threadPriority = 5

#自创建父线程
org.quartz.threadPool.threadsInheritContextClassLoaderOfInitializingThread = true

#设置为TRUE不会出现序列化非字符串类到 BLOB 时产生的类版本问题
org.quartz.jobStore.useProperties = true

# 集群配置
#激活集群
org.quartz.jobStore.isClustered = true

# 使用StdSchedulerFactory的 getScheduler()方法创建的scheduler实例名称
# 在同一个程序中可以根据该名称来区分scheduler,如果实在集群环境中使用，你必须使用同一个名称——集群环境下”逻辑”相同的scheduler,
# 默认为QuartzScheduler,此值对应SCHED_NAME字段值
org.quartz.scheduler.instanceName = QuartzScheduler

# scheduler实例的标志id，必须是全局唯一的，
# 即使在集群环境中”逻辑”相同的scheduler。 或者可以使用“SYS_PROP”通过系统属性设置id。
org.quartz.scheduler.instanceId = AUTO

#调度实例失效的检查时间间隔,200秒
org.quartz.jobStore.clusterCheckinInterval = 200000

#容许的最大作业延长时间,20小时
org.quartz.jobStore.misfireThreshold = 72000000

# Using RAMJobStore
## 如果使用RAMJobStore,请确认以下内容
## - org.quartz.jobStore.tablePrefix,
## - org.quartz.jobStore.driverDelegateClass,
## - org.quartz.jobStore.dataSource
##  所有 Quartz的数据，例如任务和触发器的数据都存放到内存中（而不是数据库中）。
#   即使你使用了数据库同时也使用了 Quartz，也建议使用 RamJobStore。
#org.quartz.jobStore.class = org.quartz.simpl.RAMJobStore
## Be sure to run the appropriate script(under docs/dbTables) first to create tables
## 数据保存方式为持久化 Using JobStoreTX
org.quartz.jobStore.class = org.quartz.impl.jdbcjobstore.JobStoreTX

# Configuring JDBCJobStore with the Table Prefix 表的前缀
org.quartz.jobStore.tablePrefix = QRTZ_

# Using DriverDelegate数据库平台
#org.quartz.jobStore.driverDelegateClass = org.quartz.jobStore.driverDelegateClass
org.quartz.jobStore.driverDelegateClass = org.quartz.impl.jdbcjobstore.oracle.OracleDelegate

# Using datasource
## 数据库别名 随便取
org.quartz.jobStore.dataSource = qzDS

# Define the datasource to use 数据库连接配置
#设置数据源
# org.quartz.dataSource.qzDS.jndiURL = CT

# 数据库Driver
org.quartz.dataSource.qzDS.driver = oracle.jdbc.driver.OracleDriver

# 数据库URL
org.quartz.dataSource.qzDS.URL = jdbc:oracle:thin:@//192.168.1.1:1521/orcl

# 数据库用户名
org.quartz.dataSource.qzDS.user = username

# 数据库密码
org.quartz.dataSource.qzDS.password = password

# 数据库最大连接数
org.quartz.dataSource.qzDS.maxConnections = 30

初始化SchedulerFactory

quartz.properties默认配置在classpath目录下通过

SchedulerFactory schedulerFactory = new StdSchedulerFactory(）

初始化SchedulerFactory，但是可以通过自定义配置文件路径读取转换为Properties进行初始化SchedulerFactory，如下

Properties quartzProperties = PropertiesUtil.getProperties("quartz.properties");
SchedulerFactory schedulerFactory = new StdSchedulerFactory(quartzProperties);

Oracle数据表

DROP TABLE  QRTZ_FIRED_TRIGGERS;
DROP TABLE QRTZ_PAUSED_TRIGGER_GRPS;
DROP TABLE QRTZ_SCHEDULER_STATE;
DROP TABLE QRTZ_LOCKS;
DROP TABLE QRTZ_SIMPLE_TRIGGERS;
DROP TABLE QRTZ_SIMPROP_TRIGGERS;
DROP TABLE QRTZ_CRON_TRIGGERS;
DROP TABLE QRTZ_BLOB_TRIGGERS;
DROP TABLE QRTZ_TRIGGERS;
DROP TABLE QRTZ_JOB_DETAILS;
DROP TABLE QRTZ_CALENDARS;


-- 存储每一个已配置的 Job 的详细信息
CREATE TABLE qrtz_job_details
(
  SCHED_NAME VARCHAR2(120) NOT NULL,
  JOB_NAME  VARCHAR2(200) NOT NULL,
  JOB_GROUP VARCHAR2(200) NOT NULL,
  DESCRIPTION VARCHAR2(250) NULL,
  JOB_CLASS_NAME   VARCHAR2(250) NOT NULL,
  IS_DURABLE VARCHAR2(1) NOT NULL,
  IS_NONCONCURRENT VARCHAR2(1) NOT NULL,
  IS_UPDATE_DATA VARCHAR2(1) NOT NULL,
  REQUESTS_RECOVERY VARCHAR2(1) NOT NULL,
  JOB_DATA BLOB NULL,
  CONSTRAINT QRTZ_JOB_DETAILS_PK PRIMARY KEY (SCHED_NAME,JOB_NAME,JOB_GROUP)
);
--  存储已配置的 Trigger 的信息
CREATE TABLE qrtz_triggers
(
  SCHED_NAME VARCHAR2(120) NOT NULL,
  TRIGGER_NAME VARCHAR2(200) NOT NULL,
  TRIGGER_GROUP VARCHAR2(200) NOT NULL,
  JOB_NAME  VARCHAR2(200) NOT NULL,
  JOB_GROUP VARCHAR2(200) NOT NULL,
  DESCRIPTION VARCHAR2(250) NULL,
  NEXT_FIRE_TIME NUMBER(13) NULL,
  PREV_FIRE_TIME NUMBER(13) NULL,
  PRIORITY NUMBER(13) NULL,
  TRIGGER_STATE VARCHAR2(16) NOT NULL,
  TRIGGER_TYPE VARCHAR2(8) NOT NULL,
  START_TIME NUMBER(13) NOT NULL,
  END_TIME NUMBER(13) NULL,
  CALENDAR_NAME VARCHAR2(200) NULL,
  MISFIRE_INSTR NUMBER(2) NULL,
  JOB_DATA BLOB NULL,
  CONSTRAINT QRTZ_TRIGGERS_PK PRIMARY KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP),
  CONSTRAINT QRTZ_TRIGGER_TO_JOBS_FK FOREIGN KEY (SCHED_NAME,JOB_NAME,JOB_GROUP)
  REFERENCES QRTZ_JOB_DETAILS(SCHED_NAME,JOB_NAME,JOB_GROUP)
);
-- 存储简单的 Trigger，包括重复次数，间隔，以及已触的次数
CREATE TABLE qrtz_simple_triggers
(
  SCHED_NAME VARCHAR2(120) NOT NULL,
  TRIGGER_NAME VARCHAR2(200) NOT NULL,
  TRIGGER_GROUP VARCHAR2(200) NOT NULL,
  REPEAT_COUNT NUMBER(7) NOT NULL,
  REPEAT_INTERVAL NUMBER(12) NOT NULL,
  TIMES_TRIGGERED NUMBER(10) NOT NULL,
  CONSTRAINT QRTZ_SIMPLE_TRIG_PK PRIMARY KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP),
  CONSTRAINT QRTZ_SIMPLE_TRIG_TO_TRIG_FK FOREIGN KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP)
  REFERENCES QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP)
);
-- 存储 Cron Trigger，包括 Cron 表达式和时区信息
CREATE TABLE qrtz_cron_triggers
(
  SCHED_NAME VARCHAR2(120) NOT NULL,
  TRIGGER_NAME VARCHAR2(200) NOT NULL,
  TRIGGER_GROUP VARCHAR2(200) NOT NULL,
  CRON_EXPRESSION VARCHAR2(120) NOT NULL,
  TIME_ZONE_ID VARCHAR2(80),
  CONSTRAINT QRTZ_CRON_TRIG_PK PRIMARY KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP),
  CONSTRAINT QRTZ_CRON_TRIG_TO_TRIG_FK FOREIGN KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP)
  REFERENCES QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP)
);
CREATE TABLE qrtz_simprop_triggers
(
  SCHED_NAME VARCHAR2(120) NOT NULL,
  TRIGGER_NAME VARCHAR2(200) NOT NULL,
  TRIGGER_GROUP VARCHAR2(200) NOT NULL,
  STR_PROP_1 VARCHAR2(512) NULL,
  STR_PROP_2 VARCHAR2(512) NULL,
  STR_PROP_3 VARCHAR2(512) NULL,
  INT_PROP_1 NUMBER(10) NULL,
  INT_PROP_2 NUMBER(10) NULL,
  LONG_PROP_1 NUMBER(13) NULL,
  LONG_PROP_2 NUMBER(13) NULL,
  DEC_PROP_1 NUMERIC(13,4) NULL,
  DEC_PROP_2 NUMERIC(13,4) NULL,
  BOOL_PROP_1 VARCHAR2(1) NULL,
  BOOL_PROP_2 VARCHAR2(1) NULL,
  CONSTRAINT QRTZ_SIMPROP_TRIG_PK PRIMARY KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP),
  CONSTRAINT QRTZ_SIMPROP_TRIG_TO_TRIG_FK FOREIGN KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP)
  REFERENCES QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP)
);
-- Trigger 作为 Blob 类型存储(用于 Quartz 用户用 JDBC 创建他们自己定制的 Trigger 类型，<span style="color:#800080;">JobStore</span> 并不知道如何存储实例的时候)
CREATE TABLE qrtz_blob_triggers
(
  SCHED_NAME VARCHAR2(120) NOT NULL,
  TRIGGER_NAME VARCHAR2(200) NOT NULL,
  TRIGGER_GROUP VARCHAR2(200) NOT NULL,
  BLOB_DATA BLOB NULL,
  CONSTRAINT QRTZ_BLOB_TRIG_PK PRIMARY KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP),
  CONSTRAINT QRTZ_BLOB_TRIG_TO_TRIG_FK FOREIGN KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP)
  REFERENCES QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP)
);
-- 以 Blob 类型存储 Quartz 的 Calendar 信息
CREATE TABLE qrtz_calendars
(
  SCHED_NAME VARCHAR2(120) NOT NULL,
  CALENDAR_NAME  VARCHAR2(200) NOT NULL,
  CALENDAR BLOB NOT NULL,
  CONSTRAINT QRTZ_CALENDARS_PK PRIMARY KEY (SCHED_NAME,CALENDAR_NAME)
);
-- 存储已暂停的 Trigger 组的信息
CREATE TABLE qrtz_paused_trigger_grps
(
  SCHED_NAME VARCHAR2(120) NOT NULL,
  TRIGGER_GROUP  VARCHAR2(200) NOT NULL,
  CONSTRAINT QRTZ_PAUSED_TRIG_GRPS_PK PRIMARY KEY (SCHED_NAME,TRIGGER_GROUP)
);
-- 存储与已触发的 Trigger 相关的状态信息，以及相联 Job 的执行信息
CREATE TABLE qrtz_fired_triggers
(
  SCHED_NAME VARCHAR2(120) NOT NULL,
  ENTRY_ID VARCHAR2(95) NOT NULL,
  TRIGGER_NAME VARCHAR2(200) NOT NULL,
  TRIGGER_GROUP VARCHAR2(200) NOT NULL,
  INSTANCE_NAME VARCHAR2(200) NOT NULL,
  FIRED_TIME NUMBER(13) NOT NULL,
  SCHED_TIME NUMBER(13) NOT NULL,
  PRIORITY NUMBER(13) NOT NULL,
  STATE VARCHAR2(16) NOT NULL,
  JOB_NAME VARCHAR2(200) NULL,
  JOB_GROUP VARCHAR2(200) NULL,
  IS_NONCONCURRENT VARCHAR2(1) NULL,
  REQUESTS_RECOVERY VARCHAR2(1) NULL,
  CONSTRAINT QRTZ_FIRED_TRIGGER_PK PRIMARY KEY (SCHED_NAME,ENTRY_ID)
);
-- 存储少量的有关 Scheduler 的状态信息，和别的 Scheduler 实例(假如是用于一个集群中)
CREATE TABLE qrtz_scheduler_state
(
  SCHED_NAME VARCHAR2(120) NOT NULL,
  INSTANCE_NAME VARCHAR2(200) NOT NULL,
  LAST_CHECKIN_TIME NUMBER(13) NOT NULL,
  CHECKIN_INTERVAL NUMBER(13) NOT NULL,
  CONSTRAINT QRTZ_SCHEDULER_STATE_PK PRIMARY KEY (SCHED_NAME,INSTANCE_NAME)
);
-- 存储程序的悲观锁的信息(假如使用了悲观锁)
CREATE TABLE qrtz_locks
(
  SCHED_NAME VARCHAR2(120) NOT NULL,
  LOCK_NAME  VARCHAR2(40) NOT NULL,
  CONSTRAINT QRTZ_LOCKS_PK PRIMARY KEY (SCHED_NAME,LOCK_NAME)
);

create index idx_qrtz_j_req_recovery on qrtz_job_details(SCHED_NAME,REQUESTS_RECOVERY);
create index idx_qrtz_j_grp on qrtz_job_details(SCHED_NAME,JOB_GROUP);

create index idx_qrtz_t_j on qrtz_triggers(SCHED_NAME,JOB_NAME,JOB_GROUP);
create index idx_qrtz_t_jg on qrtz_triggers(SCHED_NAME,JOB_GROUP);
create index idx_qrtz_t_c on qrtz_triggers(SCHED_NAME,CALENDAR_NAME);
create index idx_qrtz_t_g on qrtz_triggers(SCHED_NAME,TRIGGER_GROUP);
create index idx_qrtz_t_state on qrtz_triggers(SCHED_NAME,TRIGGER_STATE);
create index idx_qrtz_t_n_state on qrtz_triggers(SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP,TRIGGER_STATE);
create index idx_qrtz_t_n_g_state on qrtz_triggers(SCHED_NAME,TRIGGER_GROUP,TRIGGER_STATE);
create index idx_qrtz_t_next_fire_time on qrtz_triggers(SCHED_NAME,NEXT_FIRE_TIME);
create index idx_qrtz_t_nft_st on qrtz_triggers(SCHED_NAME,TRIGGER_STATE,NEXT_FIRE_TIME);
create index idx_qrtz_t_nft_misfire on qrtz_triggers(SCHED_NAME,MISFIRE_INSTR,NEXT_FIRE_TIME);
create index idx_qrtz_t_nft_st_misfire on qrtz_triggers(SCHED_NAME,MISFIRE_INSTR,NEXT_FIRE_TIME,TRIGGER_STATE);
create index idx_qrtz_t_nft_st_misfire_grp on qrtz_triggers(SCHED_NAME,MISFIRE_INSTR,NEXT_FIRE_TIME,TRIGGER_GROUP,TRIGGER_STATE);

create index idx_qrtz_ft_trig_inst_name on qrtz_fired_triggers(SCHED_NAME,INSTANCE_NAME);
create index idx_qrtz_ft_inst_job_req_rcvry on qrtz_fired_triggers(SCHED_NAME,INSTANCE_NAME,REQUESTS_RECOVERY);
create index idx_qrtz_ft_j_g on qrtz_fired_triggers(SCHED_NAME,JOB_NAME,JOB_GROUP);
create index idx_qrtz_ft_jg on qrtz_fired_triggers(SCHED_NAME,JOB_GROUP);
create index idx_qrtz_ft_t_g on qrtz_fired_triggers(SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP);

create index idx_qrtz_ft_tg on qrtz_fired_triggers(SCHED_NAME,TRIGGER_GROUP);

QuartzManager管理类

public class QuartzManager {
    private final static Logger LOGGER = LoggerFactory.getLogger(QuartzManager.class);

    private static Properties quartzProperties = PropertiesUtil.getProperties("quartz.properties");

    public static SchedulerFactory schedulerFactory;

    static {
        try {
            schedulerFactory = new StdSchedulerFactory(quartzProperties);
        } catch (SchedulerException e) {
            e.printStackTrace();
        }
    }

 /**
     * @param jobName          任务名
     * @param jobGroupName     任务组名
     * @param triggerName      触发器名
     * @param triggerGroupName 触发器组名
     * @param jobClass         任务
     * @param cron             时间设置，参考quartz说明文档
     * @Description 添加一个定时任务
     * @Description: 添加一个定时任务
     */
    public static boolean addJob(String jobName, String jobGroupName, String triggerName, String triggerGroupName, Class jobClass, String cron) {
        boolean result = false;
        try {
            Scheduler scheduler = schedulerFactory.getScheduler(); // 任务名，任务组，任务执行类
            JobDetail jobDetail = JobBuilder.newJob(jobClass).withIdentity(jobName, jobGroupName).build();
            // 触发器
            TriggerBuilder<Trigger> triggerBuilder = TriggerBuilder.newTrigger();
            // 触发器名,触发器组
            triggerBuilder.withIdentity(triggerName, triggerGroupName);
            triggerBuilder.startNow();
            // 触发器时间设定
            triggerBuilder.withSchedule(CronScheduleBuilder.cronSchedule(cron).withMisfireHandlingInstructionDoNothing());
            // 创建Trigger对象
            CronTrigger trigger = (CronTrigger) triggerBuilder.build();
            // 调度容器设置JobDetail和Trigger
            scheduler.scheduleJob(jobDetail, trigger);
            LOGGER.info("JOB【{}】创建成功", jobName);
            result = true;
        } catch (Exception e) {
            result = false;
            LOGGER.error("ERROR:调度平台-新增一个定时任务【{}】失败!", jobName, e);
        }
        return result;
    }

 /**
     * @param jobName          Job名
     * @param jobGroupName     job的组名称
     * @param triggerName      触发器名
     * @param triggerGroupName 触发器组名
     * @param cron             时间设置，参考quartz说明文档
     * @Description 修改定时调度频率
     * @Description: 修改一个任务的触发时间
     */
    public static void modifyJobTime(String jobName, String jobGroupName, String triggerName, String triggerGroupName, String cron) {
        try {
            Scheduler sched = schedulerFactory.getScheduler();
            TriggerKey triggerKey = TriggerKey.triggerKey(triggerName, triggerGroupName);
            CronTrigger trigger = (CronTrigger) sched.getTrigger(triggerKey);
            if (trigger == null) {
                return;
            }

            String oldTime = trigger.getCronExpression();
            if (!oldTime.equalsIgnoreCase(cron)) {
                /** 方式一 ：调用 rescheduleJob 开始 */
                // 触发器
                TriggerBuilder<Trigger> triggerBuilder = TriggerBuilder.newTrigger();
                // 触发器名,触发器组
                triggerBuilder.withIdentity(triggerName, triggerGroupName);
                triggerBuilder.startNow();
                // 触发器时间设定
                triggerBuilder.withSchedule(CronScheduleBuilder.cronSchedule(cron).withMisfireHandlingInstructionDoNothing());
                // 创建Trigger对象
                trigger = (CronTrigger) triggerBuilder.build();
                // 方式一 ：修改一个任务的触发时间
                sched.rescheduleJob(triggerKey, trigger);
                /** 方式一 ：调用 rescheduleJob 结束 */

                /** 方式二：先删除，然后在创建一个新的Job  */
                //JobDetail jobDetail = sched.getJobDetail(JobKey.jobKey(jobName, jobGroupName));
                //Class<? extends Job> jobClass = jobDetail.getJobClass();
                //removeJob(jobName, jobGroupName, triggerName, triggerGroupName);
                //addJob(jobName, jobGroupName, triggerName, triggerGroupName, jobClass, cron);
                /** 方式二 ：先删除，然后在创建一个新的Job */
            }
        } catch (Exception e) {
            LOGGER.error("ERROR:调度平台-修改定时任务【{}】失败!", jobName, e);
            throw new RuntimeException(e);
        }
    }

  /**
     * @param jobName          Job名
     * @param jobGroupName     job的组名称
     * @param triggerName      触发器名
     * @param triggerGroupName 触发器组名
     * @Description 删除移除一个定时任务
     */
    public static boolean removeJob(String jobName, String jobGroupName, String triggerName, String triggerGroupName) {
        boolean result = false;
        try {
            Scheduler scheduler = schedulerFactory.getScheduler();

            TriggerKey triggerKey = TriggerKey.triggerKey(triggerName, triggerGroupName);

            scheduler.pauseTrigger(triggerKey);// 停止触发器
            scheduler.unscheduleJob(triggerKey);// 移除触发器
            scheduler.deleteJob(JobKey.jobKey(jobName, jobGroupName));// 删除任务
            LOGGER.info("JOB【{}】删除成功", jobName);
            result = true;
        } catch (Exception e) {
            LOGGER.error("ERROR:调度平台-删除定时任务【{}】失败!", jobName, e);
        }
        return result;
    }

/**
     * @Description:启动所有定时任务
     */
    public static void startJobs() {
        try {
            Scheduler scheduler = schedulerFactory.getScheduler();
            scheduler.start();
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * @Description:关闭所有定时任务
     */
    public static void shutdownJobs() {
        try {
            Scheduler scheduler = schedulerFactory.getScheduler();
            if (!scheduler.isShutdown()) {
                scheduler.shutdown();
            }
        } catch (Exception e) {
            LOGGER.error("ERROR:调度平台-关闭定时调度失败!", e);
            throw new RuntimeException(e);
        }
    }

定时任务JOB类

import org.quartz.*;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.util.Properties;

public class TestJob implements Job {

  public void execute(JobExecutionContext context) throws JobExecutionException {
     JobKey key = context.getJobDetail().getKey();
     JobDataMap dataMap = context.getMergedJobDataMap(); 
     ....
     System.out.println("启动定时调度：【 " + key + "】成功");
  ｝

｝

添加一个定时任务

public class JobStoreRunner｛

     /**
     * 测试：创建一个定时任务
     *
     * @throws SchedulerException
     */
    public void taskTest() throws SchedulerException {
        // 获取Scheduler实例
        Scheduler scheduler = QuartzManager.schedulerFactory.getScheduler();
        JobDetail job = JobBuilder.newJob(TestJob.class).withIdentity("job2", "group2").build();

        // 触发时间点
        CronScheduleBuilder cronScheduleBuilder = CronScheduleBuilder.cronSchedule("0 * * * * ? *");
        Trigger trigger = TriggerBuilder.newTrigger()
                .withIdentity("trigger2", "group2")
                .withSchedule(cronScheduleBuilder)
                .usingJobData("jobSays", "Hello World1111111111111111!")
                .usingJobData("myFloatValue", 3.14122222222222f)
                .usingJobData("myStateData", String.valueOf(new ArrayList())).build();

        // 交由Scheduler安排触发
        scheduler.scheduleJob(job, trigger);
        // 关闭Scheduler
        //scheduler.shutdown();
    }

   /**
     * 启动增量调度的入口方法
     */
    public static void main(String[] args) {
        try {
            JobStoreRunner qRunner = new JobStoreRunner();
            qRunner.taskTest();
        } catch (Exception var2) {
            LOGGER.error("启动定时调度器失败!!!");
            var2.printStackTrace();
        }

    }
｝

启动定时调度

/**
* 启动定时调度
*/
public void task() {
  
  QuartzManager.startJobs();

｝

 

Liu-Lv
关注
专栏目录
SpringCloudAlibaba实战项目简介和初体验
不会写作的码农的博客
07-16 446
码力和码芸二人能让大家了解：SpringCloud版本如何控制，如何正确选择； 本系列文章通过有趣的对话方式，让大家学习不再枯燥！！！
RabbitMQ的死信队列和延时队列
DMaker1993的博客
12-26 3388
本文介绍并实战RabbitMQ的死信队列，以及通过RabbitMQ如何实现延时队列。
quartz-2.2.1使用demo
10-22
使用quartz-2.2.1实现任务，结合spring4.0.6稳定版本 ，完整完整完整完整demo
【Quartz】Quartz的搭建、应用（单独使用Quartz）
彻底拆分，一切可控！
11-24 4432
阅读目录 > 参考的优秀资料> 版本说明> 简单的搭建> 在Web应用中使用Quartz > 常用的Cron Schedule Quartz在Java构建的系统中，是十分常用的定时任务框架。 本文，记录、介绍Quartz的简单入门的单独搭建（此文入门学习Quartz为主，并非基于Spring托管形式）。   > 参考的优秀资料 Quartz Quick Start Gu
Quartz作业调度框架实战教程
最新发布
weixin_35754962的博客
09-05 1022
本文还有配套的精品资源，点击获取 简介：Quartz是一个开源的作业调度框架，专门用于在Java应用程序中安排和执行定时任务。它提供了一套丰富的API，简化了创建、管理和执行任务的过程。本文将介绍Quartz的基本组件，包括Job（任务）、Trigger（触发器）和Scheduler（调度器），并通过创建一个简单的定时任务来展示Quartz的配置和使用。本实例将指导你通过配...
Quartz实战
07-26 72
https://my.oschina.net/yinxiaoling/blog/542336?fromerr=s3ko7u33 Quartz实战 > 一、内存型（1） <bean name="complexJobDetail" class="org.springframework.scheduling.quartz.JobDetailFa...
quartz2.2.1使用 简单例子
dickzhu的专栏
02-22 188
http://www.cnblogs.com/jingmoxukong/p/5647869.html [quote] 目录 简介   Quartz是什么？   Quartz的应用场景 Quartz的安装   安装   源码 Hello World范例 API   核心API     Scheduler接口:     Job接口     JobDetail接口 ...
Quartz使用 - Quartz项目实战
改变ing
07-05 1002
出处：http://www.cnblogs.com/mengrennwpu/p/7900316.html 本博文属于转载： 我本人对mongo，elasiticsearch 目前都没有接触，所以这里是完全转载 没有任何修改。本片博文将阐述项目工作中使用Quartz的情况，包含项目背景、项目框架、Quartz集群部署等方面，重点讲述如何在实际项目中使用Quartz。1. 背景因项目需求，需要定时调用...
项目实战中的Quartz定时器
HealerJean梦想博客
02-21 685
前言 这里是我真实项目中使用的，个人认为是比较全一点的，如果不足，还希望多多包涵或者补充 接2文章的基础上又简单更改了下，变得更加规范 1、依赖 &lt;!--quartz--&gt; &lt;dependency&gt; &lt;groupId&gt;org.springframework.boot&lt;/groupId&gt; ...
SpringBoot入门（Web服务端笔记）
weixin_43261862的博客
02-05 1252
SpringBoot 第一节课 1.图例 2.三大组件 Servlet 作用 接受请求–>处理请求–>返回响应 流程 客户端发送请求到服务端 服务端将请求消息发送给Servlet Servlet生成响应发送给服务器 服务器将响应发送给客户端 Filter 作用 过滤请求和响应 流程 1.请求进入Filter，执行相关操作 2.判断通行，进入Servlet，执行完毕，再返回给Filter，最后返回请求方 3.判断失败，直接返回失败结果 Listener
Cairo包对比分析：R图形包性能大比拼
它在Linux系统中作为标准图形库被广泛使用，在其他操作系统中也有良好的支持。Cairo的优势在于其优秀的跨平台性能和高效的质量渲染，这使其成为了开发人员进行图形应用开发时的优选工具。 ## 1.2 Cairo图形包的应用...
Quartz定时任务框架实战教程(基础Java,附源码)
06-20
Quartz是OpenSymphony开源组织在Job scheduling领域又一个开源项目，它可以与J2EE与J2SE应用程序相结合也可以单独使用。Quartz可以用来创建简单或为运行十个，百个，甚至是好几万个Jobs这样复杂的程序。
Quartz任务调度的实战使用分析
01-03
详细解释关于Quartz任务调度的实战使用等问题，整理好了必要的工具及jar包等，并分析了使用场景及dome
quartz-jobs-2.2.1-sources.jar
01-18
quartz-jobs-2.2.1-sources.jar 好东西，不解释
quartz_2.2.1核心包+依赖包.zip
12-08
quartz_2.2.1核心包+依赖包.zip
quartz-2.2.1的oracle表.sql
05-28
quartz-2.2.1的oracle表的SQL脚本，有需要的同学欢迎下载。
Quartz 介绍(单独使用)
sutonline的博客
09-13 745
Quartz 介绍(单独使用)Quartz是一个java调度框架，主要由三部分组成: 1. Job。这是具体的一个job，需要实现Job接口的execute方法 2. Trigger。这个trigger是用来定义调度方式，一个trigger只能对应一个Job 3. Schedule，总调度进程。由它进行管理调度。Simple Example:SchedulerFactory sf = new
Quartz 实战
chinusyan的专栏
03-01 229
记一次Quartz重复调度(任务重复执行)的问题排查 quartz的调度过程 Quartz原理解密
Quartz 2.2.1开发者指南：实战与API详解
Quartz开发手册（Version 2.2.1）是专为Quartz Scheduler 2.2.1及其后续版本设计的一份详细指南。该文档旨在帮助开发者深入了解Quartz框架，一个强大的开源任务调度库，用于在Java应用程序中执行定期或周期性的工作...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值