java quartz 定时需要的包

一、java quartz 定时需要的包

实现定时任务需要quartz-1.5.1.jar和commons-logging-1.1.jar。

该类主要进行定时任务时间的设置和设置对应的定时任务类。

import org.quartz.CronTrigger;

import org.quartz.impl.StdSchedulerFactory;

public static void cleanUpJob(){

JobDetail jobDetail= new JobDetail();

jobDetail.setName("cleanup");

jobDetail.setJobClass(PrintJob.class);

CronTrigger trigger= new CronTrigger();

trigger.setName("cleanupTrigger");

trigger.setJobName("cleanup");

trigger.setCronExpression("0/5****?");

Scheduler sch= StdSchedulerFactory.getDefaultScheduler();

sch.scheduleJob(jobDetail, trigger);

public static void modifyJobTime(String triggerName, String time){

System.out.println("modify~~~~~~~~~~~~~~~~");

Scheduler sched= StdSchedulerFactory.getDefaultScheduler();

System.out.println("triggerName"+ triggerName);

CronTrigger trigger=(CronTrigger) sched.getTrigger(triggerName, Scheduler.DEFAULT_GROUP);

String oldTime= trigger.getCronExpression();

System.out.println("oldTime"+ oldTime);

if(!oldTime.equalsIgnoreCase(time)){

System.out.println("time"+ time);

trigger.setCronExpression(time);

throw new RuntimeException(e);

public static void main(String[] args){

modifyJobTime("cleanupTrigger","0/2****?");

该类主要定义定时任务执行的内容。

import java.text.SimpleDateFormat;

import org.quartz.JobExecutionContext;

import org.quartz.JobExecutionException;

public class PrintJob implements Job{

public void execute(JobExecutionContext arg0) throws JobExecutionException{

SimpleDateFormat sdf= new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS");

String time= sdf.format(new Date());

System.out.println("print job"+ time);

print job2014-12-03 17:06:40.031

print job2014-12-03 17:06:42.015

print job2014-12-03 17:06:44.016

print job2014-12-03 17:06:46.019

print job2014-12-03 17:06:48.019

print job2014-12-03 17:06:50.020

从输出的结果中可以看到，原本的定时任务为每5秒执行一次，但是由于后面对定时任务表达式做了修改，所以后来安照修改后的每2秒执行一次。

二、scheduler start后能再调用schedulejob吗

要使用Quartz，必须要引入以下这几个包：

这些包都在下载的Quartz包里面包含着，因此没有必要为寻找这几个包而头疼。

第二步：创建要被定执行的任务类

这一步也很简单，只需要创建一个实现了org.quartz.Job接口的类，并实现这个接口的唯一一个方法execute(JobExecutionContext arg0) throws JobExecutionException即可。如：

import java.text.SimpleDateFormat;

import org.quartz.JobExecutionContext;

import org.quartz.JobExecutionException;

public class myJob implements Job{

public void execute(JobExecutionContext arg0) throws JobExecutionException{

SimpleDateFormat sdf= new SimpleDateFormat("yyyy-MM-dd HH:mm:ss SSS");

System.out.println(sdf.format(new Date()));

import java.text.SimpleDateFormat;

import org.quartz.JobExecutionContext;

import org.quartz.JobExecutionException;

public class myJob implements Job{

public void execute(JobExecutionContext arg0) throws JobExecutionException{

SimpleDateFormat sdf= new SimpleDateFormat("yyyy-MM-dd HH:mm:ss SSS");

System.out.println(sdf.format(new Date()));

这个例子很简单，就不用解说了。

这一步应该算是最难的一步的，但其实是非常简单的，直接上代码

import static org.quartz.CronScheduleBuilder.cronSchedule;

import static org.quartz.JobBuilder.newJob;

import static org.quartz.TriggerBuilder.newTrigger;

import java.text.SimpleDateFormat;

import org.quartz.CronTrigger;

import org.quartz.SchedulerFactory;

import org.quartz.impl.StdSchedulerFactory;

public void go() throws Exception{

//首先，必需要取得一个Scheduler的引用

SchedulerFactory sf= new StdSchedulerFactory();

Scheduler sched= sf.getScheduler();

//jobs可以在scheduled的sched.start()方法前被调用

JobDetail job= newJob(myJob.class).withIdentity("job1","group1").build();

CronTrigger trigger= newTrigger().withIdentity("trigger1","group1").withSchedule(cronSchedule("0/20****?")).build();

Date ft= sched.scheduleJob(job, trigger);

SimpleDateFormat sdf= new SimpleDateFormat("yyyy-MM-dd HH:mm:ss SSS");

System.out.println(job.getKey()+"已被安排执行于:"+ sdf.format(ft)+"，并且以如下重复规则重复执行:"+ trigger.getCronExpression());

// job 2将每2分钟执行一次（在该分钟的第15秒)

job= newJob(myJob.class).withIdentity("job2","group1").build();

trigger= newTrigger().withIdentity("trigger2","group1").withSchedule(cronSchedule("15 0/2***?")).build();

ft= sched.scheduleJob(job, trigger);

System.out.println(job.getKey()+"已被安排执行于:"+ sdf.format(ft)+"，并且以如下重复规则重复执行:"+ trigger.getCronExpression());

//开始执行，start()方法被调用后，计时器就开始工作，计时调度中允许放入N个Job

//关闭定时调度，定时器不再工作

public static void main(String[] args) throws Exception{

三、java active

java active是什么，让我们一起了解一下？

在java中，Active Object模式是一种异步编程模式。它通过对方法的调用与方法的执行进行解耦来提高并发性。它的核心是允许任务的提交（相当于对异步方法的调用）和任务的执行（相当于异步方法的真正执行）分离。

首先从调用方代码来看，调用一个Active Object对象的方法与调用普通Java对象的方法并无太大差别。

1 ActiveObject ao=...; 2 Future future = ao.doSomething("data"); 3 //执行其它操作 4 String result = future.get(); 5 System.out.println(result);

那么Active Object模式的架构是什么，有什么作用？

1、当Active Object模式对外暴露的异步方法被调用时，与该方法调用相关的上下文信息，包括被调用的异步方法名（或其代表的操作）、调用方代码所传递的参数等，会被封装成一个对象。

该对象被称为方法请求（Method Request）。方法请求对象会被存入Active Object模式所维护的缓冲区（Activation Queue）中，并由专门的工作线程负责根据其包含的上下文信息执行相应的操作。

也就是说，方法请求对象是由运行调用方代码的线程通过调用Active Object模式对外暴露的异步方法生成的，而方法请求所代表的操作则由专门的线程来执行，从而实现了方法的调用与执行的分离，产生了并发。

2、Active Object模式的主要参与者有以下几种。

Proxy：负责对外暴露异步方法接口。当调用方代码调用该参与者实例的异步方法doSomething时，该方法会生成一个相应的MethodRequest实例并将其存储到Scheduler所维护的缓冲区中。doSomething方法的返回值是一个表示其执行结果的外包装对象：Future参与者的实例。异步方法doSomething运行在调用方代码所在的线程中。

MethodRequest：负责将调用方代码对Proxy实例的异步方法的调用封装为一个对象。该对象保留了异步方法的名称及调用方代码传递的参数等上下文信息。它使得将Proxy的异步方法的调用和执行分离成为可能。其call方法会根据其所包含上下文信息调用Servant实例的相应方法。

ActivationQueue：负责临时存储由Proxy的异步方法被调用时所创建的MethodRequest实例的缓冲区。

Scheduler：负责将Proxy的异步方法所创建的MethodRequest实例存入其维护的缓冲区中。并根据一定的调度策略，对其维护的缓冲区中的MethodRequest实例进行执行。其调度策略可以根据实际需要来定，如FIFO、LIFO和根据MethodRequest中包含的信息所定的优先级等。

Servant：负责对Proxy所暴露的异步方法的具体实现。

Future：负责存储和返回Active Object异步方法的执行结果。