Quartz入门

最新推荐文章于 2022-05-24 09:15:21 发布

only老K

最新推荐文章于 2022-05-24 09:15:21 发布

阅读量219

点赞数

分类专栏：框架文章标签： quartz intellij idea java 触发器

本文链接：https://blog.csdn.net/weixin_44255950/article/details/103826523

版权

框架专栏收录该内容

36 篇文章 1 订阅

订阅专栏

Quartz简介

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

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

环境搭建

在这里插入图片描述
导入pom依赖

       <!--导入需要的pom依赖-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aspects</artifactId>
        </dependency>
        <dependency>
            <groupId>org.quartz-scheduler</groupId>
            <artifactId>quartz-jobs</artifactId>
            <version>2.2.1</version>
        </dependency>

入门案例

在这里插入图片描述
直接上代码：（代码中给了注释）
Demo1

package com.onlyk.quartz01.demo;


import com.onlyk.quartz01.job.ReamJob;
import org.quartz.*;
import org.quartz.impl.StdSchedulerFactory;

import static org.quartz.JobBuilder.newJob;

/**
 * @author only老K
 * @create  2020-01-03 19:50
 * quartz的入门案例
 * 讲解quartz定时任务的调用过程
 * 4大核心类
 * schedulerFactory scheduler jobdetail trigger
 */
public class Demo1 {

    public static void main(String[] args) throws Exception {
        SchedulerFactory schedulerFactory = new StdSchedulerFactory();//创建调度工厂
        Scheduler scheduler = schedulerFactory.getScheduler();//获得调度器
        JobDetail jobDetail = newJob(ReamJob.class)//放入代码块
                .withIdentity("job1", "group1")//唯一标识
                .withDescription("这个第一个定时任务案例")//描述
                .build();//构建作业类
        //构建触发器（存放定时任务规则的）
        Trigger trigger=(Trigger) TriggerBuilder.newTrigger()
                //定时任务每6秒执行一次。执行3次  Schedule  n计划 v安排
                .withSchedule(SimpleScheduleBuilder.repeatSecondlyForTotalCount(3,6))
                .withIdentity("trigger1","group1")
                .withDescription("这个第一个触发器")
                .build();
        //将四个核心类进行组装 作业类和触发器进行组装
        scheduler.scheduleJob(jobDetail,trigger);
        //启动定时任务
        scheduler.start();
    }
}

ReamJob

package com.onlyk.quartz01.job;

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

/**
 * @author only老K
 * @create  2020-01-03 19:57
 */
public class ReamJob implements Job {//作业类
    @Override
    public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
        System.out.println("这里是定时任务启动就会执行的地方");
    }
}

效果图如下：
在这里插入图片描述

传递参数

Demo3

package com.onlyk.quartz01.demo;

import com.onlyk.quartz01.job.ReamJob;
import org.quartz.*;
import org.quartz.impl.StdSchedulerFactory;

import static org.quartz.JobBuilder.newJob;

/**
 * @author only老K 我为自己代言
 * @create 2020-01-04 11:06
 * @blogaddress https://blog.csdn.net/weixin_44255950
 * Quartz中参数传递
 *
 */
public class Demo3 {
    public static void main(String[] args) throws Exception {
        SchedulerFactory schedulerFactory = new StdSchedulerFactory();//创建调度工厂
        Scheduler scheduler = schedulerFactory.getScheduler();//获得调度器
        JobDetail jobDetail = newJob(ReamJob.class)//放入代码块
                .withIdentity("job1", "group1")//唯一标识
                .withDescription("这个第一个定时任务传递参数")//描述
                .build();//构建作业类
        JobDataMap jobDataMap = jobDetail.getJobDataMap();
        jobDataMap.put("name","onlyK");
        jobDataMap.put("level","最强王者");
        jobDataMap.put("job","LOL选手");

        //构建触发器（存放定时任务规则的）
        Trigger trigger=(Trigger) TriggerBuilder.newTrigger()
                //定时任务每6秒执行一次
                .withSchedule(CronScheduleBuilder.cronSchedule("0/6 * * * * ?"))
                .withIdentity("trigger2","group1")
                .withDescription("这个第一个触发器")
                .build();
        //将四个核心类进行组装 作业类和触发器进行组装
        scheduler.scheduleJob(jobDetail,trigger);
        //启动定时任务
        scheduler.start();
    }
}

ReamJob

package com.onlyk.quartz01.job;

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

/**
 * @author only老K
 * @create  2020-01-03 19:57
 */
public class ReamJob implements Job {//作业类
    @Override
    public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
        //传递参数
        System.out.println("传递参数");
        JobDataMap jobDataMap=jobExecutionContext.getJobDetail().getJobDataMap();
        System.out.println(jobDataMap.get("name").toString()+jobDataMap.get("level").toString()+jobDataMap.get("job"));
    }
}

在这里插入图片描述

表达式触发器

玩法一（几秒执行一次）

package com.onlyk.quartz01.demo;

import com.onlyk.quartz01.job.ReamJob;
import org.quartz.*;
import org.quartz.impl.StdSchedulerFactory;

import static org.quartz.JobBuilder.newJob;

/**
 * @author only老K
 * @create  2020-01-03 20:14
 * <p>
 * quartz的表达式触发器
 * Dome1存在问题：次数有限制，不够灵活
 */
public class Demo2 {
    public static void main(String[] args) throws Exception {
        SchedulerFactory schedulerFactory = new StdSchedulerFactory();//创建调度工厂
        Scheduler scheduler = schedulerFactory.getScheduler();//获得调度器
        JobDetail jobDetail = newJob(ReamJob.class)//放入代码块
                .withIdentity("job1", "group1")//唯一标识
                .withDescription("这个第一个定时任务案例")//描述
                .build();//构建作业类
        //构建触发器（存放定时任务规则的）
        Trigger trigger = (Trigger) TriggerBuilder.newTrigger()
                //指定表达式的触发规则 一共六个占位符
                //从第0秒开始每3秒一次
                .withSchedule(CronScheduleBuilder.cronSchedule("0/3 * * * * ?"))
                .withIdentity("trigger1", "group1")
                .withDescription("这个第一个触发器")
                .build();
        //将四个核心类进行组装 作业类和触发器进行组装
        scheduler.scheduleJob(jobDetail, trigger);
        //启动定时任务
        scheduler.start();
    }
}

在这里插入图片描述

玩法二（固定时间点执行一次）

package com.onlyk.quartz01.demo;

import com.onlyk.quartz01.job.ReamJob;
import org.quartz.*;
import org.quartz.impl.StdSchedulerFactory;

import static org.quartz.JobBuilder.newJob;

/**
 * @author only老K
 * @create  2020-01-03 20:14
 * <p>
 * quartz的表达式触发器
 * Dome1存在问题：次数有限制，不够灵活
 */
public class Demo2 {
    public static void main(String[] args) throws Exception {
        SchedulerFactory schedulerFactory = new StdSchedulerFactory();//创建调度工厂
        Scheduler scheduler = schedulerFactory.getScheduler();//获得调度器
        JobDetail jobDetail = newJob(ReamJob.class)//放入代码块
                .withIdentity("job1", "group1")//唯一标识
                .withDescription("这个第一个定时任务案例")//描述
                .build();//构建作业类
        //构建触发器（存放定时任务规则的）
        Trigger trigger = (Trigger) TriggerBuilder.newTrigger()
                //指定表达式的触发规则 一共六个占位符
                //从第0秒开始每3秒一次
//                .withSchedule(CronScheduleBuilder.cronSchedule("0/3 * * * * ?"))
                //在20.21触发定时任务
                .withSchedule(CronScheduleBuilder.cronSchedule("0 21 20 * * ?"))
                .withIdentity("trigger1", "group1")
                .withDescription("这个第一个触发器")
                .build();
        //将四个核心类进行组装 作业类和触发器进行组装
        scheduler.scheduleJob(jobDetail, trigger);
        //启动定时任务
        scheduler.start();
    }
}

在这里插入图片描述

Spring task Vs Quartz

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

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

验证线程问题

SpringTask线程

SpringTask

package com.onlyk.quartz01.springtask;

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

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

/**
 * @author only老K
 * @create  2020-01-03 20:26
 * springTask定时任务
 */
@Service
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.onlyk.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);
    }

}

在这里插入图片描**加粗样式**述
这里可以看到是每30秒一次

Quartz线程

ReamJob

package com.onlyk.quartz01.job;

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

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

/**
 * @author only老K
 * @create  2020-01-03 19:57
 */
public class ReamJob implements Job {//作业类
    @Override
    public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
//        System.out.println("这里是定时任务启动就会执行的地方");
            SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            System.err.println(format.format(new Date())+" : 这是一个quartz的定时任务...");

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

Demo2

package com.onlyk.quartz01.demo;

import com.onlyk.quartz01.job.ReamJob;
import org.quartz.*;
import org.quartz.impl.StdSchedulerFactory;

import static org.quartz.JobBuilder.newJob;

/**
 * @author only老K
 * @create  2020-01-03 20:14
 * <p>
 * quartz的表达式触发器
 * Dome1存在问题：次数有限制，不够灵活
 */
public class Demo2 {
    public static void main(String[] args) throws Exception {
        SchedulerFactory schedulerFactory = new StdSchedulerFactory();//创建调度工厂
        Scheduler scheduler = schedulerFactory.getScheduler();//获得调度器
        JobDetail jobDetail = newJob(ReamJob.class)//放入代码块
                .withIdentity("job1", "group1")//唯一标识
                .withDescription("这个第一个定时任务案例")//描述
                .build();//构建作业类
        //构建触发器（存放定时任务规则的）
        Trigger trigger = (Trigger) TriggerBuilder.newTrigger()
                //指定表达式的触发规则 一共六个占位符
                //从第0秒开始每3秒一次
//                .withSchedule(CronScheduleBuilder.cronSchedule("0/3 * * * * ?"))
                //在20.21触发定时任务
                .withSchedule(CronScheduleBuilder.cronSchedule("0/10 * * * * ?"))
                .withIdentity("trigger1", "group1")
                .withDescription("这个第一个触发器")
                .build();
        //将四个核心类进行组装 作业类和触发器进行组装
        scheduler.scheduleJob(jobDetail, trigger);
        //启动定时任务
        scheduler.start();
    }
}

在这里插入图片描述
这里可以看到是每20秒一次

only老K

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Quartz入门

目录Quartz简介环境搭建入门案例表达式触发器玩法一（几秒执行一次）玩法二（固定时间点执行一次）Spring task Vs Quartz验证线程问题SpringTask线程Quartz线程Quartz简介任务调度框架“Quartz”是OpenSymphony开源组织在Job scheduling领域又一个开源项目，是完全由java开发的一个开源的任务日程管理系统，  &nbsp...
复制链接

扫一扫