Quartz-Job 管理

最新推荐文章于 2022-09-19 16:08:20 发布
最新推荐文章于 2022-09-19 16:08:20 发布
阅读量828 收藏
点赞数 1
分类专栏： Quartz
  1.  Job 组成部分
    Job 其实是由 3 个部分组成：
    JobDetail: 用于描述这个Job是做什么的
    实现Job的类: 具体干活的
    JobDataMap: 给 Job 提供参数用的

    JobDataMap 除了usingJobData 方式之外，还可以是其他方式，像这样
    job.getJobDataMap().put("email", "admin@taobao.com");
    public class TestQuartz {
    public static void main(String[] args) throws Exception{
            jobDataMap();
 
    }
 
    private static void jobDataMap() throws SchedulerException, InterruptedException {
        Scheduler scheduler = StdSchedulerFactory.getDefaultScheduler();
  
        Trigger trigger = newTrigger().withIdentity("trigger1", "group1")
            .startNow()
            .withSchedule(simpleSchedule()
                .withIntervalInSeconds(2)
                .withRepeatCount(10))
            .build();
  
        //定义一个JobDetail
        JobDetail job = newJob(MailJob.class)
            .withIdentity("mailjob1", "mailgroup")
            .usingJobData("email", "admin@10086.com")
            .build();
         
        //用JobDataMap 修改email
        job.getJobDataMap().put("email", "admin@taobao.com");
         
        //调度加入这个job
        scheduler.scheduleJob(job, trigger);
  
        //启动
        scheduler.start();
          
        //等待20秒，让前面的任务都执行完了之后，再关闭调度器
        Thread.sleep(20000);
        scheduler.shutdown(true);
    }
}
  2. Job 并发
    默认的情况下，无论上一次任务是否，只要规定的时间到了，那么下一次就开始。

    有时候会做长时间的任务，比如数据库备份，这个时候就希望上一次备份成功结束之后，才开始下一次备份，即便是规定时间到了，也不能开始，因为这样很有可能造成 数据库被锁死 （几个线程同时备份数据库，引发无法预计的混乱）。

    那么在这种情况下，给数据库备份任务增加一个注解就好了： 
    @DisallowConcurrentExecution 
    @DisallowConcurrentExecution
public class DatabaseBackupJob implements Job {
    public void execute(JobExecutionContext context) throws JobExecutionException {
        JobDetail detail = context.getJobDetail();
        String database = detail.getJobDataMap().getString("database");
         
        System.out.printf("给数据库 %s 备份, 耗时10秒 %n" ,database);
        try {
            Thread.sleep(10000);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}
    public class TestQuartz {
    public static void main(String[] args) throws Exception{
//            jobDataMap();
            databaseCurrentJob();
 
    }
 
    private static void databaseCurrentJob() throws Exception {
        Scheduler scheduler = StdSchedulerFactory.getDefaultScheduler();
          
        Trigger trigger = newTrigger().withIdentity("trigger1", "group1")
            .startNow()
            .withSchedule(simpleSchedule()
                .withIntervalInSeconds(2)
                .withRepeatCount(10))
            .build();
  
        //定义一个JobDetail
        JobDetail job = newJob(DatabaseBackupJob.class)
            .withIdentity("backupjob", "databasegroup")
            .usingJobData("database", "how2java")
            .build();
         
        //调度加入这个job
        scheduler.scheduleJob(job, trigger);
  
        //启动
        scheduler.start();
          
        //等待200秒，让前面的任务都执行完了之后，再关闭调度器
        Thread.sleep(200000);
        scheduler.shutdown(true);      
    }
 
    private static void jobDataMap() throws SchedulerException, InterruptedException {
        Scheduler scheduler = StdSchedulerFactory.getDefaultScheduler();
  
        Trigger trigger = newTrigger().withIdentity("trigger1", "group1")
            .startNow()
            .withSchedule(simpleSchedule()
                .withIntervalInSeconds(2)
                .withRepeatCount(10))
            .build();
  
        //定义一个JobDetail
        JobDetail job = newJob(MailJob.class)
            .withIdentity("mailjob1", "mailgroup")
            .usingJobData("email", "admin@10086.com")
            .build();
         
        //用JobDataMap 修改email
        job.getJobDataMap().put("email", "admin@taobao.com");
         
        //调度加入这个job
        scheduler.scheduleJob(job, trigger);
  
        //启动
        scheduler.start();
          
        //等待20秒，让前面的任务都执行完了之后，再关闭调度器
        Thread.sleep(20000);
        scheduler.shutdown(true);
    }
}
  3.  Job 异常
    任务里发生异常是很常见的。 异常处理办法通常是两种：
    1. 当异常发生，那么就通知所有管理这个 Job 的调度，停止运行它
    2. 当异常发生，修改一下参数，马上重新运行 
    public class ExceptionJob1  implements Job {
    public void execute(JobExecutionContext context) throws JobExecutionException {
 
        int i = 0;
        try {
            //故意发生异常
            System.out.println(100/i);
             
        } catch (Exception e) {
            System.out.println("发生了异常，取消这个Job 对应的所有调度");
            JobExecutionException je =new JobExecutionException(e);
            je.setUnscheduleAllTriggers(true);
            throw je;
        }
    }
}
    public class ExceptionJob2  implements Job {
    static int i = 0;
    public void execute(JobExecutionContext context) throws JobExecutionException {
 
        try {
            //故意发生异常
            System.out.println("运算结果"+100/i);
             
        } catch (Exception e) {
            System.out.println("发生了异常，修改一下参数，立即重新执行");
            i = 1;
            JobExecutionException je =new JobExecutionException(e);
            je.setRefireImmediately(true);
            throw je;
        }
    }
}
    public class TestQuartz {
    public static void main(String[] args) throws Exception{
//            jobDataMap();
//            databaseCurrentJob();
              exceptionHandle1();
//            exceptionHandle2();
    }
 
    private static void exceptionHandle2() throws Exception {
        Scheduler scheduler = StdSchedulerFactory.getDefaultScheduler();
          
        Trigger trigger = newTrigger().withIdentity("trigger1", "group1")
            .startNow()
            .withSchedule(simpleSchedule()
                .withIntervalInSeconds(2)
                .withRepeatCount(10))
            .build();
  
        //定义一个JobDetail
        JobDetail job = newJob(ExceptionJob2.class)
            .withIdentity("exceptionJob1", "someJobGroup")
            .build();
          
        //调度加入这个job
        scheduler.scheduleJob(job, trigger);
  
        //启动
        scheduler.start();
          
        //等待20秒，让前面的任务都执行完了之后，再关闭调度器
        Thread.sleep(20000);
        scheduler.shutdown(true);  
    }
 
    private static void exceptionHandle1() throws Exception {
        Scheduler scheduler = StdSchedulerFactory.getDefaultScheduler();
          
        Trigger trigger = newTrigger().withIdentity("trigger1", "group1")
            .startNow()
            .withSchedule(simpleSchedule()
                .withIntervalInSeconds(2)
                .withRepeatCount(10))
            .build();
  
        //定义一个JobDetail
        JobDetail job = newJob(ExceptionJob1.class)
            .withIdentity("exceptionJob1", "someJobGroup")
            .build();
          
        //调度加入这个job
        scheduler.scheduleJob(job, trigger);
  
        //启动
        scheduler.start();
          
        //等待20秒，让前面的任务都执行完了之后，再关闭调度器
        Thread.sleep(20000);
        scheduler.shutdown(true);  
    }
 
    private static void databaseCurrentJob() throws Exception {
        Scheduler scheduler = StdSchedulerFactory.getDefaultScheduler();
          
        Trigger trigger = newTrigger().withIdentity("trigger1", "group1")
            .startNow()
            .withSchedule(simpleSchedule()
                .withIntervalInSeconds(2)
                .withRepeatCount(10))
            .build();
  
        //定义一个JobDetail
        JobDetail job = newJob(DatabaseBackupJob.class)
            .withIdentity("backupjob", "databasegroup")
            .usingJobData("database", "how2java")
            .build();
         
        //调度加入这个job
        scheduler.scheduleJob(job, trigger);
  
        //启动
        scheduler.start();
          
        //等待200秒，让前面的任务都执行完了之后，再关闭调度器
        Thread.sleep(200000);
        scheduler.shutdown(true);      
    }
 
    private static void jobDataMap() throws SchedulerException, InterruptedException {
        Scheduler scheduler = StdSchedulerFactory.getDefaultScheduler();
  
        Trigger trigger = newTrigger().withIdentity("trigger1", "group1")
            .startNow()
            .withSchedule(simpleSchedule()
                .withIntervalInSeconds(2)
                .withRepeatCount(10))
            .build();
  
        //定义一个JobDetail
        JobDetail job = newJob(MailJob.class)
            .withIdentity("mailjob1", "mailgroup")
            .usingJobData("email", "admin@10086.com")
            .build();
         
        //用JobDataMap 修改email
        job.getJobDataMap().put("email", "admin@taobao.com");
         
        //调度加入这个job
        scheduler.scheduleJob(job, trigger);
  
        //启动
        scheduler.start();
          
        //等待20秒，让前面的任务都执行完了之后，再关闭调度器
        Thread.sleep(20000);
        scheduler.shutdown(true);
    }
}
  4.  中断 Job
    在业务上，有时候需要中断任务，那么这个Job需要实现 InterruptableJob 接口，然后就方便中断了 
    //必须实现InterruptableJob 而非 Job才能够被中断
public class StoppableJob implements InterruptableJob {
    private boolean stop = false;
    public void execute(JobExecutionContext context) throws JobExecutionException {
 
        while(true){
 
            if(stop)
                break;
            try {
                System.out.println("每隔1秒，进行一次检测，看看是否停止");
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            System.out.println("持续工作中。。。");
        }
     
    }
    public void interrupt() throws UnableToInterruptJobException {
        System.out.println("被调度叫停");
        stop = true;
    }
}
    public class TestQuartz {
    public static void main(String[] args) throws Exception{
//            jobDataMap();
//            databaseCurrentJob();
//            exceptionHandle1();
//            exceptionHandle2();
              stop();
         
    }
 
    private static void stop() throws Exception {
        Scheduler scheduler = StdSchedulerFactory.getDefaultScheduler();
          
        Trigger trigger = newTrigger().withIdentity("trigger1", "group1")
            .startNow()
            .build();
  
        //定义一个JobDetail
        JobDetail job = newJob(StoppableJob.class)
            .withIdentity("exceptionJob1", "someJobGroup")
            .build();
          
        //调度加入这个job
        scheduler.scheduleJob(job, trigger);
  
        //启动
        scheduler.start();
     
        Thread.sleep(5000);
        System.out.println("过5秒，调度停止 job");
         
        //key 就相当于这个Job的主键
        scheduler.interrupt(job.getKey());
         
        //等待20秒，让前面的任务都执行完了之后，再关闭调度器
        Thread.sleep(20000);
        scheduler.shutdown(true);  
    }
 
    private static void exceptionHandle2() throws Exception {
        Scheduler scheduler = StdSchedulerFactory.getDefaultScheduler();
          
        Trigger trigger = newTrigger().withIdentity("trigger1", "group1")
            .startNow()
            .withSchedule(simpleSchedule()
                .withIntervalInSeconds(2)
                .withRepeatCount(10))
            .build();
  
        //定义一个JobDetail
        JobDetail job = newJob(ExceptionJob2.class)
            .withIdentity("exceptionJob1", "someJobGroup")
            .build();
          
        //调度加入这个job
        scheduler.scheduleJob(job, trigger);
  
        //启动
        scheduler.start();
          
        //等待20秒，让前面的任务都执行完了之后，再关闭调度器
        Thread.sleep(20000);
        scheduler.shutdown(true);  
    }
 
    private static void exceptionHandle1() throws Exception {
        Scheduler scheduler = StdSchedulerFactory.getDefaultScheduler();
          
        Trigger trigger = newTrigger().withIdentity("trigger1", "group1")
            .startNow()
            .withSchedule(simpleSchedule()
                .withIntervalInSeconds(2)
                .withRepeatCount(10))
            .build();
  
        //定义一个JobDetail
        JobDetail job = newJob(ExceptionJob1.class)
            .withIdentity("exceptionJob1", "someJobGroup")
            .build();
          
        //调度加入这个job
        scheduler.scheduleJob(job, trigger);
  
        //启动
        scheduler.start();
          
        //等待20秒，让前面的任务都执行完了之后，再关闭调度器
        Thread.sleep(20000);
        scheduler.shutdown(true);  
    }
 
    private static void databaseCurrentJob() throws Exception {
        Scheduler scheduler = StdSchedulerFactory.getDefaultScheduler();
          
        Trigger trigger = newTrigger().withIdentity("trigger1", "group1")
            .startNow()
            .withSchedule(simpleSchedule()
                .withIntervalInSeconds(2)
                .withRepeatCount(10))
            .build();
  
        //定义一个JobDetail
        JobDetail job = newJob(DatabaseBackupJob.class)
            .withIdentity("backupjob", "databasegroup")
            .usingJobData("database", "how2java")
            .build();
         
        //调度加入这个job
        scheduler.scheduleJob(job, trigger);
  
        //启动
        scheduler.start();
          
        //等待200秒，让前面的任务都执行完了之后，再关闭调度器
        Thread.sleep(200000);
        scheduler.shutdown(true);      
    }
 
    private static void jobDataMap() throws SchedulerException, InterruptedException {
        Scheduler scheduler = StdSchedulerFactory.getDefaultScheduler();
  
        Trigger trigger = newTrigger().withIdentity("trigger1", "group1")
            .startNow()
            .withSchedule(simpleSchedule()
                .withIntervalInSeconds(2)
                .withRepeatCount(10))
            .build();
  
        //定义一个JobDetail
        JobDetail job = newJob(MailJob.class)
            .withIdentity("mailjob1", "mailgroup")
            .usingJobData("email", "admin@10086.com")
            .build();
         
        //用JobDataMap 修改email
        job.getJobDataMap().put("email", "admin@taobao.com");
         
        //调度加入这个job
        scheduler.scheduleJob(job, trigger);
  
        //启动
        scheduler.start();
          
        //等待20秒，让前面的任务都执行完了之后，再关闭调度器
        Thread.sleep(20000);
        scheduler.shutdown(true);
    }
}



litengbin
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Quartz-2.2.3 CSDN 下载
12-28
调度器负责管理Quartz应用运行时环境。调度器不是靠自己做所有的工作，而是依赖框架内一些非常重要的部件。 Quartz不仅仅是线程和线程管理。为确保可伸缩性，Quartz采用了基于多线程的架构。启动时，框架初始化一套...
quartz自动记录日志
alan3258的专栏
07-08 772
springboot spring 环境下 quartz自动记录执行日志
定时任务quartz 管理和日志
liaoqing1999的博客
10-09 3814
定时任务quartz 管理和日志 前言 上一篇介绍了quartz的结构和基础用法，现在则是利用反射来实现定时任务的抽取，实现动态配置定时任务和相关日志管理 思路 两个实体任务表和任务日志表。 任务表存放：id、任务名、任务组名、调用类名方法名、调用目标参数、cron表达式、错误策略等 CREATE TABLE `td_sm_task` ( `task_id` varchar(64) NOT NULL COMMENT '任务ID', `task_name` varchar(64) NOT NULL D
quartz监控日志（四）自定义QuartzJobBean来实现监控
lipeng的博客
03-16 1803
quartz监控日志（一） quartz监控日志（二）添加监听器 quartz监控日志（三）查看卡死线程堆栈 上面几章介绍了quartz监控的几种方式，下面再介绍一种监听方式：自定义QuartzJobBean 一、自定义QuartzJobBean /** * 定时任务处理 * * @author lipeng * */ @DisallowConcurrentExecution publ...
Job定时任务的几种创建方式
小义助手的博客
10-10 2575
1、使用线程创建Job定时任务。 这是最基础，最笨的一种方式，并不建议。代码示例： public static class Demo01 { static long count = 0; public static void main(String[] args) { // 创建一个线程 Runnable runnable = new Runnable() { @Override public void run() { // 开始
Quartz 基本使用,任务调度quartz详解,动态定时任务,job,Trigger,Scheduler
鹏神丶明月天
09-19 4314
如一个OA系统需要在每周五9点自动生成数据报表，或者想每月10号自动还款，又或者每周给暗恋的女生定时发送邮件等等。Quartz是什么？Quartz是一个强大任务调度。
quartz-console:基于quartz集群模式的任务管理DEMO
05-09
quartz-consolequartz-console是一个基于quartz集群模式下的quartz任务管理DEMO。quartz集群模式将quartz任务持久化到DB，使得多个应用实例可以共同承担JOB的执行（每次执行前请求trigger的锁）。直接查询或修改...
Quartz-Job-Scheduling-Framework-中文版-V0.9.1.zip
12-29
内容提要：在 Struts 框架中使用 Quartz，虚构了一个叫做 Job 管理控制台的 Web 应用，。需要在 Web 应用启动时创建一个 SchedulerFactory。 第十三章. Quartz 和 Web 应用 (第三部分) 内容提要：所幸 ...
xxl-job.docx
11-26
xxljob 分布式任务调度平台， 该文档是自己通过官方文档的归纳和一些测试总结，内部比较了xxljob 与quartz 的 优势，目前有许多公司都在使用，是一个很不多的开源项目
quartz（Job系统）
08-12
俗称Job系统，能够很好的完成java任务的自动执行，提供了较为详细的定时方案。支持多种定时模式。
Java中定时任务的6种实现方式，你知道几种？
热门推荐
程序新视界
08-05 5万+
几乎在所有的项目中，定时任务的使用都是不可或缺的，如果使用不当甚至会造成资损。还记得多年前在做金融系统时，出款业务是通过定时任务对外打款，当时由于银行接口处理能力有限，外加定时任务使用不当，导致发出大量重复出款请求。还好在后面环节将交易卡在了系统内部，未发生资损。 所以，系统的学习一下定时任务，是非常有必要的。这篇文章就带大家整体梳理学习一下Java领域中常见的几种定时任务实现。 线程等待实现 先从最原始最简单的方式来讲解。可以先创建一个thread，然后让它在while循环里一直运行着，通过sleep方法
quartz中的Job
qq_38685072的博客
10-09 1032
quartz任务详解Job接口JobBuilder和JobDetailJobDetail的其他属性 Job接口 需要执行的调度任务必须实现Job接口, 重写其execute()方法. 以上就是对Job接口, 我们在使用上的理解, Job接口的定义也非常简单只有一个execute()方法 void execute(JobExecutionContext context) throws JobExecutionException; JobBuilder和JobDetail 还记得我们是怎么定义一个任务
定时任务JOB框架之Quartz (二) Quartz的进阶篇-多任务JOB
anron的专栏
02-23 1465
一、前言 在《定时任务JOB框架之Quartz (一) Quartz入门与快速Demo搭建》文章中创建的工程只有1个JOB在执行1个定时任务，在实际的应用场景中一般的项目少则十几个定时任务，多的几十上百个不等。实际应用中不可能把所有定时任务都写到一个JOB中，那样会造成： 1、一个定时任务的故障会导致后面的定时任务无法继续执行 2、代码也不好维护，太臃肿了 3、单个JOB执行一次的耗时也太...
Spring整合Quartz动态定时任务步骤分析
pscool的博客
07-16 1464
1. quartz-demo 1.导入依赖 ![在这里插入图片描述](https://img-blog.csdnimg.cn/20200716103507816.png) 如果是maven项目直接导入下面即可。 <dependency> <groupId>org.quartz-scheduler</groupId> <artifactId>quartz</artifactId> <version>2.3.2&l
SpringBoot+Quartz动态管理定时任务
xy294636185的博客
04-07 4838
前置理论： 1.小顶堆（适合任务少的，因为向下调整耗费性能） 堆：是一完全二叉树（除了最后一层节点其他层都达到最大节点数，且最后一层都靠左排列）；堆中某个节点的值总不大于或不小于其父节点。 定时任务是基于小顶堆。每一个job都对应每一个节点，节点值里面存储job的到期时间（Delay），每次取堆顶的节点去执行。 插入元素：插入尾部，然后上浮（每次与n/(2^x)的位置济宁比较，时间复杂度O(log n)。 删除堆顶元素：将尾部元素放到堆顶，然后下浮。第一个任务（最近）执行后（堆顶元素）就进行这个操
Quartz定时任务框架(一)：概述和Job、JobDetail详解
qq_42682745的博客
04-27 3996
详解quartz定时任务框架，死磕
java定时任务
weixin_42522111的博客
10-12 157
import javax.servlet.ServletContextEvent; import javax.servlet.ServletContextListener; import org.quartz.CronTrigger; import org.quartz.JobDetail; import org.quartz.Scheduler; import org.quartz.Sche...
Quartz-Job应用
zzznodoit的博客
09-03 1294
最近在写Job应用，打算整理一下。 可以在http://www.quartz-scheduler.org/站点下载 Quartz 的发布版本及其源代码。 先解释一下什么叫调度：（来自维基百科）调度，在计算机中是分配工作所需资源的方法，这里的资源可以指虚拟的计算资源，如线程、进程或数据流；也可以指硬件资源，如处理器、网络连接或扩展卡。进行调度工作的程序叫调度器。 分布式与集群：（引用）小...
springboot 定时任务 implements Job 开发。
sinat_33693619的博客
01-10 5399
1、在 application.properties 中配置要实例化的类 #quartz quartz.scheduler.instanceName:b2bScheduler 2、定时任务配置类 @Configuration public class QuarzConfig { @Value("${quartz.scheduler.instanceName}")
org.quartz-scheduler quartz和quartz-jobs
最新发布
09-20
quartz提供了任务调度的功能，它可以配置和管理各种类型的任务，包括简单的定时任务、周期性任务和基于日历的任务。quartz-jobs则是quartz框架中用于定义和执行任务的接口和类的集合，它包含了各种各样的job实现，...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值