quartz入门

介绍

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

简单的来说就是一个定时任务框架。例如：订单下单后未付款，15分钟后自动撤消订单，并自动解锁锁定的商品。

那么怎么来使用呢？

首先我们需要定义实现一个定时功能的接口，我们可以称之为Task（或Job），如定时发送邮件的task（Job），重启机器的task（Job），优惠券到期发送短信提醒的task（Job），实现接口如下：

有了任务之后，还需要一个能够实现触发任务去执行的触发器，触发器Trigger最基本的功能是指定Job的执行时间，执行间隔，运行次数等。

有了Job和Trigger后，怎么样将两者结合起来呢？即怎样指定Trigger去执行指定的Job呢？这时需要一个Schedule，来负责这个功能的实现。

所以quartz是通过调度器：Scheduler、任务：JobDetail、触发器：Trigger来组成的。

案例讲解

依赖

首先创建springboot项目，勾选quartz以及基本依赖。

再在pom.xml里添加依赖：
切面依赖：

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-aspects</artifactId>
</dependency>

jobs依赖：

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

job

写一个Job:
要变成作业类，就要实现Quartz提供的Job接口，重写execute方法

package com.zlk.quartz01.job;

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

/**
 * @author 大宝
 * @company 太厉害公司
 * @create  2019-11-17 9:07
 *
 * 基于内存RAM
 *
 * 要变成作业类，就要实现Quartz提供的Job接口，重写execute方法
 */
public class RamJob implements Job {
    @Override
    public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
        System.out.println("这是Quartz定时任务");
    }
}

trigger

写一个触发器：
触发器的话一共有五种触发器。
但常见的有简单触发器 SimpleTrigger、表达式触发器CronTirgger，

简单触发器 SimpleTrigger：
（执行几次，几秒一次）
（过程请看注解）

package com.zlk.quartz01.demo;

import com.zlk.quartz01.job.RamJob;
import org.quartz.*;
import org.quartz.impl.StdSchedulerFactory;

import static org.quartz.JobBuilder.newJob;

public class Demo1 {
    public static void main(String[] args) throws SchedulerException {
      //schedule   jobDetail   trigger   要获取的三个对象


//        jobDetail：   任务
//       根据行介绍：
//     1,填写的是你要执行的job类    2,标识和所属组织  3，添加描述   4，开始构建
        JobDetail jobDetail = newJob(RamJob.class)
                .withIdentity("job1","group1")
                .withDescription("这是第一个Quartz定时任务")
                .build();

//        trigger 触发器
//      1,创建trigger 注意的是要强转  2,定义规则  第一个参数，执行几次，第二个参数，每隔几秒执行一次
//      3，标识，因为一个触发器可以触发多个任务
        Trigger trigger = (Trigger)TriggerBuilder.newTrigger()
                .withSchedule(SimpleScheduleBuilder.repeatSecondlyForTotalCount(3,6))
                .withIdentity("trigger1","group1")
                .withDescription("这是一个触发器")
                .build();


        //      schedule： 调度器
        //获取Scheduler工厂
        SchedulerFactory factory = new StdSchedulerFactory();
        //通过工厂生产出Scheduler
        Scheduler scheduler = factory.getScheduler();

//        通过schedule绑定触发器和任务。
        scheduler.scheduleJob(jobDetail,trigger);
//        启动定时任务
        scheduler.start();

    }
}

表达式触发器CronTirgger：
（定时定点，无限循环执行某一代码逻辑）
与上面代码一样，唯一更改的是触发器的规则。

//        trigger 触发器
//      1,创建trigger 注意的是要强转  2,定义规则  第一个参数，执行几次，第二个参数，每隔几秒执行一次
//      3，标识，因为一个触发器可以触发多个任务
        Trigger trigger = (Trigger)TriggerBuilder.newTrigger()
                .withSchedule(CronScheduleBuilder.cronSchedule("0 52 09 * * ?"))
                .withIdentity("trigger2","group2")
                .withDescription("这是一个触发器")
                .build();

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

传参

在tigger中的任务对象下方添加：

        // 传参数
        String name = "zs";
        String sex = "xxx";
        int age = 12;
        JobDataMap jobDataMap = jobDetail.getJobDataMap();
        jobDataMap.put("name",name);
        jobDataMap.put("sex",sex);
        jobDataMap.put("age",age);

在job调用：

 JobDetail jobDetail = jobExecutionContext.getJobDetail();
 JobDataMap jobDataMap = jobDetail.getJobDataMap();
 System.out.println(jobDataMap.get("name")+"  "+jobDataMap.get("sex")+
 "  "+jobDataMap.get("age"));

Spring task Vs Quartz

Spring task是spring自带的任务
Spring task
优点：无需整合spring，作业类中就可以调用业务service
缺点：单线程；不能做数据存储型的定时任务

Quartz
优点：多线程；可以做数据存储型的定时任务，维护性高；
缺点：需要整合spring，不能直接调用业务层service；

如何使用Spring task：
1，首先给类添加@Component
2，给方法添加@Scheduled(cron = "0/4 * * * * ? ") 里面放的是表达式,
3，然后在主线程Application中添加@EnableScheduling注解。
即完成定时任务。

package com.zlk.quartz01.task;

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

/**
 * @author 大宝
 * @company 太厉害公司
 * @create  2019-11-17 10:06
 */
//标记为组件
@Component
public class SpringTask {
    //规则
    @Scheduled(cron = "0/4 * * * * ? ")
    public void xxx(){
        System.out.println("这是SpringTask");
    }
}

package com.zlk.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);
    }

}

要验证是否是多线程，在job下加入以下：

try {
            Thread.sleep(20*1000);
            System.out.println("模拟处理大数据量");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

若一起输出则是多线程，否单。