Quartz 动态控制job

最新推荐文章于 2024-04-17 06:32:27 发布

原创最新推荐文章于 2024-04-17 06:32:27 发布 · 5.5k 阅读

1 ·

CC 4.0 BY-SA版权

spring 专栏收录该内容

21 篇文章

订阅专栏

本文介绍了一个使用Spring框架和Quartz实现的任务调度系统。该系统通过配置文件定义了任务及其触发器，并利用自定义初始化类实现任务的动态加载。此外，还提供了一个控制器类用于动态修改任务的时间表达式。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

Scheduler 初始化：

package com.sf.module.waybill;

import java.util.List;

import org.quartz.Scheduler;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor;
import org.springframework.scheduling.quartz.CronTriggerBean;
import org.springframework.scheduling.quartz.SchedulerFactoryBean;

import com.sf.module.intfLog.biz.IBjTaskSchedulingBiz;
import com.sf.module.intfLog.domain.BjTaskScheduling;


public class TaskTriggerInit implements BeanPostProcessor{
	private IBjTaskSchedulingBiz bjTaskSchedulingBiz;
	@Override
	public Object postProcessAfterInitialization(Object arg0, String arg1)
			throws BeansException {
		if(arg1.equals("schedulerFactory"))
		{
			if(arg0 instanceof SchedulerFactoryBean){
				Scheduler scheduler = ((SchedulerFactoryBean)arg0).getScheduler();
				CronTriggerBean trigger;
				try {
					BjTaskScheduling bjTaskScheduling = new BjTaskScheduling();
					List<BjTaskScheduling> jobs = bjTaskSchedulingBiz.findBjTaskSchedulings(bjTaskScheduling);
					for(BjTaskScheduling job : jobs)
					{
						if("1".equals(job.getActive())){
							trigger = (CronTriggerBean)scheduler.getTrigger(job.getTaskName(), Scheduler.DEFAULT_GROUP);
							trigger.setCronExpression(job.getTimer());
							scheduler.rescheduleJob(job.getTaskName(), Scheduler.DEFAULT_GROUP, trigger);
						}else{
							trigger = (CronTriggerBean)scheduler.getTrigger(job.getTaskName(), Scheduler.DEFAULT_GROUP);
							scheduler.interrupt(trigger.getJobName(), Scheduler.DEFAULT_GROUP);
							scheduler.unscheduleJob(job.getTaskName(), Scheduler.DEFAULT_GROUP);
						}
					}
					
				} catch (Exception e) {
					e.printStackTrace();
				}
			}
		}
		return arg0;
	}

	@Override
	public Object postProcessBeforeInitialization(Object arg0, String arg1)
			throws BeansException {
		return arg0;
	}

	public IBjTaskSchedulingBiz getBjTaskSchedulingBiz() {
		return bjTaskSchedulingBiz;
	}

	public void setBjTaskSchedulingBiz(IBjTaskSchedulingBiz bjTaskSchedulingBiz) {
		this.bjTaskSchedulingBiz = bjTaskSchedulingBiz;
	}
}

动态改变Job时间

package com.sf.module.intfLog.biz;


import java.util.List;

import org.quartz.Scheduler;
import org.quartz.SchedulerException;
import org.quartz.Trigger;
import org.quartz.impl.StdScheduler;
import org.springframework.beans.BeansException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.scheduling.quartz.CronTriggerBean;

import com.sf.module.intfLog.domain.BjTaskScheduling;

public class SchedulerController implements ApplicationContextAware
{
	private IBjTaskSchedulingBiz bjTaskSchedulingBiz;
	private StdScheduler scheduler;
	private ApplicationContext context;
	
	/**
	 * @param triggerName
	 * @param cronExper
	 * @throws Exception
	 */
	public void changeTrigger(String triggerName, String cronExper) throws Exception
	{
		CronTriggerBean trigger = (CronTriggerBean)scheduler.getTrigger(triggerName, Scheduler.DEFAULT_GROUP);
		trigger.setCronExpression(cronExper);
		scheduler.rescheduleJob(triggerName, Scheduler.DEFAULT_GROUP, trigger);
	}
	
	public void pauseJob(String triggerName) throws Exception{
		Trigger trigger = scheduler.getTrigger(triggerName, Scheduler.DEFAULT_GROUP);
		scheduler.pauseJob(trigger.getJobName(), Scheduler.DEFAULT_GROUP);
		scheduler.pauseTrigger(triggerName, Scheduler.DEFAULT_GROUP);
	}
	
	public void resumeJob(String triggerName) throws SchedulerException{
		Trigger trigger = scheduler.getTrigger(triggerName, Scheduler.DEFAULT_GROUP);
		scheduler.resumeJob(trigger.getJobName(), Scheduler.DEFAULT_GROUP);
		scheduler.resumeTrigger(triggerName, Scheduler.DEFAULT_GROUP);
	}
	
	public  void interruptJob(String triggerName)
			throws SchedulerException{
		Trigger trigger = scheduler.getTrigger(triggerName, Scheduler.DEFAULT_GROUP);
		scheduler.interrupt(trigger.getJobName(), Scheduler.DEFAULT_GROUP);
		scheduler.unscheduleJob(triggerName, Scheduler.DEFAULT_GROUP);
	}

	public void restartJob(String triggerName) throws Exception {
		CronTriggerBean trigger = (CronTriggerBean)context.getBean(triggerName);
		BjTaskScheduling bjTaskScheduling = new BjTaskScheduling();
		bjTaskScheduling.setTaskName(triggerName);
 		List<BjTaskScheduling> dbbjTaskScheduling = bjTaskSchedulingBiz.findBjTaskSchedulings(bjTaskScheduling);
		if(dbbjTaskScheduling != null && !dbbjTaskScheduling.isEmpty())
		{
			trigger.setCronExpression(dbbjTaskScheduling.get(0).getTimer());
			scheduler.scheduleJob(trigger);
			scheduler.start();
		}
	}

	public StdScheduler getScheduler() {
		return scheduler;
	}

	public void setScheduler(StdScheduler scheduler) {
		this.scheduler = scheduler;
	}

	public IBjTaskSchedulingBiz getBjTaskSchedulingBiz() {
		return bjTaskSchedulingBiz;
	}

	public void setBjTaskSchedulingBiz(IBjTaskSchedulingBiz bjTaskSchedulingBiz) {
		this.bjTaskSchedulingBiz = bjTaskSchedulingBiz;
	}

	@Override
	public void setApplicationContext(ApplicationContext context)
			throws BeansException {
		this.context = context;
	}
	
}

配置任务

     <bean id="taskService" class="com.sf.module.waybill.biz.WayBillAccumulateService">
     </bean>
     
     <bean id="taskTrigger"  class="org.springframework.scheduling.quartz.CronTriggerBean">
        <property name="jobDetail">
            <bean id="taskJob" class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean">
	            <property name="targetObject" ref="taskService"/>
	            <property name="targetMethod" value="start"/>
	            <property name="concurrent" value="false" />
            </bean>
       </property>
        <property name="cronExpression" value="0 0 12 * 1987 ?"/> 
    </bean>
   
   <bean id="schedulerFactory" lazy-init="false" class="org.springframework.scheduling.quartz.SchedulerFactoryBean">
	  <property name="triggers">
		<list>
		  <ref local="taskTrigger" />
		</list>
	  </property>
   </bean>
	<bean class="com.sf.module.waybill.TaskTriggerInit" lazy-init="false">
		<property name="bjTaskSchedulingBiz" ref="bjTaskSchedulingInitBiz"/>
	</bean>
	<bean id="schedulerController" class="com.sf.module.intfLog.biz.SchedulerController">
    	<property name="scheduler" ref="schedulerFactory"/>
    	<property name="bjTaskSchedulingBiz" ref="bjTaskSchedulingBiz"/>
    </bean>

jobDetail

package com.sf.module.waybill.biz;

import org.quartz.InterruptableJob;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.quartz.UnableToInterruptJobException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class WayBillAccumulateService implements InterruptableJob {
	
	 private static Logger logger = LoggerFactory.getLogger(WayBillAccumulateService.class);
	 private boolean _interrupted = false;  
	public void start(){

		System.out.println("开始~~~~~~~~~~~~~~~~~~~~~~~~~~~~~");
        if(_interrupted) {  //中止正在运行的线程
		     return;   
		 }  
	}

	@Override
	public void execute(JobExecutionContext arg0) throws JobExecutionException {
		// TODO Auto-generated method stub
		
	}

	@Override
	public void interrupt() throws UnableToInterruptJobException {
		_interrupted = true;  
	}
}