quartz入门

最新推荐文章于 2023-02-16 12:47:47 发布



最新推荐文章于 2023-02-16 12:47:47 发布

阅读量140

点赞数

分类专栏： quartz 文章标签： quartz入门

本文链接：https://blog.youkuaiyun.com/qq_43514335/article/details/103101210

版权

quartz 专栏收录该内容

2 篇文章

订阅专栏

quartz入门

quartz简介

Quartz是OpenSymphony开源组织在Job scheduling领域又一个开源项目，它可以与J2EE与J2SE应用程序相结合也可以单独使用。

现在大部分也主要是用它来实现定时任务,设置触发时间主要是靠它的Trigger和它的表达式

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

quartz三大要素：

JobDetail：表示一个具体的可执行的调度程序，Job 是这个可执行程调度程序所要执行的内容，另外还包含了这个任务调度的方案和策略。
Trigger：代表一个调度参数的配置，什么时候去调。
Scheduler：代表一个调度容器，一个调度容器中可以注册多个 JobDetail 和 Trigger。当 Trigger 与 JobDetail 组合，就可以被 Scheduler 容器调度了。

实现定时任务也就主要靠这三大要素

Quartz的触发器

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

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

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

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

quartz所需pom依赖，今天是在springboot中使用，所以我只需要第一个和最后一个

	<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案例

首先需要先建一个job，具体的代码逻辑，三个案例都是这个job了，注释掉的在第三个案例打开，传参案例使用

RamJob

package com.li.quart01.job;

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

/**
 * @author dragon
 * @site
 * @company
 * @create  2019-11-14 16:25
 *
 * 基于内存Ram
 */
public class Ramjob implements Job {
    @Override
    public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
        System.out.println("quartz定时任务启动~~~~~~~~~~~~~");
//        JobDataMap jobDataMap = jobExecutionContext.getJobDetail().getJobDataMap();
//        System.out.println(jobDataMap.get("name").toString()+jobDataMap.get("level").toString()+jobDataMap.get("job").toString());

    }
}

Damo1
简单触发器（每个n秒执行，一共执行多少次）

package com.li.quart01.damo;


import com.li.quart01.job.Ramjob;
import org.quartz.*;
import org.quartz.impl.StdSchedulerFactory;

import static org.quartz.JobBuilder.newJob;

/**
 * @author dragon
 * @site
 * @company
 * @create  2019-11-14 16:30
 *
 * 简单触发器（每个n秒执行，一共执行多少次）
 */
public class Damo1 {
    public static void main(String[] args) throws SchedulerException {
//        Scheduler ，jobdetail，trigger
        SchedulerFactory factory = new StdSchedulerFactory();
        //        调度器创建
        Scheduler scheduler = factory.getScheduler();
//        具体定时任务需要执行的代码
        JobDetail jobDetail = newJob(Ramjob.class)
                .withIdentity("job1","group1")
                .withDescription("这是第一个quartz定时任务")
                .build();

        Trigger trigger = (Trigger)TriggerBuilder.newTrigger()
//                重复3次间隔6秒
                .withSchedule(SimpleScheduleBuilder.repeatSecondlyForTotalCount(3,6))
//                触发器标识
                .withIdentity("trigger1","group1")
                .withDescription("这是一个触发器")
                .build();

//       调度工厂绑定作业类及触发器
        scheduler.scheduleJob(jobDetail,trigger);
        scheduler.start();

    }
}

每6秒调用一次，总共调用了三次
在这里插入图片描述
Damo2
表达式触发器（定时定点，无限循环某一代码逻辑）

package com.li.quart01.damo;


import com.li.quart01.job.Ramjob;
import org.quartz.*;
import org.quartz.impl.StdSchedulerFactory;

import static org.quartz.JobBuilder.newJob;

/**
 * @author dragon
 * @site
 * @company
 * @create  2019-11-14 16:30
 *
 * 表达式触发器 （定时定点，无限循环某一代码逻辑）
 */
public class Damo2 {
    public static void main(String[] args) throws SchedulerException {
//        Scheduler ，jobdetail，trigger
        SchedulerFactory factory = new StdSchedulerFactory();
        //        调度器创建
        Scheduler scheduler = factory.getScheduler();
//        具体定时任务需要执行的代码
        JobDetail jobDetail = newJob(Ramjob.class)
                .withIdentity("job1","group1")
                .withDescription("这是第一个quartz定时任务")
                .build();

        Trigger trigger = (Trigger)TriggerBuilder.newTrigger()
                .withSchedule(CronScheduleBuilder.cronSchedule("0 18 17 * * ?"))
//                触发器标识
                .withIdentity("trigger1","group1")
                .withDescription("这是一个触发器")
                .build();

//       调度工厂绑定作业类及触发器
        scheduler.scheduleJob(jobDetail,trigger);
        scheduler.start();

    }
}

Demo3
Quartz中参数传递

package com.li.quart01.damo;


import com.li.quart01.job.Ramjob;
import org.quartz.*;
import org.quartz.impl.StdSchedulerFactory;

import static org.quartz.JobBuilder.newJob;

/**
 * Quartz中参数传递
 * 我们可以通过JobDataMap在我的调度器这边存储参数，并可以在Job中取出来，实现传参
 */
public class Demo3 {
    public static void main(String[] args) throws SchedulerException {
        SchedulerFactory factory = new StdSchedulerFactory();
//        调度器创建
        Scheduler scheduler = factory.getScheduler();

//        具体定时任务需要执行的代码
        JobDetail jobDetail = newJob(Ramjob.class)
                .withIdentity("job2", "group1")
                .withIdentity("这是一个quartz定时任务")
                .build();

        JobDataMap jobDataMap = jobDetail.getJobDataMap();
        jobDataMap.put("name","大叔");
        jobDataMap.put("level","高级");
        jobDataMap.put("job","软件开发");

        Trigger trigger = (Trigger) TriggerBuilder.newTrigger()
//                每6s执行一次
                .withSchedule(CronScheduleBuilder.cronSchedule("0/6 * * * * ?"))
//                定时定点执行
//                .withSchedule(CronScheduleBuilder.cronSchedule("0 52 09 * * ?"))
//                触发器标识
                .withIdentity("trigger2", "group1")
                .withDescription("这是一个触发器")
                .build();

        try {
            Thread.sleep(20*1000);
            System.out.println("模拟处理大数据...");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
//       调度工厂绑定作业类及触发器
        scheduler.scheduleJob(jobDetail, trigger);
        scheduler.start();
    }
}

Spring Task和quartz的不同

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

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

Spring Task使用是非常简单的，只需要几个注释即可，但是也就是因为它的单线程，只能用于小部分情景

我们写个案例，在运行定时的时候写一个线程休眠，看看定时的时间会不会受到影响

Demo

SpringTask

package com.li.quart01.task;

import org.springframework.scheduling.annotation.Scheduled;

import java.text.SimpleDateFormat;
import java.util.Date;

/**
 * @author dragon
 * @site
 * @company
 * @create  2019-11-16 20:35
 */
@Repository
public class SpringTask {
    @Scheduled(cron = "0/10 * * * * ?")
    public void xxx(){
        SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        System.err.println(format.format(new Date())+" : spring task启动...");

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

然后再启动类加一个注解，配置启用定时任务

package com.li.quart01;

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

@EnableScheduling
@SpringBootApplication
public class Quart01Application {

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

}