Creating Object chain in Quartz Job execution using Google Guice/Dogger in Java Web App

I started to create a cron job using Quartz in my Java web application to execute one of cleanup task. The actual job is firing as expected and no
problem with the Quatrz job execution. From the below code snippet When I try to use MyService to call the required method as part of job, Dependency is not working.

Object for the MyService class is not created. So I'm getting a null pointer exception. To avoid this I tried to use Google Guice (tried dogger as well) to manage
dependency injection but MyService object creation depends on other classes.

Let's say in this example CustomerService and this CustomerService depends on other classes and those classes depends on some other etc.. So I am going to end up creating object creation chain by using Guice or Dogger.

Code snippet:

  import com.google.inject.Inject;
import com.google.inject.Injector;
import com.google.inject.Singleton;
import org.quartz.Job;
import org.quartz.Scheduler;
import org.quartz.SchedulerException;
import org.quartz.spi.JobFactory;
import org.quartz.spi.TriggerFiredBundle;
@Singleton
public class CustomJobFactory implements JobFactory {
@Inject
private Injector injector;
@Override
public Job newJob(TriggerFiredBundle bundle, Scheduler scheduler) throws SchedulerException {
return (Job) injector.getInstance(bundle.getJobDetail().getJobClass());
}
}
public class QuartzJobHelper  {
private final Scheduler scheduler;
@Inject
public QuartzSchedulerImpl(Scheduler scheduler, CustomJobFactory customJobFactory) {
this.scheduler = scheduler;
try {
this.scheduler.setJobFactory(customJobFactory);
} catch (SchedulerException e) {
e.printStackTrace();
}
}
public static void executeJob() throws Exception {
// The Guice injector used to create instances.
Injector injector = Guice.createInjector(new MyModule());
JobDetail jobDetail = JobBuilder.newJob(MyJob.class).withIdentity("myjob", "mygroup")
.build();
Trigger trigger = TriggerBuilder.newTrigger().withIdentity("mytrigger", "mygroup")
.withSchedule(CronScheduleBuilder.cronSchedule("0/1 * * * * ?")).build();
SchedulerFactory schedulerFactory = new StdSchedulerFactory();
Scheduler scheduler = schedulerFactory.getScheduler();
// Inform Quartz scheduler to use our factory.
scheduler.setJobFactory((injector.getInstance(CustomJobFactory.class));
scheduler.scheduleJob(jobDetail, trigger);
// Start the scheduler.
scheduler.start();
}

}

import org.quartz.spi.JobFactory;
import java.io.IOException;

public class MyModule extends AbstractModule {
@Override
protected void configure() {
bind(JobFactory.class).to(MyJobFactory.class);
bind(MyService.class).to(MyServiceImpl.class);
bind(CustomerService.class).to(CustomerServiceImpl.class);
bind(MyDao.class).to(MyDaoImpl.class);
bind(CustomCache.class).to(CustomCacheImpl.class);
bind(ProxyDao.class).to(ProxyDaoImpl.class);
bind(RequestDao.class).to(DefaultRequestDao.class);
|
|
|
etc.. Likewise so many dependencies are there to inject but finding 100's of dependencies.
}
}
public class MyJob extends org.quartz.Job {
@Inject
MyService service;
public void execute(JobExecutionContext jobContext) throws JobExecutionException {
service.cleanupJunkData();
}    
}
class MyService {
void cleanupJunkData();
}
@Named
class MyServiceImpl implments MyService {
private CustomerService cs; 
private MyDao dao;
private CustomCache cache;
@Inject 
public MyServiceImpl(CustomerService cs, MyDao dao, CustomCache cache) {
this.cs = cs;
this.dao=dao;
this.cache = cache;
}
@Override
public void cleanupJunkData() {
List<Customer> customerData = cs.getCustomerData(dao.getExpiredCustId());
cache.clear(customerData);
}
}
public Class MainClass {
public static void main(Stirng[] args) {
QuartzJobHelper.executeJob();
}
}

Could someone suggest how to deal with object creation in Quartz job?

You haven't provided any Guice specific code in your example, but you want to create a JobFactory, which will be responsible for injecting each job as they are fired:

public class GuiceJobFactory implements JobFactory {
	@Inject
    private Injector guiceInjector;
	
	@Override
	public Job newJob(TriggerFiredBundle bundle, Scheduler scheduler) throws SchedulerException {
		return (Job) guiceInjector.getInstance(bundle.getJobDetail().getJobClass());
	}
}

You can create this however you choose, but you'll need to somehow get the Injector into it.

Edit

From your comment, I don't really understand. We have the following setup (with multiple jobs):

JobThatDoesSomething:
@Inject Service1 service1;

Service1:
@Inject Dao1 dao1;
@Inject Dao2 dao2;
@Inject ValidationFactory validationFactory;

ValidationFactory:
@Inject ValidationProvider provider;

This is at a high level the hierarchy of just a single job. We have about 100 that have the same level of injected dependencies. From what I can tell, this is exactly the same as you?

What are you saying? That with this factory your:

• MyService is not injected?
• MyService.CustomerService is not injected?
• Etc?

Edit 2

You need to create your injector somehow. I've added your main code, with an example of how you would use your CustomModule and JobFactory:

public Class MainClass {
  public static void main(Stirng[] args) {
       // You need to create your injector here
       Injector injector = Guice.createInjector(new CustomModule());

       SchedulerFactory schedFact = new org.quartz.impl.StdSchedulerFactory();
        Scheduler scheduler = schedFact.getScheduler();
        scheduler.setJobFactory(new GuiceJobFactory(injector));  // Use it here
        scheduler.start();
         
        // define the job and tie it to our HelloJob class
        JobBuilder jobBuilder = JobBuilder.newJob(MyJob.class);
        JobDataMap data = new JobDataMap();
        data.put("latch", this);
         
        JobDetail jobDetail = jobBuilder.usingJobData("example", "com.QuartzSchedulerExample") 
                .usingJobData(data)
                .withIdentity("myJob", "group1")
                .build();
         
         
        // Fire at curent time + 1 min every day
        Trigger trigger = TriggerBuilder.newTrigger()
        .withIdentity("myTrigger", "group1")
        .startAt(DateBuilder.todayAt(10, 20, 20))
        .withSchedule(CronScheduleBuilder.cronSchedule("0 " + (min + 1) + " " + hour + " * * ? *"))     
        .build();
         
        // Tell quartz to schedule the job using our trigger
        scheduler.scheduleJob(jobDetail, trigger);
  }
}