Trabajos de cuarzo de cocción manualmente

Question

Tenemos varios trabajos de cuarzo configurados en nuestra aplicación. Durante el desarrollo, dejamos el planificador de cuarzo en modo de espera; sin embargo, a veces deseamos comenzar un trabajo manualmente (para fines de desarrollo). Si llamo a FireTrigger, me dice que necesito iniciar el programador. Sin embargo, si inicio el programador, también se programarán inmediatamente todos los demás trabajos, que no es lo que quiero (ya que pueden desencadenarse mientras estoy depurando el trabajo disparado manualmente).

pude hacer una pausa en todos los disparadores cuando inicio el programador, pero luego tengo que lidiar con las instrucciones de fallo de encendido etc.

¿Hay una manera sencilla de disparar un trabajo manual, sin tener que lidiar con una pausa y fallos de encendido (es decir, un fireTrigger que funciona incluso si el programador está en modo de espera)?

Answer 1

Usted puede tratar de añadir un filtro de gatillo en su planificador

filtro de ejecución

this.scheduler.addGlobalTriggerListener(new DebugExecutionFilter()); 

La depuración agregará un veto cuando la ejecución no es volátil (no programado para ejecutarse inmediatamente) y se encuentra en modo de depuración.

Aquí es un ejemplo de implementación:

private static class DebugExecutionFilter implements TriggerListener 
{ 

    public DebugExecutionFilter() 
    { 
    } 

    @Override 
    public String getName() 
    { 
     return "Task execution filter"; 
    } 

    @Override 
    public void triggerFired(Trigger trigger, JobExecutionContext context) 
    { 
     // Do nothing 
    } 

    /* (non-Javadoc) 
    * 
    * @see org.quartz.TriggerListener#vetoJobExecution(org.quartz.Trigger, org.quartz.JobExecutionContext) */ 
    @Override 
    @SuppressWarnings("unchecked") 
    /** 
    * A veto is added if : 
    * - For non volatile trigger if we are in debug mode 
    */ 
    public boolean vetoJobExecution(Trigger trigger, JobExecutionContext context) 
    { 

     try 
     { 
      // 
      if (!trigger.isVolatile() && isDebugMode()) 
      { 
       return true; 
      } 

      //task is run by scheduler.triggerJobWithVolatileTrigger() for immediate schedule 
      //or task is schedule and we are not in debugMode 
      return false; 
    } 


    @Override 
    public void triggerMisfired(Trigger trigger) 
    { 
     // do nothing 
    } 

    @Override 
    public void triggerComplete(Trigger trigger, JobExecutionContext context, int triggerInstructionCode) 
    { 
     // do nothing 
    } 

} 

Answer 2

este es el bucle que se requieren para disparar el trabajo manualmente:

scheduler = stdSchedulerFactory.getScheduler(); 
    //note: "stdSchedulerFactory" is the object created of 
    //the schedulerFactory(Standard) class. 


    // loop jobs by group 
    for (String groupName : scheduler.getJobGroupNames()) { 

    // get jobkey 
    for (JobKey jobKey : scheduler.getJobKeys(GroupMatcher 
     .jobGroupEquals(groupName))) { 

     String jobName = jobKey.getName(); 
     String jobGroup = jobKey.getGroup(); 

     scheduler.triggerJob(jobName, jobGroup); 
    } 

    } 

Answer 3

No hay necesidad de start-time y end-time.

<trigger> 
     <cron> 
     <name>TestTrigger</name> 
     <group>CronSampleTrigger</group> 
     <description>CronSampleTrigger</description> 
     <job-name>TestJob</job-name> 
     <job-group>jobGroup1</job-group>  

    <!--<start-time>1982-06-28T18:15:00.0Z</start-time> 
     <end-time>2020-05-04T18:13:51.0Z</end-time>--> 

     <cron-expression>0 0/1 * * * ?</cron-expression> 
     </cron> 
</trigger> 

Answer 4

Todos los trabajos registrados en el Programador de Quartz están identificados de forma exclusiva por JobKey, que se compone de un nombre y un grupo. Puede iniciar el trabajo que tiene una JobKey determinada inmediatamente llamando al triggerJob(JobKey jobKey) de su instancia de Scheduler.

//Create a new Job 
    JobKey jobKey = JobKey.jobKey("myNewJob", "myJobGroup"); 
    JobDetail job =JobBuilder.newJob(MyJob.class).withIdentity(jobKey).storeDurably().build(); 

    //Register this job to the scheduler 
    scheduler.addJob(job, true); 

    //Immediately fire the Job MyJob.class 
    scheduler.triggerJob(jobKey); 

Nota:

planificador es la instancia Programador utilizado en toda la aplicación. Su método start() ya debe llamarse después de haber sido creado.

El trabajo es el trabajo duradero que no puede adjuntar ningún disparador o cron. Solo se puede disparar programáticamente llamando al triggerJob(JobKey jobKey).