Heim > Artikel > Java > So integrieren Sie Quartz in SpringBoot

So integrieren Sie Quartz in SpringBoot

PHPznach vorne: 2023-05-10 18:46:06902Durchsuche

Grundlegende Abhängigkeit

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-quartz</artifactId>
    <version>2.5.2</version>
</dependency>

Quartz ist ein Framework für geplante Aufgaben, das häufig in Einzelanwendungsprojekten verwendet wird. Die geplanten Aufgaben können hauptsächlich unterteilt werden in:

Aufgaben im Speicher : Im Allgemeinen im Projekt definiert und gespeichert. Wenn das Projekt neu gestartet wird und die Aufgabe nicht automatisch ausgeführt wird, wird sie nicht erneut gestartet.
Persistente Aufgaben: Speichern Sie die Eigenschaften der Aufgabe in der Datenbank. Nach dem Neustart des Projekts kann die ursprünglich ausgeführte Aufgabe erneut gelesen und ausgeführt werden.

cron-Ausdruck

corn wird verwendet, um den Zeitpunkt zu steuern, zu dem eine Aufgabe ausgelöst wird. corn是用来控制任务触发的时刻。

我列举一些常用的：

每秒钟触发

"* * * * * *"：

每隔5秒执行一次

*/5 * * * * ?

每分钟触发

"0 * * * * ?"

每一小时触发

"0 * * * * ?"

每天10点触发一次

"0 0 10 * * ?"

每天0点触发一次

"0 0 0 * * ?"

通用

需要在启动类上加上@EnableScheduling注解。

内存任务

工程启动时就在执行的任务

直接定义一个执行任务，例如：

每秒都输出测试

@Service
public class ScheduleTest {

    @Scheduled(cron = "0/1 * * * * *")
    public void test() {
        System.out.println("测试");
    }
}

启动类：

@SpringBootApplication
@EnableScheduling
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

启动后看控制台中就会输出相应的内容。

手动控制某个任务

这里需要我们自己定义任务。

定义任务

通过实现Job接口，即可定义一个任务，并且我们可以手动去控制这个任务的开启。

public class SimpleJob implements Job {
    @Override
    public void execute(JobExecutionContext context) {
        System.out.println("自定义任务");
    }
}

借助Web-Controller去开启该任务

导入依赖：

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
    <version>2.3.6.RELEASE</version>
</dependency>

编写Controller，这是一个固定的写法。

指定任务： JobBuilder.newJob(任务.class) .withIdentity(任务名, 任务组).build();
指定cron表达式，创建Trigger：

CronScheduleBuilder.cronSchedule(cron表达式);
TriggerBuilder.newTrigger().withIdentity(启动器的名字, 启动器的分组) .withSchedule(cron).build();

调用任务：scheduler.scheduleJob(任务类型对象, 启动器对象)

/**
 * @ClassName
 * @Description
 * @Author:chengyunlai
 * @Date
 * @Version 1.0
 **/
@RestController
public class DynamicScheduleController {

    @Autowired
    private Scheduler scheduler;

    @GetMapping("/addSchedule")
    public String addSchedule() throws SchedulerException {
        int random = ThreadLocalRandom.current().nextInt(1000);
        // 1. 创建JobDetail，指定定时任务实现类的类型
        JobDetail jobDetail = JobBuilder.newJob(SimpleJob.class)
                .withIdentity("test-schedule" + random, "test-group").build();
        // 2. 创建Trigger，并指定每3秒执行一次
        CronScheduleBuilder cron = CronScheduleBuilder.cronSchedule("0/3 * * * * ?");

        Trigger trigger = TriggerBuilder.newTrigger().withIdentity("test-trigger" + random, "test-trigger-group")
                .withSchedule(cron).build();

        // 3. 调度任务
        scheduler.scheduleJob(jobDetail, trigger);
        return "success";
    }

通过浏览器输入项目的地址，一般默认是localhost:8080/addSchedule，输入后即可看到控制台输出了任务执行的输出内容。

持久化

如果工程重启了，上面的SimpleJob这个定时任务并不会重新启动。解决的办法就是将任务持久化，Quartz提供了解决方案，SpringBoot简化了这个操作。我们只需要配置好：数据库、数据源、操作数据库的JDBC即可。

依赖：

<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-jdbc</artifactId>
</dependency>
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid</artifactId>
    <version>1.2.8</version>
</dependency>

使用mysql数据库：导入它的驱动，mysql-connector-java。
使用Druid作为我们的数据源：druid。
使用spring-jdbc，帮助我们自动将任务信息存入到数据库中。

配置

# 设置将定时任务的信息保存到数据库
spring.quartz.job-store-type=jdbc

# 每次应用启动的时候都初始化数据库表结构
# 如果 spring.quartz.jdbc.initialize-schema 设置为 always 的话有个问题：每次重启应用的时候，跟 Quartz 相关的表会被删除重建！
# 所以为了避免表被重复创建，我们可以提前创建表，然后将其指定为never
spring.quartz.jdbc.initialize-schema=never

# 数据库配置
spring.datasource.type=com.alibaba.druid.pool.DruidDataSource
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.datasource.url=jdbc:mysql://localhost:3306/scheduled?serverTimezone=GMT%2B8&useSSL=false&characterEncoding=utf-8
spring.datasource.username=root
spring.datasource.password=root

Quartz为我们准备了sql数据表

官网：Downloads (quartz-scheduler.org)

以我：quartz-2.3.0-SNAPSHOT为例子：

下载源码后，找到jdbcjobstore这个目录：

quartz-2.3.0-SNAPSHOTsrcorgquartzimpljdbcjobstore

然后会有一系列的sql文件，找到和你数据库匹配的那个sql文件即可，我用的是mysql。

So integrieren Sie Quartz in SpringBoot

执行SQL文件建表，我的数据库名是：scheduled，各位从我的url中应该也能看出来。

建表完成后，所有配置工作结束了，启动程序，重新在浏览器中输入：localhost:8080/addSchedule，然后刷新一下数据库，就会发现任务被持久化了，此时重启工程后，该任务依旧会自动执行。

暂停任务和删除任务

我们在手动开启该任务的时候会指定：

任务的名称和组

JobDetail jobDetail = JobBuilder.newJob(SimpleJob.class) .withIdentity(任务名,任务组).build();

在暂停和恢复任务时，就需要用JobKey.jobKey(任务名，任务组)，得到一个JobKey，然后使用scheduler.pauseJob(jobkey)即可暂停任务；scheduler.resumeJob(jobKey)恢复任务。

删除任务的时候需要将任务和Trigger都删除，而在上面我们可以拿到这个jobkey表示任务，我们也需要拿到trigger，同样的我们也定义过启动器的名字和分组。

`TriggerBuilder.newTrigger().withIdentity(启动器的名字, 启动器的分组) .withSchedule(cron).build();`

TriggerKey.triggerKey((启动器的名字, 启动器的分组);也可以拿到trigger

Ich liste einige häufig verwendete auf: 🎜🎜🎜🎜Trigger jede Sekunde🎜🎜🎜rrree🎜🎜🎜Alle 5 Sekunden ausführen🎜🎜🎜rrree🎜🎜🎜Trigger jede Minute🎜🎜🎜

// 暂停
@GetMapping("/pauseSchedule")
public String pauseSchedule(String jobName, String jobGroup) throws SchedulerException {
    JobKey jobKey = JobKey.jobKey(jobName, jobGroup);
    // 获取定时任务
    JobDetail jobDetail = scheduler.getJobDetail(jobKey);
    if (jobDetail == null) {
        return "error";
    }
    scheduler.pauseJob(jobKey);
    return "success";
}

// 恢复
@GetMapping("/remuseSchedule")
public String remuseSchedule(String jobName, String jobGroup) throws SchedulerException {
    JobKey jobKey = JobKey.jobKey(jobName, jobGroup);
    // 获取定时任务
    JobDetail jobDetail = scheduler.getJobDetail(jobKey);
    if (jobDetail == null) {
        return "error";
    }
    scheduler.resumeJob(jobKey);
    return "success";
}

// 删除定时任务
@GetMapping("/removeSchedule")
public String removeSchedule(String jobName, String jobGroup, String triggerName, String triggerGroup) throws SchedulerException {
    TriggerKey triggerKey = TriggerKey.triggerKey(triggerName, triggerGroup);
    JobKey jobKey = JobKey.jobKey(jobName, jobGroup);

    Trigger trigger = scheduler.getTrigger(triggerKey);
    if (trigger == null) {
        return "error";
    }
    // 停止触发器
    scheduler.pauseTrigger(triggerKey);
    // 移除触发器
    scheduler.unscheduleJob(triggerKey);
    // 删除任务
    scheduler.deleteJob(jobKey);
    return "success";
}

🎜🎜 🎜Trigger jede Stunde 🎜🎜🎜 rrreee🎜🎜🎜Einmal täglich um 10 Uhr ausgelöst🎜🎜🎜rrreee🎜🎜🎜Einmal täglich um 0 Uhr ausgelöst🎜🎜🎜rrreee🎜Allgemein🎜🎜Sie müssen den @EnableSchedulinghinzufügen > Anmerkung zur Startup-Klasse. 🎜🎜Speicheraufgabe🎜

Aufgabe, die ausgeführt wird, wenn das Projekt startet

🎜Definieren Sie direkt eine Ausführungsaufgabe, zum Beispiel: 🎜🎜test jede Sekunde ausgeben🎜rrreee🎜Startup-Klasse: 🎜 rrreee🎜Nach dem Start wird der entsprechende Inhalt in der Konsole ausgegeben. 🎜

Eine Aufgabe manuell steuern

🎜Hier müssen wir die Aufgabe selbst definieren. 🎜

Aufgabe definieren

🎜Durch die Implementierung der Job-Schnittstelle können wir eine Aufgabe definieren und das Öffnen dieser Aufgabe manuell steuern. 🎜rrreee

Verwenden Sie Web-Controller, um diese Aufgabe zu starten

🎜Abhängigkeiten importieren: 🎜rrreee🎜Writing Controller, dies ist eine feste Schreibweise. 🎜🎜🎜🎜Geben Sie die Aufgabe an: JobBuilder.newJob(task.class) .withIdentity(task name, task group).build();🎜🎜🎜🎜Geben Sie den Cron-Ausdruck an und erstellen Sie einen Trigger: 🎜🎜

CronScheduleBuilder.cronSchedule(cron expression);

TriggerBuilder.newTrigger().withIdentity(the name of the Launcher, Gruppierung von Startern) .withSchedule(cron).build();

scheduler.scheduleJob (Aufgabentypobjekt, Starterobjekt)

localhost:8080/addSchedule

SimpleJob

Quartz

Konfiguration

Quartz hat eine SQL-Datentabelle für uns vorbereitet

jdbcjobstore

quartz-2.3.0-SNAPSHOTsrcorgquartzimpljdbcjobstore

scheduled

localhost:8080/addSchedule

verwenden JobKey.jobKey (Aufgabenname, Aufgabengruppe)

JobKey

scheduler.pauseJob(jobkey)

jobkey

TriggerKey.triggerKey((Name des Launchers, Gruppe des Launchers);

trigger

通过以下顺序完整删除任务

scheduler.deleteJob(jobKey);
scheduler.unscheduleJob(triggerKey);
scheduler.pauseTrigger(triggerKey);
// 停止触发器
// 移除触发器
// 删除任务

// 暂停
@GetMapping("/pauseSchedule")
public String pauseSchedule(String jobName, String jobGroup) throws SchedulerException {
    JobKey jobKey = JobKey.jobKey(jobName, jobGroup);
    // 获取定时任务
    JobDetail jobDetail = scheduler.getJobDetail(jobKey);
    if (jobDetail == null) {
        return "error";
    }
    scheduler.pauseJob(jobKey);
    return "success";
}

// 恢复
@GetMapping("/remuseSchedule")
public String remuseSchedule(String jobName, String jobGroup) throws SchedulerException {
    JobKey jobKey = JobKey.jobKey(jobName, jobGroup);
    // 获取定时任务
    JobDetail jobDetail = scheduler.getJobDetail(jobKey);
    if (jobDetail == null) {
        return "error";
    }
    scheduler.resumeJob(jobKey);
    return "success";
}

// 删除定时任务
@GetMapping("/removeSchedule")
public String removeSchedule(String jobName, String jobGroup, String triggerName, String triggerGroup) throws SchedulerException {
    TriggerKey triggerKey = TriggerKey.triggerKey(triggerName, triggerGroup);
    JobKey jobKey = JobKey.jobKey(jobName, jobGroup);

    Trigger trigger = scheduler.getTrigger(triggerKey);
    if (trigger == null) {
        return "error";
    }
    // 停止触发器
    scheduler.pauseTrigger(triggerKey);
    // 移除触发器
    scheduler.unscheduleJob(triggerKey);
    // 删除任务
    scheduler.deleteJob(jobKey);
    return "success";
}

Das obige ist der detaillierte Inhalt vonSo integrieren Sie Quartz in SpringBoot. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!

Stellungnahme：

Dieser Artikel ist reproduziert unter:yisu.com. Bei Verstößen wenden Sie sich bitte an admin@php.cn löschen

Vorheriger Artikel：So konfigurieren Sie Dual Kafka in SpringbootNächster Artikel：So konfigurieren Sie Dual Kafka in Springboot

In Verbindung stehende Artikel

Mehr sehen