Lavori al quarzo che non vengono avviati

Question

Modifica: Sto usando quartz-2.1.5.jar. Ecco il riassunto delle mie classi:

HttpPollingJob estende PollingJob estende ScheduledJob attrezzi org.quartz.Job

In particolare:

1) ScheduledJob implementa quarzo Job (classe base astratta per tutti i miei Job i tipi):

import org.quartz.Job; 
import org.quartz.Trigger; 

public abstract class ScheduledJob implements Job { 
    private Trigger trigger; 

    public ScheduledJob() { 
     this(null); 
    } 

    public ScheduledJob(Trigger trig) { 
     super(); 

     if(trig == null) 
      trig = getDefaultTrigger(); 

     setTrigger(trig); 
    } 

    public Trigger getTrigger() { 
     return trigger; 
    } 

    public void setTrigger(final Trigger trig) { 
     trigger = trig; 
    } 

    protected abstract Trigger getDefaultTrigger(); 
} 

2) PollingJob estende ScheduledJob - tutte le "poller" sondaggio qualche risorsa/punto finale con una frequenza specifica:

import org.quartz.JobExecutionContext; 
import org.quartz.JobExecutionException; 
import org.quartz.SimpleScheduleBuilder; 
import org.quartz.Trigger; 
import org.quartz.TriggerBuilder; 

import com.me.jobs.ScheduledJob; 

public abstract class PollingJob extends ScheduledJob { 
    private static long DEF_FREQUENCY = 10 * 1000; // 10 secs 
    private String name;  
    private long frequency; 

    public PollingJob(final String nm) { 
     this(nm, DEF_FREQUENCY); 
    } 

    public PollingJob(final String nm, final long freq) { 
     super(); 

     setName(nm); 
     setFrequency(freq); 
    } 

    public abstract void poll(JobExecutionContext context); 

    @Override 
    public void execute(JobExecutionContext context) throws JobExecutionException { 
     poll(context);  
    } 

    public String getName() { 
     return name; 
    } 

    public void setName(final String nm) { 
     name = nm; 
    } 

    public long getFrequency() { 
     return frequency; 
    } 

    public void setFrequency(final long freq) { 
     frequency = freq; 
    } 

    protected final Trigger getDefaultTrigger() { 
     TriggerBuilder<?> triggerBuilder = TriggerBuilder.newTrigger() 
      .startNow() 
      .withSchedule(SimpleScheduleBuilder.simpleSchedule() 
      .withIntervalInMilliseconds(DEF_FREQUENCY)); 

     return triggerBuilder.build(); 
    } 
} 

3) HttpPollingJob estende PollingJob - "HTTP poller" sondaggio un server web (utilizzando HttpClient):

import org.apache.http.HttpResponse; 
import org.apache.http.HttpStatus; 
import org.apache.http.client.HttpClient; 
import org.apache.http.client.methods.HttpGet; 
import org.apache.http.impl.client.DefaultHttpClient; 
import org.quartz.JobExecutionContext; 

import com.me.MonitoredEvent; 
import com.me.MonitoredEventRegistrar; 

public class HttpPollingJob extends PollingJob { 
    private String serverURL; 
    private org.slf4j.Logger logger = 
     org.slf4j.LoggerFactory.getLogger(HttpPollingJob.class); 

    public HttpPollingJob(final String nm, final String server) { 
     super(nm); 

     setServerURL(server); 
    } 

    public String getServerURL() { 
     return serverURL; 
    } 

    public void setServerURL(final String server) { 
     serverURL = server; 
    } 

    @Override 
    public final void poll(JobExecutionContext context) { 
     MonitoredEvent event = null; 

     try { 
      // This is where we would use HttpClient to connect to a web server and poll it. 
      System.out.println("Job fired!"); 
     } 
     catch(Throwable thrown) { 
      logger.error(thrown.getMessage()); 
     } 
    } 
} 

4) JobDriver - definisce diversi HttpPollingJob s e utilizza Quartz per avviarli:

public class JobDriver { 
    private List<HttpPollingJob> jobs; 

    public JobDriver() { 
     HttpPollingJob job1 = new HttpPollingJob("job-1", "http://www.example.com/1"); 
     HttpPollingJob job2 = new HttpPollingJob("job-2", "http://www.example.com/2"); 
     HttpPollingJob job3 = new HttpPollingJob("job-3", "http://www.example.com/3"); 

     jobs = new ArrayList<HttpPollingJob>(); 
     jobs.add(job1); 
     jobs.add(job2); 
     jobs.add(job3); 
    } 

    public static void main(String[] args) { 
    JobDriver driver = new JobDriver(); 
     driver.startJobs(); 
    } 

    private void startJobs() { 
     try { 
      // Obtain a basic SchedulerFactory and fire it up. 
      SchedulerFactory schedulerFactory = new org.quartz.impl.StdSchedulerFactory(); 
      Scheduler scheduler = schedulerFactory.getScheduler(); 
      scheduler.start(); 

      // Define a job for every declared monitor. 
      JobBuilder jobBuilder = null; 

      for(ScheduledJob job : jobs) { 

      Trigger trigger = job.getTrigger(); 
      jobBuilder = JobBuilder.newJob(job.getClass()); 

      // Bind the current job to this trigger. 
      scheduler.scheduleJob(jobBuilder.build(), trigger); 

      // TODO: Shut the scheduler down politely?!?! 
     } 
     catch(Throwable exc) { 
      logger.error(exc.getMessage()); 

      // Force application to kick out. 
      throw new RuntimeException(exc); 
     } 
    } 
} 

Quando eseguo questo codice ottengo un avvio perfetto senza errori o eccezioni di runtime. Se spargo le affermazioni System.out.println, riesco a vedere ogni singola riga di codice che si esegue in modo impeccabile. L'unico problema è che, una volta avviato il programma, non viene stampato il messaggio "Job fired!" che indica che il lavoro di polling si sta avviando.

Ho provato ogni combinazione di start() e shutdown() Mi viene in mente senza successo. Qualche esperto del quarzo può guardare questo codice e dirmi perché il lavoro non sta sparando?

Nei registri (ho configurato log4j) Vedo il thread di lavoro Quartz creato per il lavoro pianificato. Mi sento come se fossi al 99% del modo in cui ci sono ma mi manca qualcosa di ovvio. Grazie in anticipo!

Answer 1

Le sue vostri costruttori - la JobBuilder cerca le no-args e dal momento che non sono definiti si rifiuta di costruire i lavori. Aggiungi vuoti no-arg e sei tutto pronto.

Answer 2

Apparentemente, non è stato avviato il trigger. Vedere Quartz Tutorial o Javadocs:

// Trigger the job to run now, and then every 40 seconds 
    Trigger trigger = newTrigger() 
     .withIdentity("myTrigger", "group1") 
     .startNow() 
     .withSchedule(simpleSchedule() 
      .withIntervalInSeconds(40) 
      .repeatForever())    
     .build(); 

Answer 3

Potrebbe provare a cambiare il codice del metodo getDefaultTrigger nella classe PollingJob nelle seguenti:

protected final Trigger getDefaultTrigger() { 

return TriggerBuilder.newTrigger() 
     .withSchedule(SimpleScheduleBuilder.simpleSchedule() 
     .withIntervalInMilliseconds(DEF_FREQUENCY)) 
     .startAt(DateBuilder.futureDate(1, DateBuilder.IntervalUnit.SECOND)) 
     .build(); 
} 

Answer 4

Mi sento qualche problema con il modo in cui si crea il grilletto. Ricordate non è possibile riutilizzare trigger per più lavori

Prova a creare grilletto con un'identità unica e gruppo come di seguito

trigger everyHourTrigger = newTrigger(). WithIdentity ("everyWeeklyTrigger", "Gruppo 1") .startNow(). withSchedule (cronSchedule ("0 1 * * *?")).costruire();

Answer 5

@ 4herpsand7derpsago Sì hai ragione, siete 99% lì, ho incontrato il codice e c'è solo un problema in esso, i costruttori di default sono assenti in HttpPollingJob e PollingJob classi, per questo motivo pianificazione non è in grado di creare le loro istanze,

Simple Solution aggiuntivo seguente codice nelle classi inferiori
HttpPollingJob classe

public HttpPollingJob() { 
} 

PollingJob classe

public PollingJob() { 
} 

Bingo, verranno stampati i seguenti messaggi

Job fired!
Job fired!
Job fired!

Se si desidera ripetere il grilletto, aggiungere seguente codice nel PollingJob

protected final Trigger getDefaultTrigger() { 
    TriggerBuilder<?> triggerBuilder = TriggerBuilder 
      .newTrigger() 
      .startNow() 
      .withSchedule(
        SimpleScheduleBuilder.simpleSchedule() 
          .withIntervalInMilliseconds(DEF_FREQUENCY).repeatForever()); 

    return triggerBuilder.build(); 
} 

Sperando che ora riceverò la bontà :)

BONUS
Sembra come si desidera effettuare il polling o fare qualcosa con gli URL, Un modo migliore per passare che l'uso di re JobDataMap

Aggiornato JobDriver

import java.util.ArrayList; 
import java.util.List; 

import org.quartz.JobBuilder; 
import org.quartz.Scheduler; 
import org.quartz.SchedulerFactory; 
import org.quartz.Trigger; 

public class JobDriver { 
private List<HttpPollingJob> jobs; 

public JobDriver() { 
    HttpPollingJob job1 = new HttpPollingJob("job-1", 
      "http://www.example.com/1"); 
    HttpPollingJob job2 = new HttpPollingJob("job-2", 
      "http://www.example.com/2"); 
    HttpPollingJob job3 = new HttpPollingJob("job-3", 
      "http://www.example.com/3"); 

    jobs = new ArrayList<HttpPollingJob>(); 
    jobs.add(job1); 
    jobs.add(job2); 
    jobs.add(job3); 
} 

public static void main(String[] args) { 
    JobDriver driver = new JobDriver(); 
    driver.startJobs(); 
} 

private void startJobs() { 
    try { 
     // Obtain a basic SchedulerFactory and fire it up. 
     SchedulerFactory schedulerFactory = new org.quartz.impl.StdSchedulerFactory(); 
     Scheduler scheduler = schedulerFactory.getScheduler(); 
     scheduler.start(); 
     // Define a job for every declared monitor. 
     JobBuilder jobBuilder = null; 

     for (HttpPollingJob job : jobs) { 

      Trigger trigger = job.getTrigger(); 
      jobBuilder = JobBuilder.newJob(job.getClass()); 
      jobBuilder.usingJobData("name", job.getName()); 
      jobBuilder.usingJobData("url", job.getServerURL()); 

      // Bind the current job to this trigger. 
      scheduler.scheduleJob(jobBuilder.build(), trigger); 

      // TODO: Shut the scheduler down politely?!?! 
     } 


    } catch (Throwable exc) { 
     // Force application to kick out. 
     throw new RuntimeException(exc); 
    } 
} 
} 

aggiornato HttpPollingJob

import java.util.Map; 

import org.quartz.JobExecutionContext; 

public class HttpPollingJob extends PollingJob { 
private String serverURL; 
private org.slf4j.Logger logger = 
    org.slf4j.LoggerFactory.getLogger(HttpPollingJob.class); 

public HttpPollingJob(final String nm, final String server) { 
    super(nm); 

    setServerURL(server); 
} 
public HttpPollingJob() { 
} 

public String getServerURL() { 
    return serverURL; 
} 

public void setServerURL(final String server) { 
    serverURL = server; 
} 

@Override 
public final void poll(JobExecutionContext context) { 

    try { 
     Map dataMap = context.getJobDetail().getJobDataMap(); 
     String nm = (String)dataMap.get("name"); 
     String url = (String)dataMap.get("url"); 
     // This is where we would use HttpClient to connect to a web server and poll it. 
     System.out.println("Job fired! name:"+nm+" url:"+url); 
    } 
    catch(Throwable thrown) { 
     logger.error(thrown.getMessage()); 
    } 
} 
} 

nuova uscita

Job fired! name:job-1 url:http://www.example.com/1
Job fired! name:job-2 url:http://www.example.com/2
Job fired! name:job-3 url:http://www.example.com/3