Quartz的具体实现

最新推荐文章于 2024-06-29 10:43:48 发布
最新推荐文章于 2024-06-29 10:43:48 发布
阅读量389 收藏
点赞数
分类专栏： 后端污水管 文章标签： quartz 工厂模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_32200417/article/details/78598434
版权

既然你翻到了我这的博客，说明你起码应该对quartz是什么有一个大致的了解了，介绍免了，直接上操作。

五步走

  1. 创建调度工厂(); //工厂模式
  2. 根据工厂取得调度器实例(); //工厂模式
  3. Builder模式构建子组件
  4. 通过调度器组装子组件 调度器.组装<子组件1,子组件2…> //工厂模式
  5. 调度器.start(); //工厂模式
基础版
public class Job implements org.quartz.Job{

    @Override
    public void execute(JobExecutionContext arg0) throws JobExecutionException {
        System.out.println("我是第1个quartz程序，继承Job"+new Date());
    }
}

//调用Job类，实现Quartz功能
public class QuartzJob {

    public static void main(String[] args) throws Exception {
//      1.任务，调用业务
        JobDetail jobDetail = new JobDetail("job_1","g_job1",Job.class);
//      2.触发器
        CronTrigger cron = new CronTrigger("trigger_1","g_trigger");
//      每五秒执行一次
        cron.setCronExpression("0/5 * * * * ?");
//      3.调度器
        SchedulerFactory schedulerFactory = new StdSchedulerFactory();
//      获取调度器
        Scheduler s = schedulerFactory.getScheduler();
//      添加任务和触发器
        s.scheduleJob(jobDetail,cron);
//      开始监听
        s.start();
    }

}
Timer写法

import java.util.Date;
import java.util.Timer;
import java.util.TimerTask;

public class JDKTimer {

    public static void main(String[] args) {
        Timer t = new Timer();
//      1.业务；2.延迟时间执行；3.重复时间执行（单位：毫秒）
        t.schedule(new Task(), 4000L, 5000L);
    }
}

class Task extends TimerTask {

    @Override
    public void run() {
        System.out.println("我是第2个quartz程序，继承TimerTask" + new Date());
    }

}
配置xml方式
import java.util.Date;

public class Job {
//  不能有参数，返回值无效
    public void job2() {
        System.out.println("我是quartz自定义方法的输出内容 "+new Date());
    }
}

xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
    http://www.springframework.org/schema/beans/spring-beans-4.0.xsd">

    <!-- 1.业务逻辑 -->
    <bean id="job" class="com.etoak.job2.Job"/>

    <!-- 2.任务，默认名称DEFAULT -->
    <bean id="jobDetail" class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean">
        <!-- 任务调用业务类 -->
        <property name="targetObject" ref="job"/>
        <!-- 任务调用业务类中的方法 -->
        <property name="targetMethod" value="job2"/>
    </bean>
    <!-- 3.触发器，默认名称DEFAULT -->
    <bean id="cronTrigger" class="org.springframework.scheduling.quartz.CronTriggerBean">
        <!-- 触发器调用任务 -->
        <property name="jobDetail" ref="jobDetail"/>
        <!-- 设置指定时间(隔五秒执行) -->
        <property name="cronExpression" value="0/5 * * * * ?" />
    </bean>
    <!-- 4.调度器(监听器) 容器启动时加载 -->
    <bean class="org.springframework.scheduling.quartz.SchedulerFactoryBean">
        <!-- 启动监听触发器 -->
        <property name="triggers">
            <list>
                <ref bean="cronTrigger"/>
            </list>
        </property>
    </bean>
</beans>

自己去web.xml配置监听器和spring支持，不表。

注解版
import java.util.Date;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;

import sun.misc.Contended;

@Component("joob")
public class Job {
    @Scheduled(cron="0/5 * * * * ?")
    public void job3() {
        System.out.println("我是使用注解的quartz输出的 : "+new Date());
    }
}

xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:context="http://www.springframework.org/schema/context"
    xmlns:task="http://www.springframework.org/schema/task"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
    http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
    http://www.springframework.org/schema/context
    http://www.springframework.org/schema/context/spring-context-4.0.xsd
    http://www.springframework.org/schema/task
    http://www.springframework.org/schema/task/spring-task-4.0.xsd">

    <!-- 扫描注解 ioc -->
    <context:component-scan base-package="com.etoak" />

    <!-- 扫描注解 quartz  监听器 -->
    <task:annotation-driven />

</beans>

如果说上面的你都看完了，并且自己写出来了，首先恭喜你的认真，

然后，重点来了！！！

==springmvc + quartz==

controller

package com.etoak.job4;

import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;

import org.quartz.CronTrigger;
import org.quartz.JobDetail;
import org.quartz.Scheduler;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.quartz.SchedulerFactoryBean;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

import com.etoak.job1.Job;
@Controller
@RequestMapping("/quartz")
public class QuartzController {
//  调度器
    @Autowired
    private SchedulerFactoryBean sfb;

    @ResponseBody
    @RequestMapping(params="method=startQ")
    public Map<String,Object> startQ() throws Exception{
        Map<String,Object> result = new HashMap<>();
//      1.任务
        JobDetail jobDetail = new JobDetail("job_1","g_job1",Job.class);
//      2.触发器
        CronTrigger cron = new CronTrigger("trigger_1","g_job1");
//      设置指定时间执行(5s)
        cron.setCronExpression("0/5 * * * * ?");
//      启动时间
        DateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        Date date = df.parse("2017-11-21 22:40:00");
        cron.setStartTime(date);
//      3.调度器（监听器）
        Scheduler s = sfb.getScheduler();
//      添加任务和触发器
        s.scheduleJob(jobDetail, cron);
        result.put("success", 200);
        return result;
    }
    @ResponseBody
    @RequestMapping(params="method=endQ")
    public Map<String,Object> endQ() throws Exception {
        Map<String,Object> result = new HashMap<>();
//      获得调度
        Scheduler s = sfb.getScheduler();
//      获取一个trigger对象（触发器对象）：1.触发器名称，spring中id别名2.参数触发器组名称
        CronTrigger cron = (CronTrigger)s.getTrigger("trigger_1","g_job1");
        DateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        Date endTime = df.parse("2017-11-21 23:50:00");
        cron.setEndTime(endTime);
//      重新添加触发器：1.触发器名称，2.触发器组名称，3.重新添加的触发器对象信息
        s.rescheduleJob("trigger_1","g_job1", cron);
        result.put("success", 200);
        return result;
    }
    @ResponseBody
    @RequestMapping(params="method=pauseQ")
    public Map<String,Object> pauseQ() throws Exception {
        Map<String,Object> result = new HashMap<>();
        Scheduler s = sfb.getScheduler();
        s.pauseTrigger("cronTrigger", Scheduler.DEFAULT_GROUP);
        result.put("success", 200);
        return result;
    }
    @ResponseBody
    @RequestMapping(params="method=resumeQ")
    public Map<String,Object> resumeQ() throws Exception {
        Map<String,Object> result = new HashMap<>();
        Scheduler s = sfb.getScheduler();
        s.resumeTrigger("cronTrigger", Scheduler.DEFAULT_GROUP);
        result.put("success", 200);
        return result;
    }
}

springmvc

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:mvc="http://www.springframework.org/schema/mvc"
    xmlns:task="http://www.springframework.org/schema/task"
    xmlns:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="http://www.springframework.org/schema/beans 
    http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
    http://www.springframework.org/schema/context
    http://www.springframework.org/schema/context/spring-context-4.0.xsd
    http://www.springframework.org/schema/task
    http://www.springframework.org/schema/task/spring-task-4.0.xsd
    http://www.springframework.org/schema/mvc
    http://www.springframework.org/schema/mvc/spring-mvc-4.0.xsd">

    <!-- 扫描注解 ioc -->
    <context:component-scan base-package="com.etoak"/>

    <!-- 映射器，适配器 -->
    <mvc:annotation-driven/>

    <!-- 视图解析器 -->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="prefix" value="/"></property>
        <property name="suffix" value=".jsp"></property>
    </bean>
</beans>

jsp

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Insert title here</title>
<script type="text/javascript" src="${pageContext.request.contextPath }/js/jquery-1.11.1.min.js"></script>
<script type="text/javascript">
    function q(param){
        $.ajax({
            url : "${pageContext.request.contextPath }/quartz.do",
            data : {"method":param},
            type : "post",
            dataType : "json",
            success : function(data){
                 if(data.msg == 200){
                    alert("成功");
                }else
                    alert("失败"); 
            }
        });
    }
</script>
</head>
<body>
    <a href="javascript:void(0);" onclick="q('startQ')">
        启动
    </a>
    <br/>
    <a href="javascript:void(0);" onclick="q('endQ')">
        结束
    </a>
    <br/>
    <a href="javascript:void(0);" onclick="q('pauseQ')">
        暂停
    </a>
    <br/>
    <a href="javascript:void(0);" onclick="q('resumeQ')">
        重启
    </a>
</body>
</html>

补充一些cron表达式用法

字段允许值允许的特殊字符
秒0-59, - * /
分0-59, - * /
小时0-23, - * /
日期1-31
    • ? / L W C
月份1-12/JAN-DEC, - * /
星期1-7/SUN-SAT, - * ? / L C #
年留空/1970-2099, - * /
顺序：秒 分 小时 日期 月份 星期 年

我感觉，与其长文介绍每种符号，不如给你点例子自己琢磨一下更好使

表达式举例

“0 0 12 * * ?” 每天中午12点触发

“0 15 10 ? * *” 每天上午10:15触发

“0 15 10 * * ?” 每天上午10:15触发

“0 15 10 * * ? *” 每天上午10:15触发

“0 15 10 * * ? 2005” 2005年的每天上午10:15触发

“0 * 14 * * ?” 在每天下午2点到下午2:59期间的每1分钟触发

“0 0/5 14 * * ?” 在每天下午2点到下午2:55期间的每5分钟触发

“0 0/5 14,18 * * ?” 在每天下午2点到2:55期间和下午6点到6:55 60期间的每5分钟触发

“0 0-5 14 * * ?” 在每天下午2点到下午2:05期间的每1分钟触发

“0 10,44 14 ? 3 WED” 每年三月的星期三的下午2:10和2:44触发

“0 15 10 ? * MON-FRI” 周一至周五的上午10:15触发

“0 15 10 15 * ?” 每月15日上午10:15触发

“0 15 10 L * ?” 每月最后一日的上午10:15触发

“0 15 10 ? * 6L” 每月的最后一个星期五上午10:15触发

“0 15 10 ? * 6L 2002-2005” 2002年至2005年的每月的最后一个星期五上午10:15触发

“0 15 10 ? * 6#3” 每月的第三个星期五上午10:15触发

本文只是简单的实现了quartz的基础实现，往后的分布式，集群等都会用到这个，

小伙伴们，任重道远，一起加油吧

此生无悔入暴漫
关注
专栏目录
使用Quartz实现定时任务
qq_41011626的博客
02-07 3688
文章目录前言一、导入Quartz的jar包二、Quartz的整体结构1.创建定时任务对象的Job2.创建执行类3.各个实例之间的关系为总结 前言 使用Quartz实现定时任务 一、导入Quartz的jar包 <dependency> <groupId>org.quartz-scheduler</groupId> <artifactId>quartz</artifactId> <version>2.2.1<..
ASP.NET使用Quartz.NET实现定时任务调度
08-03
Quartz.NET则是一个开源的作业调度库，适用于.NET平台，能够帮助开发者在.NET应用中实现复杂的时间驱动任务。结合使用Quartz.NET和TopShelf，我们可以构建一个在Windows服务中运行的定时任务调度系统。 Quartz.NET...
Quartz 的实现
u013208718的博客
07-25 156
Quartz  maven jar包 &lt;dependency&gt;     &lt;groupId&gt;org.quartz-scheduler&lt;/groupId&gt;     &lt;artifactId&gt;quartz&lt;/artifactId&gt;     &lt;version&gt;2.3.0&lt;/version&gt; &lt;/depende
SpringBoot整合Quartz实现动态定时任务
最新发布
这河里吗l的博客
06-29 2410
Quartz是一个开源的任务调度服务，它可以独立使用，也可与其它的Java EE，Java SE应用整合使用。无论是执行十个，一百个工作的简单任务，还是执行成百上千个工作的复杂调度任务都可以使用Quartz来实现，此外，Quartz还提供了很多企业级应用的特色，如JTA事务支持及集群。如果你的应用中有任务需要在特定的时间执行，亦或周期循环执行，则Quartz也许是你理想的选择。
java作业调度、定时任务实践
wade6的博客
05-26 296
最近项目中用到了定时任务，以前没有接触过，在此对java中定时任务的实现进行总结。   实现定时任务的方式有2种，一种是使用java类库中的java.util.Timer；另一种是使用quartz框架。   Timer只能实现简单的任务调度，quartz可以满足各种复杂的任务调度时间需求。   1、Timer的实现方式   在Timer中存在一个任务（Task）的概念，通过继承...
定时任务的介绍:Quartz实现
编写博客，学习交流
12-20 1141
实现的技术上来分类 Java自带的java.util.Timer类，这个类允许你调度一个java.util.TimerTask任务。使用这种方式可以让你的程序按照某一个频度执行，但不能在指定时间运行。一般用的较少。 Quartz这是一个功能比较强大的的调度器，可以让你的程序在指定时间执行，也可以按照某一个频度执行，配置起来稍显复杂。 Spring3.0以后自带的task可以...
Quartz 实现机制
魏帅超的专栏
12-17 1329
quartz 是目前使用较广的调度管理工具，提供了与Linux下Cron类似的功能，实际上还更强大，可以方便的嵌入到Java系统中，最近就这个调度工具进行了一些简单的研究，主要研究调度后台的机制，quartz中包括的分布式调度和基于数据库的记录不在此处的研究范围，记录在这里方便以后回顾 quartz 调度的主要结构  quartz调度主要由三块组成:Scheduler 调度服务,Tri
Quartz如何实现判断某个任务是否正在运行,在项目中用到的,已经测试过了
06-28
Quartz是一款广泛应用于Java开发中的开源任务调度框架，它提供了强大的定时...在具体实现时，需要结合项目的实际情况，如分布式部署、并发控制等因素进行调整。通过上述步骤，你可以有效地管理和监控你的Quartz任务。
SpringBoot 整合Quartz（集群）实现定时任务调度
02-14
创建一个实现了`org.quartz.Job`接口的类，这个类代表一个具体的任务。通过`@DisallowConcurrentExecution`注解，我们可以防止同一任务在多个节点上同时执行。此外，还需要创建一个`JobDetail`来注册任务，并使用`...
实现quartz定时器及quartz定时器原理介绍
09-04
在本文中，我们将深入探讨Quartz的核心概念以及如何通过一个简单的例子来实现一个基础的定时器。 ### 一、Quartz核心概念 1. **Job**：Job是Quartz的基本执行单元，它定义了一个需要执行的任务。`Job`接口只有一个...
简单的Quartz实现
qq_31484583的博客
10-25 193
创建项目。倒jar包。需要的jar包自己在官网下。或者在我的网盘下载    链接：http://pan.baidu.com/s/1eR5fVbW 密码：4wrn 创建一个类。实现 Job 接口。实现接口里面的方法。做一个简单的输出。 简单的测试代码如下：
quartz的分布式调度大致分两种方式实现
06-08
一.基于JDBC-Jobstore的方式实现集群（有数据库JobStoreTX或JobStoreCMT） 二.TerracottaJobStore的配置（无数据库的集群） 本文介绍的是JDBC-Jobstore基于数据库的集群： 1.目前，群集仅适用于JDBC-Jobstore（JobStoreTX或JobStoreCMT），通过使群集的每个节点共享相同的数据库来工作。 2.负载平衡自动发生，群集的每个节点都尽可能快地触发jobs。当Triggers的触发时间发生时，获取任务的第一个节点（通过在其上放置一个锁定）是将触发它的节点。 3.当其中一个节点在执行一个或多个作业期间失败时发生故障切换。当节点出现故障时，其他节点会检测到该状况并识别数据库中在故障节点内正在进行的作业。任何标记为恢复的作业（在JobDetail上都具有&ldquo;请求恢复&rdquo;属性）将被剩余的节点重新执行。 没有标记为恢复的作业将在下一次相关的Triggers触发时简单地被释放以执行。 4.集群功能最适合扩展长时间运行或cpu密集型作业（通过多个节点分配工作负载）。如果需要扩展以支持数千个短期运行（例如1秒）作业，则可以考虑通过使用多个不同的调度程序（包括HA的多个群集调度程序）对作业集进行分区。 调度程序使用集群范围的锁，这种模式会在添加更多节点（超过三个节点 - 取决于数据库的功能等）时降低性能。
一个简单的Quartz实现
技术分享
04-11 1081
概念： Job——表示一个工作，要执行的具体内容。         接口中只有一个方法： void execute(JobExecutionContext context)  throws JobExecutionException;         JobExecutionContext 是包含各种永远任务调度环境的信息（如源码截图）：
quartz的简单实现
Vivian_xlw的博客
11-09 416
工作中要用到quartz来实现定时任务的触发，任务的触发和暂停都涉及到scheduler，而scheduler的获取方式如下两行代码private static SchedulerFactory sf = new StdSchedulerFactory(); Scheduler sche = sf.getScheduler();于是有点困惑，如果只将sf设置成全局变量，在触发和暂停的方法里分别获取s
Quartz 两种实现方式
08-12 1526
Example to run multiple jobs in Quartz By mkyong | July 30, 2012 | Updated : August 29, 2012 In this example, we show you how to declare multiple Quartz jobs via Quartz APIs, Quartz XML and
Quartz实现定时任务（一）
小灯光环
03-11 2533
关于Quartz框架的简介与应用
Quartz实现任务调度
象在舞的技术专栏
03-16 336
       Quartz是java开源的一个定时任务的工具，它本身不仅可以实现固定时间的定时任务计算还可以实现类似Crontab的指定时间点间隔的定时任务计算。这篇文章以代码为主讲述了如何实现Quartz的任务调度。废话不多说，直接上代码~一、pom.xml文件的配置&lt;!-- https://mvnrepository.com/artifact/org.quartz-scheduler/q...
Quartz实现原理
yjc0403的博客
12-17 1063
Quartz实现原理     主要组成部分：   scheduler（调度器）：将job和trigger绑定在一起 job（任务）              ：配置具体哪个类实现定时任务 trigger（触发器）     ：配置定时器参数，如：多久执行一次，执行多上次等                 Quartz工作原理   分两类线程： Scheduler调度...
使用Quartz实现动态任务调度
在实现类中，可能包含了`execute`方法，这是Quartz Job接口要求的方法，用于执行具体的任务。文章中提到了使用Cron表达式的问题，Cron表达式是Quartz中用来定义调度规则的一种方式，它可以表示复杂的定时策略。然而...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值