quartz入门

1. Quartz介绍

   任务调度框架“Quartz”是OpenSymphony开源组织在Job scheduling领域又一个开源项目，是完全由java开发的一个开源的任务日程管理系统，“任务进度管理器”就是一个在预先确定（被纳入日程）的时间到达时，负责执行（或者通知）其他软件组件的系统。

2. Quartz的触发器

   触发器用来告诉调度程序作业什么时候触发。框架提供了5种触发器类型，但两个最常用的SimpleTrigger和CronTrigger。

   五种类型的Trigger(定时器)
   SimpleTrigger，CronTirgger，DateIntervalTrigger，NthIncludedDayTrigger和Calendar类（ org.quartz.Calendar）。

   场景：
   SimpleTrigger：执行N次，重复N次
   CronTrigger：几秒 几分 几时 哪日 哪月 哪周 哪年，执行

1、流失客户    凌晨2点来判断这个客户是不是流失客户
   小说上传    定时发布章节
这个是定点定时的调用后台代码
2、物流订单，
    假设：订单表 
        一个县在一个小时内产生的1000条订单
        一个市：1w
        一个省：10w
        全国：100w
如果从这么多条数据查询某一条的数据，那么它的运行速度很慢
解决办法：设置定时任务，每个小时将订单表的数据转入历史表（历史表存的是付款
是否成功不需要的数据）看订单是否付款成功查的是100w的数据，订单到了哪里是查5000w（两天的数据）的
数据

需要循环调用后台代码
 

3 核心类和核心类之间关系

  3.1 QuartzSchedulerThread 
      负责执行向QuartzScheduler注册的触发Trigger的工作的线程。
 
  3.2 
ThreadPool
      Scheduler使用一个线程池作为任务运行的基础设施，任务通过共享线程池中
的线程提供运行效率。

  3.3 
QuartzSchedulerResources
     包含创建QuartzScheduler实例所需的所有资源（JobStore，ThreadPool等）。

  3.4 SchedulerFactory
      提供用于获取调度程序实例的客户端可用句柄的机制。

  3.5 JobStore
      通过类实现的接口，这些类要为org.quartz.core.QuartzScheduler的使用提供一个org.quartz.Job和org.quartz.Trigger存储机制。作业和触发器的存储应该以其名称和组的组合为唯一性。 

  3.6 
QuartzScheduler
      这是Quartz的核心，它是org.quartz.Scheduler接口的间接实现，包含调度org.quartz.Jobs，注册org.quartz.JobListener实例等的方法。

  3.7 Scheduler
      这是Quartz Scheduler的主要接口，代表一个独立运行容器。调度程序维护JobDetails和触发器的注册表。一旦注册，调度程序负责执行作业，当他们的相关联的触发器触发（当他们的预定时间到达时）。 

  3.8 Trigger
      具有所有触发器通用属性的基本接口，描述了job执行的时间出发规则。 - 使用TriggerBuilder实例化实际触发器。 

  3.9 JobDetail
      传递给定作业实例的详细信息属性。 JobDetails将使用JobBuilder创建/定义。
       
      1.jobname+jobgroup=primary key identity
      2.jobdetail每执行一次都会新建一个job实例

       XxxJob/XxxTask
  35.10 
Job：
       要由表示要执行的“作业”的类实现的接口。只有一个方法 
       void execute(jobExecutionContext context) 
(jobExecutionContext 提供调度上下文各种信息，运行时数据保存在jobDataMap中) 

       Job有个子接口StatefulJob ,代表有状态任务。 有状态任务不可并发，前次任务没有执行完，后面任务处于阻塞等待
   
       jobName+groupName=primary key
  注1：这里面最最重要的接口是Scheduler接口。它提供了简单的操作，例如：将任
务纳入日程或者从日程中取消，开始/停止/暂停日程进度。
       翻译：Scheduler的中文是：“调度程序，日程安排程序” 

<定时任务后台代码的代码什么时候执行由调度器、触发器、工作类来决定
当我这个触发器具体某一个时间段要执行什么代码需要一个作业类（jobDetail>

4、图解quartz工作流程

 

quartz相关表达式

在线生成表达式网址：http://cron.qqe2.com/

 

4、代码演示（包含简单调度器以及表达式触发器两类）

所需pom依赖

<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.3.0</version>
      </dependency>

具体作业类

package com.xxx.quartz01.quartz;

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

/**
 * @author Zhang
 */
public class RamJob implements Job {

    @Override
    public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
        System.out.println("启动定时任务----------------");
        JobDataMap jobDataMap = jobExecutionContext.getJobDetail().getJobDataMap();
        System.out.println(jobDataMap.get("level") + "" + jobDataMap.get("job"));

    }
}

执行具体作业类逻辑

package com.xxx.quartz01;

import com.xxx.quartz01.quartz.RamJob;
import org.quartz.*;
import org.quartz.impl.StdSchedulerFactory;

import static org.quartz.JobBuilder.newJob;

/**
 * @author Zhang
 */
public class QuartzTest {
    public static void main(String[] args) throws SchedulerException {
//        创建调度器
//        将具体的作业类（Ramjob）绑定到调度任务详情中
//        创建触发器
        Scheduler scheduler = new StdSchedulerFactory().getScheduler();
        JobDetail jobDetail=newJob(RamJob.class)
                .withDescription("this is a job")
                .withIdentity("job1","group1")
                .usingJobData("level","老手")
                .build();

        JobDataMap jobDataMap = jobDetail.getJobDataMap();
        jobDataMap.put("job","司机");


        Trigger trigger = TriggerBuilder.newTrigger()
                .withDescription("this is a trigger1")
//                每隔10秒重复执行3次
                .withSchedule(SimpleScheduleBuilder.repeatSecondlyForTotalCount(3,10))
//                .withSchedule(CronScheduleBuilder.cronSchedule("0 36 16 * * ?"))
                .withIdentity("trigger1","group1")
                .build();
//        将触发器以及调度详情绑定到调度器上
        scheduler.scheduleJob(jobDetail,trigger);
//        启动调度器
        scheduler.start();

    }
}

spring自带定时任务

package com.zhang.quartz01.quartz;

import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Service;

/**
 * @author Zhang
 */
@Service
public class SpringTask {
//     @Autowired service  只有spring自带的定时任务才能注入service
//    spring自带定时任务（SpringTask）是单线程的（当上一个定时任务没有结束，他不会调用新的定时任务）
    @Scheduled(cron = "0/5 * * * * *")
    public void hh(){
        System.out.println("spring task执行");

        try {
            Thread.sleep(10*1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("spring task执行结束");
    }
}

package com.zhang.quartz01;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.scheduling.annotation.EnableScheduling;

@EnableScheduling
@SpringBootApplication
public class Quartz01Application {

    public static void main(String[] args) {
        SpringApplication.run(Quartz01Application.class, args);
    }

}