Programando tareas en Java: Quartz

Hace poco, en el trabajo, me pidieron que creará una tarea de realización de Backups de datos de una aplicación que se realizará en segundo plano. Me dijeron que el usuario debía tener total libertad para poder programar la tarea a su antojo y, que como dicho usuario tendría conocimientos avanzados, debía ser similar al CRON de los sistema Unix.

Para el que no le suene una pequeña explicación segun Wikipedia y un enlace hacia la página (Cron_wikipedia):

" En el sistema operativo Unix, cron es un administrador regular de procesos en segundo plano (demonio) que ejecuta procesos o guiones a intervalos regulares (por ejemplo, cada minuto, día, semana o mes). Los procesos que deben ejecutarse y la hora en la que deben hacerlo se especifican en el fichero crontab. El nombre cron viene del griego chronos que significa 'tiempo' "

Hasta ahora para este tipo de tareas había usado la clase Timer de java, pero dicha clase no nos permite usar un CRON como los de UNIX, así que buscando un poco en la web dí con la solución: Quartz.

La verdad que no conocía esta herramienta y me sorprendió la facilidad de uso de la misma, apenas en media hora ya la tenia implementada en mi aplicación y solo quedaba darle los retoques finales.

Básicamente lo único que nos hace falta para integrar Quartz en cualquier aplicación es seguir estos simples pasos:

1.- Si usamos maven tendremos que incluir esta dependencia en el pom.xml:

<dependency>
<groupid>opensymphony</groupid>
<artifactid>quartz</artifactid>
<version>1.6.3</version>
</dependency>

<dependency>
<groupid>commons-collections</groupid>
<artifactid>commons-collections</artifactid>
<version>3.2.1</version>
</dependency>

Sin usar maven podríamos descargar la librería de aqui http://repo1.maven.org/maven2/quartz/quartz/1.5.2/quartz-1.5.2.jar
También nos hará falta la libreria commons-logging de apache que la encontraréis aquí http://repo1.maven.org/maven2/commons-logging/commons-logging/1.1.1/commons-logging-1.1.1.jar
Tras descargarlas tendremos que añadirlas al build path de nuestro proyecto.


2.- Una vez tenemos la librería en nuestro proyecto podemos comenzar a usarla, aquí os dejo un ejemplo de código:

package com.holamundo;

import java.text.ParseException;
import java.util.Date;

import org.quartz.CronTrigger;
import org.quartz.Job;
import org.quartz.JobDetail;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.quartz.Scheduler;
import org.quartz.SchedulerException;
import org.quartz.SchedulerFactory;
import org.quartz.Trigger;
import org.quartz.impl.StdSchedulerFactory;

public class testQuartz implements Job {

	private static final String	JOB_GROUP	= "jobGroup";
	private static final String	CRON_GROUP	= "cronGroup";

	private static Scheduler	sched;

	public static void main(String[] args) {
		init();
		try {
			Thread.sleep(5000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		shutdown();
	}

	@Override
	public void execute(JobExecutionContext context) throws JobExecutionException {
		Object jobParam = context.getJobDetail().getJobDataMap().get("jobParamKey");
		System.out.println("Execute job - " + jobParam);
	}

	public static void init() {
		SchedulerFactory sf = new StdSchedulerFactory();
		try {
			sched = sf.getScheduler();
		} catch (SchedulerException e) {
			System.out.println("Failed to get the default scheduler");
			return;
		}

		// Create the job detail information
		JobDetail jd=new JobDetail("jobname",testQuartz.JOB_GROUP,testQuartz.class);
		// put needed params
		jd.getJobDataMap().put("jobParamKey", new Date());
		// Define cron trigger
		CronTrigger ct;
		try {
		    ct = new CronTrigger("cronName", testQuartz.CRON_GROUP, "0/1 * * * * ?");
  		    // Cron para cada segundo "0/1 * * * * ?"
		    // "s m H dM M dW y"
		    // Schedule the job
		    sched.scheduleJob(jd, ct);

		    // Start scheduler
		    sched.start();
		} catch (ParseException e) {
			e.printStackTrace();
		} catch (SchedulerException e) {
			e.printStackTrace();
		}

	}

	public static Date rescheduleBackup(String jobkey, String newCron, boolean isActive)
			throws SchedulerException, ParseException {

		Trigger trigger = sched.getTrigger(jobkey, testQuartz.CRON_GROUP);
		if (trigger != null) {
		    CronTrigger ct = new CronTrigger(jobkey, testQuartz.CRON_GROUP, newCron);
		    ct.setJobGroup(JOB_GROUP);
		    ct.setJobName(jobkey);
		    Date date = sched.rescheduleJob(jobkey, testQuartz.CRON_GROUP, ct);
		    System.out.println("Job has been modified, has scheduled to " + date);
		    return ct.getNextFireTime();

		} else {
			sched.deleteJob(jobkey, testQuartz.JOB_GROUP);
			return null;
		}
	}

	public static void shutdown() {
		System.out.println("Shutting down the scheduler...");
		try {
			sched.shutdown();
		} catch (SchedulerException e) {
			System.out.println("Error shutting down the backup scheduler.");
		}
		System.out.println("Scheduler is shutdown");
	}

}

Como veis, en primer lugar necesitamos que nuestra clas implemente la interfaz Job, con esto le estamos diciendo a Quartz que en esta clase ejecutaremos una tarea que será programada, implementar Job nos obliga a sobre-escribir el método execute(JobExecutionContext context) throws JobExecutionException que será el que se ejecute cuando llegué el momento de ejecutar una tarea.

Para programar la tarea usamos el metodo init(), paso a paso lo que hacemos en él es:
1.- Obtenemos el scheduler, usando el SchedulerFactory.
2.- Creamos un objeto jobDetail que especifica quien se encarga de ejecutar la tarea, aquí le daremos un nombre a la tarea, la incluimos en un grupo y le decimos que clase va a realizar dicha tarea (en este caso es la misma clase testQuartz).
3.- En el siguiente paso lo que hacemos es pasar un parametro que será usaremos en la ejecucion de la tarea.
4.- Luego creamos el cron mediante un objeto CronTrigger, es en este objeto donde especificamos cada cuanto tiempo o cuando exactamente debe ejecutarse la tarea. Para crear este objeto le pasamos un nombre, un nombre de grupo y la configuración de cron que más adelante explico.
5.-Después programamos la tarea mediante el metodo scheduleJob al que pasamos el job a realizar y la configuración del cron.
6.- Por último arrancamos nuestro programador mediante el metodo start().

Además en el codigo se incluyen un par de metodos de utilidad com rescheduleJob() que nos permite reprogramar una tarea y shutdown() que termina el programador.

En el metodo execute lo unico que hacemos es recuperar el parametro que le pasamos en el momento de crearla y sacar por consola una linea de texto.

Se incluye tambien un main de ejemplo que arranca el programador, espera 5 segundos y lo termina.

Podeis encontrar una explicacion del cron de Quartz en la pagina oficial: Cron-Quartz

Espero le sirva a alguien.

Referencias:
http://www.quartz-scheduler.org/
http://www.quartz-scheduler.org/documentation/quartz-2.1.x/tutorials/crontrigger

-Saludos Patateros-