Comment utiliser Quartz pour implémenter des tâches planifiées Java à haute disponibilité ?

Guide d'utilisation des tâches planifiées

Si vous souhaitez effectuer des tâches planifiées, avez des exigences de haute disponibilité ou souhaitez simplement démarrer rapidement et démarrer facilement, alors vous ont raison de le choisir. 高可用方面的需求，或者仅仅想入门快，上手简单，那么选用它准没错。

定时任务模块是对Quartz框架进一步封装，使用更加简洁。

1、引入依赖

<dependency>
    <groupId>xin.altitude.cms</groupId>
    <artifactId>ucode-cms-quartz</artifactId>
    <version>1.5.4.1</version>
</dependency>

2、快速上手

实现org.quartz.Job接口；使用注解CronExp添加任务的调度策略；使用注解Component将任务注入容器中。

启动项目，定时任务便处于监听与运行中。

@Component
@DisallowConcurrentExecution
@CronExp(cron = "0/5 * * * * ?")
public class DemoJob implements Job {
    @Override
    public void execute(JobExecutionContext context) {
        System.out.println("任务1：" + LocalDateTime.now());
    }
}

3、手动触发定时任务

定时任务除了以既有频率周期性运行外，还有通过接口手动被触发的能力。

调用如下接口，可手动触发任务ID编号为jobId的任务。

http://localhost:8080/cms-api/quartz/job/{jobId}

如果有手动触发定时任务的需求，则需要任务ID唯一并且已知，因此需要在编写定时任务时手动指定。

@CronExp(id = 1, cron = "0/5 * * * * ?")

通过注解CronExp的id属性可指定任务ID，不显示指定则使用随机ID，不满足已知的条件，因此无法手动触发。

4、带参数任务

尽管大多数任务不需要注入参数，但仍有少量的场景需要向定时任务注入参数。

public void execute(JobExecutionContext context) {
    /* 如果在调用任务时传入了参数，则能够从Map中获取 */
    Map<String, Object> dataMap = context.getMergedJobDataMap();
    /* 比如从Map中获取一个键值对，一般来说参数均为基本数据类型 */
    Object key = dataMap.get("key");
    System.out.println("任务2：" + LocalDateTime.now() + ": " + key);
}

在编写定时任务时，可从JobExecutionContext对象中解析一个Map，从而完成参数的注入。

http://localhost:8080/cms-api/quartz/job/1?key=a

上述http调用的含义是手动触发任务ID为【1】的任务，并且向其传递参数为【key】值为【a】的参数。

5、任务并发

本框架不支持任务并发，换句话说并发对定时任务不利，因此需要手动禁止。

需要注意的是Quartz的并发是指当任务执行耗时超过任务调度周期时，上一个任务未执行完，新任务是否执行。

一般来说需要显示禁止并发，在任务类上添加注解DisallowConcurrentExecution

Le module de tâches planifiées encapsule davantage le framework Quartz et le rend plus simple à utiliser.

1. Introduisez les dépendances

spring:
  quartz:
    properties:
      org.quartz.jobStore.isClustered: true
      org.quartz.jobStore.class: org.quartz.impl.jdbcjobstore.JobStoreTX
      org.quartz.jobStore.driverDelegateClass: org.quartz.impl.jdbcjobstore.StdJDBCDelegate
      org.quartz.jobStore.dataSource: qzDS
      org.quartz.dataSource.qzDS.driver: com.mysql.cj.jdbc.Driver
      org.quartz.dataSource.qzDS.URL: jdbc:mysql://localhost:3306/quartz-demo
      org.quartz.dataSource.qzDS.user: root
      org.quartz.dataSource.qzDS.password: 123456

2. Commencez rapidement

Implémentez l'interface org.quartz.Job ; utilisez l'annotation CronExp pour ajouter la stratégie de planification des tâches ; utilisez l'annotation Component pour injecter des tâches dans le conteneur.

Démarrez le projet et les tâches planifiées seront surveillées et exécutées.

rrreee

3. Déclenchez manuellement les tâches planifiées

En plus de s'exécuter périodiquement à la fréquence existante, les tâches planifiées ont également la possibilité d'être déclenchées manuellement via l'interface. 🎜🎜Appelez l'interface suivante pour déclencher manuellement la tâche avec le numéro d'identification de la tâche jobId. 🎜🎜http://localhost:8080/cms-api/quartz/job/{jobId}🎜🎜S'il est nécessaire de déclencher manuellement une tâche planifiée, l'ID de la tâche doit être unique et code> et est connu, il doit donc être spécifié manuellement lors de l'écriture d'une tâche planifiée. 🎜rrreee🎜Vous pouvez spécifier l'ID de la tâche en annotant l'attribut id de CronExp Si vous ne le spécifiez pas explicitement, un ID aléatoire sera utilisé. Il ne remplit pas les conditions connues, il ne peut donc pas. être déclenché manuellement. 🎜🎜4. Tâches avec paramètres🎜🎜Bien que la plupart des tâches n'aient pas besoin d'injecter de paramètres, il existe encore un petit nombre de scénarios qui nécessitent l'injection de paramètres dans des tâches planifiées. 🎜rrreee🎜Lors de l'écriture d'une tâche planifiée, vous pouvez analyser une carte à partir de l'objet JobExecutionContext pour terminer l'injection des paramètres. 🎜rrreee🎜La signification de l'appel http ci-dessus est de déclencher manuellement la tâche avec l'ID de tâche [1], et de lui transmettre le paramètre [key] avec la valeur [a]. 🎜🎜5. Concurrence des tâches🎜🎜Ce framework ne prend pas en charge la simultanéité des tâches. En d'autres termes, la simultanéité n'est pas bonne pour les tâches planifiées, elle doit donc être désactivée manuellement. 🎜🎜Il convient de noter que la concurrence de Quartz fait référence au fait de savoir si la nouvelle tâche sera exécutée lorsque le temps d'exécution de la tâche dépasse le cycle de planification des tâches et que la tâche précédente n'a pas été exécutée. 🎜🎜 De manière générale, il est nécessaire d'afficher l'interdiction de concurrence. Ajoutez l'annotation DisallowConcurrentExecution à la classe de tâches pour désactiver la concurrence des tâches. 🎜🎜6. Persistance🎜🎜Si la tâche planifiée a des exigences de haute disponibilité, alors la tâche doit être persistante. Une fois les données des tâches planifiées conservées dans la base de données, plusieurs applications peuvent être ouvertes. Après un déploiement persistant sur plusieurs nœuds de tâches planifiées, une défaillance d'un seul nœud dans le cluster n'affectera pas l'exécution des tâches planifiées. 🎜🎜Persistance des tâches chronométrées, il vous suffit de modifier la configuration du fichier yml pour atteindre l'objectif, sans modifier le code. De manière générale, Mysql est utilisé comme conteneur persistant. 🎜rrreee🎜À l'exception de la modification des cinq paramètres d'hôte, de port, de nom de base de données, de nom d'utilisateur et de mot de passe, utilisez les valeurs par défaut pour les autres paramètres. 🎜🎜🎜Après avoir configuré la connexion à la base de données, utilisez le script SQL et faites attention à l'initialisation de la base de données🎜🎜

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!