web-dev-qa-db-fra.com

Exemple Java: Planification dynamique de travaux avec Quartz

Je souhaite exposer une interface utilisateur pour définir dynamiquement des JOB Quartz. Où l'utilisateur devrait avoir la possibilité de définir des propriétés JOB comme le nom du JOB, l'expression cron ou l'intervalle de temps, la classe Java spécifique à la tâche, etc.

Existe-t-il un logiciel libre qui facilite cette fonctionnalité? Ou bien, si je veux créer mon propre module pour le planificateur dynamique de quartz, comment le faire?

springquartz-scheduler
23
Narendra Verma

Exemple de code pour la planification dynamique des emplois Quartz:

Dépendances Maven 

         <dependency>
            <groupId>org.quartz-scheduler</groupId>
            <artifactId>quartz</artifactId>
            <version>1.8.5</version>
         </dependency>
            <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-beans</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context-support</artifactId>
            <version>${spring.version}</version>
        </dependency>

Fichier de contexte d'application (dynamic-jobs.xml) 

<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p"
    xmlns:aop="http://www.springframework.org/schema/aop" xmlns:context="http://www.springframework.org/schema/context"
    xmlns:jee="http://www.springframework.org/schema/jee" xmlns:tx="http://www.springframework.org/schema/tx"
    xsi:schemaLocation="
            http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
            http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd
            http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd
            http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee-3.0.xsd
            http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd
            http://www.springmodules.org/schema/ehcache http://www.springmodules.org/schema/cache/springmodules-ehcache.xsd">


    <!-- The Task Bean-->
    <bean id="myTask" class="com.xxx.example.dynamicjob.MyTask" />

    <!-- The quartz scheduler configuration -->
    <bean id="scheduler" class="org.springframework.scheduling.quartz.SchedulerFactoryBean"/>

</beans>

Java Class for Task 

package com.xxx.example.dynamicjob;

    public class MyTask
    {
        public void performAction() {
            System.out.println("Hey, you reached me...:)");
        }          
    }

Classe Java pour créer un travail dynamique 

package com.xxx.example.dynamicjob;
import org.quartz.JobDetail;
import org.quartz.Scheduler;
import org.springframework.beans.factory.xml.XmlBeanFactory;
import org.springframework.core.io.ClassPathResource;
import org.springframework.scheduling.quartz.CronTriggerBean;
import org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean;

public class DynamicJobExample {

    /**
    * @param args
    */
    public static void main(String[] args) {

                ClassPathResource res = new ClassPathResource("dynamic-jobs.xml");
                XmlBeanFactory factory = new XmlBeanFactory(res);

                //get the quartzFactory bean
                Scheduler scheduler = (Scheduler) factory.getBean("scheduler");

                //get the task bean
                MyTask myTask = (MyTask) factory.getBean("myTask");

                try {
                // create JOB
                MethodInvokingJobDetailFactoryBean jobDetail = new MethodInvokingJobDetailFactoryBean();
                jobDetail.setTargetObject(myTask);
                jobDetail.setTargetMethod("performAction");
                jobDetail.setName("MyJobDetail");
                jobDetail.setConcurrent(false);
                jobDetail.afterPropertiesSet();

                /* SimpleTriggerBean trigger = new SimpleTriggerBean();
                trigger.setBeanName("MyTrigger");
                trigger.setJobDetail((JobDetail) jobDetail.getObject());
                trigger.setRepeatInterval(5000);
                trigger.afterPropertiesSet();
                */

                // create CRON Trigger
                CronTriggerBean cronTrigger = new CronTriggerBean();
                cronTrigger.setBeanName("CRON0001");

                // Execute after each 5 second
                String expression = "5 * * * * ?";
                cronTrigger.setCronExpression(expression);
                cronTrigger.afterPropertiesSet();

                //scheduler.scheduleJob(jobDetail, cronTrigger);

                scheduler.scheduleJob((JobDetail) jobDetail.getObject(), cronTrigger);

                // Start Scheduler        
                scheduler.start();

                } catch (Exception e) {                      
                    e.printStackTrace();
                } 
    }
}
21
Narendra Verma

Spring 4 me permet de le faire sans aucun problème (Quartz 2.0) - Spring-dispatcher-servlet.xml

<task:annotation-driven executor="myExecutor" scheduler="myScheduler"/>
<task:scheduler id="myScheduler" pool-size="10"/>
<task:executor id="myExecutor" pool-size="1"/>

Injecter le haricot créé ci-dessus dans le haricot du printemps ou la classe de service

@Service
public class DynamicJobExample {

@Autowired
@Qualifier("myScheduler")
private TaskScheduler scheduler;

public void schedule() throws ParseException {
    scheduler.schedule(new MyTask(), new CronTrigger("5 * * * * ?"));
  }
}

MyTask devrait être une classe exécutable

public class MyTask implements Runnable{

@Override
public void run() {
    System.out.println("Hey, you reached me...:)");
  }
}

Les dépendances Maven sont (pom.xml)

<spring.version>4.1.0.RELEASE</spring.version>

   <dependency>
        <groupId>org.quartz-scheduler</groupId>
        <artifactId>quartz</artifactId>
        <version>2.2.1</version>
    </dependency>
10
Munish Chandel

Vous pouvez créer les objets JobDetail et Trigger de cette façon aussi:

JobDetail jobDetail;
String myJobClass = "com.MyJobClass";
String myJobName = "myJobName";
String myJobGroup ="myJobGroup";
Class myJobClassType= Class.forName(myJobClass);            
jobDetail =JobBuilder.newJob().ofType(myJobClassType)
.withIdentity(myJobName, myJobGroup).build();


String myGroup = "myGroup";
String name = "TriggerName";
String expresion = "5 * * * * ?";


Trigger trigger = TriggerBuilder
.newTrigger()
.withIdentity(name, myGroup)
.withSchedule(
CronScheduleBuilder.cronSchedule(expresion))
.build();
1
omcartagena
package com.myproject;

import Java.text.ParseException;

import org.quartz.JobBuilder;
import org.quartz.JobDetail;
import org.quartz.Scheduler;
import org.quartz.SchedulerException;
import org.quartz.SchedulerFactory;
import org.quartz.impl.triggers.CronTriggerImpl;
import org.springframework.stereotype.Component;

@Component
public class QuartzSchedulerExample {
    public QuartzSchedulerExample() {
        SchedulerFactory schedFact = new org.quartz.impl.StdSchedulerFactory();
        Scheduler scheduler;
        try {
            scheduler = schedFact.getScheduler();
            JobDetail details = JobBuilder.newJob(MyMailBean.class)
                    .withDescription("something")
                    .withIdentity("mejob","myGroup")
                    .storeDurably(true).build();

            CronTriggerImpl trigger = new CronTriggerImpl();
            trigger.setName("T1");

            try {
                trigger.setCronExpression("0 0 0 * * ? *");
            } catch (ParseException e) {
                e.printStackTrace();
            }
            trigger.setDescription("desc");
            scheduler.scheduleJob(details,trigger);
            scheduler.start();
        } catch (SchedulerException e) {
            e.printStackTrace();
        }
    }
}

Le travail sera exécuté tous les jours 00:00:00 (heure: minute: seconde)

0
zawhtut