java调度框架Quartz（一）

前段时间项目中使用到了quartz这个调度框架,最近有时间正好可以做一总结,现在使用的主要是两个版本,一个就是2.0以下版本,还要一个就是2.0以上今天咱们从quartz的本地启动-->quartz持久化数据库两大方面来总结和学习quartz。首先咱们先来看一下几个概念，学习技术的基础就是理论先行，所谓知其然知其所以然。

Paste_Image.png
首先来看一下这个图，这个图是我从网上截取的图片，这个文章讲的很好可以作为进阶来学习。学习地址
我们看一下上图：
Job：Job就是一个接口，咱们想要执任务调度就要实现该接口，他只有一个方法需要咱们实现，可以看下源码，我们的任务作业就在这个方法里：

package org.quartz;

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

public interface Job {
    void execute(JobExecutionContext var1) throws JobExecutionException;
}

Scheduler：Scheduler是咱们任务调度器，你就当他是一个池子这个池子有好多个输水管道。
Trigger：知道意思就是触发器的意思，那这个就是咱们任务的触发器，就是池子中的一个触发引擎（输水管道）。触发器的话就要有一个规则促使他如何执行，咱们这边有主要有SimpleTrigger和CronTrigger这两个子类。区别就是一个是简单的执行策略，比如心跳执行规则，而 CronTrigger 是正则表达式规则执行，咱们后面再说。
JobDetail：每个任务的具体的细节，包括job名，job的group，job的监听信息等。
ThreadPool：顾名思义就是线程池，我们都知道线程池的好处，当然好的框架就使用最优的性能的代码啦，使用共享线程池可以提高作业的处理能力
Calendar：quartz的特殊时间点集合，比如咱们需要在某个时间点执行或者不执行，就要Trigger结合Calendar使用。
以上就是一个任务的基本的需要的元素。
具体的执行就是咱们的调度器Schedule调度咱们的一个触发器Trigger，这个触发器绑定这一个JobDetail作业，这个任务就根据触发器中的执行规则配置执行Job中的作业就可以了。是不是很简单，当然具体的执行还有很多细节，但是咱们先有个大的框架。
好了我们先来看一下在内存中创建一个任务，先练练手咱们主要看1.8.6和2.1.7两个版本的不同使用方法，在持久化的时候咱们使用高版本。
1.需要的依赖包：

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

2.创建我们的任务，就是实现Job：

package com.spring.traning.quartz;

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

/**
 * Created by luyang.li on 17/1/9.
 */
public class SimpleQuartzJob implements Job {

    public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
        System.out.println("Simple Quertz Test!");
    }
}

我把import带着防止有的同学引错包，我们刚才看了源码，只有一个方法需要实现execute:

void execute(JobExecutionContext context)throwsJobExecutionException;

这个方法就是我们需要执行的作业任务，我们的业务逻辑到时候就在这个里面实现啦。
3.任务有了接下来咱们绑定任务和创建调度器等：
3.1创建调度器

       SchedulerFactory sf = new StdSchedulerFactory();
       Scheduler scheduler = sf.getScheduler();

我们来看一下这个创建过程：StdSchedulerFactory类实现了SchedulerFactory工厂类，这个工厂类是一个接口，他的方法：getScheduler里面大有学问：咱们一路跟进去看看：

public Scheduler getScheduler() throws SchedulerException {
        if (cfg == null) {
            initialize();
        }

        SchedulerRepository schedRep = SchedulerRepository.getInstance();

        Scheduler sched = schedRep.lookup(getSchedulerName());

        if (sched != null) {
            if (sched.isShutdown()) {
                schedRep.remove(getSchedulerName());
            } else {
                return sched;
            }
        }

        sched = instantiate();

        return sched;
    }

首选会初始化cfg,就是咱们的配置文件，要是咱们没有添加的配置的话就使用的Quartz自己的配置，我就不贴代码了，感兴趣的同学可以深入去看看。
主要在这里：

SchedulerRepository schedRep = SchedulerRepository.getInstance();

    public static synchronized SchedulerRepository getInstance() {
        if (inst == null) {
            inst = new SchedulerRepository();
        }

        return inst;
    }

没有实例的话就创建一个实例：

    private SchedulerRepository() {
        schedulers = new HashMap();
    }

哈哈其实他是一个Map，那么久印证了图里面画的，其实咱们的任务都在JobDataMap中呢。

Scheduler sched = schedRep.lookup(getSchedulerName());

    private String getSchedulerName() {
        return cfg.getStringProperty(PROP_SCHED_INSTANCE_NAME,
                "QuartzScheduler");
    }

这个方法里是读取quartz的配置构造咱们的实例。在这里咱们得到的是quartz默认的实例。好了我们得到了一个调度器了，下面我们就可以添加东西了。

        //创建一个作业 注册 作业名 和 组
        JobDetail jobDetail = new JobDetail("simpleQuartz", "group1", SimpleQuartzJob.class);
        //任务触发器
        SimpleTrigger trigger = new SimpleTrigger("simpleQuartzTime", "group1");

创建作业和触发器。并把作业绑定在触发器上，这里注意的是new JobDetail的时候第一个参数是Job的名name，第二个参数是job组group,第三个是咱们需要执行的Class。Trigger咱们先使用的心跳的方式执行：SimpleTrigger参数分别是name和group。
来看下完整的代码：

package com.spring.traning.quartz;

import org.quartz.JobDetail;
import org.quartz.Scheduler;
import org.quartz.SchedulerException;
import org.quartz.SchedulerFactory;
import org.quartz.SimpleTrigger;
import org.quartz.Trigger;
import org.quartz.impl.StdSchedulerFactory;

import java.util.Date;

/**
 * Created by luyang.li on 17/1/9.
 */
public class SimpleQuertzApp {

    public static void main(String[] args) throws SchedulerException, InterruptedException {
        SimpleQuertzApp simpleQuertzApp = new SimpleQuertzApp();
        simpleQuertzApp.run();
//        Thread.sleep(1000000);
    }

    private void run() throws SchedulerException {
        Date runTime = new Date();

        //创建一个调度器
        SchedulerFactory sf = new StdSchedulerFactory();
        Scheduler scheduler = sf.getScheduler();

        //创建一个作业 注册 作业名 和 组
//        JobDetail jobDetail = newJob(SimpleQuartzJob.class).withIdentity("simpleQuartz", "group1").build();
        JobDetail jobDetail = new JobDetail("simpleQuartz", "group1", SimpleQuartzJob.class);
        //任务触发器
//        Trigger trigger = newTrigger().withIdentity("simpleQuartzTime", "group1").startAt(runTime).build();
        SimpleTrigger trigger = new SimpleTrigger("simpleQuartzTime", "group1");

        long ctime = System.currentTimeMillis();
        trigger.setStartTime(new Date(ctime));

        //设置作业执行间隔
        trigger.setRepeatInterval(1000);

        //设置作业执行次数
        trigger.setRepeatCount(10);

        //设置作业执行优先级默认为5
        trigger.setPriority(10);

        //把触发器 和 作业绑定在调度器上
        scheduler.scheduleJob(jobDetail, trigger);

        //执行
        scheduler.start();

//        try {
//            Thread.sleep(65 * 1000);
//        } catch (InterruptedException e) {
//            e.printStackTrace();
//        }
//
//        scheduler.shutdown();
        System.out.println("运行结束!");

    }
}

执行就可以看到心跳任务执行了，下一节咱们看下2.1.7和持久化任务执行以及整合Spring