Ordonnancement de tâches avec Java Quartz




 

 
Nous n’abordons ici que l’ordonnancement de tâches avec Spring 2.5 et Java Quartz.

 

Java Quartz, c’est quoi ?

Java Quartz est une API java d’ordonnancement de tâches. Elle permet d’automatiser le lancement de traitements oneshot ou bien réguliers.

 

Outils

Java implicitement, Eclipse notre IDE java, maven pour les dépendances nécessaires au développement de notre tutorial.

 

Connaissances prérequises souhaitées mais non obligatoires

– Eclipse IDE;
– Spring framework.

 

Création du projet maven

– Démarrer Eclipse et lancer le wizard de création de projet via le menu File/New/Other ou via le raccourci clavier CTRL+N;




– Dans la liste qui apparaît, sélectionner Maven/Maven Project et cliquer sur le bouton Next;



– Cocher la case Create a simple project et cliquer sur le bouton Next;



– Identifier votre projet en renseignant les zones Group Id et Artifact Id, puis cliquer sur le bouton Finish : votre projet est créé.

 

Ajout des dépendances

Pour utiliser Java Quartz, le projet doit disposer de l’api (idem pour Spring). Il suffit donc d’ajouter ces dépendances au fichier pom.xml du projet.

– Editer le fichier pom.xml et ajouter les dépendances suivantes juste avant la balise </project> :

<dependencies>
  <dependency>
    <groupId>org.opensymphony</groupId>
    <artifactId>quartz</artifactId>
    <version>1.6.1</version>
  </dependency>
  <dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring</artifactId>
    <version>2.5.6</version>
  </dependency>
  <dependency>
    <groupId>commons-collections</groupId>
    <artifactId>commons-collections</artifactId>
    <version>3.1</version>
  </dependency>
</dependencies>

– Sauvegarder le fichier.

 

Le fichier de configuration Spring

Afin de rendre visible par Java le fichier de configuration Spring, celui-ci doit être placé dans le CLASSPATH de notre projet. Il suffit de créer un dossier source que l’on nomme conf via le menu contextuel du projet (clic bouton droit) New / Source Folder.
Dans ce dossier, il faut désormais intégrer le fichier de configuration Spring que l’on nomme applicationContext.xml. Dans ce dossier, il faut désormais intégrer le fichier de configuration Spring que l’on nomme applicationContext.xml et dont le contenu est pour le moment:

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans" 
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">			
</beans>

 

Architecture de notre exemple

– Niveau 4 : Le main (programme principal) qui lancera le job;
– Niveau 3 : Le job Quartz qui lancera le traitement à réaliser via le business manager;
– Niveau 2 : Le business manager : les traitements métiers (besoin fonctionnel) utilisateurs de la couche de niveau 1;
– Niveau 1 : Le ou les objets permettant la satisfaction du ou des traitements métier.

 

Création du job (Niveau 3)

Un job n’est qu’un simple POJO intégrant une méthode d’exécution du job. Pour satisfaire à notre architecture, ce job intègre aussi un objet Manager que l’on nommera génériquement pour l’exemple BusinessManager, BusinessManager dont on appelle une méthode d’exécution satisfaisant un besoin fonctionnel. Pour permettre l’injection par Spring du manager, la définition d’un accesseur (setter) est nécessaire.

Le source :

package quartz.exemple.job;

import quartz.exemple.manager.BusinessManager;

public class QuartzExempleJob {
  private BusinessManager businessManager;   
  public void execute() {
    System.out.println("In quartz job, I call the business manager") ;
    businessManager.runAction();
  }

  public void setBusinessManager(BusinessManager businessManager) {
    this.businessManager = businessManager;
  }
}

 

Création du business manager (Niveau 2)

Le business manager de notre exemple n’est qu’un simple objet intégrant une méthode (satisfaisant notre besoin fonctionnel) qui sera appelée par notre job.

Le source :

package quartz.exemple.manager;

public class BusinessManager {
  public void runAction() {
    System.out.println("In business manager, I call the business action") ;
  }
}

 

Configuration du job dans Spring

Dans le fichier applicationContext.xml, nous déclarons :
– le business manager

<bean id="businessManager" class="quartz.exemple.manager.BusinessManager"/>

– le POJO job et l’injection du business manager dans ce job

<bean id="QuartzExempleJob" class="quartz.exemple.job.QuartzExempleJob">
  <property name="businessManager" ref="businessManager"/>
</bean>    

– le lien entre le POJO job et l’API quartz (objet + méthode appelée)

<bean name="jobDetail" class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean">
  <property name="targetObject" ref="QuartzExempleJob"/>
  <property name="targetMethod" value="execute"/>
</bean>

– les paramètres de notre job (fréquence d’exécution) via une cron expression

<bean id="jobCronScheduler" class="org.springframework.scheduling.quartz.CronTriggerBean">
  <property name="jobDetail" ref="jobDetail"/>
  <property name="cronExpression" value="1 * * ? * *"/>
</bean>

– le lancement de notre job dans lequel on spécifie soit un lancement (implicite) automatique au démarrage par Spring (lazy-init=false), soit un lancement (explicite) manuel à la demande de l’utilisateur (lazy-init=true)

<bean id="schedulerBean" 
class="org.springframework.scheduling.quartz.SchedulerFactoryBean" lazy-init="false">
  <property name="triggers">
    <list>
      <ref bean="jobCronScheduler"/>
    </list>
  </property>
</bean>

 

Création du main (Niveau 4)

Notre main ne fait que charger le fichier de configuration Spring.

Le source en lazy-init=false :

package quartz.exemple;

import org.springframework.context.support.ClassPathXmlApplicationContext;

public class App {
  public static void main( String[] args ) {
    System.out.println( "Loading Spring applicationContext.xml file...." );
    ClassPathXmlApplicationContext ClassPathXmlApplicationContext("applicationContext.xml");
    System.out.println( "Spring applicationContext.xml loaded" );
  }
}

Le source en lazy-init=true, où il est nécessaire de démarrer le job explicitement

package quartz.exemple;

import org.springframework.context.support.ClassPathXmlApplicationContext;

public class App {
  public static void main( String[] args ) {
    System.out.println( "Loading Spring applicationContext.xml file...." );
    ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
    Scheduler scheduler = (Scheduler)ctx.getBean("schedulerBean");
    scheduler.start();
    System.out.println( "Spring applicationContext.xml loaded" );
  }
}

 

Pour ceux qui souhaitent ne pas utiliser Spring

API Quartz Spring Quartz Framework
Job QuartzJobBean
JobDetail JobDetailBean
CronTrigger CronTriggerBean
SimpleTrigger SimpleTriggerBean
SchedulerFactory SchedulerFactoryBean

 

Liens utiles

http://www.opensymphony.com/quartz/
http://static.springframework.org/spring/docs/1.2.9/reference/scheduling.html

 

Conclusion

J’espère avoir été clair dans mon propos. N’hésitez pas à faire vos remarques ou posez vos questions.

 

Posté dans javaTaggé developpement java, java quartz, quartz, quartz tutorial, spring quartz  |  3 commentaires

3 réponses à "Ordonnancement de tâches avec Java Quartz"

Répondre

*