Quartz任务调度框架的简单应用

首先创建Maven项目并添加依赖

 1 <!-- https://mvnrepository.com/artifact/org.quartz-scheduler/quartz -->
 2         <dependency>
 3             <groupId>org.quartz-scheduler</groupId>
 4             <artifactId>quartz</artifactId>
 5             <version>2.2.3</version>
 6         </dependency>
 7         <!-- https://mvnrepository.com/artifact/org.slf4j/slf4j-nop -->
 8         <dependency>
 9             <groupId>org.slf4j</groupId>
10             <artifactId>slf4j-nop</artifactId>
11             <version>1.7.7</version>
12
13         </dependency>

创建一个需要执行的任务取名为HelloJob.java

public class HelloJob implements Job {
    /*用来传值
        private String message;
    private Float FloatJobValue;
    private Double DoubleTriggerValue;

    public String getMessage() {
        return message;
    }

    public void setMessage(String message) {
        this.message = message;
    }

    public Float getFloatJobValue() {
        return FloatJobValue;
    }

    public void setFloatJobValue(Float FloatJobValue) {
        this.FloatJobValue = FloatJobValue;
    }

    public Double getDoubleTriggerValue() {
        return DoubleTriggerValue;
    }

    public void setDoubleTriggerValue(Double DoubleTriggerValue) {
        this.DoubleTriggerValue = DoubleTriggerValue;
    }*/

    public void execute(JobExecutionContext context) throws JobExecutionException {
        // TODO Auto-generated method stub
        // 打印当前的执行时间
        try {
            Thread.sleep(5000L);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        Date date = new Date();
        SimpleDateFormat sf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        System.out.println("Current Exec Time Is:" + sf.format(date));
        // 编写具体的业务逻辑
        // ①
         System.out.println("Hello World");
        // ②
        /*
         * JobKey key = context.getJobDetail().getKey();
         * System.out.println("My name and group are:" + key.getName() + ":" +
         * key.getGroup()); TriggerKey trkey = context.getTrigger().getKey();
         * System.out.println("My name and group are:" + trkey.getName() + ":" +
         * trkey.getGroup()); //JobDataMap dataMap =
         * context.getMergedJobDataMap(); //JobDataMap tdataMap =
         * context.getTrigger().getJobDataMap(); String Msg =
         * dataMap.getString("message"); Float jobFloatValue =
         * dataMap.getFloat("FloatJobValue"); //String triggerMsg =
         * dataMap.getString("message"); Double triggerDoubleValue =
         * dataMap.getDouble("DoubleTriggerValue");
         * //System.out.println("JobMsg is:"+jobMsg);
         * System.out.println("jobFloatValue is:"+FloatJobValue);
         * System.out.println("Msg is:"+message);
         * System.out.println("triggerDoubleValue is:"+DoubleTriggerValue);
         */
        // ③
        /*Trigger currentTrigger = context.getTrigger();
        System.out.println("Start Time Is:" + sf.format(currentTrigger.getStartTime()));
        System.out.println("End Time Is:" + sf.format(currentTrigger.getEndTime()));
        JobKey jobKey = currentTrigger.getJobKey();
        System.out.println("JobKey info---jobName:" + jobKey.getName() + "jobGroup:" + jobKey.getGroup());*/

    }

}            

HelloScheduler.java

 1 public class HelloScheduler {
 2     public static void main(String[] args) throws SchedulerException, InterruptedException {
 3         // 打印当前的执行时间
 4         Date date = new Date();
 5         SimpleDateFormat sf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
 6         System.out.println("Current Time Is:" + sf.format(date));
 7         // 创建一个JobDetail实例,将该实例与HelloJob Class绑定
 8         JobDetail jobDetail = JobBuilder.newJob(HelloJob.class)
 9                 .withIdentity("myJob")
10                 /*.usingJobData("message", "hello myJob1")
11                 .usingJobData("FloatJobValue", 3.14F)*/
12                 .build();
13         //获取距离当前时间4秒后的时间
14         date.setTime(date.getTime()+4000L);
15         //获取距离当前时间6秒后的时间
16         Date endDate = new Date();
17         endDate.setTime(endDate.getTime() + 6000);
18         /*System.out.println("jobDetail‘s name:" + jobDetail.getKey().getName());
19         System.out.println("jobDetail‘s group:" + jobDetail.getKey().getGroup());
20         System.out.println("jobDetail‘s jobClass:" + jobDetail.getJobClass().getName());*/
21         // 创建一个trigger实例,定义该Job立即执行,并且每隔两秒钟重复执行一次,直到永远
22         //距离当前时间4秒钟后首次执行,之后每隔两秒钟
23         //SimpleTrigger
24         /*SimpleTrigger trigger = (SimpleTrigger)TriggerBuilder.newTrigger()
25                 .usingJobData("message", "hello myTrigger1")
26                 .usingJobData("DoubleTriggerValue",2.0D)
27                 .withIdentity("myTrigger", "group1")
28                 //设置开始时间结束时间,优先于执行次数
29                 .startAt(date)
30                 .endAt(endDate)
31                 //每两秒钟执行一次
32                 .withSchedule(
33                         SimpleScheduleBuilder
34                             .simpleSchedule()
35                             .withIntervalInSeconds(2)
36                             .withRepeatCount(3)
37                                     .repeatForever())
38                 .build();*/
39
40         // CronTrigger
41         CronTrigger trigger = (CronTrigger) TriggerBuilder
42                 .newTrigger()
43                 .withIdentity("myTrigger", "group1")
44                 // 设置开始时间结束时间,优先于执行次数
45                 //.startAt(date).endAt(endDate)
46                 // 每两秒钟执行一次
47                 .withSchedule(CronScheduleBuilder.cronSchedule("* * * * * ?"))
48                 .build();
49         //1.2017年内每天10点15分触发一次
50         // 0 15 10 ? * * 2017
51         //2.每天的14点整至14点59分55秒,以及18点整至18点59分55秒,每5秒钟触发一次
52         //0/5 * 14,18 * * ?
53         //3.每月周一至周五的10点15分触发一次
54         //0 15 10 ? * 2-6
55         //4.每月最后一天的10点15分触发一次
56         //0 15 10 L * ?
57         //5.每月第三个周五的10点15分触发一次
58         //0 15 10 ? * 6#3
59         // 创建scheduler实例
60         SchedulerFactory sfact = new StdSchedulerFactory();
61         Scheduler scheduler = sfact.getScheduler();
62         scheduler.start();
63         System.out.println("Scheduled time is :"+sf.format(scheduler.scheduleJob(jobDetail, trigger)));
64         //scheduler执行两秒后挂起
65         /*Thread.sleep(2000L);
66         scheduler.shutdown(false);
67         System.out.println("scheduler is shut down?" + scheduler.isShutdown());*/
68 /*        scheduler.standby();
69         Thread.sleep(3000L);
70         scheduler.start();*/
71     }
72 }

配置文件quartz.properties

org.quartz.scheduler.instanceName: DefaultQuartzScheduler
org.quartz.scheduler.rmi.export: false
org.quartz.scheduler.rmi.proxy: false
org.quartz.scheduler.wrapJobExecutionInUserTransaction: false

org.quartz.threadPool.class: org.quartz.simpl.SimpleThreadPool
org.quartz.threadPool.threadCount: 10
org.quartz.threadPool.threadPriority: 5
#0-9
org.quartz.threadPool.threadsInheritContextClassLoaderOfInitializingThread: true

org.quartz.jobStore.misfireThreshold: 60000

org.quartz.jobStore.class: org.quartz.simpl.RAMJobStore

原文地址:https://www.cnblogs.com/wwwjie/p/8277180.html

时间: 2024-09-27 13:00:05

Quartz任务调度框架的简单应用的相关文章

配置quartz任务调度框架

<properties> <quartz.version>2.2.2</quartz.version> </properties> <dependencyManagement> <dependencies> <!-- quartz任务调度框架 --> <dependency> <groupId>org.quartz-scheduler</groupId> <artifactId&g

quartz任务调度框架与spring整合

Quartz是什么? Quartz 是一种功能丰富的,开放源码的作业调度库,可以在几乎任何Java应用程序集成 - 从最小的独立的应用程序到规模最大电子商务系统.Quartz可以用来创建简单或复杂的日程安排执行几十,几百,甚至是十万的作业数 - 作业被定义为标准的Java组件,可以执行几乎任何东西,可以编程让它们执行. Quartz调度包括许多企业级功能,如JTA事务和集群支持. 通过触发器结合cron表达式,可以实现丰富的执行策略满足生产需求. maven引入quartz包 <dependen

Quartz任务调度框架使用

一.什么是Quartz Quartz是一个完全由java编写的开源作业调度框架.不要让作业调度这个术语吓着你.尽管Quartz框架整合了许多额外功能, 但就其简易形式看,你会发现它易用得简直让人受不了! 下载官网:http://www.quartz-scheduler.org/ 可以在maven项目中导入对应的坐标 二.Quartz快速入门 建立一个maven项目 导入Quartz的maven坐标 其中官网中提供了一下案例可以参考一下 网站:http://www.quartz-scheduler

Quartz 任务调度框架整合Spring使用

简介 Quartz是一个完全由java编写的开源作业调度框架,其实是启动定时任务的框架.使用时只需创建一个org.quartz.Job接口的实现类,实现唯一的方法:public void execute(JobExecutionContext context) throws JobExecutionException,将你的逻辑任务添加到execute()方法即可. 一.基本概念 (一).执行对象 Job :工作任务 ,你要做什么 Trigger:执行工作任务 触发条件 , 什么时间执行, 多久

.NET中Quartz任务调度器的简单应用实例

1.首先从NuGet中安装Quartz,安装最新版本就OK 2.新建一个Job类实现Quart中的IJob接口用于执行业务逻辑,代码如下: class CheckUpdateJob : IJob { public async Task Execute(IJobExecutionContext context) { //在此处实现业务 } } 3.新建一个任务执行类用于启动任务,代码如下: class JobController { //调度器 IScheduler scheduler; //调度

SpringBoot 1.5.x 集成 Quartz 任务调度框架

Quartz 有分 内存方式 和 数据库方式 内存方式任务信息保存在内存中, 停机会丢失, 需手动重新执行, 数据库方式: 任务信息保存在数据库中, 重点是支持集群. 内存方式 RAMJobStore 和 数据库方式 JobStoreTX, RAMJobStore 适合单机, 不支持集群,  JobStoreTX 支持集群. 下面介绍的就是 JobStoreTX 数据库方式. 1. 添加主要的相关依赖, 其他依赖这里就不说了 <dependency> <groupId>org.qu

Quartz任务调度框架

Quartz使用总结 教程

Quartz任务调度实践

最近在写一个任务调度程序,需要每隔几秒查询数据库,并取出数据做一些处理操作.使用到了Quartz任务调度框架. 基本概念 Quartz包含几个重要的对象,分别为任务(Job),触发器(Trigger),调度器(Scheduler) Job:一个接口只有一个方法void execute(),我们需要执行的任务就需要实现这个接口,在execute中实现我们要做的事情. JobDetail:在Quartz执行每次执行Job时,都需要创建一个Job实例,所以它直接接受一个实现类以便运行时实例化,还需要一

java计划任务调度框架quartz结合spring实现调度的配置实例代码分享

点击链接加入群[JavaEE(SSH+IntelliJIDE+Maven)]:http://jq.qq.com/?_wv=1027&k=L2rbHv 一:quartz简介 OpenSymphony 的Quartz提供了一个比较完美的任务调度解决方案. Quartz 是个开源的作业调度框架,定时调度器,为在 Java 应用程序中进行作业调度提供了简单却强大的机制. Quartz中有两个基本概念:作业和触发器.作业是能够调度的可执行任务,触发器提供了对作业的调度 二:quartz spring配置详