Java Przykład: Dynamiczne planowanie zadań za pomocą kwarcu

Question

Chcę udostępnić interfejs użytkownika w celu dynamicznego definiowania zadań kwarcowych. Gdzie użytkownik powinien mieć możliwość definiowania właściwości zadania, takich jak nazwa JOB, wyrażenie crona lub przedział czasu, określona klasa języka Java dla zadania itp.

Czy istnieje dowolne Open Source, które ułatwia tę funkcję? Lub, jeśli chcę stworzyć własny moduł dla dynamicznego Quartz Scheduler, jaki powinien być sposób na zrobienie tego?

Answer 1

kod Przykład Dynamic Quartz planowania zadań:

Maven Zależności

  <dependency> 
      <groupId>org.quartz-scheduler</groupId> 
      <artifactId>quartz</artifactId> 
      <version>1.8.5</version> 
     </dependency> 
      <dependency> 
      <groupId>org.springframework</groupId> 
      <artifactId>spring-core</artifactId> 
      <version>${spring.version}</version> 
     </dependency> 
     <dependency> 
      <groupId>org.springframework</groupId> 
      <artifactId>spring-beans</artifactId> 
      <version>${spring.version}</version> 
     </dependency> 
     <dependency> 
      <groupId>org.springframework</groupId> 
      <artifactId>spring-context</artifactId> 
      <version>${spring.version}</version> 
     </dependency> 
     <dependency> 
      <groupId>org.springframework</groupId> 
      <artifactId>spring-context-support</artifactId> 
      <version>${spring.version}</version> 
     </dependency> 

kontekst aplikacji File (dynamicznie jobs.xml)

<beans xmlns="http://www.springframework.org/schema/beans" 
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p" 
    xmlns:aop="http://www.springframework.org/schema/aop" xmlns:context="http://www.springframework.org/schema/context" 
    xmlns:jee="http://www.springframework.org/schema/jee" xmlns:tx="http://www.springframework.org/schema/tx" 
    xsi:schemaLocation=" 
      http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd 
      http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd 
      http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd 
      http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee-3.0.xsd 
      http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd 
      http://www.springmodules.org/schema/ehcache http://www.springmodules.org/schema/cache/springmodules-ehcache.xsd"> 


    <!-- The Task Bean--> 
    <bean id="myTask" class="com.xxx.example.dynamicjob.MyTask" /> 

    <!-- The quartz scheduler configuration --> 
    <bean id="scheduler" class="org.springframework.scheduling.quartz.SchedulerFactoryBean"/> 

</beans> 

Java dla klasy Zadanie

package com.xxx.example.dynamicjob; 

    public class MyTask 
    { 
     public void performAction() { 
      System.out.println("Hey, you reached me...:)"); 
     }   
    } 

Java klasy do tworzenia dynamicznych Job

package com.xxx.example.dynamicjob; 
import org.quartz.JobDetail; 
import org.quartz.Scheduler; 
import org.springframework.beans.factory.xml.XmlBeanFactory; 
import org.springframework.core.io.ClassPathResource; 
import org.springframework.scheduling.quartz.CronTriggerBean; 
import org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean; 

public class DynamicJobExample { 

    /** 
    * @param args 
    */ 
    public static void main(String[] args) { 

       ClassPathResource res = new ClassPathResource("dynamic-jobs.xml"); 
       XmlBeanFactory factory = new XmlBeanFactory(res); 

       //get the quartzFactory bean 
       Scheduler scheduler = (Scheduler) factory.getBean("scheduler"); 

       //get the task bean 
       MyTask myTask = (MyTask) factory.getBean("myTask"); 

       try { 
       // create JOB 
       MethodInvokingJobDetailFactoryBean jobDetail = new MethodInvokingJobDetailFactoryBean(); 
       jobDetail.setTargetObject(myTask); 
       jobDetail.setTargetMethod("performAction"); 
       jobDetail.setName("MyJobDetail"); 
       jobDetail.setConcurrent(false); 
       jobDetail.afterPropertiesSet(); 

       /* SimpleTriggerBean trigger = new SimpleTriggerBean(); 
       trigger.setBeanName("MyTrigger"); 
       trigger.setJobDetail((JobDetail) jobDetail.getObject()); 
       trigger.setRepeatInterval(5000); 
       trigger.afterPropertiesSet(); 
       */ 

       // create CRON Trigger 
       CronTriggerBean cronTrigger = new CronTriggerBean(); 
       cronTrigger.setBeanName("CRON0001"); 

       // Execute after each 5 second 
       String expression = "5 * * * * ?"; 
       cronTrigger.setCronExpression(expression); 
       cronTrigger.afterPropertiesSet(); 

       //scheduler.scheduleJob(jobDetail, cronTrigger); 

       scheduler.scheduleJob((JobDetail) jobDetail.getObject(), cronTrigger); 

       // Start Scheduler   
       scheduler.start(); 

       } catch (Exception e) {      
        e.printStackTrace(); 
       } 
    } 
} 

Answer 2

Można utworzyć JobDetail i wyzwalania obiektów w ten sposób także:

JobDetail jobDetail; 
String myJobClass = "com.MyJobClass"; 
String myJobName = "myJobName"; 
String myJobGroup ="myJobGroup"; 
Class myJobClassType= Class.forName(myJobClass);    
jobDetail =JobBuilder.newJob().ofType(myJobClassType) 
.withIdentity(myJobName, myJobGroup).build(); 


String myGroup = "myGroup"; 
String name = "TriggerName"; 
String expresion = "5 * * * * ?"; 


Trigger trigger = TriggerBuilder 
.newTrigger() 
.withIdentity(name, myGroup) 
.withSchedule(
CronScheduleBuilder.cronSchedule(expresion)) 
.build(); 

Answer 3

sprężyna 4 pozwala mi zrobić to bez żadnych problem (Quartz 2.0) - dyspozytor sprężyn-servlet.xml

<task:annotation-driven executor="myExecutor" scheduler="myScheduler"/> 
<task:scheduler id="myScheduler" pool-size="10"/> 
<task:executor id="myExecutor" pool-size="1"/> 

Inject powyżej utworzonego fasoli lub fasoli w wiosennej klasy usług

@Service 
public class DynamicJobExample { 

@Autowired 
@Qualifier("myScheduler") 
private TaskScheduler scheduler; 

public void schedule() throws ParseException { 
    scheduler.schedule(new MyTask(), new CronTrigger("5 * * * * ?")); 
    } 
} 

MyTask Powinny być Runnable Klasa

public class MyTask implements Runnable{ 

@Override 
public void run() { 
    System.out.println("Hey, you reached me...:)"); 
    } 
} 

Maven Zależności są (pom.xml)

<spring.version>4.1.0.RELEASE</spring.version> 

    <dependency> 
     <groupId>org.quartz-scheduler</groupId> 
     <artifactId>quartz</artifactId> 
     <version>2.2.1</version> 
    </dependency> 

Answer 4

package com.myproject; 

import java.text.ParseException; 

import org.quartz.JobBuilder; 
import org.quartz.JobDetail; 
import org.quartz.Scheduler; 
import org.quartz.SchedulerException; 
import org.quartz.SchedulerFactory; 
import org.quartz.impl.triggers.CronTriggerImpl; 
import org.springframework.stereotype.Component; 

@Component 
public class QuartzSchedulerExample { 
    public QuartzSchedulerExample() { 
     SchedulerFactory schedFact = new org.quartz.impl.StdSchedulerFactory(); 
     Scheduler scheduler; 
     try { 
      scheduler = schedFact.getScheduler(); 
      JobDetail details = JobBuilder.newJob(MyMailBean.class) 
        .withDescription("something") 
        .withIdentity("mejob","myGroup") 
        .storeDurably(true).build(); 

      CronTriggerImpl trigger = new CronTriggerImpl(); 
      trigger.setName("T1"); 

      try { 
       trigger.setCronExpression("0 0 0 * * ? *"); 
      } catch (ParseException e) { 
       e.printStackTrace(); 
      } 
      trigger.setDescription("desc"); 
      scheduler.scheduleJob(details,trigger); 
      scheduler.start(); 
     } catch (SchedulerException e) { 
      e.printStackTrace(); 
     } 
    } 
} 

Praca w źle działa codziennie 00:00:00 (godzina: minuta: sekunda)