Quartz 的 应用

本章知识：

1、Quartz 简介 及 应用场景
2、Quartz 简单触发器 SimpleTrigger
3、Quartz 表达式触发器 CronTirgger
4、Quartz 中 参数传递
5、Spring task 与 Quartz 的比较

Quartz 简介 及 应用场景

Quartz 简介

1. Quartz介绍

   任务调度框架“Quartz”是 OpenSymphony 开源组织在 Job scheduling 领域又一个开源项目，
   是完全由 java 开发的一个开源的任务日程管理系统，
   “任务进度管理器” 就是一个在预先确定（被纳入日程）的时间到达时，负责执行（或者通知）其他软件组件的系统。
   （是不是看不太明白，没关系，咱们往下看 ♪(^∇*) ）

   简单来说就是 实现 “计划(或定时)任务” 的系统 ，
   例如：订单下单后未付款，15分钟后自动撤消订单，并自动解锁锁定的商品。

2. Quartz的触发器

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

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

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

3. 存储方式

   RAMJobStore(内存作业存储类型) 和 JDBCJobStore(数据库作业存储类型)

   两种方式对比如下：

       			     		优点                              	      缺点
   
   RAMJobStore  不要外部数据库，配置容易，运行速度快     		因为调度程序信息是存储在被分配给JVM的内存里面，
                                                        	所以，当应用程序停止运行时，所有调度信息将被丢失。
                                                    	    另外因为存储到JVM内存里面，所以可以存储多少个Job和Trigger将会受到限制
   
   JDBCJobStor  支持集群，因为所有的任务信息都会保存    		运行速度的快慢取决与连接数据库的快慢
                到数据库中，可以控制事物，还有就是如
                果应用服务器关闭或者重启，任务信息都
                不会丢失，并且可以恢复因服务器关闭或
                者重启而导致执行失败的任务   
   

   quartz工作流程图解：
   

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

---

Quartz 应用

所需 pom 依赖

		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-aspects</artifactId>
		</dependency>
		<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.2.1</version>
		</dependency>

Quartz 简单触发器 SimpleTrigger

RamJob.java

	package com.dj.quartz01.job;
	
	import org.quartz.Job;
	import org.quartz.JobExecutionContext;
	import org.quartz.JobExecutionException;
	
	/**
	 * @author dj
	 * @company xxx公司
	 * @create 2019- 11 - 14 - 22:49
	 */
	public class RamJob implements Job {
	
	    @Override
	    public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
	        System.out.println("Quartz 定时任务启动！！！！");
	    }
	}

Demo1.java

	package com.dj.quartz01.demo;
	
	import com.dj.quartz01.job.RamJob;
	import org.quartz.*;
	import org.quartz.impl.StdSchedulerFactory;
	
	import static org.quartz.JobBuilder.newJob;
	
	/**
	 * @author dj
	 * @company xxx公司
	 * @create 2019- 11 - 14 - 22:44
	 */
	public class Demo1 {
	    public static void main(String[] args) throws SchedulerException {
	        //实例化工厂SchedulerFactory
	        SchedulerFactory sf = new StdSchedulerFactory();
	
	        //创建调度器Scheduler
	        Scheduler scheduler = sf.getScheduler();
	
	        // 具体定时任务需要执行的代码
	        JobDetail jobDetail = newJob(RamJob.class)
	                .withIdentity("job1","group1") //标识定时任务
	                .withDescription("this is a job")//可不要
	                .build();
	
	        //触发器 规则
	        Trigger trigger = (Trigger)TriggerBuilder.newTrigger()
	                 //重复3次 间隔6秒
	                .withSchedule(SimpleScheduleBuilder.repeatSecondlyForTotalCount(3,6))
	                //触发器标识
	                .withIdentity("name1","group1")
	                .withDescription("这是一个触发器 Trigger")
	                .build();
	
	//       调度工厂绑定作业类及触发器
	        scheduler.scheduleJob(jobDetail,trigger);
	        scheduler.start();
	    }
	}

控制台效果：

---

Quartz 表达式触发器 CronTirgger

	    public static void main(String[] args) throws SchedulerException {
	        //实例化工厂SchedulerFactory
	        SchedulerFactory sf = new StdSchedulerFactory();
	
	        //创建调度器Scheduler
	        Scheduler scheduler = sf.getScheduler();
	
	        // 具体定时任务需要执行的代码
	        JobDetail jobDetail = newJob(RamJob.class)
	                .withIdentity("job1","group1") //标识定时任务
	                .withDescription("this is a job")//可不要
	                .build();
	
	        //触发器 规则
	        Trigger trigger = (Trigger)TriggerBuilder.newTrigger()
	                 //重复3次 间隔6秒
	//                .withSchedule(SimpleScheduleBuilder.repeatSecondlyForTotalCount(3,6))
	                //定时执行
	//                .withSchedule(CronScheduleBuilder.cronSchedule("0 06 10 * * ?"))
	                //每隔6秒执行一次
	                .withSchedule(CronScheduleBuilder.cronSchedule("0/6 * * * * ?"))
	                //触发器标识
	                .withIdentity("name1","group1")
	                .withDescription("这是一个触发器 Trigger")
	                .build();
	
	//       调度工厂绑定作业类及触发器
	        scheduler.scheduleJob(jobDetail,trigger);
	        scheduler.start();
	    }

每隔六秒执行一次：

Quartz 中参数传递

	    public static void main(String[] args) throws SchedulerException {
	        //实例化工厂SchedulerFactory
	        SchedulerFactory sf = new StdSchedulerFactory();
	
	        //创建调度器Scheduler
	        Scheduler scheduler = sf.getScheduler();
	
	        // 具体定时任务需要执行的代码
	        JobDetail jobDetail = newJob(RamJob.class)
	                .withIdentity("job1","group1") //标识定时任务
	                .withDescription("this is a job")//可不要
	                .usingJobData("name","战战")//传参
	                .build();
	
	        JobDataMap jobDataMap = jobDetail.getJobDataMap();
	        jobDataMap.put("job","羡羡");
	        jobDataMap.put("level","陈情");
	
	        //触发器 规则
	        Trigger trigger = (Trigger)TriggerBuilder.newTrigger()
	                 //重复3次 间隔6秒
	//                .withSchedule(SimpleScheduleBuilder.repeatSecondlyForTotalCount(3,6))
	                //定时执行
	//                .withSchedule(CronScheduleBuilder.cronSchedule("0 06 10 * * ?"))
	                //每隔6秒执行一次
	                .withSchedule(CronScheduleBuilder.cronSchedule("0/6 * * * * ?"))
	                //触发器标识
	                .withIdentity("name1","group1")
	                .withDescription("这是一个触发器 Trigger")
	                .build();
	
	//       调度工厂绑定作业类及触发器
	        scheduler.scheduleJob(jobDetail,trigger);
	        scheduler.start();
	    }


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

---

Spring task 和 Quartz

Spring task

Spring 自带的定时任务

优点：无需整合spring，任务类中就可以调用业务service

缺点：单线程；不能做数据存储型的定时任务

Quartz

优点：多线程；可以做数据存储型的定时任务，维护性高；

缺点：需要整合spring，不能直接调用业务层service；

这样子说可能没啥子感觉，那我们来线程论证一下：

Spring task 代码 ：

	package com.dj.quartz01.task;
	
	import org.springframework.scheduling.annotation.Scheduled;
	
	/**
	 * @author dj
	 * @company xxx公司
	 * @create 2019- 11 - 15 - 10:03
	 */
	public class SpringTask {

	    /**
	     * 每10秒执行一次
	     *
	     * SpringTask 是单线程还是多线程？
	     * 10s 执行一次，多线程
	     * 30s 执行一次，单线程
	     */
	    @Scheduled(cron = "0/10 * * * * ?")
	    public void xxx(){
	        System.out.println("SpringTask  天官赐福，百无禁忌。"+System.currentTimeMillis());
	        try {
	            Thread.sleep(20*1000);
	            System.out.println("处理大数据量的耗时操作。。。。。。。。。。。");
	        } catch (InterruptedException e) {
	            e.printStackTrace();
	        }
	    }
	}

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

结果 ：SpringTask 中的定时任务30s执行一次，说明SpringTask是单线程。

Quartz 代码 ：

	package com.dj.quartz01.job;
	
	import org.quartz.Job;
	import org.quartz.JobExecutionContext;
	import org.quartz.JobExecutionException;
	
	import java.text.SimpleDateFormat;
	import java.util.Date;
	
	/**
	 * @author dj
	 * @company xxx公司
	 * @create 2019- 11 - 14 - 22:49
	 */
	public class RamJob implements Job {
	
	    @Override
	    public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
	        SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
	        System.err.println(format.format(new Date()) +" : 基于RAM的 Quartz 调度框架定时任务...");
	
	        try {
	            Thread.sleep(20*1000);
	            System.out.println("模拟正在处理大数据....");
	        } catch (InterruptedException e) {
	            e.printStackTrace();
	        }
	    }
	
	}

结果：不管前一个定时任务的线程是否结束，都会开启下一个线程，依然每10s执行一次，说明Quartz是多线程；