In this tutorial I would explain how to configure quartz scheduler using properties file and xml file. Properties file will be used for configuring the JobStore details and XML configuration path. XML will store the list of Job details and cron triggers. In my previous post I have explained how to setup quartz scheduler pro-grammatically. However, in web application or any huge applications having multiple jobs to be configured, correct approach is to use the XML configuration file. Lets look at the below example and post your questions in the comments section.

Required JAR Files

Add the following JSR files to the classpath before start running the below example application.

• quartz-2.2.1.jar
• quartz-jobs-2.2.1.jar
• slf4j-api-1.7.5.jar
• jta-1.1.jar

1. Create A Job

FirstJob.java

[code lang=”java”]
package javabeat.net.quartz;

import org.quartz.Job;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;

public class FirstJob implements Job{

@Override
public void execute(JobExecutionContext context) throws JobExecutionException {
System.out.println("This is my first quartz job!!");
}

}
[/code]

2. Create Properties File

quartz.properties

[code]
org.quartz.scheduler.instanceName = MyScheduler
org.quartz.threadPool.threadCount = 3
org.quartz.jobStore.class = org.quartz.simpl.RAMJobStore
org.quartz.plugin.jobInitializer.class =org.quartz.plugins.xml.XMLSchedulingDataProcessorPlugin
org.quartz.plugin.jobInitializer.fileNames = javabeat/net/quartz/quartz-config.xml
org.quartz.plugin.jobInitializer.failOnFileNotFound = true
[/code]

3. Create XML File with Quartz Job and Cron Trigger

quartz-config.xml

[code lang=”xml”]
<?xml version="1.0" encoding="UTF-8"?>
<job-scheduling-data
xmlns="http://www.quartz-scheduler.org/xml/JobSchedulingData"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.quartz-scheduler.org/xml/JobSchedulingData
http://www.quartz-scheduler.org/xml/job_scheduling_data_1_8.xsd"
version="1.8">

<schedule>
<job>
<name>FirstJob</name>
<group>DummyGroup</group>
<description>This is FirstJob</description>
<job-class>javabeat.net.quartz.FirstJob</job-class>
</job>
<trigger>
<cron>
<name>dummyTrigger</name>
<job-name>FirstJob</job-name>
<job-group>GroupDummy</job-group>
<!– It will run every 2 seconds –>
<cron-expression>0/2 * * * * ?</cron-expression>
</cron>
</trigger>
</schedule>
</job-scheduling-data>
[/code]

4. Run the Quartz Application

QuartzXmlExample.java

[code lang=”java”]
package javabeat.net.quartz;

import org.quartz.Scheduler;
import org.quartz.SchedulerException;
import org.quartz.SchedulerFactory;
import org.quartz.impl.StdSchedulerFactory;

public class QuartzXmlExample {
public static void main(String args[]) throws SchedulerException {
// Creating scheduler factory and scheduler
SchedulerFactory factory = new StdSchedulerFactory(
"javabeat/net/quartz/quartz.properties");
Scheduler scheduler = factory.getScheduler();
// Start scheduler
scheduler.start();
}
}
[/code]

If you run the above example, it would work perfectly and job is invoked for every 2 seconds. Hope this helps you to understand how to configure quartz scheduler using XML file.

5. Why JTA JAR file?

You may get the following exception if you are not adding the jta.jar file to the classpath when running the above application. You can get these jar file from here. It looks like quartz libraries are internally using this JSr file for managing the transactions.

[code]
Exception in thread "main" java.lang.NoClassDefFoundError: javax/transaction/UserTransaction
at java.lang.Class.getDeclaredMethods0(Native Method)
at java.lang.Class.privateGetDeclaredMethods(Class.java:2451)
at java.lang.Class.privateGetPublicMethods(Class.java:2571)
at java.lang.Class.getMethods(Class.java:1429)
at java.beans.Introspector.getPublicDeclaredMethods(Introspector.java:1261)
at java.beans.Introspector.getTargetMethodInfo(Introspector.java:1122)
at java.beans.Introspector.getBeanInfo(Introspector.java:414)
at java.beans.Introspector.getBeanInfo(Introspector.java:161)
at org.quartz.impl.StdSchedulerFactory.setBeanProps(StdSchedulerFactory.java:1393)
at org.quartz.impl.StdSchedulerFactory.instantiate(StdSchedulerFactory.java:1057)
at org.quartz.impl.StdSchedulerFactory.getScheduler(StdSchedulerFactory.java:1519)
at javabeat.net.quartz.QuartzXmlExample.main(QuartzXmlExample.java:13)
Caused by: java.lang.ClassNotFoundException: javax.transaction.UserTransaction
at java.net.URLClassLoader$1.run(URLClassLoader.java:366)
at java.net.URLClassLoader$1.run(URLClassLoader.java:355)
at java.security.AccessController.doPrivileged(Native Method)
at java.net.URLClassLoader.findClass(URLClassLoader.java:354)
at java.lang.ClassLoader.loadClass(ClassLoader.java:423)
at sun.misc.Launcher$AppClassLoader.loadClass(Launcher.java:308)
at java.lang.ClassLoader.loadClass(ClassLoader.java:356)
… 12 more
[/code]

In my previous posts I have explained about writing simple quartz scheduler and how to list jobs. This tutorial explains how to write a listener for the scheduler. In certain scenarios, we have to execute few lines of code or log messages before and after the batch process. The listeners are very useful for achieving those goals. In quartz, JobListener interface provides jobToBeExecuted and jobWasExecuted as the callback methods for before and after every job is executed. These methods takes the parameter of JobExecutionContext, with this you can access the current Job details and print them. For the complete setup of the quartz scheduler, please refer my previous tutorial. If you have any questions, please write it in the comments section.

1. Create a Job

FirstJob.java

[code lang=”java”]
package javabeat.net.quartz;

import org.quartz.Job;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;

public class FirstJob implements Job{

@Override
public void execute(JobExecutionContext arg0) throws JobExecutionException {
System.out.println("This is my first quartz job!!");
}

}
[/code]

2. Create Quartz Job Listener

FirstJobListener.java

[code lang=”java”]
package javabeat.net.quartz;

import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.quartz.JobListener;

public class FirstJobListener implements JobListener{

@Override
public String getName() {
return "FirstJobListener";
}

@Override
public void jobToBeExecuted(JobExecutionContext context) {
System.out.println("jobToBeExecuted : " + context.getJobDetail().getKey().toString());

}
@Override
public void jobWasExecuted(JobExecutionContext context,
JobExecutionException arg1) {
System.out.println("jobWasExecuted : " + context.getJobDetail().getKey().toString());

}
@Override
public void jobExecutionVetoed(JobExecutionContext context) {
System.out.println("jobExecutionVetoed : " + context.getJobDetail().getKey().toString());
}

}
[/code]

3. Add Quartz Job Listener to Scheduler

QuartzExample.java

[code lang=”java”]
package javabeat.net.quartz;

import java.util.Date;

import org.quartz.Scheduler;
import org.quartz.SchedulerException;
import org.quartz.SchedulerFactory;
import org.quartz.SimpleTrigger;
import org.quartz.impl.JobDetailImpl;
import org.quartz.impl.StdSchedulerFactory;
import org.quartz.impl.triggers.SimpleTriggerImpl;

public class QuartzExample {
public static void main(String args[]) throws SchedulerException{
//Creating scheduler factory and scheduler
SchedulerFactory factory = new StdSchedulerFactory();
Scheduler scheduler = factory.getScheduler();

//Creating Job and link to our Job class
JobDetailImpl jobDetail = new JobDetailImpl();
jobDetail.setName("First Job");
jobDetail.setJobClass(FirstJob.class);

//Creating schedule time with trigger
SimpleTriggerImpl simpleTrigger = new SimpleTriggerImpl();
simpleTrigger.setStartTime(new Date(System.currentTimeMillis() + 1000));
simpleTrigger.setRepeatCount(SimpleTrigger.REPEAT_INDEFINITELY);
simpleTrigger.setRepeatInterval(2000);
simpleTrigger.setName("FirstTrigger");

//Start scheduler
scheduler.start();
scheduler.scheduleJob(jobDetail,simpleTrigger);

//Adding the listener
scheduler.getListenerManager().addJobListener(new FirstJobListener());
}
}
[/code]

In my previous article I have explained about how to write a simple quartz scheduler. In some cases, you would like to get the list of Jobs running on the scheduler. It is obvious that there will be multiple batch process configured in a large applications. If you could get the list of jobs and the next triggered time for each job, it is good for developers to use in their programming. With the extension of my previous example, this tutorial adds code snippet for listing the jobs running on scheduler. This also get the next trigger time for that particular job. Hope this helps. If you have any questions, please write it in the comments section.

getJobGroupNames() method in the scheduler instance returns the list of jobs. Also you can use the size method to get number of jobs.

ListJobs.java

[code lang=”java”]
package javabeat.net.quartz;

import java.util.Date;
import java.util.List;

import org.quartz.JobKey;
import org.quartz.Scheduler;
import org.quartz.SchedulerException;
import org.quartz.SimpleTrigger;
import org.quartz.Trigger;
import org.quartz.impl.JobDetailImpl;
import org.quartz.impl.StdSchedulerFactory;
import org.quartz.impl.matchers.GroupMatcher;
import org.quartz.impl.triggers.SimpleTriggerImpl;

public class ListJobs {
public static void main(String args[]) throws SchedulerException {
Scheduler scheduler = new StdSchedulerFactory().getScheduler();
// Creating Job and link to our Job class
JobDetailImpl jobDetail = new JobDetailImpl();
jobDetail.setName("First Job");
jobDetail.setJobClass(FirstJob.class);

// Creating schedule time with trigger
SimpleTriggerImpl simpleTrigger = new SimpleTriggerImpl();
simpleTrigger.setStartTime(new Date(System.currentTimeMillis() + 1000));
simpleTrigger.setRepeatCount(SimpleTrigger.REPEAT_INDEFINITELY);
simpleTrigger.setRepeatInterval(2000);
simpleTrigger.setName("FirstTrigger");

// Start scheduler
scheduler.start();
scheduler.scheduleJob(jobDetail, simpleTrigger);

for (String groupName : scheduler.getJobGroupNames()) {
for (JobKey jobKey : scheduler.getJobKeys(GroupMatcher
.jobGroupEquals(groupName))) {
String jobName = jobKey.getName();
String jobGroup = jobKey.getGroup();
List<Trigger> triggers = (List<Trigger>) scheduler
.getTriggersOfJob(jobKey);
Date nextFireTime = triggers.get(0).getNextFireTime();
System.out.println("[jobName] : " + jobName + " [groupName] : "
+ jobGroup + " – " + nextFireTime);
}

}
}
}

[/code]

Schedulers are important for running the batch process in your application. There are plenty of Java scheduler frameworks available in the market. Among them, Quartz Scheduler is the most popular and most widely used by Java projects. This tutorial provides very simple example to write Quartz scheduler. When you complete reading this tutorial, you will be able to write your won quartz scheduler. If you have any questions, please write it in the comments section.

1. SetUp Quartz Scheduler

Get the quartz JSR files from here. Also you would need slf4j-api-1.7.5.jar to run the quartz examples. Quartz is internally using this API for the logging purposes. Add these files to the classpath and imprt to the eclipse environment. I assume that you have already created a Java project in eclipse.

2. Create A Quartz Job

As a first step, implement org.quartz.Job interface and write your own Job. You must override the method execute which will be invoked for the batch process. The below code snippet is the simple example for writing a Job.

FirstJob.java

[code lang="java"]
package javabeat.net.quartz;

import org.quartz.Job;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;

public class FirstJob implements Job{

	@Override
	public void execute(JobExecutionContext arg0) throws JobExecutionException {
		System.out.println("This is my first quartz job!!");
	}

}
[/code]

3. Register Quartz Scheduler

This is the final step where we initialize the Quartz scheduler. The following are the steps to initialize this scheduler.

1. Create scheduler factory which is required for getting the scheduler instance.
2. Get the scheduler instance from the factory.
3. Create the JobDetailImpl instance and register our FirstJob to that object.
4. Create and set the values for trigger. Trigger is very important for setting the details about the frequecny of batch process.
5. Start the scheduler
6. Schedule the Job by linking our Job and trigger.
7. Your Quartz scheduler is ready and running.

QuartzExample.java

[code lang="java"]
package javabeat.net.quartz;

import java.util.Date;

import org.quartz.Scheduler;
import org.quartz.SchedulerException;
import org.quartz.SchedulerFactory;
import org.quartz.SimpleTrigger;
import org.quartz.impl.JobDetailImpl;
import org.quartz.impl.StdSchedulerFactory;
import org.quartz.impl.triggers.SimpleTriggerImpl;

public class QuartzExample {
	public static void main(String args[]) throws SchedulerException{
		//Creating scheduler factory and scheduler
		SchedulerFactory factory = new StdSchedulerFactory();
		Scheduler scheduler = factory.getScheduler();

		//Creating Job and link to our Job class
		JobDetailImpl jobDetail = new JobDetailImpl();
		jobDetail.setName("First Job");
		jobDetail.setJobClass(FirstJob.class);

		//Creating schedule time with trigger
		SimpleTriggerImpl simpleTrigger = new SimpleTriggerImpl();
		simpleTrigger.setStartTime(new Date(System.currentTimeMillis() + 1000));
		simpleTrigger.setRepeatCount(SimpleTrigger.REPEAT_INDEFINITELY);
		simpleTrigger.setRepeatInterval(2000);
		simpleTrigger.setName("FirstTrigger");

		//Start scheduler
		scheduler.start();
		scheduler.scheduleJob(jobDetail,simpleTrigger);
	}
}
[/code]

In this section we are going to develop a simple Quartz Scheduler application with the help of Quartz framework. That will display Hello World Quartz Scheduler :date & time on the console window after specified time schedule.

Before using Scheduler you have to instantiate it. For doing this some users may keep an instance of a factory serialized in a JNDI store, and some other users may find it just to instantiate and use a factory instance. Firstly create the instance of SchedulerFactory by getting the reference of org.Quartz.impl.StdSchedulerFactory Class. Invoke the getScheduler() method by this instance to instantiate the Scheduler.

Quartz Scheduler Application

We have published list of articles on latest Quartz scheduler.

• Quartz Scheduler Articles and Tutorials
• Quartz Scheduler Tutorial
• Configure Quartz Scheduler Jobs using XML File

execute(): Any software components you want to schedule then you must implement the Job interface and override it execute() method.

JobExecutionContext: The JobExecutionContext object that is passed to execute() method provides the job instance with information about its run-time environment a handle to the Scheduler that executed it, a handle to the Trigger that triggered the execution, the job’s JobDetail object, and a few other items.

SchedulerFactory: SchedulerFactory is a interface provides a mechanism for obtaining client-usable handles to Scheduler instances.

StdSchedulerFactory(): A Class StdSchedulerFactory is a class and it is implementation of SchedulerFactory interface. Here it just using for create an instance of SchedulerFactory instance.

Scheduler: Scheduler interface is the main interface (API) to this functionality. It provides some simple operations like scheduling jobs, unschedulingjobs, starting/stopping/pausing the scheduler.

getScheduler():SchedulerFactoy interface having the getScheduler() method that returns an instance of Scheduler.

start(): This method is used to starts the Scheduler’s threads that fire Triggers. At the first time when we create the Scheduler it is in stand-by mode, and will not fire triggers. The scheduler can also be send back into stand-by mode by invoking the standby() method.

JobDetail(String name, String group, Class jobclass): The JobDetail object is created at the time the Job is added to scheduler. It contains various property settings like job name, group name and job class name. It can be used to store state information for a given instance of job class.

SimpleTrigger(String name, String group, Date startTime, Date endTime, int repeatCount, long repeatInterval): Trigger objects are used to firing the execution of jobs. When you want to schedule the job, instantiate the trigger and set the properties to provide the scheduling.

DEFAULT_GROUP: It is a constant, specified that Job and Trigger instances are belongs to which group.

REPEAT_INDEFINITELY: It is a constant used to indicate the ‘repeat count‘ of the trigger is indefinite.

scheduleJob(JobDetail jd, SimpleTrigger st): This method is used to add the JobDetail to the Scheduler, and associate the Trigger with it.

Here is the code of Job Class:

1. Create a Job using Quartz’s Job Interface

HelloJob.java

[code lang=”java”]
import org.quartz.Job;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import java.util.Date;public class HelloJob implements Job {
public void execute(JobExecutionContext arg0) throws JobExecutionException{
System.out.println(Hello World Quartz Scheduler: + new Date());
}
}
[/code]

Here is the code of Scheduler Class:

2. Create a Schedule with Trigger

HelloSchedule.java

[code lang=”java”]
import java.util.Date;
import org.quartz.JobDetail;
import org.quartz.Scheduler;
import org.quartz.SchedulerFactory;
import org.quartz.SimpleTrigger;
import org.quartz.impl.StdSchedulerFactory;

public class HelloSchedule {
public HelloSchedule()throws Exception{
SchedulerFactory sf=new StdSchedulerFactory();
Scheduler sched=sf.getScheduler();
sched.start();
JobDetail jd=new JobDetail("myjob",sched.DEFAULT_GROUP,HelloJob.class);
SimpleTrigger st=new SimpleTrigger("mytrigger",sched.DEFAULT_GROUP,new Date(),
null,SimpleTrigger.REPEAT_INDEFINITELY,60L*1000L);
sched.scheduleJob(jd, st);
}
public static void main(String args[]){
try{
new HelloSchedule();
}catch(Exception e){}
}
}
[/code]