Développement back-end Java : utilisation de Java Quartz pour la gestion des tâches planifiées de l'API

Le développement backend Java est un domaine très vaste et populaire car le langage Java est largement utilisé dans le développement d'applications au niveau de l'entreprise. Dans ce domaine, les développeurs doivent maîtriser de nombreuses technologies et outils pour parvenir à une écriture logicielle de haute qualité. L'une des technologies importantes est la gestion des tâches planifiées de l'API, et Java Quartz est un outil remarquable pour réaliser cette tâche.

Java Quartz est un framework de planification de tâches open source qui peut être utilisé dans les applications Java pour mettre en œuvre divers besoins de planification. Ce framework dispose de fonctions très puissantes qui peuvent planifier des tâches en fonction de différentes normes telles que l'heure, la date, la semaine, le mois, l'année, etc., et peuvent également envoyer les résultats de l'exécution des tâches aux applications sous forme d'événements.

Pour les développeurs, utiliser Java Quartz est très simple et pratique. Il nous suffit d'introduire sa bibliothèque de dépendances correspondante et de configurer certains paramètres pour l'utiliser pour gérer les tâches planifiées de l'API. Ci-dessous, nous présenterons quelques méthodes d'utilisation de Java Quartz pour gérer les tâches planifiées de l'API.

1. Ajouter des bibliothèques dépendantes et des fichiers de configuration

Tout d'abord, nous devons introduire les bibliothèques dépendantes de Java Quartz dans notre projet. Vous pouvez utiliser Maven pour gérer ces dépendances. Ajoutez le contenu suivant au fichier pom.xml du projet :

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

Où x.x.x est le numéro de version de Java Quartz. Nous pouvons vérifier la dernière version sur le site officiel de Java Quartz.

Après avoir introduit la bibliothèque dépendante, nous devons créer un fichier de configuration pour configurer les paramètres de Java Quartz. Pour les paramètres de configuration spécifiques, vous pouvez consulter la documentation officielle de Java Quartz. Nous donnons ici un exemple simple de fichier de configuration :

# Quartz properties
org.quartz.scheduler.wait_for_jobs_to_complete = true
org.quartz.threadPool.class = org.quartz.simpl.SimpleThreadPool
org.quartz.threadPool.threadCount = 5

# JobStore properties
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.jobStore.isClustered = false

# DataSource properties
org.quartz.dataSource.myDS.driver = com.mysql.jdbc.Driver
org.quartz.dataSource.myDS.URL = jdbc:mysql://localhost:3306/quartz
org.quartz.dataSource.myDS.user = quartz
org.quartz.dataSource.myDS.password = password

Dans ce fichier de configuration, nous définissons la taille du pool de threads sur 5, utilisons la base de données MySQL comme stockage de données de Quartz, le préfixe de la table de données est QRTZ_ et définissons également le attente de la configuration Quartz pour l'achèvement de la tâche.

2. Créer des tâches planifiées API

Ensuite, nous devons créer des tâches planifiées API. Cette tâche peut être un simple appel de fonction ou une opération complexe, comme l'envoi d'emails, la génération de rapports, etc.

Dans Java Quartz, nous pouvons implémenter des tâches planifiées par API en créant une classe de tâches qui implémente l'interface Job. Dans cette classe de tâches, nous devons implémenter la méthode d'exécution pour effectuer des opérations de tâches de planification spécifiques.

Ce qui suit est un exemple simple :

package com.example.quartz;

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

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

Dans cette classe de tâches, nous utilisons System.out.println pour imprimer un message.

3. Configurer le déclencheur de la tâche planifiée de l'API

Après avoir créé la classe de tâches, nous devons créer un déclencheur pour décider quand exécuter la tâche. Dans Java Quartz, un déclencheur est un composant utilisé pour spécifier quand une tâche sera exécutée. Ils peuvent planifier des tâches en fonction de différents critères, tels que l'heure ou la date.

Java Quartz prend en charge de nombreux types de déclencheurs différents. Dans cet article, nous présentons les types de déclencheurs les plus couramment utilisés : SimpleTrigger, CronTrigger, DailyTimeIntervalTrigger.

Parmi eux, SimpleTrigger est le type de déclencheur le plus simple. Il ne sera exécuté qu'une ou plusieurs fois en fonction de certains paramètres. CronTrigger est un déclencheur basé sur des expressions Cron, et nous pouvons l'utiliser pour planifier des tâches en fonction de modèles de date ou d'heure. DailyTimeIntervalTrigger est un déclencheur basé sur des intervalles de temps relatifs ou absolus, qui peut être utilisé pour effectuer des tâches régulièrement, comme chaque jour, chaque heure, chaque minute, etc.

Ci-dessous, nous donnerons un exemple simple de CronTrigger :

package com.example.quartz;

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

public class CronTriggerExample {
    public static void main(String[] args) throws Exception {

        JobDetail job = JobBuilder.newJob(MyJob.class)
                .withIdentity("myJob", "group1")
                .build();

        CronTrigger trigger = TriggerBuilder.newTrigger()
                .withIdentity("myTrigger", "group1")
                .withSchedule(CronScheduleBuilder.cronSchedule("0/5 * * * * ?"))
                .build();

        Scheduler scheduler = new StdSchedulerFactory().getScheduler();
        scheduler.start();
        scheduler.scheduleJob(job, trigger);
    }
}

Dans cet exemple, nous créons un CronTrigger qui s'exécutera toutes les 5 secondes. Ce déclencheur planifiera la tâche avec une instance de Job comme paramètre. Cette tâche est une instance de la classe MyJob.

4. Exécuter la tâche planifiée de l'API

Enfin, nous devons exécuter cette tâche. Nous pouvons utiliser la classe Scheduler de Java Quartz pour démarrer la tâche et spécifier l'heure de planification de la tâche correspondante. La classe Scheduler fournit de nombreuses méthodes et propriétés pour contrôler l'exécution des tâches, telles que pauseJob(), curriculum vitae(), shutdown(), etc.

Ce qui suit est un exemple simple de démarrage d'une tâche planifiée API :

package com.example.quartz;

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

public class QuartzTest {
    public static void main(String[] args) throws Exception {

        SchedulerFactory sf = new StdSchedulerFactory();
        Scheduler scheduler = sf.getScheduler();

        // start the scheduler
        scheduler.start();

        // define the job and tie it to our MyJob class
        JobDetail job = JobBuilder.newJob(MyJob.class)
                .withIdentity("myJob", "group1")
                .build();

        // Trigger the job to run now, and then every 40 seconds
        Trigger trigger = TriggerBuilder.newTrigger()
                .withIdentity("myTrigger", "group1")
                .startNow()
                .withSchedule(SimpleScheduleBuilder.simpleSchedule()
                        .withIntervalInSeconds(40)
                        .repeatForever())
                .build();

        // Tell quartz to schedule the job using our trigger
        scheduler.scheduleJob(job, trigger);

        // wait until Quartz has finished executing jobs
        Thread.sleep(60000);

        // shutdown the scheduler
        scheduler.shutdown(true);
    }
}

Dans cet exemple, nous utilisons un SimpleTrigger, qui planifie la tâche maintenant, puis planifie à nouveau la tâche toutes les 40 secondes. À la fin de la méthode principale, nous mettons le thread en veille pendant 60 secondes, puis utilisons la méthode programmer.shutdown(true) pour arrêter la tâche.

De cette façon, nous pouvons facilement mettre en œuvre la gestion des tâches planifiées par API. Que ce soit dans le processus de développement de produits ou dans l'exploitation et la maintenance quotidiennes, Java Quartz est un outil qui mérite une attention particulière.

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!