首页手记 Quartz任务调度项目实战教程

Quartz任务调度项目实战教程

标签：

Java 架构

概述

本文详细介绍了Quartz任务调度项目实战，包括Quartz的安装、环境搭建、核心概念和API详解，以及如何创建和执行任务。文中还提供了多个实战案例，如定时发送邮件和备份数据库，帮助读者深入了解并掌握Quartz任务调度项目实战。

Quartz任务调度项目实战教程

Quartz简介与安装

Quartz介绍

Quartz是一个开源的任务调度框架，常用于Java应用程序中执行定时任务。它提供了丰富的API和功能，可以帮助开发者实现灵活的任务调度。Quartz可以运行在JVM中，支持多种触发器类型，如简单的定时触发器和cron表达式触发器等。

Quartz具有以下特点：

任务调度灵活，支持多种触发器类型
支持分布式任务调度
支持持久化任务存储
易于使用，API设计简单直观

Quartz环境搭建

添加依赖
在Maven项目中，需要在pom.xml文件中添加Quartz的依赖。以下是一个示例配置：
```
<dependencies>
   <dependency>
       <groupId>org.quartz-scheduler</groupId>
       <artifactId>quartz</artifactId>
       <version>2.3.2</version>
   </dependency>
</dependencies>
```
请确保使用最新版本的Quartz库，可以访问Quartz的官方文档获取最新版本。

配置Quartz
创建一个配置文件，例如quartz.properties，设置Quartz的一些基本参数：

org.quartz.scheduler.instanceName = MyScheduler
org.quartz.scheduler.instanceId = AUTO
org.quartz.threadPool.class = org.quartz.simpl.SimpleThreadPool
org.quartz.threadPool.threadCount = 5
org.quartz.threadPool.threadPriority = 5
org.quartz.scheduler.jobFactory.class = org.quartz.simpl.SimpleJobFactory

第一个Quartz任务实例

创建一个简单的Job实现类，并通过Scheduler来触发执行。

创建Job实现类

import org.quartz.Job;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;

public class HelloJob implements Job {
   @Override
   public void execute(JobExecutionContext context) throws JobExecutionException {
       System.out.println("Hello Quartz!");
   }
}

配置并执行Job

import org.quartz.JobBuilder;
import org.quartz.JobDetail;
import org.quartz.Scheduler;
import org.quartz.SchedulerFactory;
import org.quartz.SimpleTrigger;
import org.quartz.TriggerBuilder;
import org.quartz.impl.StdSchedulerFactory;

public class QuartzExample {
   public static void main(String[] args) throws Exception {
       // 创建调度器工厂
       SchedulerFactory schedulerFactory = new StdSchedulerFactory();
       // 获取调度器
       Scheduler scheduler = schedulerFactory.getScheduler();
       // 创建JobDetail实例
       JobDetail jobDetail = JobBuilder.newJob(HelloJob.class)
                                        .withIdentity("job1", "group1")
                                        .build();
       // 创建定时器
       SimpleTrigger simpleTrigger = (SimpleTrigger) TriggerBuilder.newTrigger()
                                                                  .withIdentity("trigger1", "group1")
                                                                  .startNow()
                                                                  .withSchedule(SimpleScheduleBuilder.simpleSchedule()
                                                                                                 .withIntervalInSeconds(10)
                                                                                                 .repeatForever())
                                                                  .build();
       // 将Job与Trigger添加到调度器中
       scheduler.scheduleJob(jobDetail, simpleTrigger);
       // 启动调度器
       scheduler.start();
   }
}

这个示例中，HelloJob会在调度器启动后每10秒执行一次。

Quartz核心概念及API详解

Job与Trigger

Job 是Quartz中表示任务执行逻辑的一个类。在实际使用中，用户需要实现Job接口来定义具体的任务执行逻辑。

Trigger 是用于定义何时以及如何触发Job的类。Quartz提供了多种Trigger类型，如SimpleTrigger和CronTrigger等。

Job接口

public class SimpleJob implements Job {
   @Override
   public void execute(JobExecutionContext context) throws JobExecutionException {
       System.out.println("执行简单任务");
   }
}

Trigger
- SimpleTrigger 用于简单的定时触发，可以指定间隔时间和触发次数。
- CronTrigger 使用cron表达式来定义复杂的触发规则，例如每小时的第一分钟执行任务。

Scheduler

Scheduler 是Quartz中的调度器，负责管理Job和Trigger。通过Scheduler可以添加、删除、暂停、恢复任务等。

import org.quartz.Scheduler;
import org.quartz.SchedulerFactory;
import org.quartz.impl.StdSchedulerFactory;

public class SchedulerExample {
    public static void main(String[] args) throws Exception {
        SchedulerFactory schedulerFactory = new StdSchedulerFactory();
        Scheduler scheduler = schedulerFactory.getScheduler();
        // 添加Job与Trigger
        // ...
        // 启动调度器
        scheduler.start();
    }
}

JobDetail与CronTrigger

JobDetail 用于定义Job实例的相关信息，包括Job类、Job数据等。

CronTrigger 使用cron表达式来定义复杂的触发规则。

创建JobDetail

import org.quartz.JobBuilder;
import org.quartz.JobDetail;

JobDetail jobDetail = JobBuilder.newJob(SimpleJob.class)
                                 .withIdentity("job2", "group2")
                                 .build();

创建CronTrigger

import org.quartz.TriggerBuilder;
import org.quartz.Trigger;
import org.quartz.CronScheduleBuilder;

Trigger trigger = TriggerBuilder.newTrigger()
                               .withIdentity("trigger2", "group2")
                               .withSchedule(CronScheduleBuilder.cronSchedule("0 0/5 * * * ?"))
                               .build();

创建与执行任务

创建简单任务

创建一个简单的任务，使用SimpleTrigger来定义定时任务。

定义Job

public class SimpleTaskJob implements Job {
   @Override
   public void execute(JobExecutionContext context) throws JobExecutionException {
       System.out.println("执行简单的定时任务");
   }
}

配置并执行任务

import org.quartz.JobBuilder;
import org.quartz.JobDetail;
import org.quartz.Scheduler;
import org.quartz.SchedulerFactory;
import org.quartz.SimpleTrigger;
import org.quartz.TriggerBuilder;
import org.quartz.impl.StdSchedulerFactory;

public class SimpleTaskExample {
   public static void main(String[] args) throws Exception {
       SchedulerFactory schedulerFactory = new StdSchedulerFactory();
       Scheduler scheduler = schedulerFactory.getScheduler();
       JobDetail jobDetail = JobBuilder.newJob(SimpleTaskJob.class)
                                        .withIdentity("job3", "group3")
                                        .build();
       SimpleTrigger simpleTrigger = (SimpleTrigger) TriggerBuilder.newTrigger()
                                                                  .withIdentity("trigger3", "group3")
                                                                  .withSchedule(SimpleScheduleBuilder.simpleSchedule()
                                                                                                 .withIntervalInSeconds(5)
                                                                                                 .repeatForever())
                                                                  .build();
       scheduler.scheduleJob(jobDetail, simpleTrigger);
       scheduler.start();
   }
}

使用Cron表达式

使用Cron表达式来定义更复杂的任务调度。

创建Job

public class CronTaskJob implements Job {
   @Override
   public void execute(JobExecutionContext context) throws JobExecutionException {
       System.out.println("执行基于Cron表达式的任务");
   }
}

配置并执行任务

import org.quartz.JobBuilder;
import org.quartz.JobDetail;
import org.quartz.Scheduler;
import org.quartz.SchedulerFactory;
import org.quartz.Trigger;
import org.quartz.TriggerBuilder;
import org.quartz.CronScheduleBuilder;
import org.quartz.impl.StdSchedulerFactory;

public class CronTaskExample {
   public static void main(String[] args) throws Exception {
       SchedulerFactory schedulerFactory = new StdSchedulerFactory();
       Scheduler scheduler = schedulerFactory.getScheduler();
       JobDetail jobDetail = JobBuilder.newJob(CronTaskJob.class)
                                        .withIdentity("job4", "group4")
                                        .build();
       Trigger trigger = TriggerBuilder.newTrigger()
                                       .withIdentity("trigger4", "group4")
                                       .withSchedule(CronScheduleBuilder.cronSchedule("0 0/10 * * * ?"))
                                       .build();
       scheduler.scheduleJob(jobDetail, trigger);
       scheduler.start();
   }
}

实现JobListener监听器

可以使用JobListener来监听任务执行过程中的各种事件，例如任务开始、结束等。

定义JobListener

import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.quartz.JobListener;

public class MyJobListener implements JobListener {
   @Override
   public String getName() {
       return "myJobListener";
   }

   @Override
   public void jobToBeFired(JobExecutionContext context) {
       System.out.println("任务即将执行");
   }

   @Override
   public void jobWasExecuted(JobExecutionContext context, JobExecutionException jobExecutionException) {
       System.out.println("任务已执行");
   }

   @Override
   public void jobWasCancelled(JobExecutionContext context, JobExecutionException jobExecutionException) {
       System.out.println("任务已取消");
   }
}

注册JobListener

import org.quartz.JobBuilder;
import org.quartz.JobDetail;
import org.quartz.Scheduler;
import org.quartz.SchedulerFactory;
import org.quartz.Trigger;
import org.quartz.TriggerBuilder;
import org.quartz.CronScheduleBuilder;
import org.quartz.JobListener;
import org.quartz.impl.StdSchedulerFactory;

public class JobListenerExample {
   public static void main(String[] args) throws Exception {
       SchedulerFactory schedulerFactory = new StdSchedulerFactory();
       Scheduler scheduler = schedulerFactory.getScheduler();
       JobDetail jobDetail = JobBuilder.newJob(CronTaskJob.class)
                                        .withIdentity("job5", "group5")
                                        .build();
       Trigger trigger = TriggerBuilder.newTrigger()
                                       .withIdentity("trigger5", "group5")
                                       .withSchedule(CronScheduleBuilder.cronSchedule("0 0/10 * * * ?"))
                                       .build();
       JobListener listener = new MyJobListener();
       scheduler.getListenerManager().addJobListener(listener);
       scheduler.scheduleJob(jobDetail, trigger);
       scheduler.start();
   }
}

任务的管理

调度任务的添加、暂停、恢复与删除

Quartz提供了丰富的功能来管理任务，包括添加、暂停、恢复和删除任务。

添加任务

import org.quartz.JobBuilder;
import org.quartz.JobDetail;
import org.quartz.Scheduler;
import org.quartz.Trigger;
import org.quartz.TriggerBuilder;
import org.quartz.CronScheduleBuilder;
import org.quartz.impl.StdSchedulerFactory;

public class TaskManagementExample {
   public static void main(String[] args) throws Exception {
       SchedulerFactory schedulerFactory = new StdSchedulerFactory();
       Scheduler scheduler = schedulerFactory.getScheduler();
       JobDetail jobDetail = JobBuilder.newJob(CronTaskJob.class)
                                        .withIdentity("job6", "group6")
                                        .build();
       Trigger trigger = TriggerBuilder.newTrigger()
                                       .withIdentity("trigger6", "group6")
                                       .withSchedule(CronScheduleBuilder.cronSchedule("0 0/10 * * * ?"))
                                       .build();
       scheduler.scheduleJob(jobDetail, trigger);
       scheduler.start();
   }
}

暂停任务
```
scheduler.pauseJob("job6", "group6");
```
恢复任务
```
scheduler.resumeJob("job6", "group6");
```
删除任务
```
scheduler.deleteJob("job6", "group6");
```

动态修改任务执行时间

可以通过重新配置Trigger来动态修改任务的执行时间。

修改执行时间

import org.quartz.Trigger;
import org.quartz.TriggerBuilder;
import org.quartz.CronScheduleBuilder;

public class ModifyTaskTimeExample {
   public static void main(String[] args) throws Exception {
       SchedulerFactory schedulerFactory = new StdSchedulerFactory();
       Scheduler scheduler = schedulerFactory.getScheduler();
       Trigger trigger = TriggerBuilder.newTrigger()
                                       .withIdentity("trigger7", "group7")
                                       .withSchedule(CronScheduleBuilder.cronSchedule("0 0/10 * * * ?"))
                                       .build();
       Trigger newTrigger = TriggerBuilder.newTrigger()
                                          .withIdentity("trigger7", "group7")
                                          .withSchedule(CronScheduleBuilder.cronSchedule("0 0/5 * * * ?"))
                                          .build();
       scheduler.rescheduleJob(trigger.getKey(), newTrigger);
   }
}

异常处理与日志

捕获和处理任务执行异常

任务执行过程中可能会遇到各种异常，可以通过实现JobListener来捕获和处理这些异常。

定义JobListener

public class MyJobListener implements JobListener {
   @Override
   public String getName() {
       return "myJobListener";
   }

   @Override
   public void jobToBeFired(JobExecutionContext context) {
       System.out.println("任务即将执行");
   }

   @Override
   public void jobWasExecuted(JobExecutionContext context, JobExecutionException jobExecutionException) {
       if (jobExecutionException != null) {
           System.err.println("任务执行异常: " + jobExecutionException.getMessage());
       }
   }

   @Override
   public void jobWasCancelled(JobExecutionContext context, JobExecutionException jobExecutionException) {
       System.out.println("任务已取消");
   }
}

注册JobListener

import org.quartz.JobBuilder;
import org.quartz.JobDetail;
import org.quartz.Scheduler;
import org.quartz.SchedulerFactory;
import org.quartz.Trigger;
import org.quartz.TriggerBuilder;
import org.quartz.CronScheduleBuilder;
import org.quartz.JobListener;
import org.quartz.impl.StdSchedulerFactory;

public class ExceptionHandlingExample {
   public static void main(String[] args) throws Exception {
       SchedulerFactory schedulerFactory = new StdSchedulerFactory();
       Scheduler scheduler = schedulerFactory.getScheduler();
       JobDetail jobDetail = JobBuilder.newJob(CronTaskJob.class)
                                        .withIdentity("job8", "group8")
                                        .build();
       Trigger trigger = TriggerBuilder.newTrigger()
                                       .withIdentity("trigger8", "group8")
                                       .withSchedule(CronScheduleBuilder.cronSchedule("0 0/10 * * * ?"))
                                       .build();
       JobListener listener = new MyJobListener();
       scheduler.getListenerManager().addJobListener(listener);
       scheduler.scheduleJob(jobDetail, trigger);
       scheduler.start();
   }
}

集成日志系统记录任务执行日志

为了更好地监控任务执行情况，可以将任务执行日志集成到日志系统中，例如Log4j。

配置Log4j
创建log4j.properties配置文件：

log4j.rootLogger=DEBUG, stdout, file

log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.Target=System.out
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%d{ABSOLUTE} %5p %c{1}:%L - %m%n

log4j.appender.file=org.apache.log4j.RollingFileAppender
log4j.appender.file.File=quartz.log
log4j.appender.file.MaxFileSize=5MB
log4j.appender.file.MaxBackupIndex=10
log4j.appender.file.layout=org.apache.log4j.PatternLayout
log4j.appender.file.layout.ConversionPattern=%d{ABSOLUTE} %5p %c{1}:%L - %m%n

在Job中记录日志

public class LoggingJob implements Job {
   @Override
   public void execute(JobExecutionContext context) throws JobExecutionException {
       Logger logger = Logger.getLogger(LoggingJob.class);
       logger.info("执行任务");
       // 具体任务逻辑...
   }
}

配置并执行Job

import org.quartz.JobBuilder;
import org.quartz.JobDetail;
import org.quartz.Scheduler;
import org.quartz.SchedulerFactory;
import org.quartz.Trigger;
import org.quartz.TriggerBuilder;
import org.quartz.CronScheduleBuilder;
import org.quartz.impl.StdSchedulerFactory;

public class LoggingExample {
   public static void main(String[] args) throws Exception {
       SchedulerFactory schedulerFactory = new StdSchedulerFactory();
       Scheduler scheduler = schedulerFactory.getScheduler();
       JobDetail jobDetail = JobBuilder.newJob(LoggingJob.class)
                                        .withIdentity("job9", "group9")
                                        .build();
       Trigger trigger = TriggerBuilder.newTrigger()
                                       .withIdentity("trigger9", "group9")
                                       .withSchedule(CronScheduleBuilder.cronSchedule("0 0/10 * * * ?"))
                                       .build();
       scheduler.scheduleJob(jobDetail, trigger);
       scheduler.start();
   }
}

实战案例

实现定时发送邮件

可以使用Quartz来实现定时发送邮件的功能，例如每周一早上发送一封周报。

定义邮件发送任务

public class EmailJob implements Job {
   @Override
   public void execute(JobExecutionContext context) throws JobExecutionException {
       // 实现邮件发送逻辑
       System.out.println("发送邮件任务");
   }
}

配置并执行任务

import org.quartz.JobBuilder;
import org.quartz.JobDetail;
import org.quartz.Scheduler;
import org.quartz.SchedulerFactory;
import org.quartz.Trigger;
import org.quartz.TriggerBuilder;
import org.quartz.CronScheduleBuilder;
import org.quartz.impl.StdSchedulerFactory;

public class EmailExample {
   public static void main(String[] args) throws Exception {
       SchedulerFactory schedulerFactory = new StdSchedulerFactory();
       Scheduler scheduler = schedulerFactory.getScheduler();
       JobDetail jobDetail = JobBuilder.newJob(EmailJob.class)
                                        .withIdentity("emailJob", "group10")
                                        .build();
       Trigger trigger = TriggerBuilder.newTrigger()
                                       .withIdentity("emailTrigger", "group10")
                                       .withSchedule(CronScheduleBuilder.cronSchedule("0 0 8 * * 1"))
                                       .build(); // 每周一早上8点执行任务
       scheduler.scheduleJob(jobDetail, trigger);
       scheduler.start();
   }
}

实现定时备份数据库

可以通过Quartz实现定时备份数据库的功能，例如每天凌晨2点备份数据库。

定义数据库备份任务

public class DatabaseBackupJob implements Job {
   @Override
   public void execute(JobExecutionContext context) throws JobExecutionException {
       // 实现数据库备份逻辑
       System.out.println("备份数据库任务");
   }
}

配置并执行任务

import org.quartz.JobBuilder;
import org.quartz.JobDetail;
import org.quartz.Scheduler;
import org.quartz.SchedulerFactory;
import org.quartz.Trigger;
import org.quartz.TriggerBuilder;
import org.quartz.CronScheduleBuilder;
import org.quartz.impl.StdSchedulerFactory;

public class DatabaseBackupExample {
   public static void main(String[] args) throws Exception {
       SchedulerFactory schedulerFactory = new StdSchedulerFactory();
       Scheduler scheduler = schedulerFactory.getScheduler();
       JobDetail jobDetail = JobBuilder.newJob(DatabaseBackupJob.class)
                                        .withIdentity("databaseBackupJob", "group11")
                                        .build();
       Trigger trigger = TriggerBuilder.newTrigger()
                                       .withIdentity("databaseBackupTrigger", "group11")
                                       .withSchedule(CronScheduleBuilder.cronSchedule("0 0 2 * * ?")) // 每天凌晨2点执行任务
                                       .build();
       scheduler.scheduleJob(jobDetail, trigger);
       scheduler.start();
   }
}

通过以上实现，可以灵活地使用Quartz来实现各种定时任务，提高应用的自动化管理水平。

点击查看更多内容

为 TA 点赞

若觉得本文不错，就分享一下吧！

评论

评论

共同学习，写下你的评论

评论加载中...

展开查看更多评论

作者其他优质文章

正在加载中

海绵宝宝撒

JAVA开发工程师

手记
篇

粉丝

40

获赞与收藏

124

关注作者，订阅最新文章

相关文章推荐

初入Quartz任务调度

最牛逼的任务调度工具 | Quartz

Spring Boot 中使用 Quartz 实现任务调度

[源码分析] 定时任务调度框架 Quartz 之故障切换

实现一个分布式调度系统-Quartz

阅读免费教程

Java并发工具

23个小节 19133 310

Java 并发原理入门教程

26个小节 38736 565

Java 入门教程

50个小节 339380 3141

推荐

评论

收藏

共同学习，写下你的评论



感谢您的支持，我会继续努力的～

扫码打赏，你说多少就多少

赞赏金额会直接到老师账户

支付方式

打开微信扫一扫，即可进行扫码打赏哦

今天注册有机会得

100积分直接送

付费专栏免费学

大额优惠券免费领

立即参与放弃机会

点击
抽奖

慕课手记新用户专享福利

恭喜你，你的运气太好了，居然抽中了 100个积分！

恭喜你，抽中了价值元的专栏！

太棒了，直接落到你账户里！

积分商城里的罗技鼠标、机械键盘、
Kindle 阅读器、小米平衡车
Apple iPad （10.2英寸）、大额优惠券
在等着你去兑换了噢

作者：

免费赠送

兑换码：1111222211 复制

优惠券可用于购买实战课、体系课
无门槛使用

先去看看，有什么好东西马上兑换我爱学习，选课去


热搜

最近搜索清空

Quartz任务调度项目实战教程

Quartz介绍

Quartz环境搭建

第一个Quartz任务实例

Job与Trigger

Scheduler

JobDetail与CronTrigger

创建简单任务

使用Cron表达式

实现JobListener监听器

调度任务的添加、暂停、恢复与删除

动态修改任务执行时间

捕获和处理任务执行异常

集成日志系统记录任务执行日志

实现定时发送邮件

实现定时备份数据库

相关文章推荐

阅读免费教程