spring quartz 实现全局任务

spring quartz 实现全局任务  

  |字号 订阅

最近公司要在项目里加入 定时任务服务模块 

采用spring quartz 

首先一部分任务需要初始化加入  一部分任务需要动态就如 首先配置applicationContext.xml

<初始化任务类>

<bean id="MyTask" class="com.wooboo.service.SpringQuartz.MyTask"></bean>

  <!-- 定义调用对象和调用对象的方法 -->

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

<!-- 调用的类 -->

<property name="targetObject">

<ref bean="MyTask" />

</property>

<!-- 调用类中的方法 -->

<property name="targetMethod">

<value>Global</value>

</property>

</bean>

    <!-- 触发器 -->

<bean id="simpleTrigger" class="org.springframework.scheduling.quartz.SimpleTriggerFactoryBean">

        <property name="jobDetail" ref="jobtask" />

     <!--间隔多久执行一次 -->

        <property name="repeatInterval" value="86400000" />

     <!--延迟 -->

        <property name="startDelay" value="3000" />

    </bean>

<!--dubbo RPC-->>

<dubbo:reference id="promotionService" interface="com.wooboo.service.promotion.service.PromotionService" timeout="5000"/>

 <!-- 总管理类 如果将lazy-init='false'那么容器启动就会执行调度程序  -->

        <bean id="scheduler" lazy-init="false" autowire="no" class="org.springframework.scheduling.quartz.SchedulerFactoryBean">

            <property name="triggers">

                <list>

                    <ref bean="simpleTrigger"/>

                </list>

            </property>

        </bean>

首先来看一下初始化任务类 MyTask

package com.wooboo.service.SpringQuartz;

import java.util.Iterator;

import org.quartz.CronScheduleBuilder;

import org.quartz.CronTrigger;

import org.quartz.Scheduler;

import org.quartz.TriggerBuilder;

import org.quartz.TriggerKey;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.context.support.ClassPathXmlApplicationContext;

import org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean;

public class  InitTask  { 

static ClassPathXmlApplicationContext context=null;

     //调度器的注入

 @Autowired

 Scheduler scheduler;

//接口类名称 这里我们实现用spring管理bean (由于项目实现对RPC的调用 所以采用dubbo 接口注入)

static String [] interfacename=new String[]{"promotionService"};

       //接口类方法

static String [] methodname=new String[]{"initSeckillData"};

       //时间表达式

static String [] CronExpression=new String[]{"0 0 24 * * ?"}; 

//将任务加入到jobMap(jobmap 类 具体看下面 接触此容器 可以实现页面控制任务的开关)

 static {

 for(int i=0;i<interfacename.length;i++){

 ScheduleJob job = new ScheduleJob();

job.setJobId(interfacename[i]+"-"+methodname[i]);

job.setJobName(interfacename[i]+"-"+methodname[i]);

job.setJobGroup(StaticUtil.jobprefix);

job.setJobStatus("1");

job.setCronExpression(CronExpression[i]);

job.setDesc("shop定时任务");

try {

addJob(job);

} catch (Exception e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

 }

 }

/**

 * 添加任务

 * @param scheduleJob

 */

public static void addJob(ScheduleJob scheduleJob)throws Exception {

StaticUtil.jobMap.put(scheduleJob.getJobGroup() + "-" + scheduleJob.getJobName(), scheduleJob);

}

public void  Global( ) throws Exception {

               if(StaticUtil.jobMap.size()>0){

for(String key : StaticUtil.jobMap.keySet()){

ScheduleJob job=StaticUtil.jobMap.get(key);

 

TriggerKey triggerKey = TriggerKey.triggerKey(job.getJobName(), job.getJobGroup());

 

//获取trigger，即在spring配置文件中定义的 bean id="myTrigger"

CronTrigger trigger = (CronTrigger) scheduler.getTrigger(triggerKey);

System.err.println(triggerKey);

 

 String[] keys=key.split("-");

//不存在，创建一个

if (null == trigger) {

Object object =  context.getBean(keys[1]);

                              //具体job

MethodInvokingJobDetailFactoryBean jobDetail = new MethodInvokingJobDetailFactoryBean();

             jobDetail.setTargetObject(object);

             jobDetail.setTargetMethod(keys[2]);

             jobDetail.setName(keys[1]+"-"+keys[2]);

             jobDetail.setConcurrent(false);

             jobDetail.setGroup(StaticUtil.jobprefix);

             jobDetail.afterPropertiesSet();

             

//表达式调度构建器

CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(job.getCronExpression());

 

//按新的cronExpression表达式构建一个新的trigger

trigger = TriggerBuilder.newTrigger().withIdentity(job.getJobName(), job.getJobGroup()).withSchedule(scheduleBuilder).build();

scheduler.scheduleJob(jobDetail.getObject(),trigger);

ShopQuartzimpl.updateQuartzState(keys[1], keys[2], "1");

} else {

// Trigger已存在，那么更新相应的定时设置

//表达式调度构建器

CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(job.getCronExpression());

 

//按新的cronExpression表达式重新构建trigger

trigger = trigger.getTriggerBuilder().withIdentity(triggerKey).withSchedule(scheduleBuilder).build();

//按新的trigger重新设置job执行

scheduler.rescheduleJob(triggerKey, trigger);

ShopQuartzimpl.updateQuartzState(keys[1], keys[2], "1");

}

}

       }

    }  

       //方法测试

public static void main(String[] args) {

context= new ClassPathXmlApplicationContext( new String[] { "META-INF/spring/applicationContext.xml" });

context.start();

}

package com.wooboo.service.SpringQuartz;

public class ScheduleJob {

/** 任务id */

    private String jobId;

 

    /** 任务名称 */

    private String jobName;

 

    /** 任务分组 */

    private String jobGroup;

 

    /** 任务状态  1启用  2暂停  3删除*/

    private String jobStatus;

 

    /** 任务运行时间表达式 */

    private String cronExpression;

 

    /** 任务描述 */

    private String desc;

public String getJobId() {

return jobId;

}

public void setJobId(String jobId) {

this.jobId = jobId;

}

public String getJobName() {

return jobName;

}

public void setJobName(String jobName) {

this.jobName = jobName;

}

public String getJobGroup() {

return jobGroup;

}

public void setJobGroup(String jobGroup) {

this.jobGroup = jobGroup;

}

public String getJobStatus() {

return jobStatus;

}

public void setJobStatus(String jobStatus) {

this.jobStatus = jobStatus;

}

public String getCronExpression() {

return cronExpression;

}

public void setCronExpression(String cronExpression) {

this.cronExpression = cronExpression;

}

public String getDesc() {

return desc;

}

public void setDesc(String desc) {

this.desc = desc;

}

}