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("任务成功运行");
 
    }
}