Spring Quartz 动态配置定时任务

from:Spring Quartz 动态配置定时任务

1、Quartz在Spring中的简单配置

Spring配置文件quartz.xml：

Java代码

1. <?xml version="1.0" encoding="UTF-8"?>


2.         <!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd">


3. <beans>




5.     <bean id="scheduleInfoService" class="com.erry.tntops.web.task.ScheduleInfoService">


6.          <property name="scheduler" ref="schedulerFactory"/>


7.      </bean>




9.      <bean id="jobDetail" class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean">


10.          <property name="targetObject" ref="scheduleInfoService"/>


11.          <property name="targetMethod" value="test"/>


12.          <property name="concurrent" value="false"/>


13.      </bean>




15.      <bean id="cronTrigger" class="org.springframework.scheduling.quartz.CronTriggerBean" >


16.           <property name="jobDetail" ref="jobDetail"/>


17.           <property name="cronExpression">


18.               <value>0/10 * * * * ?</value>


19.           </property>


20.       </bean>




22.      <bean id="schedulerFactory" class="org.springframework.scheduling.quartz.SchedulerFactoryBean">


23.          <property name="triggers">


24.              <list>


25.                  <ref local="cronTrigger"/>


26.              </list>


27.          </property>


28.     </bean>


29. </beans>

<?xml version="1.0" encoding="UTF-8"?>
        <!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd">
<beans>

    <bean id="scheduleInfoService" class="com.erry.tntops.web.task.ScheduleInfoService">
         <property name="scheduler" ref="schedulerFactory"/>
     </bean>

     <bean id="jobDetail" class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean">
         <property name="targetObject" ref="scheduleInfoService"/>
         <property name="targetMethod" value="test"/>
         <property name="concurrent" value="false"/>
     </bean>

     <bean id="cronTrigger" class="org.springframework.scheduling.quartz.CronTriggerBean" >
          <property name="jobDetail" ref="jobDetail"/>
          <property name="cronExpression">
              <value>0/10 * * * * ?</value>
          </property>
      </bean>

     <bean id="schedulerFactory" class="org.springframework.scheduling.quartz.SchedulerFactoryBean">
         <property name="triggers">
             <list>
                 <ref local="cronTrigger"/>
             </list>
         </property>
    </bean>
</beans>

在上面的配置中设定：

① targetMethod: 指定需要定时执行scheduleInfoAction中的test()方法

② concurrent：对于相同的JobDetail，当指定多个Trigger时, 很可能第一个job完成之前，第二个job就开始了。指定concurrent设为false，多个job不会并发运行，第二个job将不会在第一个job完成之前开始。

③ cronExpression：0/10 * * * * ?表示每10秒执行一次，具体可参考附表。

④ triggers：通过再添加其他的ref元素可在list中放置多个触发器。

scheduleInfoAction中的simpleJobTest()方法

注意：此方法没有参数，如果scheduleInfoAction有两个方法test()和test(String argument)，则spring只会去执行无参的test().

Java代码  

1. public void test() {


2.          log.warn("uh oh, Job is scheduled !'" + "' Success...");


3. }

2、Quartz在Spring中动态设置cronTrigger方法一

（1）、Spring配置文件quartz.xml：

Java代码  

1. <?xml version="1.0" encoding="UTF-8"?>


2.         <!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd">


3. <beans>


4.     <bean id="scheduleInfoAction" class="com.erry.tntops.web.task.ScheduleInfoAction">


5.         <property name="scheduler" ref="schedulerFactory"/>


6.         <!-- ref中的emsService是xml中配置的bean的id -->


7.         <property name="emsService" ref="emsService"/>


8.      </bean>




10.      <bean id="jobDetail" class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean">


11.          <property name="targetObject" ref="scheduleInfoAction"/>


12.          <property name="targetMethod" value="reScheduleJob"/>


13.          <property name="concurrent" value="false"/>


14.      </bean>




16.      <bean id="cronTrigger" class="com.erry.tntops.web.task.InitCronTrigger">


17.           <property name="jobDetail" ref="jobDetail"/>


18.           <property name="cronExpression">


19.               <value>0/10 * * * * ?</value>


20.           </property>


21.       </bean>




23.      <bean id="schedulerFactory" class="org.springframework.scheduling.quartz.SchedulerFactoryBean">


24.          <property name="triggers">


25.              <list>


26.                  <ref local="cronTrigger"/>


27.              </list>


28.          </property>


29.     </bean>


30. </beans>

<?xml version="1.0" encoding="UTF-8"?>
        <!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd">
<beans>
    <bean id="scheduleInfoAction" class="com.erry.tntops.web.task.ScheduleInfoAction">
        <property name="scheduler" ref="schedulerFactory"/>
        <!-- ref中的emsService是xml中配置的bean的id -->
        <property name="emsService" ref="emsService"/>
     </bean>

     <bean id="jobDetail" class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean">
         <property name="targetObject" ref="scheduleInfoAction"/>
         <property name="targetMethod" value="reScheduleJob"/>
         <property name="concurrent" value="false"/>
     </bean>

     <bean id="cronTrigger" class="com.erry.tntops.web.task.InitCronTrigger">
          <property name="jobDetail" ref="jobDetail"/>
          <property name="cronExpression">
              <value>0/10 * * * * ?</value>
          </property>
      </bean>

     <bean id="schedulerFactory" class="org.springframework.scheduling.quartz.SchedulerFactoryBean">
         <property name="triggers">
             <list>
                 <ref local="cronTrigger"/>
             </list>
         </property>
    </bean>
</beans>

（2）、类ScheduleInfoAction：

Java代码  

1. import org.apache.log4j.Logger;


2. import org.quartz.Scheduler;


3. import org.quartz.SchedulerException;


4. import org.springframework.scheduling.quartz.CronTriggerBean;




6. import java.text.ParseException;


7. import java.util.Date;




9. public class ScheduleInfoAction{


10.     Logger logger = Logger.getLogger(ScheduleInfoAction.class);




12.      private Scheduler scheduler;


13.      // 设值注入，通过setter方法传入被调用者的实例scheduler


14.      public void setScheduler(Scheduler scheduler) {


15.          this.scheduler = scheduler;


16.     }




18.     private EmsService emsService;




20.     public void setEmsService(EmsService emsService){


21.         this.emsService = emsService;


22.     }




24.     public void reScheduleJob() throws SchedulerException {


25.         // 运行时可通过动态注入的scheduler得到trigger，注意采用这种注入方式在有的项目中会有问题，如果遇到注入问题，可以采取在运行方法时候，获得bean来避免错误发生。


26.         CronTriggerBean trigger = (CronTriggerBean) scheduler.getTrigger("cronTrigger", Scheduler.DEFAULT_GROUP);


27.         logger.info("*********** trigger: " + trigger);


28.         String dbCronExpression = getCronExpressionFromDB();


29.         logger.info("*********** dbCronExpression: " + dbCronExpression);


30.         String originConExpression = trigger.getCronExpression();


31.         logger.info("*********** originConExpression: " + originConExpression);


32.         // 判断从DB中取得的任务时间(dbCronExpression)和现在的quartz线程中的任务时间(originConExpression)是否相等


33.         // 如果相等，则表示用户并没有重新设定数据库中的任务时间，这种情况不需要重新rescheduleJob


34.         if(!originConExpression.equalsIgnoreCase(dbCronExpression)){


35.             try{


36.                 trigger.setCronExpression(dbCronExpression);


37.                 scheduler.rescheduleJob("cronTrigger", Scheduler.DEFAULT_GROUP, trigger);


38.             } catch (ParseException e) {


39.                 logger.error("------------------- ParseException Error! -------------------");


40.                 e.printStackTrace();


41.                 logger.error("-------------------------------------------------------------");


42.             }


43.         }




45.         //执行task


46.         logger.info("task start time: " + new Date());


47.         System.out.println("Task test success!");


48.         logger.info("  task end time: " + new Date());


49.     }




51.     private String getCronExpressionFromDB(){


52.         String sql = "select CRON from t_test_task_trigger where available = 1 and trigger_name = 'cronTrigger'";


53.         return emsService.getCron(sql);


54.     }


55. }

import org.apache.log4j.Logger;
import org.quartz.Scheduler;
import org.quartz.SchedulerException;
import org.springframework.scheduling.quartz.CronTriggerBean;

import java.text.ParseException;
import java.util.Date;

public class ScheduleInfoAction{
    Logger logger = Logger.getLogger(ScheduleInfoAction.class);

     private Scheduler scheduler;
     // 设值注入，通过setter方法传入被调用者的实例scheduler
     public void setScheduler(Scheduler scheduler) {
         this.scheduler = scheduler;
    }

    private EmsService emsService;

    public void setEmsService(EmsService emsService){
        this.emsService = emsService;
    }

    public void reScheduleJob() throws SchedulerException {
        // 运行时可通过动态注入的scheduler得到trigger，注意采用这种注入方式在有的项目中会有问题，如果遇到注入问题，可以采取在运行方法时候，获得bean来避免错误发生。
        CronTriggerBean trigger = (CronTriggerBean) scheduler.getTrigger("cronTrigger", Scheduler.DEFAULT_GROUP);
        logger.info("*********** trigger: " + trigger);
        String dbCronExpression = getCronExpressionFromDB();
        logger.info("*********** dbCronExpression: " + dbCronExpression);
        String originConExpression = trigger.getCronExpression();
        logger.info("*********** originConExpression: " + originConExpression);
        // 判断从DB中取得的任务时间(dbCronExpression)和现在的quartz线程中的任务时间(originConExpression)是否相等
        // 如果相等，则表示用户并没有重新设定数据库中的任务时间，这种情况不需要重新rescheduleJob
        if(!originConExpression.equalsIgnoreCase(dbCronExpression)){
            try{
                trigger.setCronExpression(dbCronExpression);
                scheduler.rescheduleJob("cronTrigger", Scheduler.DEFAULT_GROUP, trigger);
            } catch (ParseException e) {
                logger.error("------------------- ParseException Error! -------------------");
                e.printStackTrace();
                logger.error("-------------------------------------------------------------");
            }
        }

        //执行task
        logger.info("task start time: " + new Date());
        System.out.println("Task test success!");
        logger.info("  task end time: " + new Date());
    }

    private String getCronExpressionFromDB(){
        String sql = "select CRON from t_test_task_trigger where available = 1 and trigger_name = 'cronTrigger'";
        return emsService.getCron(sql);
    }
}

3、Quartz在Spring中动态设置cronTrigger方法二

在2中我们已经能够实现动态配置cronException，但是我们依然需要设定一个默认的cronException：

Java代码  

1. <property name="cronExpression">


2.               <value>0/10 * * * * ?</value>


3.           </property>

<property name="cronExpression">
              <value>0/10 * * * * ?</value>
          </property>

如果我们拿掉它，则容器（如Jboss）会报错。

实际上我们希望容器启动时就去数据库获得dbCronException,而不需要再初始化一个cronException。观察CronTriggerBean，需要初始化cronException，我们可以创建类InitCronTrigger继承CronTriggerBean，从DB中获得数据初始化cronException，这样问题就解决了。

（1）、Spring配置文件quartz.xml：

Java代码  

1. <?xml version="1.0" encoding="UTF-8"?>


2.         <!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd">


3. <beans>




5.     <bean id="scheduleInfoAction" class="wym.task.ScheduleInfoAction">


6.         <property name="scheduler" ref="schedulerFactory"/>


7.         <property name="emsService" ref="EmsService"/>


8.      </bean>




10.      <bean id="jobDetail" class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean">


11.          <property name="targetObject" ref="scheduleInfoAction"/>


12.          <property name="targetMethod" value="reScheduleJob"/>


13.          <!-- concurrent设为false，多个job不会并发运行 -->


14.          <property name="concurrent" value="false"/>


15.      </bean>




17.      <bean id="cronTrigger" class="wym.task.InitCronTrigger">


18.           <property name="jobDetail" ref="jobDetail"/>


19.          <!--<property name="cronExpression">-->


20.              <!--<value>0/30 * * * * ?</value>-->


21.          <!--</property>-->


22.           <property name="emsService" ref="EmsService"/>


23.       </bean>




25.      <bean id="schedulerFactory" class="org.springframework.scheduling.quartz.SchedulerFactoryBean">


26.          <property name="triggers">


27.              <list>


28.                  <ref local="cronTrigger"/>


29.              </list>


30.          </property>


31.     </bean>


32. </beans>

（2）、类InitCronTrigger

注意：在注入scheduleInfoManager属性的时候，我们可以去读取DB任务时间（之所以放在setter方法中，是因为需要在设置scheduleInfoManager后进行getCronExpressionFromDB()，否则，也可以①②逻辑把放在类的构造函数中）.

注意InitializingCronTrigger必须extends CronTriggerBean.

Java代码  

1. import com.erry.tntops.ems.service.EmsService;


2. import org.springframework.scheduling.quartz.CronTriggerBean;




4. import java.io.Serializable;


5. import java.text.ParseException;




7. public class InitCronTrigger extends CronTriggerBean implements Serializable {


8.     private EmsService emsService;




10.     public void setEmsService(EmsService emsService) throws ParseException {


11.         this.emsService = emsService;


12.         String cronException = getCronExceptionDB();


13.         setCronExpression(cronException);


14.     }




16.     private String getCronExceptionDB(){


17.         String sql = "select CRON from t_test_task_trigger where available = 1 and trigger_name = 'cronTrigger'";


18.         System.out.println("*****" + sql);


19.         return emsService.getCron(sql);


20.     }


21. }

import com.erry.tntops.ems.service.EmsService;
import org.springframework.scheduling.quartz.CronTriggerBean;

import java.io.Serializable;
import java.text.ParseException;

public class InitCronTrigger extends CronTriggerBean implements Serializable {
    private EmsService emsService;

    public void setEmsService(EmsService emsService) throws ParseException {
        this.emsService = emsService;
        String cronException = getCronExceptionDB();
        setCronExpression(cronException);
    }

    private String getCronExceptionDB(){
        String sql = "select CRON from t_test_task_trigger where available = 1 and trigger_name = 'cronTrigger'";
        System.out.println("*****" + sql);
        return emsService.getCron(sql);
    }
}