L'annotation @Scheduled au printemps

1. Vue d'ensemble

Dans ce didacticiel, nous illustrerons comment l' annotation Spring @Scheduled peut être utilisée pour configurer et planifier des tâches.

Les règles simples que nous devons suivre pour annoter une méthode avec @Scheduled sont:

  • une méthode doit avoir le type de retour void
  • une méthode ne doit accepter aucun paramètre

2. Activer la prise en charge de la planification

Pour activer la prise en charge de la planification des tâches et de l' annotation @Scheduled dans Spring, nous pouvons utiliser l'annotation de style d'activation Java:

@Configuration @EnableScheduling public class SpringConfig { ... }

A l'inverse, on peut faire la même chose en XML:

3. Planifier une tâche à délai fixe

Commençons par configurer une tâche à exécuter après un délai fixe:

@Scheduled(fixedDelay = 1000) public void scheduleFixedDelayTask() { System.out.println( "Fixed delay task - " + System.currentTimeMillis() / 1000); }

Dans ce cas, la durée entre la fin de la dernière exécution et le début de la prochaine exécution est fixe. La tâche attend toujours que la précédente soit terminée.

Cette option doit être utilisée lorsqu'il est obligatoire que l'exécution précédente soit terminée avant de recommencer.

4. Planifier une tâche à un taux fixe

Exécutons maintenant une tâche à un intervalle de temps fixe:

@Scheduled(fixedRate = 1000) public void scheduleFixedRateTask() { System.out.println( "Fixed rate task - " + System.currentTimeMillis() / 1000); }

Cette option doit être utilisée lorsque chaque exécution de la tâche est indépendante.

Notez que les tâches planifiées ne s'exécutent pas en parallèle par défaut. Ainsi, même si nous avons utilisé fixedRate , la tâche suivante ne sera pas appelée tant que la précédente ne sera pas terminée.

Si nous voulons prendre en charge le comportement parallèle dans les tâches planifiées, nous devons ajouter l' annotation @Async :

@EnableAsync public class ScheduledFixedRateExample { @Async @Scheduled(fixedRate = 1000) public void scheduleFixedRateTaskAsync() throws InterruptedException { System.out.println( "Fixed rate task async - " + System.currentTimeMillis() / 1000); Thread.sleep(2000); } }

Désormais, cette tâche asynchrone sera appelée chaque seconde, même si la tâche précédente n'est pas terminée.

5. Taux fixe vs délai fixe

Nous pouvons exécuter une tâche planifiée à l'aide de l' annotation @Scheduled de Spring , mais en fonction des propriétés fixedDelay et fixedRate, la nature de l'exécution change.

La propriété fixedDelay garantit qu'il existe un délai de n millisecondes entre l'heure de fin d'une exécution d'une tâche et l'heure de début de la prochaine exécution de la tâche.

Cette propriété est particulièrement utile lorsque nous devons nous assurer qu'une seule instance de la tâche s'exécute tout le temps. Pour les emplois dépendants, c'est très utile.

La propriété fixedRate exécute la tâche planifiée toutes les n millisecondes. Il ne vérifie aucune exécution précédente de la tâche.

Ceci est utile lorsque toutes les exécutions de la tâche sont indépendantes. Si nous ne prévoyons pas dépasser la taille de la mémoire et du pool de threads, fixedRate devrait être assez pratique.

Cependant, si les tâches entrantes ne se terminent pas rapidement, il est possible qu'elles se terminent par une «exception Mémoire insuffisante».

6. Planifier une tâche avec un délai initial

Ensuite, planifions une tâche avec un délai (en millisecondes):

@Scheduled(fixedDelay = 1000, initialDelay = 1000) public void scheduleFixedRateWithInitialDelayTask() { long now = System.currentTimeMillis() / 1000; System.out.println( "Fixed rate task with one second initial delay - " + now); }

Notez comment nous utilisons à la fois fixedDelay et initialDelay dans cet exemple. La tâche sera exécutée la première fois après la valeur initialDelay , et elle continuera à être exécutée selon le fixedDelay .

Cette option est pratique lorsque la tâche a une configuration qui doit être terminée.

7. Planifier une tâche à l'aide d'expressions Cron

Parfois, les délais et les tarifs ne suffisent pas, et nous avons besoin de la flexibilité d'une expression cron pour contrôler le calendrier de nos tâches:

@Scheduled(cron = "0 15 10 15 * ?") public void scheduleTaskUsingCronExpression() { long now = System.currentTimeMillis() / 1000; System.out.println( "schedule tasks using cron jobs - " + now); }

Notez que dans cet exemple, nous planifions une tâche à exécuter à 10 h 15 le 15 de chaque mois.

Par défaut, Spring utilisera le fuseau horaire local du serveur pour l'expression cron. Cependant, nous pouvons utiliser l' attribut zone pour modifier ce fuseau horaire :

@Scheduled(cron = "0 15 10 15 * ?", zone = "Europe/Paris")

Avec cette configuration, Spring programmera la méthode annotée pour qu'elle s'exécute à 10h15 le 15 de chaque mois à l'heure de Paris.

8. Paramétrage de l'horaire

Le codage en dur de ces calendriers est simple, mais nous devons généralement être en mesure de contrôler le calendrier sans recompiler et redéployer l'application entière.

Nous utiliserons Spring Expressions pour externaliser la configuration des tâches, et nous les stockerons dans des fichiers de propriétés.

Une tâche fixedDelay :

@Scheduled(fixedDelayString = "${fixedDelay.in.milliseconds}")

Une tâche à taux fixe :

@Scheduled(fixedRateString = "${fixedRate.in.milliseconds}")

Une tâche basée sur une expression cron :

@Scheduled(cron = "${cron.expression}")

9. Configuration des tâches planifiées à l'aide de XML

Spring fournit également un moyen XML de configurer les tâches planifiées. Voici la configuration XML pour les configurer:

10. Conclusion

Dans cet article, nous avons discuté de la façon de configurer et d'utiliser l' annotation @Scheduled .

Nous avons couvert le processus d'activation de la planification et diverses façons de configurer les modèles de tâches de planification.

Les exemples ci-dessus peuvent être trouvés sur GitHub.