quartz 基本使用【附带源码】

最近有些需求设计到quartz比较多。回家写几个测试看一看。一共5个文件，有兴趣的可以看看。

其中我把spring-quartz 和原生态的quartz分开做了测试。

先贴上Job类：

 

import java.util.Date;

import org.quartz.Job;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;

/**
 * 原生态方式调用job
 * @author Administrator
 *
 */
public class OrdinaryPrintJob implements Job {

	@Override
	public void execute(JobExecutionContext context)
			throws JobExecutionException {
		System.out.println("ordinary..."+new Date());
	}
}

 spring-quartz方式，job无需时间job接口：

import java.util.Date;

import org.quartz.JobExecutionException;

/**
 * spring方式,无需实现job接口
 * 原因是 
 * MethodInvokingJobDetailFactoryBean 有个内部类MethodInvokingJob 继承了 QuartzJobBean，而QuartzJobBean
 * 实现了Job接口， MethodInvokingJob 通过反射机制去调用这个没有实现job接口的类的targetMethod方法，比较巧妙
 * @author Administrator
 *
 */
public class SpringPrintJob {

	public void execute( )
			throws JobExecutionException {
		System.out.println("spring task.."+new Date());
	}

}

  

下面是实际中测试的类，内含main方法：

/**
 * 测试类
 * @author Administrator
 *
 */
public class ScheduleTest  {

	private static final String cron = "0/3 * * * * ?";
	
	/**
	 * 普通调度quartz
	 */
	public static void ordinaryScheduleTest () {
		OrdinaryTasker ot = new OrdinaryTasker(cron);
		executeProcess(ot);
	}
	
	/**
	 * spring方式quartz
	 */
	public static void springScheduleTest() {
		SpringTasker st = new SpringTasker(cron);
		executeProcess(st);
	}
	
	private static void executeProcess(TestTaskInterface tti) {
		// 打印日志
		tti.run();
		try {
			Thread.sleep(11000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		// 修改cron
		tti.changeTime();
		try {
			Thread.sleep(10000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		// 卸载
		tti.unschedual();
		// 停止调度
		tti.stop();
	}
	
	public static void main(String[] args) {
//		System.out.println("---------------java普通调度开始-------------------");
//		ordinaryScheduleTest(); // 普通调度方法
		System.out.println("---------------spring调度开始-------------------");
		springScheduleTest();     // spring调度方法，基本上不会用java方式调用，高清一下原理
	}
	
	interface TestTaskInterface {
		
		public final String changedCron = "0/5 * * * * ?";
		
		public void run();
		
		public void stop();
		
		public void unschedual() ;
		
		public void changeTime();
	}
	
}

 

使用了两种调度方式，原生态：

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

import org.quartz.CronTrigger;
import org.quartz.JobDetail;
import org.quartz.Scheduler;
import org.quartz.SchedulerException;
import org.quartz.SchedulerFactory;
import org.quartz.impl.StdSchedulerFactory;

import schedualer.ScheduleTest.TestTaskInterface;

public class OrdinaryTasker implements TestTaskInterface {

	private SchedulerFactory schedulerFactory = null;
	private Scheduler scheduler = null;
	private JobDetail jobDetail = null;
	private CronTrigger trigger = null;
	
	public OrdinaryTasker (String cron) {
		schedulerFactory = new StdSchedulerFactory();
		try {
			scheduler = schedulerFactory.getScheduler();
		} catch (SchedulerException e) {
			System.err.println(e);
		}
		assert(scheduler == null);
		jobDetail = new JobDetail();
		jobDetail.setJobClass(OrdinaryPrintJob.class);
		jobDetail.setName(this.getClass().getName()+"_job");
		try {
			trigger = new CronTrigger (this.getClass().getName()+"_trigger",null,cron);
		} catch (ParseException e) {
			System.err.println(e);
		}
		trigger.setStartTime(new Date());
	}
	
	@Override
	public void run() {
		try {
			// 设置调度job
			scheduler.scheduleJob(jobDetail,trigger);
			// 开始调度任务，如果不调用start方法，上面设置的job不会执行
			scheduler.start();
			System.out.println("run start...");
		} catch (SchedulerException e) {
			e.printStackTrace();
		}
	}

	@Override
	public void stop() {
		try {
			scheduler.shutdown();
			System.out.println("stop start...");
		} catch (SchedulerException e) {
			System.err.println(e);
		}
	}

	@Override
	public void unschedual() {
		try {
			scheduler.unscheduleJob(this.trigger.getName(), null);
			System.out.println("unschedual start...");
		} catch (SchedulerException e) {
			System.err.println(e);
		}
	}

	@Override
	public void changeTime() {
		try {
			CronTrigger cronTrigger = (CronTrigger)scheduler.getTrigger(trigger.getName(), null);
			cronTrigger.setCronExpression(TestTaskInterface.changedCron);
			scheduler.resumeTrigger(trigger.getName(), null);
			System.out.println("changeTime start...");
		} catch (SchedulerException e) {
			System.err.println(e);
		} catch (ParseException e) {
			System.err.println(e);
		}
	}
	
}

 

 spring-quartz方式（当然，实际中不可能是这样，我只是用来测试）：

import java.text.ParseException;

import org.quartz.CronExpression;
import org.quartz.CronTrigger;
import org.quartz.JobDetail;
import org.quartz.Scheduler;
import org.quartz.SchedulerException;
import org.quartz.SchedulerFactory;
import org.quartz.Trigger;
import org.quartz.impl.StdSchedulerFactory;
import org.springframework.scheduling.quartz.CronTriggerBean;
import org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean;
import org.springframework.scheduling.quartz.SchedulerFactoryBean;

import schedualer.ScheduleTest.TestTaskInterface;

/**
 * spring方法
 * @author Administrator
 *
 */
public class SpringTasker implements TestTaskInterface {
	
	private SchedulerFactory schedulerFactory = null;
	private Scheduler scheduler = null;
	private JobDetail jobDetail = null;
	private CronTriggerBean trigger = null;
	
	public SpringTasker (String cron) {
		schedulerFactory = new StdSchedulerFactory();
		try {
			scheduler = schedulerFactory.getScheduler();
		} catch (SchedulerException e) {
			System.err.println(e);
		}
		assert(scheduler == null);
		// spring提供的Jobdetail 工厂
		MethodInvokingJobDetailFactoryBean mij = new MethodInvokingJobDetailFactoryBean();
		mij.setTargetObject( new SpringPrintJob());
		mij.setTargetMethod("execute");
		mij.setName(this.getClass().getName()+"_job");
		try {
			mij.afterPropertiesSet();
		} catch (ClassNotFoundException e1) {
			e1.printStackTrace();
		} catch (NoSuchMethodException e1) {
			e1.printStackTrace();
		}
		jobDetail = mij.getObject();
		trigger = new CronTriggerBean ();
		try {
			trigger.setCronExpression(new CronExpression(cron));
		} catch (ParseException e) {
			System.err.println(e);
		}
		trigger.setJobDetail(jobDetail);
		trigger.setName(this.getClass().getName()+"_trigger");
		try {
			trigger.afterPropertiesSet();
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
	
	@Override
	public void run() {
		SchedulerFactoryBean sfb = new SchedulerFactoryBean();
		sfb.setTriggers(new Trigger[]{trigger});
		try {
			sfb.afterPropertiesSet();
		} catch (Exception e1) {
			e1.printStackTrace();
		}
		try {
			scheduler = sfb.getObject();
			assert(scheduler == null);
			//spring的scheduler不需要调用 schedule方法，因为在sfb.afterPropertiesSet(); 中已经注册过，如果再次调用此方法将会出现此job已经存在
			scheduler.start();
			System.out.println("run start...");
		} catch (SchedulerException e) {
			e.printStackTrace();
		}
	}

	@Override
	public void stop() {
		try {
			scheduler.shutdown();
			System.out.println("stop start...");
		} catch (SchedulerException e) {
			System.err.println(e);
		}
	}

	@Override
	public void unschedual() {
		try {
			scheduler.unscheduleJob(this.trigger.getName(), null);
			System.out.println("unschedual start...");
		} catch (SchedulerException e) {
			System.err.println(e);
		}
	}

	@Override
	public void changeTime() {
		try {
			CronTrigger cronTrigger = (CronTrigger)scheduler.getTrigger(trigger.getName(), null);
			cronTrigger.setCronExpression(TestTaskInterface.changedCron);
			//恢复调度
			System.out.println(trigger.getCronExpression());
			// job被pause之后，或者block之后可以恢复
			// 在此期间你可以动态修改时间表达式
			scheduler.resumeJob(trigger.getName(), null);
			// 重新调度一个trigger,和resume有所区别
			//scheduler.rescheduleJob(trigger.getName(), null,cronTrigger);
			System.out.println("changeTime start...");
		} catch (SchedulerException e) {
			System.err.println(e);
		} catch (ParseException e) {
			System.err.println(e);
		}
	}
	
}

 

直接执行 ScheduleTest 类里面的main方法即可看到原生态和spring-quartz的调度结果。

 

maven依赖：

	<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-context</artifactId>
			<version>3.1.1.RELEASE</version>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-context-support</artifactId>
			<version>3.1.1.RELEASE</version>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-tx</artifactId>
			<version>3.1.1.RELEASE</version>
		</dependency>
		<dependency>  
            <groupId>org.springframework</groupId>  
            <artifactId>spring-web</artifactId>  
            <version>3.0.5.RELEASE</version>  
        </dependency> 
		<dependency>
			<groupId>org.quartz-scheduler</groupId>
			<artifactId>quartz</artifactId>
			<version>1.8.5</version>
		</dependency>	

 

有同学跑不通的话给我留言好了。