FAQ Spring

Sommaire > Intégration d'API
        Comment créer une tache plannifiée avec l'API Timer et Spring ?
        Comment intégrer EhCache et Spring ?
        Comment créer une tâche planifiée avec Spring et Quartz ?

Comment créer une tache plannifiée avec l'API Timer et Spring ?

[haut]

auteur : Gildas Cuisinier

Il est tout à fait possible d'utiliser l'API Timer de Java afin de gérer une plannification de tâches avec Spring.
Pour cela, la première étape est de créer un Bean qui possèdera une méthode qui représentera la tâche en question :


public class JobTest {
    
    public void lancementProgramme(){
        System.out.println("Lancement");
    }
}

Ce bean doit bien evidemment être défini dans le contexte Spring :


<bean id="tachePlannifie" class="com.developpez.spring.Tache">
   </bean>

Ce Bean peut être configurer via Spring comme n'importe quel Bean afin d'avoir accès par exemple à une base de données, ou autre. Notons par la même occasion que cet objet est un simple POJO et n'est aucunement lié à un framework spécifique. Ce Bean n'hérite d'aucune classe, n'implémente aucune interface et il n'y a pas de standard défini en ce qui concerne le nom de la méthode qui représente la tâche.

L'étape suivant est de définir un Bean qui va justement faire la liaison entre un gestionnaire de tâches et notre précedent Bean afin de spécifier quelle méthode doit justement être utilisée :


<bean id="tachePlannifieTask" class="org.springframework.scheduling.timer.MethodInvokingTimerTaskFactoryBean">
       <property name="targetObject"><ref bean="tachePlannifie"/> </property>
        <property name="targetMethod"><value>lancementProgramme</value></property>       
   </bean>

Maintenant qu'on a définit "Quoi faire", il est nécessaire de spécifier "Quand le faire". Pour cela, il faut utiliser une classe ScheduledTimerTask :


<bean id="tachePlannifieScheduledTask" class="org.springframework.scheduling.timer.ScheduledTimerTask">
        <!-- Attendre une minute avant le premier lancement -->
        <property name="delay" value="60000"/>
        <!-- Et relancer ensuite toutes les 10 minutes -->
        <property name="period" value="600000"/>
        <property name="timerTask">
            <ref bean="tachePlannifieTask"/>
        </property>
    </bean>

Ici, une minutes d'attente ( 60 000 millisecondes ) avant le premièr lancement sera réalisée, et ensuite la tâche sera relancée toutes les 10 minutes ( 600 000 millisecondes ).

Une fois que le quand et le quoi sont défini, il est nécessaire de provoquer le lancement de cette tâche, et cela est géré par le TimerFactoryBean :


<bean id="timerFactory" class="org.springframework.scheduling.timer.TimerFactoryBean">
        <property name="scheduledTimerTasks">
            <list>
                <ref bean="tachePlannifieScheduledTask"/>
            </list>
        </property>
    </bean>

Cette fabrique possède une propriété scheduledTimerTasks de type liste de ScheduledTimerTask. Elle permet donc de gérer plusieurs tâches plannifiées.

lien :

JDK Timer support, Documentation officielle

Comment intégrer EhCache et Spring ?

[haut]

auteur : Righetto Dominique

Pour intégrer EhCache et Spring afin de pouvoir injecter directement un bean Cache, on définit le bean ci-dessous dans un des fichiers de définition du contexte Spring :


<bean id="customCache" class="org.springframework.cache.ehcache.EhCacheFactoryBean">
		<property name="cacheManager">
			<bean class="org.springframework.cache.ehcache.EhCacheManagerFactoryBean">
				<property name="configLocation"
					value="classpath:ehcache.xml" />
				<property name="shared" value="false" />
			</bean>
		</property>
		<property name="cacheName" value="SampleConfigOne" />
	</bean>

On place la valeur de la propriété cacheName sur le nom d'une des définitions de cache spécifiées dans le fichier ehcache.xml.

Dans cette déclaration, on précise que le fichier de définition des caches se trouve dans le classpath au niveau de la racine (on pourrait également utiliser classpath*:ehcache.xml pour lui indiquer de chercher ce fichier dans tous les classpath). On précise également que le CacheManager n'est pas partagé via la propriété shared.

Ensuite on peut injecter ce bean normalement dans tout bean qui en aurait besoin via :


<bean >
     <property name="cache" value="customCache" />
</bean>

lien : Site du projet EhCache

Comment créer une tâche planifiée avec Spring et Quartz ?

[haut]

auteur : Gildas Cuisinier

Quartz est une API destinée à la création de tâches plannifiées. Elle possède certains avantages par rapport à la méthode basée sur le Timer :

Planification plus fine, avec une synthaxe basée sur le Crontab Linux
Possibilité de rendre les tâches persistantes, afin d'avoir un historique des exécutions entres les différents lancements d'une application
Possibilité d'intégration avec JTA pour la gestion des transactions

Spring possède une intégration avec celle-ci, et permet l'exécution de tâches basées sur des POJOs.

La première étape est donc de créer une tâche, par la définition d'un bean :


ublic class MonJob {

    public void jobMethod(){
        // Code de la méthode
    }
}


  <bean id="MonJob" class="com.developpez.spring.quartz.MonJob"/>

La tâche est donc bien un POJO, et le nom de la méthode du job est au choix du développeur.

L'étape suivante est d'utiliser une classe fournie par Spring, qui va crée le JobDetail ( la tâche qui sera compréhensible par Quartz ) :


<bean name="tache" class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean">
        <property name="targetObject" ref="MonJob"/>
        <property name="targetMethod" value="jobMethod"/>
    </bean>

Il suffit donc de définir la propriete targetObject avec une référence vers le bean défini juste avant, et la propriété targetMethod avec le nom de la méthode à utiliser.

Une fois la tâche définie, il est nécessaire de définir le moment où elle doit être exécutée. Pour cela, deux classes existent : une pour une planification simple, une autre pour une planification plus complexe :


  <!-- Méthode simple -->
  <bean id="triggerTache" class="org.springframework.scheduling.quartz.SimpleTriggerBean">
        <property name="jobDetail" ref="tache"/>
        <!-- Démarre la première fois après 10 secondes -->
        <property name="startDelay" value="10000"/>
        <!-- Ensuite toute les 50 secondes -->
        <property name="repeatInterval" value="50000"/>
    </bean>
    
      <!-- Méthode complexe -->
    <bean id="triggerTache2" class="org.springframework.scheduling.quartz.CronTriggerBean">
        <property name="jobDetail" ref="tache"/>
        <!-- Exécution toute les 5 secondes -->
        <property name="cronExpression" value="0/5 * * * * ?"/>
    </bean>

Le premier trigger est simple, il suffit de définir le moment de la première exécution et ensuite la période d'éxecution.
Le deuxième est un peu plus complexe et se base sur une syntaxe Crontab : seconde minute heure jour-dans-le-mois mois jour-dans-la-semaine annee

La dernière étape est de définir un gestionnaire de planification :


    <bean class="org.springframework.scheduling.quartz.SchedulerFactoryBean">
        <property name="triggers">
            <list>
                <ref bean="triggerTache2"/>
            </list>
        </property>
    </bean>

lien :

Format des expressions Cron

Consultez les autres F.A.Q's

Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée par les droits d'auteur. Copyright © 2004 Developpez Developpez LLC. Tous droits réservés Developpez LLC. Aucune reproduction, même partielle, ne peut être faite de ce site ni de l'ensemble de son contenu : textes, documents et images sans l'autorisation expresse de Developpez LLC. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.