Batch java avec Spring 3

 

 
Spring 3 implémente nativement une API d’ordonnancement de tâches comme le fait l’API Quartz. Cet article montre comment créer une tâche et l’ordonnancer avec Spring 3 via le fichier de configuration ou les annotations. Pour les utilisateurs de Spring 2.5, l’ordonnancement de tâches se fait avec l’API Quartz.
Un article a donc été écrit sur le sujet: Ordonnancement de tâches avec Quartz et Spring 2.5.

 

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 3 framework.

Je ne reviens pas sur la création du projet maven sous Eclipse abordée en détail dans l’article sur l’API Quartz.

 

Ajout des dépendances

Pour utiliser Spring 3, le projet doit disposer de l’API. Il suffit donc d’ajouter ces dépendances au fichier pom.xml du projet.

<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-aop</artifactId>
  <version>3.0.0.RELEASE</version>
</dependency>
<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-context</artifactId>
  <version>3.0.0.RELEASE</version>
</dependency>

 

Le fichier de configuration Spring : applicationContext.xml

Dans le dossier /src/main/resources, créer un fichier nommé applicationContext.xml 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" 
       xmlns:context="http://www.springframework.org/schema/context" 
       xmlns:task="http://www.springframework.org/schema/task" 
       xsi:schemaLocation="http://www.springframework.org/schema/beans 
                           http://www.springframework.org/schema/beans/spring-beans-3.0.xsd 
                           http://www.springframework.org/schema/task 
                           http://www.springframework.org/schema/task/spring-task-3.0.xsd 
                           http://www.springframework.org/schema/context 
                           http://www.springframework.org/schema/context/spring-context-3.0.xsd">
</beans>

 

Développement du job

L’exemple est ici volontairement simplifier par rapport à ce qui a été abordé avec Quartz, l’adaptation à l’architecture de l’exemple Quartz étant triviale. Nous ne ferons donc que créer le job et son ordonnancement dans différentes configurations, notamment via les fichiers de configuration et/ou les annotations.

 

Exclusivement par fichier de configuration

  Le Job, un objet très simple

Créer un package job, puis créer la classe TheJob dans ce package intégrant une méthode runAction qui sera la méthode exécutée par le job.

package job;

public class TheJob 
{					
  public void runAction() 
  {
    System.out.println("I'm the Job");
  }
}

  La configuration de l’ordonnancement sous Spring

La déclaration de la classe de notre job (un bean) est ici classique et se fait dans e fichier applicationContext.xml .
Pour l’ordonnancement, nous faisons appel au namespace task dans lequel nous indiquons :
– le bean ainsi que la méthode qui sera appelée au lancement de la tâche;
– l’expression cron qui va bien pour ordonnancer la tâche.

<bean id="job" class="job.Job"/>
<task:scheduled-tasks>
  <task:scheduled ref="job" method="runAction" cron="3/10 * * * * ?"/>
</task:scheduled-tasks>

  Lancement de notre job

Ici c’est du classique, on crée une classe Main qui chargera notre fichier applicationContext.xml afin que Spring démarre notre job.

import org.springframework.context.support.ClassPathXmlApplicationContext;

public class App 
{
  public static void main(String[] args)  
  {
    new ClassPathXmlApplicationContext("applicationContext.xml");
  }
}

 

Par les annotations

  Le Job

Modifier la classe TheJob en ajoutant l’annotation @Component(« theJob ») où « theJob » sera le nom du bean déclaré. Cette annotation n’est pas exclusive à Spring 3, Spring 2.5 l’implémente aussi.

package job;

import org.springframework.stereotype.Component;

@Component("theJob")
public class TheJob 
{	
  public void runAction() 
  {
    System.out.println("I'm the Job");
  }	
}

  La configuration de l’ordonnancement sous Spring

Modifier le fichier applicationContext.xml en remplaçant la balise bean par la balise context. La balise context:component-scan indique à Spring d’explorer le package donné (spécifié dans la propriété base-package) à la recherche d’annotations. En l’occurence, notre job est annoté avec l’annotation @Component(« theJob »), ce qui en fera un bean nommé theJob. Cette balise n’est pas exclusive à Spring 3, Spring 2.5 l’implémente aussi. Ce qui donne:

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans" 
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
       xmlns:context="http://www.springframework.org/schema/context" 
       xmlns:task="http://www.springframework.org/schema/task" 
       xsi:schemaLocation="http://www.springframework.org/schema/beans 
                           http://www.springframework.org/schema/beans/spring-beans-3.0.xsd http://www.springframework.org/schema/task 
                           http://www.springframework.org/schema/task/spring-task-3.0.xsd http://www.springframework.org/schema/context 
                           http://www.springframework.org/schema/context/spring-context-3.0.xsd">
  <context:component-scan base-package="job"/>
    <task:scheduled-tasks>
      <task:scheduled ref="theJob" method="runAction" cron="3/10 * * * * ?"/>
    </task:scheduled-tasks>

</beans>

  Lancement de notre job

Même chose que précédemment.

import org.springframework.context.support.ClassPathXmlApplicationContext;

public class App 
{
  public static void main(String[] args) 
  {
    new ClassPathXmlApplicationContext("applicationContext.xml");
  }
}

 

Un peu plus loin avec les annotations

Ici, le fichier de configuration Spring sera alimenté avec le strict minimum.

  Le Job

Modifier la classe TheJob en ajoutant l’annotation @Component(« theJob ») (déclaration du bean) sur la classe et l’annotation @Scheduled(cron= »3/10 * * * * ? ») sur la méthode runActioncron est une expression cron d’ordonnancement, ce qui donne:
Pour activer le mode lazy (lancement manuel du job), il suffit d’ajouter l’annotation @Lazy avec le paramètre true (@Lazy(true)).

package job;

import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;</code>

@Component("theJob")
public class TheJob 
{
  @Scheduled(cron = "3/10 * * * * ?")
  public void runAction() 
  {
    System.out.println("Le Job c'est moi");
  }	
}

  La configuration de l’ordonnancement sous Spring

Modifier le fichier applicationContext.xml en remplaçant la balise task:scheduled-tasks par la balise task:annotation-driven.
Par ce biais, l’ordonnancement de notre job est configuré via les annotations, ce qui donne:

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

  <context:component-scan base-package="job"/>
  <task:annotation-driven/>
</beans>

  Lancement de notre job

import org.springframework.context.support.ClassPathXmlApplicationContext;

public class App 
{
  public static void main(String[] args) 
  {
   new ClassPathXmlApplicationContext("applicationContext.xml");
  }
}

  Lancement de notre job en lazy

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");
    TheJob theJob = (TheJob)ctx.getBean("theJob");
    theJob.runAction();
    System.out.println( "Spring applicationContext.xml loaded" );
  }
}

Pour tester, il ne reste plus qu’à exécuter ce java main.

 

Posté dans javaTaggé developpement java, job, ordonnancement, scheduled task, spring 2.5, Spring 3  |  1 commentaire

Une réponse à "Batch java avec Spring 3"

Répondre