【SpringBoot】调度和执行定时任务--Quartz(超详细)

已于 2024-09-14 21:43:10 修改
阅读量629 收藏 14
点赞数 10
分类专栏： SpringBoot java 文章标签： spring boot 后端 java spring
于 2024-09-14 18:17:39 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45687669/article/details/142264340
版权

Quartz 是一个功能强大的任务调度框架，广泛用于在 Java 应用程序中定时执行任务，同时它支持 Cron 表达式、持久化任务、集群等特性。以下是 Quartz 的详细使用教程，包括安装、基本概念、简单示例和高级功能。

1. 安装 Quartz

首先，在你的项目中添加 Quartz 依赖。对于 Maven 项目，可以在 pom.xml 中添加以下依赖：

<dependency>
    <groupId>org.quartz-scheduler</groupId>
    <artifactId>quartz</artifactId>
    <version>2.3.2</version>
</dependency>

对于 Gradle 项目，可以在 build.gradle 中添加以下依赖：

implementation 'org.quartz-scheduler:quartz:2.3.2'

2. 基本概念

Quartz 的核心概念包括：

  • Scheduler：调度器，是 Quartz 的核心，负责管理和调度任务。
  • Job：任务，是实际执行的工作单元。需要实现 Job 接口。
  • JobDetail：定义任务的详细信息，包括任务的名称、组、以及任务的类。
  • Trigger：触发器，定义任务何时执行。常用的触发器包括 SimpleTrigger 和 CronTrigger。
  • JobStore：任务存储，定义任务的存储方式。常见的有 RAMJobStore（内存存储）和 JDBCJobStore（数据库存储）。

3. 简单示例

以下是一个简单的 Quartz 示例，展示如何创建和调度一个任务。

1. 定义 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! Current time: " + System.currentTimeMillis());
    }
}

2. 配置 Scheduler 和 Job

import org.quartz.*;
import org.quartz.impl.StdSchedulerFactory;

public class QuartzExample {
    public static void main(String[] args) throws SchedulerException {
        // 创建 Scheduler 实例
        Scheduler scheduler = StdSchedulerFactory.getDefaultScheduler();

        // 定义一个 JobDetail 实例
        JobDetail job = JobBuilder.newJob(HelloJob.class)
                .withIdentity("helloJob", "group1")
                .build();

        // 创建一个触发器，每隔5秒执行一次
        Trigger trigger = TriggerBuilder.newTrigger()
                .withIdentity("helloTrigger", "group1")
                .startNow()
                .withSchedule(SimpleScheduleBuilder.simpleSchedule()
                        .withIntervalInSeconds(5)
                        .repeatForever())
                .build();

        // 调度任务
        scheduler.start();
        scheduler.scheduleJob(job, trigger);
    }
}

4. 高级功能

1. 使用 CronTrigger

CronTrigger 允许使用 Cron 表达式来定义复杂的调度规则。

import org.quartz.*;
import org.quartz.impl.StdSchedulerFactory;

public class CronTriggerExample {
    public static void main(String[] args) throws SchedulerException {
        Scheduler scheduler = StdSchedulerFactory.getDefaultScheduler();

        JobDetail job = JobBuilder.newJob(HelloJob.class)
                .withIdentity("cronJob", "group1")
                .build();

        // 使用 Cron 表达式创建触发器
        Trigger trigger = TriggerBuilder.newTrigger()
                .withIdentity("cronTrigger", "group1")
                .withSchedule(CronScheduleBuilder.cronSchedule("0/10 * * * * ?"))
                .build();

        scheduler.start();
        scheduler.scheduleJob(job, trigger);
    }
}

2. Cron 表达式

Cron 表达式用于定义任务调度的时间规则。它由6或7个字段组成，字段之间用空格分隔。以下是每个字段的含义：

┌───────────── 秒 (0 - 59)
│ ┌───────────── 分 (0 - 59)
│ │ ┌───────────── 小时 (0 - 23)
│ │ │ ┌───────────── 日 (1 - 31)
│ │ │ │ ┌───────────── 月 (1 - 12)
│ │ │ │ │ ┌───────────── 星期几 (0 - 7) (0 和 7 都是星期日)
│ │ │ │ │ │
│ │ │ │ │ │
* * * * * *

2.1 特殊字符

  • *: 表示任意值。
  • ?: 仅在日和星期字段中使用，表示不指定值。
  • -: 表示范围，例如 10-12 表示从10到12。
  • ,: 表示列表值，例如 1,2,3 表示1、2、3。
  • /: 表示增量，例如 0/15 表示从0开始每15分钟。
  • L: 表示最后，例如 L 在日字段表示月的最后一天。
  • W: 表示最近的工作日，例如 15W 表示最接近15号的工作日。
  • #: 表示第几个星期几，例如 2#1 表示第一个星期一。

2.2 示例

  • 0 0 12 * * ?: 每天中午12点执行。
  • 0 15 10 ? * *: 每天上午10:15执行。
  • 0 15 10 * * ?: 每天上午10:15执行。
  • 0 15 10 * * ? 2024: 2024年每天上午10:15执行。
  • 0 * 14 * * ?: 每天下午2点到2:59每分钟执行一次。
  • 0 0/5 14 * * ?: 每天下午2点到2:55每5分钟执行一次。
  • 0 0/5 14,18 * * ?: 每天下午2点到2:55每5分钟执行一次，以及每天下午6点到6:55每5分钟执行一次。
  • 0 0-5 14 * * ?: 每天下午2点到2:05每分钟执行一次。
  • 0 10,44 14 ? 3 WED: 每年三月的每个星期三下午2:10和2:44执行。

3. 使用 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 jobToBeExecuted(JobExecutionContext context) {
      //在任务即将被执行时调用，可以在任务执行前进行一些准备工作或记录日志。
        System.out.println("Job is about to be executed: " + context.getJobDetail().getKey());
    }
    @Override
    public void jobExecutionVetoed(JobExecutionContext context) {
      //在任务执行被否决时调用，当某些条件满足时，可以阻止任务的执行，并在此方法中执行相应的处理逻辑。
        System.out.println("Job execution was vetoed: " + context.getJobDetail().getKey());
    }
    @Override
    public void jobWasExecuted(JobExecutionContext context, JobExecutionException jobException) {
      //在任务执行完成后调用，可以在任务执行后进行一些清理工作或记录日志。如果任务执行过程中抛出异常，jobException 将包含该异常信息。
        System.out.println("Job was executed: " + context.getJobDetail().getKey());
        if (jobException != null) {
            System.out.println("Job encountered an exception: " + jobException.getMessage());
        }
    }
}

在 Scheduler 中注册 JobListener：

import org.quartz.*;
import org.quartz.impl.StdSchedulerFactory;

public class JobListenerExample {
    public static void main(String[] args) throws SchedulerException {
        Scheduler scheduler = StdSchedulerFactory.getDefaultScheduler();
      //创建任务
        JobDetail job = JobBuilder.newJob(HelloJob.class)
                .withIdentity("listenerJob", "group1")
                .build();
      创建触发器
        Trigger trigger = TriggerBuilder.newTrigger()
                .withIdentity("listenerTrigger", "group1")
                .startNow()
                .withSchedule(SimpleScheduleBuilder.simpleSchedule()
                        .withIntervalInSeconds(5)
                        .repeatForever())
                .build();

        // 创建并注册 JobListener
        MyJobListener listener = new MyJobListener();
        scheduler.getListenerManager().addJobListener(listener);

        scheduler.start();
        scheduler.scheduleJob(job, trigger);
    }
}

5. 持久化支持

Quartz 支持将任务数据持久化到数据库中，以便在系统重启后恢复任务状态。可以使用 JDBCJobStore 来实现这一点。

在 quartz.properties 文件中配置 JDBCJobStore：

org.quartz.jobStore.class = org.quartz.impl.jdbcjobstore.JobStoreTX
org.quartz.jobStore.driverDelegateClass = org.quartz.impl.jdbcjobstore.StdJDBCDelegate
org.quartz.jobStore.dataSource = myDS
org.quartz.jobStore.tablePrefix = QRTZ_

org.quartz.dataSource.myDS.driver = com.mysql.cj.jdbc.Driver
org.quartz.dataSource.myDS.URL = jdbc:mysql://localhost:3306/quartz
org.quartz.dataSource.myDS.user = root
org.quartz.dataSource.myDS.password = password
org.quartz.dataSource.myDS.maxConnections = 5

6. 并发控制

在 Quartz 中，默认情况下，任务是并发执行的。如果需要确保同一个任务实例不被并发执行，可以实现 DisallowConcurrentExecution 接口。为了清楚地展示 DisallowConcurrentExecution 注解的作用，我们可以创建两个示例：一个使用 DisallowConcurrentExecution 注解，另一个不使用该注解。通过这两个示例，我们可以观察到任务在并发执行方面的差异。

示例 1：不使用 DisallowConcurrentExecution

在这个示例中，我们创建一个简单的任务类，它会模拟一个长时间运行的任务，并且不使用 DisallowConcurrentExecution 注解。

1. 定义 Job 类

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

public class ConcurrentJob implements Job {
    @Override
    public void execute(JobExecutionContext context) throws JobExecutionException {
        System.out.println("ConcurrentJob is executing at: " + System.currentTimeMillis());
        try {
            // 模拟长时间运行的任务
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("ConcurrentJob finished at: " + System.currentTimeMillis());
    }
}

2. 配置 Scheduler 和 Job

import org.quartz.*;
import org.quartz.impl.StdSchedulerFactory;

public class ConcurrentJobExample {
    public static void main(String[] args) throws SchedulerException {
        Scheduler scheduler = StdSchedulerFactory.getDefaultScheduler();

        JobDetail job = JobBuilder.newJob(ConcurrentJob.class)
                .withIdentity("concurrentJob", "group1")
                .build();

        // 创建一个触发器，每隔2秒执行一次
        Trigger trigger = TriggerBuilder.newTrigger()
                .withIdentity("concurrentTrigger", "group1")
                .startNow()
                .withSchedule(SimpleScheduleBuilder.simpleSchedule()
                        .withIntervalInSeconds(2)
                        .repeatForever())
                .build();

        scheduler.start();
        scheduler.scheduleJob(job, trigger);
    }
}

示例 2：使用 DisallowConcurrentExecution

在这个示例中，我们创建一个类似的任务类，但这次使用 DisallowConcurrentExecution 注解，确保任务不会并发执行。

1. 定义 Job 类

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

@DisallowConcurrentExecution
public class NonConcurrentJob implements Job {
    @Override
    public void execute(JobExecutionContext context) throws JobExecutionException {
        System.out.println("NonConcurrentJob is executing at: " + System.currentTimeMillis());
        try {
            // 模拟长时间运行的任务
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("NonConcurrentJob finished at: " + System.currentTimeMillis());
    }
}

2. 配置 Scheduler 和 Job

import org.quartz.*;
import org.quartz.impl.StdSchedulerFactory;

public class NonConcurrentJobExample {
    public static void main(String[] args) throws SchedulerException {
        Scheduler scheduler = StdSchedulerFactory.getDefaultScheduler();

        JobDetail job = JobBuilder.newJob(NonConcurrentJob.class)
                .withIdentity("nonConcurrentJob", "group1")
                .build();

        // 创建一个触发器，每隔2秒执行一次
        Trigger trigger = TriggerBuilder.newTrigger()
                .withIdentity("nonConcurrentTrigger", "group1")
                .startNow()
                .withSchedule(SimpleScheduleBuilder.simpleSchedule()
                        .withIntervalInSeconds(2)
                        .repeatForever())
                .build();

        scheduler.start();
        scheduler.scheduleJob(job, trigger);
    }
}

运行示例

当你运行这两个示例时，你会看到以下行为：

不使用 DisallowConcurrentExecution 的输出

ConcurrentJob is executing at: 1633017600000
ConcurrentJob is executing at: 1633017602000
ConcurrentJob finished at: 1633017605000
ConcurrentJob is executing at: 1633017604000
ConcurrentJob finished at: 1633017607000
ConcurrentJob finished at: 1633017609000

可以看到，任务是并发执行的，多个任务实例同时运行。

使用 DisallowConcurrentExecution 的输出

NonConcurrentJob is executing at: 1633017600000
NonConcurrentJob finished at: 1633017605000
NonConcurrentJob is executing at: 1633017605000
NonConcurrentJob finished at: 1633017610000
NonConcurrentJob is executing at: 1633017610000
NonConcurrentJob finished at: 1633017615000

可以看到，任务是顺序执行的，新的任务实例只有在前一个实例完成后才会开始执行。

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

@DisallowConcurrentExecution
public class NonConcurrentJob implements Job {
    @Override
    public void execute(JobExecutionContext context) throws JobExecutionException {
        System.out.println("Non-concurrent job is executing at: " + System.currentTimeMillis());
    }
}

通过这两个示例，我们可以清楚地看到 DisallowConcurrentExecution 注解的作用：它确保同一个任务实例不会并发执行，而是顺序执行。这在某些需要严格控制任务执行顺序的场景中非常有用。

7. 任务依赖管理

Quartz 本身并不直接支持任务依赖管理（即任务之间的依赖关系），但可以通过编程方式实现这一功能。通常的方法是使用多个 Job 和 Trigger，并在 Job 执行完成后手动调度下一个依赖的 Job。

1. 异步任务依赖管理

Quartz 本身并不直接支持任务依赖管理（即任务之间的依赖关系），但可以通过编程方式实现这一功能。通常的方法是使用多个 Job 和 Trigger，并在 Job 执行完成后手动调度下一个依赖的 Job。

以下是一个示例，展示如何在 Quartz 中实现任务依赖管理：

示例场景

假设有三个任务：

  1. 任务 A：完成后触发任务 B。
  2. 任务 B：完成后触发任务 C。
  3. 任务 C：最后执行。

实现步骤

  1. 定义三个 Job 类。
  2. 配置 Scheduler 和 Job。
  3. 在每个 Job 中执行完成后手动调度下一个依赖的 Job。

代码示例

1. 定义 Job 类
import org.quartz.Job;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;

public class JobA implements Job {
    @Override
    public void execute(JobExecutionContext context) throws JobExecutionException {
        System.out.println("Job A executed at: " + System.currentTimeMillis());

        // 获取 Scheduler 实例
        Scheduler scheduler = context.getScheduler();
        try {
            // 创建 JobB 的 JobDetail
            JobDetail jobB = JobBuilder.newJob(JobB.class)
                    .withIdentity("jobB", "group1")
                    .build();

            // 创建立即触发的 Trigger
            Trigger triggerB = TriggerBuilder.newTrigger()
                    .withIdentity("triggerB", "group1")
                    .startNow()
                    .build();

            // 调度 JobB
            scheduler.scheduleJob(jobB, triggerB);
        } catch (SchedulerException e) {
            throw new JobExecutionException(e);
        }
    }
}

public class JobB implements Job {
    @Override
    public void execute(JobExecutionContext context) throws JobExecutionException {
        System.out.println("Job B executed at: " + System.currentTimeMillis());

        // 获取 Scheduler 实例
        Scheduler scheduler = context.getScheduler();
        try {
            // 创建 JobC 的 JobDetail
            JobDetail jobC = JobBuilder.newJob(JobC.class)
                    .withIdentity("jobC", "group1")
                    .build();

            // 创建立即触发的 Trigger
            Trigger triggerC = TriggerBuilder.newTrigger()
                    .withIdentity("triggerC", "group1")
                    .startNow()
                    .build();

            // 调度 JobC
            scheduler.scheduleJob(jobC, triggerC);
        } catch (SchedulerException e) {
            throw new JobExecutionException(e);
        }
    }
}

public class JobC implements Job {
    @Override
    public void execute(JobExecutionContext context) throws JobExecutionException {
        System.out.println("Job C executed at: " + System.currentTimeMillis());
    }
}
2. 配置 Scheduler 和 Job
import org.quartz.*;
import org.quartz.impl.StdSchedulerFactory;

public class QuartzDependencyExample {
    public static void main(String[] args) throws SchedulerException {
        // 创建 Scheduler 实例
        Scheduler scheduler = StdSchedulerFactory.getDefaultScheduler();

        // 定义 JobA
        JobDetail jobA = JobBuilder.newJob(JobA.class)
                .withIdentity("jobA", "group1")
                .build();

        // 创建立即触发的 Trigger
        Trigger triggerA = TriggerBuilder.newTrigger()
                .withIdentity("triggerA", "group1")
                .startNow()
                .build();

        // 调度 JobA
        scheduler.start();
        scheduler.scheduleJob(jobA, triggerA);
    }
}

解释

  1. JobA：在执行完成后，手动调度 JobB。
  2. JobB：在执行完成后，手动调度 JobC。
  3. JobC：最后执行，没有后续任务。

通过这种方式，可以实现任务之间的依赖关系。在每个任务执行完成后，手动调度下一个依赖的任务。这样，即使 Quartz 本身不直接支持任务依赖管理，也可以通过编程方式实现这一功能。

注意事项

  1. 异常处理：确保在调度下一个任务时正确处理异常，防止由于调度失败导致任务链中断。
  2. 并发控制：如果有多个任务链，需要确保并发控制，防止多个任务同时调度同一个任务。
  3. 持久化支持：如果任务链较长或需要持久化，确保使用持久化的 Scheduler 配置，以便在系统重启后恢复任务状态。

2. 同步任务依赖管理

在上面的示例中，任务之间的调度是异步的。每个 Job 在执行完成后，会立即调度下一个 Job，但不会等待下一个 Job 的执行完成。这种方式适用于大多数场景，但如果需要同步执行（即一个任务必须等待前一个任务执行完成后再执行），则需要一些额外的机制来确保任务的同步执行。

为了实现同步的任务依赖管理，可以使用以下方法：

  1. 使用 JobListener：监听每个任务的执行完成事件，并在事件触发时调度下一个任务。
  2. 使用共享的状态或信号量：在任务之间共享状态或使用信号量来确保任务按顺序执行。

以下是一个使用 JobListener 实现同步任务依赖管理的示例：

实现步骤

  1. 定义三个 Job 类。
  2. 实现 JobListener接口。
  3. 配置 Scheduler 和 Job。
  4. 当触发jobWasExecuted后调度下一个依赖的 Job。

示例代码

1. 定义 Job 类
import org.quartz.Job;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;

public class JobA implements Job {
    @Override
    public void execute(JobExecutionContext context) throws JobExecutionException {
        System.out.println("Job A executed at: " + System.currentTimeMillis());
    }
}

public class JobB implements Job {
    @Override
    public void execute(JobExecutionContext context) throws JobExecutionException {
        System.out.println("Job B executed at: " + System.currentTimeMillis());
    }
}

public class JobC implements Job {
    @Override
    public void execute(JobExecutionContext context) throws JobExecutionException {
        System.out.println("Job C executed at: " + System.currentTimeMillis());
    }
}
2. 定义 JobListener
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.quartz.JobListener;
import org.quartz.SchedulerException;

public class DependencyJobListener implements JobListener {

    private Scheduler scheduler;

    public DependencyJobListener(Scheduler scheduler) {
        this.scheduler = scheduler;
    }

    @Override
    public String getName() {
        return "DependencyJobListener";
    }

    @Override
    public void jobToBeExecuted(JobExecutionContext context) {
        // No action needed before job execution
    }

    @Override
    public void jobExecutionVetoed(JobExecutionContext context) {
        // No action needed if job execution is vetoed
    }

    @Override
    public void jobWasExecuted(JobExecutionContext context, JobExecutionException jobException) {
        String jobName = context.getJobDetail().getKey().getName();
        try {
            if ("jobA".equals(jobName)) {
                // 调度 JobB
                JobDetail jobB = JobBuilder.newJob(JobB.class)
                        .withIdentity("jobB", "group1")
                        .build();

                Trigger triggerB = TriggerBuilder.newTrigger()
                        .withIdentity("triggerB", "group1")
                        .startNow()
                        .build();

                scheduler.scheduleJob(jobB, triggerB);
            } else if ("jobB".equals(jobName)) {
                // 调度 JobC
                JobDetail jobC = JobBuilder.newJob(JobC.class)
                        .withIdentity("jobC", "group1")
                        .build();

                Trigger triggerC = TriggerBuilder.newTrigger()
                        .withIdentity("triggerC", "group1")
                        .startNow()
                        .build();

                scheduler.scheduleJob(jobC, triggerC);
            }
        } catch (SchedulerException e) {
            e.printStackTrace();
        }
    }
}
3. 配置 Scheduler 和 Job
import org.quartz.*;
import org.quartz.impl.StdSchedulerFactory;

public class QuartzDependencyExample {
    public static void main(String[] args) throws SchedulerException {
        // 创建 Scheduler 实例
        Scheduler scheduler = StdSchedulerFactory.getDefaultScheduler();

        // 定义 JobA
        JobDetail jobA = JobBuilder.newJob(JobA.class)
                .withIdentity("jobA", "group1")
                .build();

        // 创建立即触发的 Trigger
        Trigger triggerA = TriggerBuilder.newTrigger()
                .withIdentity("triggerA", "group1")
                .startNow()
                .build();

        // 添加 JobListener
        scheduler.getListenerManager().addJobListener(new DependencyJobListener(scheduler));

        // 调度 JobA
        scheduler.start();
        scheduler.scheduleJob(jobA, triggerA);
    }
}

解释

  1. JobA、JobB、JobC：分别定义三个独立的 Job 类。
  2. DependencyJobListener：实现 JobListener 接口，在每个 Job 执行完成后，根据当前执行的 Job 调度下一个 Job。
  3. Scheduler 配置：在 Scheduler 中注册 DependencyJobListener，并调度初始的 JobA。

注意事项

  1. 异常处理：确保在调度下一个任务时正确处理异常，防止由于调度失败导致任务链中断。
  2. 并发控制：如果有多个任务链，需要确保并发控制，防止多个任务同时调度同一个任务。
  3. 持久化支持：如果任务链较长或需要持久化，确保使用持久化的 Scheduler 配置，以便在系统重启后恢复任务状态。

3. 任务拦截

在 Quartz 中，可以通过实现 JobListener 来拦截任务的执行。JobListener 提供了几个方法，可以在任务执行前、执行后以及任务被否决时进行拦截和处理。

下面是一个详细的示例代码，展示如何使用 JobListener 来拦截任务的执行，并附有详细注释。

示例代码

1. 定义 Job 类
import org.quartz.Job;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;

// 定义一个简单的 Job 类
public class SampleJob implements Job {
    @Override
    public void execute(JobExecutionContext context) throws JobExecutionException {
        System.out.println("SampleJob is executing at: " + System.currentTimeMillis());
    }
}
2. 实现 JobListener
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.quartz.JobListener;

// 实现 JobListener 接口
public class MyJobListener implements JobListener {

    @Override
    public String getName() {
        // 返回监听器的名称
        return "MyJobListener";
    }

    @Override
    public void jobToBeExecuted(JobExecutionContext context) {
        // 在任务即将执行时调用
        System.out.println("Job is about to be executed: " + context.getJobDetail().getKey());
    }

    @Override
    public void jobExecutionVetoed(JobExecutionContext context) {
        // 在任务被否决时调用
        System.out.println("Job execution was vetoed: " + context.getJobDetail().getKey());
    }

    @Override
    public void jobWasExecuted(JobExecutionContext context, JobExecutionException jobException) {
        // 在任务执行完成后调用
        System.out.println("Job was executed: " + context.getJobDetail().getKey());
        if (jobException != null) {
            System.out.println("Job encountered an exception: " + jobException.getMessage());
        }
    }
}
3. 配置 Scheduler 和 Job
import org.quartz.*;
import org.quartz.impl.StdSchedulerFactory;

public class QuartzJobListenerExample {
    public static void main(String[] args) throws SchedulerException {
        // 创建 Scheduler 实例
        Scheduler scheduler = StdSchedulerFactory.getDefaultScheduler();

        // 定义一个 JobDetail 实例
        JobDetail job = JobBuilder.newJob(SampleJob.class)
                .withIdentity("sampleJob", "group1")
                .build();

        // 创建一个触发器
        Trigger trigger = TriggerBuilder.newTrigger()
                .withIdentity("sampleTrigger", "group1")
                .startNow()
                .build();

        // 创建并注册 JobListener
        MyJobListener listener = new MyJobListener();
        scheduler.getListenerManager().addJobListener(listener);

        // 调度任务
        scheduler.start();
        scheduler.scheduleJob(job, trigger);
    }
}

解释

  1. SampleJob：定义一个简单的 Job 类，包含一个 execute 方法，打印当前时间。
  2. MyJobListener：实现 JobListener 接口，提供四个方法：
    • getName：返回监听器的名称。
    • jobToBeExecuted：在任务即将执行时调用，打印任务的 Key。
    • jobExecutionVetoed：在任务被否决时调用，打印任务的 Key。
    • jobWasExecuted：在任务执行完成后调用，打印任务的 Key 和异常信息（如果有）。
  3. QuartzJobListenerExample：主类，配置 Scheduler 和 Job：
    • 创建 Scheduler 实例。
    • 定义一个 JobDetail 实例。
    • 创建一个触发器。
    • 创建并注册 JobListener 实例。
    • 调度任务并启动 Scheduler。

注意事项

  1. 异常处理：在 jobWasExecuted 方法中处理任务执行中的异常，确保异常信息被记录或处理。
  2. 并发控制：如果有多个任务并发执行，需要确保监听器的实现是线程安全的。
  3. 持久化支持：在需要持久化任务状态时，确保 Scheduler 配置支持持久化。
Vesper63
关注
专栏目录
【SpringBoot】82、SpringBoot集成Quartz实现动态管理定时任务
Asurplus
06-29 3万+
Quartz 是一个开源的作业调度框架，它完全由 Java 写成，并设计用于 J2SE 和 J2EE 应用中。它提供了巨大的灵 活性而不牺牲简单性。你能够用它来为执行一个作业而创建简单的或复杂的调度。它有很多特征，如：数据库支持，集群，插件，EJB 作业预构 建，JavaMail 及其它，支持 cron-like 表达式等等
Springboot2-Quartz 后台可动态配置的定时任务
02-28
本项目“Springboot2-Quartz 后台可动态配置的定时任务”是基于SpringBoot 2.x版本与Quartz Scheduler整合的一个示例，它展示了如何在后台管理系统中动态地创建、更新和删除定时任务，以及监控这些任务的状态，为...
SpringBoot实现定时任务-Quartz
Lucius_的博客
07-26 532
Quartz 是一个开源的 Java 任务调度框架，用于在应用程序中调度和管理任务，可以与 Spring 等框架无缝集成。
定时任务之Springboot整合Quartz详解
qq_45087487的博客
08-02 7068
Springboot整合Quartz详解
springboot之quartz动态可控定时任务
qq_14926283的博客
10-19 901
Quartz是一个开源的任务调度框架，可以用来实现定时任务的调度，如定时发送邮件、定时备份数据等。Quartz具有很高的可靠性和灵活性，支持集群部署和分布式调度，并且提供了丰富的API和插件，可以轻松实现复杂的调度需求。Quartz的工作原理是通过Job和Trigger两个核心概念来实现的，Job是具体需要执行的任务，Trigger用来触发任务的执行时机。在Quartz中，可以通过定义各种Trigger来实现不同的调度策略，如简单调度、Cron调度等。
SpringBoot结合Quartz实现定时任务
Herishwater的博客
12-01 3741
Quartz 作为一个优秀的开源调度框架，本文将选用 Quartz 来实现两个简单的业务需求，带大家学习如何动态创建任务。
【SpringBoot】9 定时任务（Quartz）
weixin_44088274的博客
08-13 1119
多种方式实现定时任务实现不同效果。java定时任务调度的实现方式：Quartz 。
【SpringBoot定时任务篇】-----Quartz以及Task详解
Learning_xzj的博客
06-28 984
​ Quartz技术是一个比较成熟的定时任务框架，怎么说呢？有点繁琐，用过的都知道，配置略微复杂。springboot对其进行整合后，简化了一系列的配置，将很多配置采用默认设置，这样开发阶段就简化了很多。再学习springboot整合Quartz前先普及几个Quartz的概念。​ 简单说就是你定时干什么事情，这就是工作，工作不可能就是一个简单的方法，还要设置一些明细信息。工作啥时候执行，设置一个调度器，可以简单理解成设置一个工作执行的时间。工作和调度都是独立定义的，它们两个怎么配合到一起呢？用触发器。完
SpringBoot项目多线程实现定时任务-只需要三步
小白先生的博客
08-21 464
众所周知，项目中需要使用定时任务发布的需求时非常常见的，例如：数据同步，清理垃圾文件，清理过期用户等需求，可能需要我们定时去清理数据。但是我们如果集成xxl-job，Quartz，spring task等定时任务框架，但是我们如果只是针对某些小需求进行定时任务，完全用不到这样调度框架，Spring Boot框架中集成了@Schedule定时任务。
SpringBoot定时任务 - 集成quartz实现定时任务（单实例和分布式两种方式)
pdai的博客
08-01 3059
Quartz是OpenSymphony开源组织在Job scheduling领域又一个开源项目，它可以与J2EE与J2SE应用程序相结合也可以单独使用。Quartz可以用来创建简单或为运行十个，百个，甚至是好几万个Jobs这样复杂的程序。Jobs可以做成标准的Java组件或 EJBs。它的特点如下注： 上图来源于https://www.cnblogs.com/jijm123/p/14240320.html当程序突然被中断时，如断电，内存超出时，很有可能造成任务的丢失。 可以将调度信息存储到数据库里面，进行持
SpringBoot定时任务+Quartz 动态调度
weixin_46455069的博客
06-06 278
SpringBoot定时任务+Quartz动态调度，详解
java-springboot-quartz-定时任务.zip
09-29
// 将任务和触发器关联并加入调度器 scheduler.scheduleJob(job, trigger); } } ``` 在上述代码中，`MyTask`是你自定义的任务类，它需要实现`org.quartz.Job`接口，并重写`execute`方法，以定义任务的具体逻辑。 ...
springboot2.3集成quartz定时任务持久化数据库,支持集群
07-13
执行完脚本后，数据库将包含如`QRTZ_JOB_DETAILS`, `QRTZ_TRIGGERS`等表，用于存储任务和触发器的信息。 数据库连接参数的修改至关重要，确保Quartz能正确连接到你的数据库。在`application.properties`文件中，...
Springboot整合Quartz实现定时任务数据库动态配置
03-17
本篇文章将详细探讨如何在Spring Boot项目中整合Quartz，并通过MySQL数据库实现定时任务的动态配置。 首先，我们需要在项目中添加依赖。在Spring Boot的`pom.xml`文件中，引入Spring Boot的`spring-boot-starter-...
深入理解Spring Boot结合MyBatis调用MySQL，并实现主从复制读写分离
J老熊
09-04 1952
MyBatis作为一款灵活的持久层框架，与Spring Boot结合使用，可以为开发者提供高效、简洁的数据库访问层。本文将详细讲解如何在Spring Boot项目中结合MyBatis调用MySQL，并实现主从复制的读写分离。我们将以电商交易系统为案例，通过实际代码示例展示如何进行配置和实现。
Spring Boot 框架下的房屋租赁业务创新
最新发布
2401_85341950的博客
09-10 999
预约看房管理：通过列表可以获取预约编号、房屋名称、房屋类型、房屋状态、房屋状态、小区、月租价格、押金、租用月数、租用金额、预约时间、用户名、姓名、身份证、联系电话、房主账号、房主姓名、审核回复、审核状态等信息、进行查看详情信息操作，如图5-10所示。预约看房管理：通过列表可以获取预约编号、房屋名称、房屋类型、房屋状态、小区、月租价格、押金、租用月数、预约时间、用户名、姓名、身份证、联系电话、房主账号、房主姓名、审核回复、审核状态等信息，进行审核或删除操作，如图5-6所示。JSP程序简单实用，面向用户。
Spring Boot详解
weixin_47260194的博客
09-07 1392
Spring Boot 是为简化 Spring 开发而生的，它为开发者屏蔽了许多底层细节，让你能够专注于业务逻辑，同时又保持了 Spring 强大的功能性和灵活性。通过自动配置、内嵌服务器和丰富的 starter 依赖，Spring Boot 能帮助开发者快速构建、部署和运行应用，是现代 Java 开发的利器。在学习 Spring Boot 的过程中，建议你多做项目实践，理解它的核心原理和如何与各种常用的技术栈结合应用。
Spring Boot3.x 启动自动执行sql脚本
D_J_Dragon的博客
09-08 797
ALWAYS：始终初始化数据库EMBEDDED：仅初始化嵌入式数据库NEVER：从不初始化数据库spring.sql.init.enabled：初始化的开关，默认是true。spring.sql.init.username：初始化脚本的用户名spring.sql.init.password：初始化脚本的密码spring.sql.init.schema-locations：配置与schema变更相关的sql脚本，多个用分号割开。
Spring boot启动过程详解
chyohn的博客
09-05 1509
本篇主要介绍spring boot在启动过程中都做了哪些工作，重点介绍在spring容器ApplicationContext刷新前都做了哪些准备，本篇以源码解释为主，示例为辅进行梳理其过程。Spring boot整个启动过程分为3部分，分别是1.准备环境配置，2. 准备Spring容器并刷新容器，3. 容器刷新后处理。每个部分又有如下图所示的步骤，本篇详细讲解这些步骤。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值