Spring, Quartz and Auto-wiring of Quartz jobs

Facing Null Pointer Exceptions in Quartz jobs? This is an example on how to do Spring Quartz Integration with Auto-wiring.

Quartz Enterprise scheduler is a neat application that lets you setup periodic jobs within a J2EE or J2SE environment. Quartz is not as powerful as other commercial enterprise job schedulers like Autosys but its ability to run simple cron-like jobs within an Application server environment is commendable.  Above all Quartz and Spring integrates very nicely with a little effort.

I have seen that many people complain about Null Pointer Exception in the Quartz jobs. It is due to the inability of Quartz to auto-wire Spring beans since the job bean is instantiated by Quartz. One option people talk about is to use the MethodInvokingJobDetailFactoryBean of Spring to invoke a method in your spring bean. The disadvantage is that you would not have access to the JobExcecutionContext which I think is important in many advanced jobs. Here is a document that explains this method:
http://www.zabada.com/technology/Wiki.jsp?page=SpringAndQuartz

I have successfully instantiated Job beans will full auto-wiring using the technique explained below. In this technique I pass the actual job bean name to a delegating job bean through the job data map.  Now the delegating job bean instantiates the actual job bean based on name retrieved from the job data map. After instantiating the job bean, the delegating job bean invokes methods in it as defined by the contract, JobInterface.

First you define an interface (or a contract) for your jobs. Let us call it JobInterface:

// JobInterface.java
package com.harinair.jobs;

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

public interface JobInterface {
public void init(JobExecutionContext jobExecutionContext)
      throws JobExecutionException
public void execute() throws JobExecutionException;
public void destroy();
}

Now write the job bean that implements this interface:

package com.harinair.jobs;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
/**
 * @author hari.gangadharan
 * @spring.bean id="checkMailJobBean" autowire="byName"
 */
public class CheckMailJobBean implements JobInterface {
    public void init (JobExecutionContext jobExecutionContext)
        throws JobExecutionException {
        // Do your job initialization
    }
    public void execute() throws JobExecutionException {
        // Write your job logic
    }
    public void destroy() {
        // Do the cleanup
    }
// Add all others setters and getters for your
// Spring auto-wiring
}

It is time to write a delegating job bean that can execute the above job bean:

package com.harinair.jobs;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.quartz.SchedulerContext;
import org.quartz.SchedulerException;
import org.springframework.context.ApplicationContext;
import org.springframework.scheduling.quartz.QuartzJobBean;
/**
 * @author hari.gangadharan
 */
public class DelegatingJobBean extends QuartzJobBean {
    private static final String APPLICATION_CONTEXT_KEY
        = "applicationContext";
    private static final String JOB_BEAN_NAME_KEY
        = "job.bean.name";
    protected Log log = LogFactory.getLog(getClass());

    @Override
    protected final void executeInternal(JobExecutionContext
              jobExecutionContext) throws JobExecutionException {
        SchedulerContext schedulerContext = null;
        try {
            schedulerContext = jobExecutionContext.getScheduler()
                 .getContext();
        } catch(SchedulerException e) {
            throw new JobExecutionException(
                "Failure accessing scheduler context", e);
        }
        ApplicationContext appContext = (ApplicationContext)
             schedulerContext.get(APPLICATION_CONTEXT_KEY);
        String jobBeanName = (String) jobExecutionContext
                  .getJobDetail()
                  .getJobDataMap().get(JOB_BEAN_NAME_KEY);
        log.info("Starting job: " + jobBeanName);
        JobInterface jobBean = (JobInterface) appContext
               .getBean(jobBeanName);
        try {
            jobBean.init(jobExecutionContext);
            jobBean.execute();
        } finally {
            jobBean.destroy();
        }
    }
}

Now you are ready to make the application context changes:

Spring Context (I have also attached it here):
http://shared-files.s3.amazonaws.com/springContext.xml

< !DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN"
      "http://www.springframework.org/dtd/spring-beans.dtd"> 




   

    
  


 






 

   

 

  
   


      
    
  
   

      applicationContext
  

Now fire up your application. Your job will run daily at 6:30 AM.