मैन्युअल रूप से फायरिंग क्वार्ट्ज नौकरियां

Question

हमारे पास हमारे आवेदन में कई क्वार्ट्ज नौकरियां कॉन्फ़िगर की गई हैं। विकास के दौरान, हम क्वार्ट्ज शेड्यूलर स्टैंडबाय में छोड़ देते हैं - हालांकि, हम कभी-कभी मैन्युअल रूप से नौकरी शुरू करना चाहते हैं (विकास उद्देश्यों के लिए)। अगर मैं फायर ट्रिगर कहता हूं, तो यह मुझे बताता है कि मुझे शेड्यूलर शुरू करने की ज़रूरत है। हालांकि, अगर मैं शेड्यूलर शुरू करता हूं, तो यह तुरंत अन्य सभी नौकरियों को भी शेड्यूल करेगा, जो मैं नहीं चाहता हूं (क्योंकि जब मैं मैन्युअल रूप से निकाली गई नौकरी डिबग कर रहा हूं तो वे ट्रिगर कर सकते हैं)।

मैं सभी रोके जा सकते हैं चलाता है जब मैं अनुसूचक शुरू करते हैं, लेकिन फिर मैं न दग़ना निर्देश आदि

से निपटने के लिए वहाँ मैन्युअल रूप से रोकने या misfires से निपटने के लिए बिना एक नौकरी बंद आग के लिए एक सरल तरीका है (यानी एक अग्निरोधक जो शेड्यूलर स्टैंडबाय में भी काम करता है)?

Answer 1

आप जब निष्पादन अस्थिर नहीं है एक ट्रिगर फ़िल्टर अपने अनुसूचक में

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

डिबग निष्पादन फ़िल्टर जोड़ने के लिए एक वीटो जोड़ देगा कोशिश कर सकते हैं (तुरंत चलाने के लिए निर्धारित नहीं) और आप डिबग मोड में हैं।

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

इस पाश आप मैन्युअल रूप से काम आग की आवश्यकता होगी:

यहाँ एक कार्यान्वयन उदाहरण है

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

start-time और 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

क्वार्ट्ज शेड्यूलर में पंजीकृत सभी नौकरियां विशिष्ट रूप से जॉबकी द्वारा पहचानी जाती हैं जो नाम और समूह से बना है। आप अपने शेड्यूलर इंस्टेंस के triggerJob(JobKey jobKey) पर कॉल करके तुरंत नौकरी को नौकरी दे सकते हैं।

//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); 

नोट:

अनुसूचक अपने आवेदन भर में इस्तेमाल समयबद्धक उदाहरण है। इसकी शुरुआत() विधि को पहले ही बनाया जाने के बाद बुलाया जाना चाहिए।

नौकरी टिकाऊ नौकरी है जो किसी भी ट्रिगर या क्रॉन को संलग्न नहीं कर सकती है। इसे triggerJob(JobKey jobKey) पर कॉल करके केवल प्रोग्रामेटिक रूप से निकाल दिया जा सकता है।