Quartz2.x使用

参考：http://blog.csdn.net/seven_3306/article/details/17098493
          http://lavasoft.blog.51cto.com/62575/181907/

Quartz是Java版开源定时调度器，功能强大，使用方便。。
 
一、核心概念
1.Job：表示一个作业/任务，要执行的具体内容。此接口中只有一个方法void execute(JobExecutionContext context)，自定义任务时需要实现此接口的execute方法。
2.JobDetail：JobDetail表示一个具体的可执行的调度程序，Job是这个可执行程调度程序所要执行的内容，另外JobDetail还包含了这个任务调度的方案和策略。
3.Trigger：作业执行的触发器，用于定义作业调度如何触发。比如每一小时定时触发一次。有SimpleTrigger和CronTrigger两种类型
4.Scheduler：代表一个调度容器，负责作业/任务调度，一个调度容器中可以注册多个JobDetail和Trigger。当Trigger与JobDetail组合，就可以被Scheduler容器调度了。
5.SchedulerListener：调度器的监听器。
6.Triggerlistener：触发器的监听器。
7.JobListener：job的监听器。
8.ListenerManager：监听器管理类，用于添加，移除，设置监听器等。比如scheduler.getListenerManager.addJobListener(JobListener joblistener,Matcher<JobKey> matcher)；
9.Matcher：用于匹配监听器。
10.JobBuilder：Job生成的工具类，用于定义、构造JobDetail的实例。
11.TriggerBuilder：Trrigger构造的工具类，用于定义、构造Trigger的实例。
12.JobKey：Job的识别键，封装jobName和jobGruopName。
13.TriggerKey：类似JobKey,Trigger的识别键，封装triggerName和triggerGruopName。

二、示例：

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

import java.time.LocalTime;
import java.util.concurrent.TimeUnit;

@DisallowConcurrentExecution
public class EasyJob implements Job {
    @Override
    public void execute(JobExecutionContext context) throws JobExecutionException {
        System.out.println(LocalTime.now() + " Hello, easy job!");
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(LocalTime.now() + " end easy job!");
    }
}

注意，这里的DisallowConcurrentExecution注解表示不允许EasyJob并行执行，即如果当前job还在运行，那么下一个job只能延时运行。

import org.quartz.*;
import org.quartz.impl.StdSchedulerFactory;
import org.quartz.impl.matchers.KeyMatcher;

import java.util.Date;
import java.util.Properties;

import static org.quartz.SimpleScheduleBuilder.simpleSchedule;


public class QuartzTest {
    private Scheduler scheduler = null;

    public Scheduler init() {
        if (scheduler == null) {
            try {
                //通过SchedulerFactory获取一个调度器实例
                scheduler = StdSchedulerFactory.getDefaultScheduler();

                // 此处修改修改可以设置监听器，以下几个方法没有指定matcher，那么都是全局的，针对所有的
                // scheduler.getListenerManager().addJobListener(new MonitorJobListener());
                // scheduler.getListenerManager().addSchedulerListener(new MonitorSchedulerListener());
                // scheduler.getListenerManager().addTriggerListener(new MonitorTriggerListener());
            } catch (SchedulerException e) {
                e.printStackTrace();
            }
        }
        return scheduler;
    }

    /**
     * 此方法可以设置quartz属性，比如misfire，threadCount等属性
     * @return
     */
    public Scheduler getScheduler(Properties props) {
        if (scheduler == null) {
            try {
               /* props = new Properties();
                props.put(StdSchedulerFactory.PROP_THREAD_POOL_CLASS,
                        "org.quartz.simpl.SimpleThreadPool");
                // quartz的线程数，同时运行的线程数
                props.put("org.quartz.threadPool.threadCount", "8");
                // trigger过期1小时内还有效
                props.put("org.quartz.jobStore.misfireThreshold", "60*60*1000");
                */
                StdSchedulerFactory factory = new StdSchedulerFactory();
                factory.initialize(props);
                scheduler = factory.getScheduler();
            } catch (SchedulerException e) {
                e.printStackTrace();
            }
        }
        return scheduler;
    }

    public void addJobListener(JobKey jobKey, JobListener jobListener) throws SchedulerException {
        Matcher<JobKey> matcher = KeyMatcher.keyEquals(jobKey);
        try {
            this.scheduler.getListenerManager().addJobListener(jobListener, matcher);
        } catch (SchedulerException e) {
            e.printStackTrace();
            throw e;
        }
    }

    public void addTriggerListener(TriggerKey triggerkey, TriggerListener triggerListener) 
        throws SchedulerException {
        Matcher<TriggerKey> matcher = KeyMatcher.keyEquals(triggerkey);

        try {
            this.scheduler.getListenerManager().addTriggerListener(triggerListener, matcher);
        } catch (SchedulerException e) {
            e.printStackTrace();
            throw e;
        }
    }

    /**
     * cron任务
     * @param jobKey
     * @param triggerKey
     * @param cronExpression
     * @param jobClass
     */
    public void scheduleCronJob(JobKey jobKey, TriggerKey triggerKey, String cronExpression,
                               Class<? extends Job> jobClass) {
        //通过过JobDetail封装jobClass，同时指定Job在Scheduler中所属jobKey
        JobDetail jobDetail = JobBuilder.newJob(jobClass)
                .withIdentity(jobKey).build();//.withIdentity("myJob", "myJobGroup")

//        // Build JobDetail instance.
//        JobDetailImpl jdi = new JobDetailImpl();
//        jdi.setName(jobKey.getName());
//        jdi.setGroup(jobKey.getGroup());
//        jdi.setJobClass(jobClass);
//        jdi.setDurability(true);
//        jdi.getJobDataMap().put("methodInvoker", this);

        //创建一个CronTrigger实例
        CronTrigger trigger = TriggerBuilder.newTrigger()
                .withIdentity(triggerKey).forJob(jobDetail)
                .withSchedule(CronScheduleBuilder.cronSchedule(cronExpression))
                .build();
        try {
            //注册并进行调度
            this.scheduler.scheduleJob(jobDetail, trigger);
        } catch (SchedulerException e) {
            e.printStackTrace();
        }

//        //修改时间
//        trigger.setCronExpression(time);
//        //重启触发器
//        scheduler.resumeTrigger(triggerKey);
    }

    public void scheduleSimpleJob(JobKey jobKey, TriggerKey triggerKey, Class<? extends Job> jobClass) {
        //通过过JobDetail封装jobClass，同时指定Job在Scheduler中所属jobKey
        JobDetail jobDetail = JobBuilder.newJob(jobClass)
                .withIdentity(jobKey).build();//.withIdentity("myJob", "myJobGroup")

        //SimpleTrigger
        SimpleTrigger trigger = TriggerBuilder.newTrigger()
                .withIdentity(triggerKey)
                .withSchedule(simpleSchedule()
                                .withIntervalInSeconds(2)//重复间隔
                                .withRepeatCount(3)//重复次数
                             )
                .startAt(new Date()).build();
        try {
            //注册并进行调度
            this.scheduler.scheduleJob(jobDetail, trigger);
        } catch (SchedulerException e) {
            e.printStackTrace();
        }
    }

    /**
     * 设置立刻生成
     * @param jobKey
     * @param jobClass
     */
    public void triggerJobNow(JobKey jobKey, Class<? extends Job> jobClass) {
        JobDetail jobDetail = null;
        jobDetail = JobBuilder.newJob(jobClass).withIdentity(jobKey)
                .storeDurably(true).build();
        try {
            this.scheduler.addJob(jobDetail, true);
        } catch (SchedulerException e) {
            e.printStackTrace();
        }
        try {
            this.scheduler.triggerJob(jobKey);
        } catch (SchedulerException e) {
            e.printStackTrace();
        }

    }

    /**
     * 启动调度器
     */
    public void start() {
        try {
            this.scheduler.start();
        } catch (SchedulerException e) {
            e.printStackTrace();
        }
    }

    public void stop() {
        try {
            //调度器停止运行
            this.scheduler.shutdown(true);
        } catch (SchedulerException e) {
            e.printStackTrace();
        }
    }

    public void removeJob(TriggerKey triggerKey, JobKey jobKey)
            throws SchedulerException {
        scheduler.pauseTrigger(triggerKey);//停止触发器
        scheduler.unscheduleJob(triggerKey);//移除触发器
        scheduler.deleteJob(jobKey);//删除任务
    }

    public static void main(String[] args) {
        QuartzTest test = new QuartzTest();
        JobKey jobKey = new JobKey("myJob", "myJobGroup");
        test.init();
        try {
            test.addJobListener(jobKey, new JobListener() {
                @Override
                public String getName() {
                    return "jobListener";
                }

                @Override
                public void jobToBeExecuted(JobExecutionContext context) {
                    System.out.println("jobToBeExecuted");
                }

                @Override
                public void jobExecutionVetoed(JobExecutionContext context) {
                    System.out.println("jobExecutionVetoed");
                }

                @Override
                public void jobWasExecuted(JobExecutionContext context, JobExecutionException jobException) {
                    System.out.println("jobWasExecuted");
                }
            });
        } catch (SchedulerException e) {
            e.printStackTrace();
        }
//        test.triggerJobNow(jobKey, EasyJob.class);
        test.scheduleSimpleJob(jobKey, new TriggerKey("myTrigger", "myTriggerGroup"), EasyJob.class);
        test.start();

        // TriggerKey triggerKey = new TriggerKey("myTrigger", "myTriggerGroup");
        // //每隔10S执行一次
        // String cronExpression = "0/10 * * * * ?";
        // test.init();
        // test.scheduleCronJob(jobKey, triggerKey, cronExpression, HelloJob.class);
        // test.start();
    }
}