quartz 不同时间间隔调度任务

Quartz

---

　　Quartz是OpenSymphony开源组织在Job scheduling领域又一个开源项目，它可以与J2EE与J2SE应用程序相结合也可以单独使用。Quartz可以用来创建简单或为运行十个，百个，甚至是好几万个Jobs这样复杂的程序。Jobs可以做成标准的Java组件或 EJBs。Quartz的最新版本为Quartz 2.3.0。

　　目的：最近在想弄一下不同的时间段调度任务，不是以往那样在相同的间隔调度，而是不同的间隔时间，参考了一下Quartz官网和一些前辈的，加上自己总结的改进的方法  

　　参考文章：Quartz使用总结

　　Quartz的API： http://www.quartz-scheduler.org/api/2.1.7/index.html

　　jar下载地址：http://www.quartz-scheduler.org/downloads/

　　Maven：

<dependency>
    <groupId>org.quartz-scheduler</groupId>
    <artifactId>quartz</artifactId>
    <version>2.2.1</version>
  </dependency>
  <dependency>
    <groupId>org.quartz-scheduler</groupId>
    <artifactId>quartz-jobs</artifactId>
    <version>2.2.1</version>
  </dependency>  

　　主要思想：将你要想要调度的时间隔间传入，但是是使用一个实列　

代码：

package com.test.util;
import org.quartz.*;
import org.quartz.impl.StdSchedulerFactory;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import static org.quartz.JobBuilder.newJob;
import static org.quartz.TriggerBuilder.newTrigger;

/**
 * @author zhouguanglin
 * @date 2018/1/6 11:17
 */
public class QuartzTest{
    private  static volatile  Scheduler scheduler=null;
    private static List<Integer> list=new ArrayList<Integer>();
    static {
        list.add(5);
        list.add(10);
        list.add(5);
        list.add(10);
    }
    //单列模式创建scheduler
    public static Scheduler getScheduler(){
        if (scheduler==null) {
            synchronized (QuartzTest.class) {
                try {
                    if (scheduler==null) {
                        scheduler = StdSchedulerFactory.getDefaultScheduler();
                    }
                } catch (SchedulerException e) {
                    e.printStackTrace();
                }
            }
        }
        return scheduler;
    }
    //任务调度
    public static Scheduler getSchedulerTask(String taskName,int time){
        Scheduler scheduler=getScheduler();

        try {
            //看是否启动
            if (!scheduler.isStarted()){
                scheduler.start();
            }
            //运行一段时间后关闭
            Thread.sleep(time*1000);
            //定义一个Trigger
            Trigger trigger = newTrigger().withIdentity("trigger", "group") //定义name/group
                    .startAt(new Date(time))//在这个时间之后发生
　　　　　　　　　　　　//这里还可以用withwithSchedule（）来控制调度情况 其中添加simpleSchedule（）来控制间隔多少执行一次，执行多少次，还是一直执行

                    .build();
            //定义一个JobDetail
            JobDetail job = newJob(QuartzTask.class) //定义Job类为QuartzTask类，这是真正的执行逻辑所在
                    .withIdentity("job", "group") //定义name/group
                    .usingJobData("name", taskName) //定义属性
                    .usingJobData("zhou","zhouguanglin")
                    .build();
            //加入这个调度
            scheduler.scheduleJob(job, trigger);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return scheduler;
    }
    public static void main(String[] args) throws SchedulerException, InterruptedException {

       for (int j=0;j<list.size();j++) {
           getSchedulerTask("任务："+j,list.get(j));
       }
       //最后将scheduler关闭
        if (!scheduler.isShutdown()) {
           scheduler.shutdown();
        }
    }
}

真正的调度的任务逻辑在这：

package com.test.util;

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

/**
 * @author zhouguanglin
 * @date 2018/1/6 15:09
 */
public class QuartzTask implements Job {
    public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
        //这里是读取上下文，得到其中的东西，只可意会不可言传，，，就好像Spring的感觉差不错
        JobDetail detail = jobExecutionContext.getJobDetail();
        String name = detail.getJobDataMap().getString("name");
       String zhou=detail.getJobDataMap().getString("zhou");
        System.out.println("任务开始。。。-------name："+name+"   zhou:"+zhou);
        System.out.println(System.currentTimeMillis());
    }
}

　　               【版本声明】本文为博主原创文章，转载请注明出处