Quartz基本使用

1.Quartz概述:简单的说就是java的一个定时任务的框架，没有那么复杂的解释，跟前端的定时器一样。在了解它之前，首先熟悉几个概念。

2.基本概念

2.1 Job：表示一个工作，要执行的具体内容。此接口中只有一个方法      void execute(JobExecutionContext context)

2.2 JobDetail：JobDetail 表示一个具体的可执行的调度程序， Job 是这个可执行程调度程序所要执行的内容，另外 JobDetail 还包含了这个任务调度的方案和策略。

2.3 Trigger 代表一个调度参数的配置，什么时候去调。

2.4  Scheduler 代表一个调度容器，一个调度容器中可以注册多个 JobDetail 和 Trigger。当Trigger 与 JobDetail 组合，就可以被 Scheduler 容器调度了。

解释：
l 编写 job 实现业务，要做什么具体事情问题。
l 使用 JobDetail 包装 job，是任务对象，可以被调度
l 使用 Trigger （触发器对象）定制什么时候去调用某任务对象。
l 使用 Scheduler 结合任务对象和触发器对象，很像一个大管家。

3.运行原理

下面实例：开启大管家，启动，关闭

引入相应的jar包

  <dependencies>
        <dependency>
            <groupId>org.quartz-scheduler</groupId>
            <artifactId>quartz</artifactId>
            <version>2.2.3</version>
        </dependency>
        <dependency>
            <groupId>org.quartz-scheduler</groupId>
            <artifactId>quartz-jobs</artifactId>
            <version>2.2.3</version>
        </dependency>
        <!-- slf4j log4j -->
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-log4j12</artifactId>
            <version>1.7.7</version>
        </dependency>
<dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.11</version>
            <scope>test</scope>
        </dependency>
    </dependencies>

Job：

package com.quartz.job;

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

public class HelloJob implements Job {

    /*
     * set方法
     * */
    private String message;

    private Float math;

    public String getMessage() {
        return message;
    }

    public void setMessage(String message) {
        this.message = message;
    }

    public Float getMath() {
        return math;
    }

    public void setMath(Float math) {
        this.math = math;
    }

    @Override
    public void execute(JobExecutionContext context)throws JobExecutionException {

        /*String mes = (String) context.getJobDetail().getJobDataMap().get("message");
        System.out.println("jobdetail's message:  "+mes);

        Float ms = (Float) context.getTrigger().getJobDataMap().get("math");
        System.out.println("trigger's math:  "+ms);*/

        System.out.println("jobdetail's message:  "+message);
        System.out.println("trigger's math:  "+math);
        System.out.println("业务逻辑处理中...");
    }
}

jobdetail,Trigger ,Scheduler :

package com.quartz.scheduler;

import org.quartz.CronScheduleBuilder;
import org.quartz.CronTrigger;
import org.quartz.JobBuilder;
import org.quartz.JobDetail;
import org.quartz.Scheduler;
import org.quartz.SchedulerException;
import org.quartz.SimpleScheduleBuilder;
import org.quartz.SimpleTrigger;
import org.quartz.Trigger;
import org.quartz.TriggerBuilder;
import org.quartz.impl.StdSchedulerFactory;

import com.quartz.job.HelloJob;

public class TestQuartz {
    public static void main(String[] args) throws SchedulerException, InterruptedException {

//        定义jobdetail
        JobDetail jb = JobBuilder.newJob(HelloJob.class)
                .withIdentity("myjob", "group1")
                .usingJobData("message", "hello,Myjobdetail")
                .build();

        System.out.println("jobDetail's name:  "+jb.getKey().getName());
        System.out.println("jobDetail's group:  "+jb.getKey().getGroup());
        System.out.println("jobDetail's jobclass:  "+jb.getJobClass().getName());

//        定义trigger
        CronTrigger trigger = TriggerBuilder.newTrigger()
                .withIdentity("mytrigger","group1")
                .startNow()
                .usingJobData("math", 3.15f)
//                .withSchedule(SimpleScheduleBuilder.simpleSchedule().withIntervalInSeconds(2).repeatForever())
                .withSchedule(CronScheduleBuilder.cronSchedule("* * * * * ? *"))
                .build();

//        创建scheduler
        StdSchedulerFactory ssf = new StdSchedulerFactory();
        Scheduler sc = ssf.getScheduler();
        sc.start();
        sc.scheduleJob(jb, trigger);

//        两秒挂起
        Thread.sleep(2000L);
        sc.standby();

        Thread.sleep(2000L);
        sc.start();

//        sc.shutdown(false); //直接关闭Scheduler
//        sc.shutdown(true);  //执行完所有的job后关闭Scheduler

    }
}

这里需要理解一下standBy（），该方法是让scheduler挂起，要想开始直接调用start（）方法。shutdown（false）该方法是shutdown（）直接关闭scheduler，而shutdown（true）表示等待执行完所有的job后关闭Scheduler。