quartz入门（1）

原创

阳某 2021-09-02 11:02:03 ©著作权

文章标签 quartz入门 spring ide 触发器定时任务 文章分类 后端开发

©著作权归作者所有：来自51CTO博客作者阳某的原创作品，请联系作者获取转载授权，否则将追究法律责任

文章目录

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

这是我项目目录
quartz入门（1）_spring
首先需要先建一个job，你具体的代码逻辑，我三个案例都是这个job了，注解在第三个案例打开，传参使用
RamJob

package com.xy.quartz01.job;

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

/**
 * @author 阳某
 * @create 2019-11-14 16:30
 *
 * 基于内存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("job")
//                +jobDataMap.get("level"));
    }
}

demo01，简单触发器(每个n秒执行，一共执行多少次)

package com.xy.quartz01.demo;

import com.xy.quartz01.job.RamJob;
import org.quartz.*;
import org.quartz.impl.StdSchedulerFactory;
import org.quartz.simpl.RAMJobStore;

import static org.quartz.JobBuilder.newJob;

/**
 * @author 阳某
 * @create 2019-11-14 16:12
 *
 *
 * 简单触发器(每个n秒执行，一共执行多少次)
 */
public class demo01 {
    public static void main(String[] args) throws SchedulerException {
        SchedulerFactory factory = new StdSchedulerFactory();
//       调度器创建
        Scheduler scheduler = factory.getScheduler();

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

        Trigger trigger=(Trigger)TriggerBuilder.newTrigger()
                .withSchedule(SimpleScheduleBuilder.repeatSecondlyForTotalCount(3,6))
                .withIdentity("trigger1","group1")
                .withDescription("这是一个触发器")
                .build();

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

它每6秒调用一次，总共调用了三次
quartz入门（1）_定时任务_02
demo02,表达式触发器(定时定点，无线循环执行某一代码),比如我这里写的表达式是16：45：00时执行，所以一刀这个时间就会执行

package com.xy.quartz01.demo;

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

import static org.quartz.JobBuilder.newJob;

/**
 * @author 阳某
 * @create 2019-11-14 16:12
 *
 * 表达式触发器(定时定点，无线循环执行某一代码)
 */
public class demo02 {
    public static void main(String[] args) throws SchedulerException {
        SchedulerFactory factory = new StdSchedulerFactory();
//       调度器创建
        Scheduler scheduler = factory.getScheduler();

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

        Trigger trigger=(Trigger)TriggerBuilder.newTrigger()
                .withSchedule(CronScheduleBuilder.cronSchedule("50 45 16 * * ?"))
                .withIdentity("trigger2","group2")
                .withDescription("这是一个触发器")
                .build();

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

demo03,我们可以通过JobDataMap在我的调度器这边存储参数，并可以在Job中取出来，实现传参

package com.xy.quartz01.demo;

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

import java.util.Random;

import static org.quartz.JobBuilder.newJob;

/**
 * @author 阳某
 * @create 2019-11-14 16:47
 */
public class demo03 {

    public static void main(String[] args) throws SchedulerException {
        SchedulerFactory factory = new StdSchedulerFactory();

        Scheduler scheduler = factory.getScheduler();

        JobDetail jobDetail = newJob(RamJob.class)
                .withIdentity("job3","group3")
                .withIdentity("参数的传递")
                .build();

        JobDataMap jobDataMap = jobDetail.getJobDataMap();
        jobDataMap.put("name","阳某");
        jobDataMap.put("job","软件开发");
        jobDataMap.put("level","高级程序员");

        Trigger trigger=(Trigger) TriggerBuilder.newTrigger()
//                每6秒执行一次
                .withSchedule(CronScheduleBuilder.cronSchedule("0/6 * * * * ?"))
//                定时定点执行
//                .withIdentity(CronScheduleBuilder.cronSchedule("0 52 09 * * ?"))
                .withIdentity("trigge03r","group3")
                .withDescription("this is a trigger")
                .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

package com.xy.quartz01.demo;

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

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

/**
 * @author 阳某
 * @create 2019-11-14 17:01
 */
@Repository
public class SpringTask {

    @Scheduled(cron = "0/10 * * * * ?")
    public void test(){
        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.xy.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);
	}

}

可以看到，时间只设置了10秒，但是线程休眠了20秒，因为它单线程，所以它等到了30秒后才执行方法
quartz入门（1）_quartz入门_03
end…