[Batch] Thread singleton lancé à partir du context Spring

Thread singleton lancé à partir du context Spring

Bonjour

tout est dans le titre...je cherche à executer un thread directement depuis le contexte Spring de mon application. Je m'explique :

J'ai une application qui demande à l'utilisateur de saisir/selectionner certaines informations

Suite à cela, une requete (sous forme String) et générée en fonction des choix de l'utilisateur

Pour finir, cette requete est inserée dans une table de ma BDD

Ainsi, je souhaiterais qu'un thread recupère cette requete dans la base puis l'execute. Ce thread serait en quelques sortes un job de l'application qui s'executerais par exemple tous les soirs pour voir s'il y a des requetes a executer...

Mon problème est que je ne vois pas comment je peux executer mon thread directement au lancement de l'application ??? J'ai vu qu'il existait spring-batch mais je ne connais pas du tout et je ne trouve pas de doc bien faite dessus, est ce que ca serait la solution a mon probleme? sinon comment puis je lancer ce thread?

merci

ce genre de problème est facilement résolue en utiliant quartz qui est un scheduler qui permet de faire exactement ce que tu as enoncé. et d'ailleurs spring le support donc tu peux utiliser les wrapper du framework soit l'utiliser directement et le configurer dans ton applicationContext.

J'ai fait une implémentation de Quartz il y a peu pour un des mes projets.

Ca marche pas trop mal, je reste encore bloqué par certaines limitations que je n'ai pas encore résolu mais ça fait son boulot :)

J'implémente Quartz via cette configuration XML:

Je commence par définir le job: SynchroArcoleJob (le but du job est de synchroniser un annuaire applicatif avec l'application ArcoleRH).

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
<bean name="SynchroArcoleJob"
	class="com.test.annuaire.scheduler.jobs.SynchroArcoleJob"
	autowire="no">
</bean>
<bean name="jobDetail" class="org.springframework.scheduling.quartz.JobDetailBean">
	<property name="jobClass" value="com.test.annuaire.scheduler.DelegatingSynchroAnnuaireJob"/>
	<property name="jobDataAsMap">
		<map>
			<!-- This specifies the actual job bean name -->
			<entry key="job.bean.name" value="SynchroArcoleJob"></entry>
		</map>
		</property>
</bean>

Je défini ensuite le déclencheur (ici, il se déclenche toutes les 5 minutes)

Code:

1
2
3
4
5
 
<bean id="cronTrigger" class="org.springframework.scheduling.quartz.CronTriggerBean">
	<property name="jobDetail" ref="jobDetail"/>
	<property name="cronExpression" value="0 0/5 * * * ?"/><!-- Se déclenche toutes les 5min -->
</bean>

Puis je rassemble l'ensemble des morceaux au sein du scheduler:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 
<bean id="jobFactory" class="org.springframework.scheduling.quartz.SpringBeanJobFactory"/>
<bean id="schedulerFactoryBean"
	autowire="no"
	class="org.springframework.scheduling.quartz.SchedulerFactoryBean">
	<property name="triggers">
		<list>
			<ref bean="cronTrigger" />
		</list>
	</property>
	<property name="jobFactory" ref="jobFactory" />
	 	<property name="applicationContextSchedulerContextKey">  
      		<value>applicationContext</value>  
  	</property>
</bean>

Mon "DelegatingJob" ressemble à ça:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
 
private void loadBean2JEC(JobExecutionContext jec, String label, Class clazz) throws SchedulerException {
	//on charge le contexte applicatif
	ApplicationContext appContext = (ApplicationContext) jec.getScheduler().getContext().get("applicationContext");
	//on créé le bean
	Object bean = appContext.getAutowireCapableBeanFactory().createBean(clazz,
		AutowireCapableBeanFactory.AUTOWIRE_BY_NAME,
		false);
		appContext.getAutowireCapableBeanFactory().autowireBean(bean);
	//on injecte le bean dans le jec
	jec.put(label, bean);
}
 
protected void executeInternal(JobExecutionContext jec) throws JobExecutionException {
	//on vérifie si le job est activé sur ce contexte (LB)
	Boolean trigger = Boolean.FALSE;
 
	SchedulerContext schedulerContext = null;
	try {
		schedulerContext = jec.getScheduler().getContext();
	} catch (SchedulerException e) {
		throw new JobExecutionException("Failure accessing scheduler context", e);
	}
 
	ApplicationContext appContext = (ApplicationContext) schedulerContext.get("applicationContext");
 
	String jobBeanName = (String) jec.getJobDetail().getJobDataMap().get("job.bean.name");
	log.info("Starting job: " + jobBeanName);
	I_JobInterface jobBean = (I_JobInterface) appContext.getBean(jobBeanName);
	try {
		//on injecte la sf dans le jec.
		SessionFactory sf = (SessionFactory) appContext.getBean("sessionFactory", SessionFactory.class);
		jec.put("sessionFactory", sf);
 
		//On injecte les DAO dans le jec.
		loadBean2JEC(jec, "testDAO", testDAO.class);
 
		jobBean.init(jec);
		jobBean.execute();
	} catch (Exception e) {
		e.printStackTrace();
	} finally {
		jobBean.destroy();
		log.info("Job finished: " + jobBeanName);
	}
}

Ce DelegatingJob a pour rôle d'initialiser les différents bean car, apparemment, Quartz ne permet pas de gérer l'autowiring "simplement". Il initialise donc tout ça et exécute le job.

Code:

1
2
3
4
5
6
7
8
9
10
11
 
public void init(JobExecutionContext jec) throws JobExecutionException {
	testDAO = (TestDAO) jec.get("testDAO");
}
 
public void execute() throws JobExecutionException {
	testDAO.get(1);
	testDAO.setTest("test");
	testDAO.saveOrUpdate();
	//...
}

ce n'est pas quartz d'assurer le autowiring, ça c'est le job de spring.
ton role c'est implementer soit directement l'interfce Job de quartz ou QuanrtzBean de spring et qui représnete la tacheà réaliser. et ensuite configurer le trigger pour le déclenchment.