Java Example: Dynamic Job Scheduling with Quartz

Question

I want to expose an user interface to define Quartz JOBs dynamically. Where user should have facility to define JOBs properties like JOB name, cron expression or time interval, specific java class for task etc.

Is there any Open Source that facilitates this feature? Or, If I want to create my own module for dynamic Quartz Scheduler, what should be the way to do so?

Answer 1

I have similar issue where I want to update the cron expression in JOB_DETAILS table of quartz(2.3.2 version). The scenario is like, I have already a scheduled job running and I want to update it and run it on different frequency. Rest of the things I managed but the update on the table won't happen. So after reading the documentation I found out that you can update the details of the job using add method.

// store, and set overwrite flag to 'true'
scheduler.addJob(jobDetail, true);

The things I am doing with Java only.

Answer 2

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();
        }
    }
}

The job will run every day 00:00:00 (hour:minute:second)

Answer 3

Spring 4 allows me to do this without any problem (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"/>

Inject above created bean into Spring bean or Service Class

@Service
public class DynamicJobExample {

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

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

MyTask Should be a Runnable Class

public class MyTask implements Runnable{

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

Maven Dependencies are (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>

Answer 4

You can create the JobDetail and Trigger objects this way also:

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();

Answer 5

Example code for Dynamic Quartz JOB Scheduling:

Maven Dependencies

         <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>

Application Context File (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...:)");
        }          
    }

Java Class to Create Dynamic Job

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();
                } 
    }
}