1. Classification

• Du point de vue de la technologie de mise en œuvre, il existe actuellement trois technologies principales :

1. L'utilitaire Java de Java. Classe .Timer, cette classe vous permet de planifier une tâche java.util.TimerTask. L'utilisation de cette méthode permet à votre programme d'être exécuté à une certaine fréquence, mais pas à une heure spécifiée.

2. Utilisez Quartz, qui est un planificateur relativement puissant qui permet d'exécuter votre programme à une heure spécifiée ou à une certaine fréquence. La configuration est un peu compliquée.

3. Les tâches fournies avec Spring 3.0 et versions ultérieures peuvent être considérées comme un Quartz léger, et elles sont beaucoup plus simples à utiliser que Quartz.

• De la méthode d'héritage de la classe d'emploi, elle peut être divisée en deux catégories :

1. Les classes de tâches doivent hériter d'une classe de base de classe de tâches spécifique. Par exemple, Quartz doit hériter de org.springframework.scheduling.quartz.QuartzJobBean ; java.util.Timer doit hériter de java.util.TimerTask.

2. La classe de travail est une classe Java ordinaire et n'a pas besoin d'hériter d'une classe de base.

Remarque : je recommande personnellement d'utiliser la deuxième méthode, car tous les cours sont des cours communs et n'ont pas besoin d'être traités différemment à l'avance.

• À partir du timing de déclenchement de la planification des tâches, voici principalement les déclencheurs utilisés pour les tâches, il en existe principalement les deux types suivants :

1. est déclenché à chaque heure spécifiée. Le déclencheur correspondant dans Quartz est : org.springframework.scheduling.quartz.SimpleTriggerBean

2. Chaque Il se déclenchera une fois. à l'heure spécifiée. Le planificateur correspondant dans Quartz est : org.springframework.scheduling.quartz.CronTriggerBean

Remarque : toutes les tâches ne peuvent pas utiliser ces deux déclencheurs tels que java.util. Les tâches .TimerTask ne peuvent utiliser que la première. Les tâches à quartz et à ressort peuvent prendre en charge ces deux conditions de déclenchement.

2. Mode d'emploi

Présentez en détail comment utiliser chaque outil de planification de tâches, y compris Quartz et Spring Task.

Quartz

Tout d'abord, la classe de travail hérite d'une classe de base spécifique : org.springframework.scheduling.quartz.QuartzJobBean.

Étape 1 : Définir la classe d'emploi

 说明：org.springframework.scheduling.quartz.JobDetailBean有两个属性，jobClass属性即我们在java代码中定义的

第三步：配置作业调度的触发方式（触发器）

Quartz的第一种Si mpleTriggerBean，只支持按照一定频度调用任务，如每隔30分钟运行一次。

配置方式如下：

 

Xml代码  

bean class=

"org.springframework.scheduling.quartz.SchedulerFactoryBean"> >

>

1. list> >ref bean="cronTrigger" /> >list

   >

2. Description : Ce paramètre spécifie le nom du déclencheur précédemment configuré. Étape 5 : Démarrez simplement votre application, c'est-à-dire déployez le projet sur Tomcat ou d'autres conteneurs.

   Deuxièmement, la classe d'emplois n'hérite pas d'une classe de base spécifique.
3. Spring peut supporter cette approche grâce à deux classes :

   org.springframework.scheduling.timer.MethodInvokingTimerTaskFactoryBeanorg.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBeanCes deux classes correspondent respectivement aux deux méthodes de planification de tâches supportées par spring, à savoir la méthode des tâches timer et la méthode Quartz fournies avec Java comme mentionné ci-dessus. Ici, j'écris uniquement sur l'utilisation de MethodInvokingJobDetailFactoryBean. L'avantage de l'utilisation de cette classe est que notre classe de tâches n'a plus besoin d'hériter d'une classe, mais est un pojo ordinaire.

Première étape : Écrire la classe de tâches

4. Code Java public

   class Job2 {

5. public void doJob2() {

6. System.out.println("N'hérite pas de la méthode QuartzJobBean - planification en cours...");

   }

7. } Comme vous pouvez le voir, il s'agit d'une classe ordinaire et a une méthode.

Étape 2 : Configurer la classe d'emploi

Code XML

1. bean id="job2"  

2. class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean">  

3. property name="targetObject">  

4. bean class="com.gy.Job2 " />  

5. propriété>  

6. property name="targetMethod" value=" doJob2" />  

7. propriété name= "concurrent" value="false" />  

8. haricot> ;  

 说明：一步是关键步骤，声明一个MethodInvokingJobDetailFactoryBean，有两个关键属Nom : targetObject指定任务类，targetMethod指定运行的方法。往下的步骤就与方法一相同了，为了完整，同样贴出。

第三步：配置作业调度的触发方式（触发器）

Quartz的作业触发器有两种，分别是

org.springframework.scheduling.quartz.SimpleTriggerBean

org.springframework.scheduling.quartz.CronTriggerBean

第一种SimpleTriggerBean，只支持按照一定频度调用任务，如每隔30分钟运行一次。

配置方式如下：

 第二种CronTriggerBean，支持到指定时间运行一次，如每天12:00运行一次等。

配置方式如下：

bean class=

"org.springframework.scheduling.quartz.SchedulerFactoryBean"> >

>

1. list> >ref bean="cronTrigger" /> >list

   >

2. Explication : Ce paramètre spécifie le nom du déclencheur précédemment configuré. Étape 5 : Démarrez simplement votre application, c'est-à-dire déployez le projet sur Tomcat ou d'autres conteneurs. À ce stade, la configuration de base de Quartz au printemps a été introduite. Bien sûr, avant de l'utiliser, vous devez y importer le package spring correspondant. il n'y a pas besoin de plus.

   En fait, on voit que la configuration de Quartz semble assez compliquée. Il n'y a aucun moyen, car Quartz est en fait un outil lourd. Si l'on veut simplement exécuter quelques tâches planifiées simples, y en a-t-il. quelque chose de plus simple ? Des outils, oui !
3. Veuillez consulter mon introduction à la tâche Spring ci-dessous.

   Spring-TaskLa section précédente a présenté l'utilisation de Quartz au Spring. Cet article présente l'outil de tâches planifiées auto-développé après Spring 3.0, spring task, qui. peut être C'est comme un Quartz léger, et il est très simple à utiliser. Il ne nécessite pas de packages supplémentaires à l'exception des packages liés à Spring, et il prend en charge deux formes d'annotations et de fichiers de configuration. Ces deux seront présentés ci-dessous.

   La première : méthode du fichier de configuration

4. La première étape : écrire la classe de travail qui est un pojo ordinaire, comme suit : Code Java

   1. import org.springframework.stereotype.Service;

   public
   2. class TaskJob { 

   3.  public

      void job1() {
   5. System.out .println("Tâche en cours...");

      }  

   6. }  

   7. Étape 2 : Ajoutez l'espace de noms et la description
   Code XML
   "http://www.springframework.org/schema/beans"
   xmlns:task=

   "http://www.springframework.org/schema/task"

   1. . . . . . . xsi:schemaLocation="http://www.springframework.org/schema/task "

      > >

   2. Étape 3 : Définir des tâches spécifiques dans le fichier de configuration Spring

   3. Code XML

   4. tâche : tâches planifiées> 

    tâche : planifiée

   ref=

   "taskJob"

   method="job1"

   cron=

   "0 * * * * ?"

   /> 

   2. tâche : tâches planifiées> >context:component-scan base-package=" com.gy.mytask " />

      Explication : Le paramètre ref spécifie la classe de tâches, la méthode spécifie la méthode qui doit être exécuté, expressions cron et cronExpression, la méthode d'écriture spécifique n'est pas présentée ici, détails Voir l'annexe de l'article précédent.
   3. Inutile de dire que cette configuration est utilisée pour les annotations d'analyse de printemps.

      La configuration est complète ici, n'est-ce pas très simple ? Deuxièmement : utiliser le formulaire d'annotation Peut-être que nous ne voulons pas le configurer dans le fichier XML à chaque fois que nous écrivons une classe de tâches. Nous pouvons utiliser l'annotation @Scheduled. au fichier source. Définition de l'annotation :

   4. Code Java

   1. @Target({java.lang.annotation.ElementType.METHOD, java.lang.annotation.ElementType.ANNOTATION_TYPE})

   2. @Retention(RetentionPolicy.RUNTIME)

   3. @Documenté

   4. public @interface Planifié

   5. {

   6. public abstract String cron() ;

   8. public résumé long fixDelay();

   10. public résumé long fixRate(); 🎜>

       }
   On voit que cette annotation a trois méthodes ou paramètres, ce qui signifie :
   cron : Spécifiez l'expression cron
   fixedDelay : Explication du document officiel : Un déclencheur basé sur un intervalle où l'intervalle est mesuré à partir du temps d'achèvement de la tâche précédente. La valeur de l'unité de temps est mesurée en millisecondes. . Cela signifie l'intervalle entre l'achèvement de la tâche précédente et le début de la tâche suivante, l'unité est en millisecondes.
   fixedRate : Explication du document officiel : Un déclencheur basé sur un intervalle où l'intervalle est mesuré à partir de l'heure de début de la tâche précédente. La valeur de l'unité de temps est mesurée en millisecondes. à la tâche suivante L'intervalle de démarrage en millisecondes.
   Laissez-moi le configurer ensuite.

   Première étape : écrire du pojo

   Code Java
   

   importer org.springframework.scheduling.annotation.Scheduled
   2. @Component("taskJob")

   3. public

      class TaskJob {

   4. @Scheduled(cron =
   "0 0 3 * * ?")

   5.  

      public 
   void job1() { 

   6.  System.out.println("Tâche en cours. . ”);  

   7.                      Étape 2 : Ajouter la configuration liée à la tâche :

      Code XML

   8. 1. xml version="1.0" encoding="UTF-8"?>  

      2. haricots xmlns= "http://www.springframework.org/schema/beans"  

      3.     xmlns:xsi=" http://www.w3.org/2001/XMLSchema-instance" xmlns:aop="http://www.springframework.org/schema/aop"  

      4.     xmlns:context="http://www.springframework.org/schema/context"  

      5.     xmlns:tx="http://www.springframework.org/schema/tx"  

      6.     xmlns:task="http://www.springframework.org/schema/task"  

      7.     xsi:schemaLocation ="  

      13.          "  

      14.     default-lazy-init="faux">  

      17.     context:annotation-config />  

      18.     >  

      19.     context:component-scan base-package="com.gy.mytask" /> ;  

      21. >  

      22.     task:annotation-driven scheduler="qbScheduler" mode="proxy" />  

      23.     tâche:planificateur id="qbScheduler" pool-size="10"/>  

   Remarque : Théoriquement, il vous suffit d'ajouter la phrase de configuration . Ces paramètres ne sont pas nécessaires.

   Ok, la configuration est terminée. Bien sûr, la tâche Spring a encore de nombreux paramètres, je ne les expliquerai pas un par un. Veuillez vous référer au document xsd pour plus de détails.

   Annexe :

   instructions de configuration de cronExpression, pour une utilisation et des paramètres spécifiques, veuillez Baidu google

   champ autorisé valeurs Caractères spéciaux autorisés

   secondes 0-59 , - * /

   minutes 0-59 , - * /

   Heure 0-23, - * /

   Date 1-31, - * / L W C

   Mois 1 -12 ou JAN-DEC , - * /

   Semaine 1-7 ou SUN-SAT , - * ? / L C #

   Année (Facultatif) Laisser vide, 1970-2099, - * /

   - Intervalle

   * Wildcard

    ? Vous ne souhaitez pas définir ce champ

   Ce qui suit ne sont que quelques exemples

   Expression CRON Formule Signification

   "0 0 12 * * ?" Déclenché tous les jours à 12h

   "0 15 10 ? * *" Chaque matin Déclenché à 10h15

   "0 15 10 * * ?" Déclenché à 10h15 chaque matin

   "0 15 10 * * ? * " Déclenché tous les matins à 10h15

   "0 15 10 * * ? Déclenché tous les matins à 10h15 en 2005

   "0*14* *?" Déclenché toutes les minutes de 14h00 à 14h59 tous les jours

   "0 0/5 14* * ?" à partir de 14h Déclenché toutes les 5 minutes jusqu'à fin 14h55

   "0 0/5 14,18* *?" à 18h00 Déclenché toutes les 5 minutes en deux périodes de 55

   "0 0-5 14 * * ?" Déclenché une fois par minute de 14h00 à 14h05 tous les jours

   "0 10,44 14 ? 3 MER" Déclenché tous les mercredis à 14h10 et 14h44 en mars

   "0 15 10 ? *MON-FRI" se déclenche tous les lundis, mardis, mercredis, jeudis et vendredis à 10h15

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!