Spring 4.2.5 + Quartz 2.2.0整合

jar包使用的Maven庫管理的，在這就不羅列了，注意下只有spring3.x以上的版本才支持quartz2.x的版本。

配置文件：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context"
   xmlns:aop="http://www.springframework.org/schema/aop" xmlns:util="http://www.springframework.org/schema/util"
   xmlns:tx="http://www.springframework.org/schema/tx" xmlns:task="http://www.springframework.org/schema/task"
   xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
   http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.0.xsd
   http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.0.xsd
   http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd
   http://www.springframework.org/schema/task http://www.springframework.org/schema/task/spring-task-4.0.xsd
   http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-3.0.xsd"
   default-autowire="byName" default-lazy-init="false">


   <!-- 定時任務配置 scheduler 方式 注解 暫時不支持動態更新 -->
   <context:component-scan base-package="org.core.timer" />
   <task:executor id="executor" pool-size="5" />
   <task:scheduler id="scheduler" pool-size="10" />
   
   <bean id="taskJob" class="orgcore.timer.Job"/>
   <bean id="jobDetail" class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean">
      <property name="group" value="job_work"/>
      <property name="name" value="job_work_name"/>
      <!--false表示等上一個任務執行完后再開啟新的任務-->
      <property name="concurrent" value="false"/>
      <property name="targetObject">
         <ref bean="taskJob"/>
      </property>
      <property name="targetMethod">
         <value>oneOClockPerDay</value>
      </property>
   </bean>

   <!--  調度觸發器 -->
   <bean id="taskDemoServiceTaskCronTrigger"
        class="org.springframework.scheduling.quartz.CronTriggerFactoryBean">
      <property name="name" value="taskDemoServiceTaskCronTrigger"/>
      <property name="group" value="DEFAULT"/>
      <property name="jobDetail">
         <ref bean="jobDetail" />
      </property>
      <property name="cronExpression" value="0/5 * * * * ?"/>

   </bean>
   <!-- 定時任務調度器 -->
   <bean id="schedulerFactory" lazy-init="false" autowire="no"
      class="org.springframework.schedling.quartz.SchedulerFactoryBean">
      <property name="triggers">
         <list>
            <!--<ref bean="taskDemoServiceTaskCronTrigger"></ref>-->
         </list>
      </property>
   </bean>

</beans>

由於本人是新手，更深的層次我也不懂，就簡單羅列下我理解的東西，各位看官請多指教！
在這個配置文件中，這是實現了一個簡單的任務，

taskJob：我自己定義的一個job類，沒有實現Quartz的job接口，使用配置文件的方式實現。

jobDetail：用上面定義好的taskJob來填充jobDetail，

<property name="targetObject">
         <ref bean="taskJob"/>
      </property>
      <property name="targetMethod">
         <value>oneOClockPerDay</value>
      </property>
使用這種方式把自定義job類綁定，觸發時執行類里的oneOClockPerDay方法

public class Job {

    public void oneOClockPerDay(){
        org.jeecgframework.core.util.LogUtil.info("1h");
        System.out.println("===============asda========================");
    }
       
}

taskDemoServiceTaskCronTrigger：自定義的CronTrigge觸發器，綁定好上變設定好的設置好的jobDetail，設置好觸發時間。

schedulerFactory：scheduler工廠，lazy-init="false" autowire="no"這兩個設置可以在tomcat啟動時觸發定時任務。<ref bean="taskDemoServiceTaskCronTrigger">在這里設置好配置好的觸發器
啟動就能實現簡單的定時任務。

上邊所說的是在配置文件配置好的定時任務，接下來我們實現動態的定時任務。（PS：我覺得配置文件只需要加上schedulerFactory的配置就可以了）
廢話不多說，直接粘代碼（我也說不明白..... 哈哈哈哈）

創建/更新任務:

    public void creatJob(String triggerName,String groupName,String cronExpression ) {
      
        JobDetail jobDetail=null;
        CronTrigger trigger=null;
        TriggerKey triggerKey = new TriggerKey(triggerName,groupName);
        CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(cronExpression );
       
        try {
            
            trigger= (CronTrigger) schedulerFactory.getTrigger(triggerKey);
            //判斷觸發器是否存在，存在更新，不存在創建
            if(trigger!=null){
                trigger=trigger.getTriggerBuilder().withIdentity(triggerKey)
                        .withSchedule(scheduleBuilder).build();
                //按照新的參數重新構建任務
                schedulerFactory.rescheduleJob(triggerKey,trigger);
              
            }else {
                //QuartzJobFactory 這是自定義的job類 繼承job接口 這就是不同於在配置文件中配置job類的另一種方法
                 jobDetail = JobBuilder.newJob(QuartzJobFactory.class).withIdentity(triggerName, groupName).build();
                 trigger = TriggerBuilder.newTrigger().
                        withIdentity(triggerKey).withSchedule(scheduleBuilder).build();
               //創建任務，配置文件schedulerFactory已經配置為tomcat啟動后自啟動，就不需要schedule.strat()啟動了
                schedulerFactory.scheduleJob(jobDetail,trigger);
               
            }

        } catch (Exception e) {
            
        }

   
    }

暫停/開始觸發器：

public boolean startOrStop(String triggerName,
                                  boolean start) {
        TriggerKey triggerKey = TriggerKey.triggerKey(triggerName, Scheduler.DEFAULT_GROUP);
        //獲取trigger，即在spring配置文件中定義的 bean id="myTrigger"
        try {
            if (start) {
                schedulerFactory.resumeTrigger(triggerKey);
                return true;
            } else {
                schedulerFactory.pauseTrigger(triggerKey);
                return true;
            }
        } catch (SchedulerException e) {
            e.printStackTrace();
            return false;
        }

    }

刪除任務：

public voiddel(String triggerName,String groupName) throws SchedulerException {
     
        TriggerKey triggerKey=new TriggerKey(triggerName,groupName);
        schedulerFactory.pauseTrigger(triggerKey);//停止觸發器
        schedulerFactory.unscheduleJob(triggerKey);//移除觸發器
        schedulerFactory.deleteJob(JobKey.
                        jobKey(triggerName,groupName);//刪除任務 
 }

 自定義的QuartzJobFactory類

public class QuartzJobFactory implements org.quartz.Job {

    @Override
    public void execute(JobExecutionContext context) throws JobExecutionException {
        System.out.println("任務成功運行");

    }
}