quartz学习02-job以及jobDetail(1)

介绍一下job的生命周期，每当trigger触发器出发的时候都会创建一个新的job实例，也就是在上一个博客中的HelloJob的实例每执行一次调度就会实例化一次，等实例化完成之后就会被垃圾回收。我们可以这样做一下实验，以验证这个：

public class HelloJob implements Job {
	
	static int i = 0;
	public HelloJob(){
		i++;
	}

	public void execute(JobExecutionContext context) throws JobExecutionException {
		System.out.println("现在的i是： " + i);	
	}
}

然后我们执行定时任务后发现i是会不停的增长的，也就是说每一次执行都是调用了构造方法，创建了新的实例。

 

我们在上一博客中写了将JobDetail的组成是由job的，也就是执行的代码，但是我们传入的是一个.class文件，

JobDetail job = newJob(HelloJob.class).withIdentity("myJob", Scheduler.DEFAULT_GROUP).xxxx

 很容易就会想到，一定是用的反射，也就是newInstance的方法，这个方法要求有一个无参数的构造方法。现在就存在这样的一个问题，如果我要求执行的job的execute方法中含有依赖于其他内容的代码呢，也就是说execute中执行的方法不是定死的，是在运行中产生的，因为采用的是反射，我们无法向job的实现类的的实例通过setter方法或者是构造方法传入值，所以这是一个问题。

 

那么如何解决呢，文档中给了我们答案：使用JobDataMap进行传值。

文档中给出的在创建JobDetail时使用JobDataMap进行传值的代码：

JobDetail job = newJob(DumbJob.class)
      .withIdentity("myJob", "group1") // name "myJob", group "group1"
      .usingJobData("jobSays", "Hello World!")
      .usingJobData("myFloatValue", 3.141f)
      .build();

 我通过实验发现，也可以在创建完jobDetail之后设置，代码如下：

//创建job任务
JobDetail job = newJob(HelloJob.class).withIdentity("myJob", Scheduler.DEFAULT_GROUP).build();
job.getJobDataMap().put("name1", "jobDetail");
job.getJobDataMap().put("name2", "job2");  //使用的方法和map一样。

 在Job的实现类中，我们这里是HelloJob，可以通过传入的参数JobExecutionContext获得JobDetail和Trigger，来自官网的代码：

public void execute(JobExecutionContext context) throws JobExecutionException{
      JobKey key = context.getJobDetail().getKey();

      JobDataMap dataMap = context.getJobDetail().getJobDataMap();

      String jobSays = dataMap.getString("jobSays");
      float myFloatValue = dataMap.getFloat("myFloatValue");

      System.err.println("Instance " + key + " of DumbJob says: " + jobSays + ", and val is: " + myFloatValue);
}

如果我们在Job的实现类中设置了setter方法，那么在执行execute方法之前会先执行那些setter方法，但是执行的方法是和从JobDataMap相关的，之后在JobDataMap中存在的key的属性的setter方法才能执行，我们看官网的例子，他设置了jobSays、myFloatValue这两个属性，那么会执行setJobSays和setMyFloatValue这两个方法（如果这两个方法存在的话），但是不会执行其他setter方法。也就是说通过JobDataMap传入的值可以通过在Job中设置setter属性来传入到通过反射设置的job实例中，然后我们就可以通过在execute方法中调用调用getter方法来获取这些值了，这样就免去了必须从传入的JobExecutionContext中获取值了。

 

不光是是有JobDetail含有JobDataMap，在Trigger中也可以设置，设置的方法和JobDetail一样，我们也可以在JoBExecutionContext中获得设置的值。文档中还提到我们可以通过JobExecutionContext获得一个JobDataMap，这里面的值是合并了JobDetail中的map和Trigger中的map，后者会覆盖前者的值，如果key相同的话。通过这个Map我们就可以获得所有要传入的值了，获得方法：JobDataMap map = context.getMergedJobDataMap()

 

现在有个疑问，传入到execute方法中的参数是复制了一份参数呢，还是就是把原来放入到JobDataMap中参数不复制的传入呢？官网上的文档说的是复制一份，我们做一个实验：

如果不是复制的话，如果我们在execute方法中改变了JobDetail中的map，那么我们在主动调度中也能获得改变后的值，测试下能不能获得。代码如下：

import org.quartz.JobBuilder;
import org.quartz.JobDetail;
import org.quartz.Scheduler;
import org.quartz.SchedulerException;
import org.quartz.SimpleScheduleBuilder;
import org.quartz.Trigger;
import org.quartz.impl.StdScheduler;
import org.quartz.impl.StdSchedulerFactory;
import static    org.quartz.TriggerBuilder.newTrigger;
import job.CheckJobDataMapCopyOrNotJob;
/**
 * 检查传入到job中的参数是不是复制
 * @author wuguohua
 *
 */
public class CheckJobDataMapCopyOrNot {
	
	public static void main(String[] args) throws SchedulerException, InterruptedException {
	    StdSchedulerFactory fac = new StdSchedulerFactory();
	    StdScheduler scheduler = (StdScheduler) fac.getScheduler();
	    scheduler.start();
	    
	    JobDetail jobDetail = JobBuilder.newJob(CheckJobDataMapCopyOrNotJob.class)
	    		.withIdentity("CheckJobDataMapCopyOrNotJobDetail", Scheduler.DEFAULT_GROUP).build();
	    
	    jobDetail.getJobDataMap().put("name", "1");
	    
    Trigger trigger = newTrigger().withIdentity("CheckJobDataMapCopyOrNotTrigger", Scheduler.DEFAULT_GROUP).startNow()
	    		.withSchedule(SimpleScheduleBuilder.repeatSecondlyForTotalCount(100,3)).build();//这个表示每3秒执行一次，一共执行100次。
	    trigger.getJobDataMap().put("age", 1);
	    scheduler.scheduleJob(jobDetail, trigger);
	    
	    for(;true;){
	    	System.out.println("xxxxx        " + jobDetail.getJobDataMap().get("name") + "      " + trigger.getJobDataMap().get("age"));
	    	Thread.sleep(1000*2);
	    }
	      		
	}
}

 Job的代码：

import org.quartz.Job;
import org.quartz.JobDataMap;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
public class CheckJobDataMapCopyOrNotJob implements Job {
	public void execute(JobExecutionContext context) throws JobExecutionException {
		JobDataMap map1 = context.getJobDetail().getJobDataMap();
		JobDataMap map2 = context.getTrigger().getJobDataMap();
  		System.out.println("yyyy         "  + map1.get("name") + "    " +  map2.get("age"));
		 map1.put("name", "2");
		 map2.put("age",2);
	}
}

我们在job中改变了name和age的值，如果不是复制的话，在xxxx开头的打印中也会出现2才对。

结果如下：

 

xxxxx        1      1
yyyy         1    1
xxxxx        1      1
yyyy         1    1
xxxxx        1      1
yyyy         1    1
xxxxx        1      1
xxxxx        1      1
yyyy         1    1
xxxxx        1      1
.......

 结果显示无论是xxxx还是yyyy都是打印的1，证明真的是将参数也复制了一份。

我证明这个原因是文档中提到了可以通过某个方法来实现在执行execute之后将改变的值回传给JobDetail中的JobDataMap，方法是在Job的实现类上加上这个注解：

@PersistJobDataAfterExecution，我在CcheckJobDataCopyOrNotJob加上之后，做的测试结果如下：

xxxxx        1      1
yyyy         1    1
xxxxx        1      1
yyyy         2    1
xxxxx        1      1
yyyy         2    1
xxxxx        1      1
xxxxx        1      1
yyyy         2    1
xxxxx        1      1
yyyy         2    1
xxxxx        1      1
xxxxx        1      1

 结果证明了JobDetail中的map的确是被更新了，但是Trigger中的map并没有更新，文档中并没有提及Trigger也会被更新。

文档中还提及了一个概念，如果一个job的执行时间大于调度周期怎么办？也就是说如果完成一次调度需要2秒，而调度周期只有1秒，怎么办。quartz提供了可以配置的方案，也就是可以并发，也可以防止并发。默认情况下是可以并发的，可以通过在Job的实现类上加 @DisallowConcurrentExecution来实现。

我得测试代码如下：  调度类：

import static org.quartz.JobBuilder.newJob;
import static org.quartz.TriggerBuilder.newTrigger;
import org.quartz.JobDetail;
import org.quartz.Scheduler;
import org.quartz.SchedulerException;
import org.quartz.SimpleScheduleBuilder;
import org.quartz.Trigger;
import org.quartz.impl.StdScheduler;
import org.quartz.impl.StdSchedulerFactory;

import job.HelloJob;

public class Demo1 {
	public static void main(String[] args) throws InterruptedException {
		try {
			 StdSchedulerFactory schedFact = new org.quartz.impl.StdSchedulerFactory();
 			StdScheduler sched = (StdScheduler) schedFact.getScheduler();
 			 //开始调度器
			 sched.start();
			//创建job任务
			JobDetail job = newJob(HelloJob.class).withIdentity("myJob", Scheduler.DEFAULT_GROUP).build();
			//创建trigger，触发器
			 Trigger trigger = newTrigger().withIdentity("myTrigger",Scheduler.DEFAULT_GROUP).startNow()
					           .withSchedule(SimpleScheduleBuilder.repeatSecondlyForTotalCount(100,3)).build();//3秒调度一次
 			//将任务和触发器绑定到调度器
			 sched.scheduleJob(job, trigger);
 			Thread.sleep(1000000);
 			sched.shutdown();
		 } catch (SchedulerException se) {
			 se.printStackTrace();
		}
	}
}

 工作类的execute方法：

public void execute(JobExecutionContext context) throws JobExecutionException {
	System.out.println("helloJob     begin");
	try {
		Thread.sleep(5*1000);            //睡眠五秒
	} catch (InterruptedException e) {
		// TODO Auto-generated catch block
		e.printStackTrace();
	}
	System.out.println("helloJob    end");
}

如果可以并发执行的话，那么一开始会出现两个"helloJob    begin"，因为5秒之后才会输出"helloJob     end"。我们不加@DisallowConcurrentExecution时的结果如下：

 

helloJob     begin
helloJob     begin
helloJob    end
helloJob     begin
helloJob    end
helloJob     begin
helloJob    end
helloJob     begin
..... 

加了之后的结果是：

helloJob     begin
helloJob    end
helloJob     begin
helloJob    end
helloJob     begin
helloJob    end
helloJob     begin

 并且执行的速度要慢得多。这里也验证了官网的文档。

 

官网还推荐，这两个一定要配合使用，当使用@persistJobDataAfterExecution时，一定要使用@DisallowConcurrentExecution，因为要修改JobDetail中的map，如果不加同步限制的话会造成对JobDetail的map的并发修改。