Spring中使用quartz

最新推荐文章于 2023-06-08 19:37:06 发布
最新推荐文章于 2023-06-08 19:37:06 发布
阅读量72 收藏
点赞数
文章标签： 数据库 python java
原文链接：https://my.oschina.net/douspeng/blog/397274
版权

2019独角兽企业重金招聘Python工程师标准>>> hot3.png

1.Quartz基础

     quartz对任务调度核心领域问题惊醒了高度抽象，提出了调度器，任务，和触发器这三个核心概念，并在org.quartz通过接口和类对核心概念进行描述。

Scheduler接口: quartz的执行线程，它根据Trigger决定调度时刻，根据JobDetail的说明实例化并运行Job

JobDetail类: 可持久化的任务描述信息。任务虽然分组，但是仅用作管理标示，任务之间并无实质性关联, 例如无法定义job chain。

Trigger类:任务的调度策略。这里的特点是调度策略与任务描述分开，调度策略和任务描述都可以分别在Scheduler注册，然后再关联起来。JobDetail与Trigger的关系是一对多。

JobDataMap: 将任务的运行时可持久化状态信息从JobDetail类中分离出来

Job接口: 任务的执行代码

StatefulJob接口: 无状态任务对应的JobDataMap可以认为是只读的,而有状态的任务在多次执行过程中保留对JobDataMap所作的修改,一个后果是有状态任务无法被并发执行。

JobExecutionException类: 可以通过JobExecutionException调整调度程序的下一步动作

Calendar接口: 用于从trigger的调度计划中排除某些时间段，例如假期等。

 ThreadPool:

2.使用SimpleTrigger与CronTrigger：

import org.quartz.*;
import org.quartz.impl.StdSchedulerFactory;
/**
 * Created by Dou on 2014/12/1 0001.
 */
public class SimpleTriggerAndCornTriggerRunner {
    public static void main(String[] args) {
        try {
            /**
             * quartz jar 2.2.1版本写法
             */
            //创建jobDeail实例，绑定Job实现类
            //指明job的名称，组名，以及绑定的类 jar包版本为2.2.1
            JobDetail jobDetail = JobBuilder.newJob(SimpleJob.class).withIdentity("job1_2", "jGroup1").build();
            //使用simpleTrigger规则  jar包版本为2.2.1
            Trigger simpleTrigger = TriggerBuilder.newTrigger().withIdentity("trigger1_1","tgroup1").startNow()
                    .withSchedule(SimpleScheduleBuilder.simpleSchedule()
                            .withIntervalInSeconds(2) //时间价格
                            .withRepeatCount(4)       //重复次数（将执行5次）
                    )
                    .build();
            //使用CornTrigger规则  jar包版本为2.2.1
            Trigger trigger = TriggerBuilder.newTrigger().withIdentity("trigger1_2","tgroup1")
                    .withSchedule(CronScheduleBuilder.cronSchedule("0/3 * * * * ？"))
                    .startNow()
                    .build();
            /**
             * quartz jar 1.8.4版本写法
             */
//            JobDetail jobDetail = new JobDetail("job1_1", "jgroup1",SimpleJob.class);
//              //使用CornTrigger规则 1.8.4版本写法
//            SimpleTrigger simpleTrigger = new SimpleTrigger("trigger1_1","tgroup1");
//            simpleTrigger.setStartTime(new Date());
//              simpleTrigger.setRepeatInterval(2000);
//              simpleTrigger.setRepeatCount(100);
              //使用CornTrigger规则 1.8.4版本写法
/*            CronTrigger cronTrigger = new CronTrigger("trigger1_2", "tgroup1");
              CronExpression cexp = new CronExpression("0/5 * * * * ?");
              cronTrigger.setCronExpression(cexp);*/
            /**
             * quartz jar 1.8.4版本写法end
             */
        
            SchedulerFactory schedulerFactory =new StdSchedulerFactory();
            Scheduler scheduler = null;
            //通过schedulerFActory获得一个调度器
            scheduler = schedulerFactory.getScheduler();
            //把作业和触发器注册到任务调度中
            scheduler.scheduleJob(jobDetail,simpleTrigger);
            //启动调度
            scheduler.start();
            //1.8.4版本 使用corntrigger方式看本例的时候需要通过(Thread.currentThread().sleep();)方式让主线程睡眠一段时间，
            //使用调度器可以继续执行任务调度的工作。否则在调度器启动后，因为主线程马上推出去，
            //寄生于主线程的调度器也将关闭，调度器中的任务都将相应销毁，导致看不清实际的运行效
            //果。
            //可以通过单元测试的时候让主线程睡眠一段时间，使用下面的方式。
            //
/*            try {
                // wait 30 seconds to show jobs
                Thread.sleep(30L * 1000L);
                // executing...
            } catch (Exception e) {
            }
            scheduler.shutdown(true);*/
        }catch (Exception e){
        }
    }
}


所需job类：

import org.quartz.Job;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import java.text.SimpleDateFormat;
import java.util.Date;
/**
 * Created by Dou on 2014/11/28 0028.
 */
/*
<!-- 如果在spring中使用MethodInvokingJobDetailFactoryBean 业务类注册job时候不用实现job接口 在spring3.x.x版本后可用 -->
 */
public class SimpleJob implements Job {
    @Override
    public void execute(JobExecutionContext jobEC) throws JobExecutionException {
        System.out.println(" Time is: "+( new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date())));
    }
    public void doWork(){
        System.out.println(" Time is: "+( new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date())));
    }
}
public class MyService { 不实现Job接口的job
    public void test(){
        System.out.println("Hello!");
    }
}

quart与spring:

web.xml:
 <context-param>
   <param-name>contextConfigLocation</param-name>
   <param-value>
         classpath*:/applicationContext-main.xml,classpath*:/applicationContext-quartz.xml
       </param-value>
</context-param>
applicationContext-quartz.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"
       xmlns:p="http://www.springframework.org/schema/p"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.0.xsd"
       default-lazy-init="true">
    <!-- 启动触发器 -->
    <bean name="scheduler" lazy-init="false" autowire="no" class="org.springframework.scheduling.quartz.SchedulerFactoryBean">
        <property name="triggers">
            <list>
                <ref bean="myJobTrigger" />
                <ref bean="simpleTrigger" />
            </list>
        </property>
        <property name="startupDelay" value="30" />  <!--单位：秒-->
        <property name="configLocation" value="classpath:/quartz.properties" />
    </bean>
    <!-- 调度配置 -->
    <!-- 调度配置cronTrigger -->
    <bean id="myJobTrigger" class="org.springframework.scheduling.quartz.CronTriggerFactoryBean"
         p:startDelay="1000" >  <!--单位：毫秒-->
        <property name="jobDataAsMap">
            <map>
                <entry key="count" value="10" />
            </map>
        </property>
        <property name="jobDetail">
            <ref bean="myJobDetail" />
        </property>
        <property name="cronExpression">
            <value>0/3 * * * * ?</value>
        </property>
    </bean>
    <!-- 调度配置simpleTrigger -->
    <bean id="simpleTrigger" class="org.springframework.scheduling.quartz.SimpleTriggerFactoryBean"
          p:jobDetail-ref="myJobDetail" p:startDelay="1000" p:repeatInterval="2000"
          p:repeatCount="100">
        <property name="jobDataAsMap">
            <map>
                <entry key="count" value="10" />
            </map>
        </property>
    </bean>
    
    <!-- job配置 -->
    <!-- 使用MethodInvokingJobDetailFactoryBean 业务类不用实现job接口 在spring3.x.x版本后可用 -->
    <bean id="myJobDetail" class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean">
        <property name="targetObject">
            <ref bean="myService" />
        </property>
        <property name="targetMethod">
            <value>test</value>
        </property>
        <property name="concurrent">  <!-- 指定任务类型是否与状态 false：有状态，有状态的任务不能并发执行-->
            <value>false</value>
        </property>
    </bean>
    <bean id="myJob" class="com.dou.app.quartz.SimpleJob"/>
    <bean id="myService" class="com.dou.app.quartz.MyService"/>
<!-- quartz.jar.1.x 版本写法 -->
    <!--<bean name="jobDetail" class="org.springframework.scheduling.quartz.JobDetailBean"-->
          <!--p:jobClass="com.dou.app.quartz.SimpleJob"-->
          <!--p:applicationContextJobDataKey="applicationContext">-->
        <!--<property name="jobDataAsMap">-->
            <!--<map>-->
                <!--<entry key="size" value="10" />-->
            <!--</map>-->
        <!--</property>-->
    <!--</bean>-->
    <!--<bean id="scheduler"-->
          <!--class="org.springframework.scheduling.quartz.SchedulerFactoryBean">-->
        <!--<property name="triggers">-->
            <!--<list>-->
                <!--<ref bean="simpleTrigger" />-->
            <!--</list>-->
        <!--</property>-->
        <!--<property name="schedulerContextAsMap">-->
            <!--<map>-->
                <!--<entry key="timeout" value="30" />-->
            <!--</map>-->
        <!--</property>-->
        <!--<property name="quartzProperties">-->
            <!--<props>-->
                <!--<prop key="org.quartz.threadPool.class">-->
                    <!--org.quartz.simpl.SimpleThreadPool-->
                <!--</prop>-->
                <!--<prop key="org.quartz.threadPool.threadCount">10</prop>-->
            <!--</props>-->
        <!--</property>-->
    <!--</bean>-->
</beans>

quartz.properties:

#集群的配置，这里不使用集群
#org.quartz.scheduler.instanceName = DefaultQuartzScheduler
#配置调度器的线程池
org.quartz.threadPool.class = org.quartz.simpl.SimpleThreadPool
org.quartz.threadPool.threadCount = 10
org.quartz.threadPool.threadPriority = 5
org.quartz.threadPool.threadsInheritContextClassLoaderOfInitializingThread = true
# Using RAMJobStore
## if using RAMJobStore, please be sure that you comment out the following
## - org.quartz.jobStore.tablePrefix, 
## - org.quartz.jobStore.driverDelegateClass, 
## - org.quartz.jobStore.dataSource
#配置任务调度现场数据保存机制
# RAMJobStore：将信息保存在RAM中
org.quartz.jobStore.class = org.quartz.simpl.RAMJobStore
# Using JobStoreTX 将调度现场数据保存在数据库中
## Be sure to run the appropriate script(under docs/dbTables) first to create tables
#org.quartz.jobStore.class = org.quartz.impl.jdbcjobstore.JobStoreTX
# Configuring JDBCJobStore with the Table Prefix 设定数据库表前缀
#org.quartz.jobStore.tablePrefix = QRTZ_
# Using DriverDelegate
#org.quartz.jobStore.driverDelegateClass = org.quartz.impl.jdbcjobstore.StdJDBCDelegate
#org.quartz.jobStore.driverDelegateClass = org.quartz.impl.jdbcjobstore.oracle.OracleDelegate
#org.quartz.jobStore.driverDelegateClass=org.quartz.impl.jdbcjobstore.HSQLDBDelegate
# Using datasource 设置数据源名称
#org.quartz.jobStore.dataSource = qzDS
# Define the datasource to use
##Mysql
#org.quartz.dataSource.qzDS.driver = com.mysql.jdbc.Driver
#org.quartz.dataSource.qzDS.URL = jdbc:mysql://192.168.3.128:3306/manager?useUnicode=true&characterEncoding=utf-8
#org.quartz.dataSource.qzDS.user = root
#org.quartz.dataSource.qzDS.password = 1234
#org.quartz.dataSource.qzDS.maxConnections = 30
#Oracle
#org.quartz.dataSource.qzDS.driver = oracle.jdbc.driver.OracleDriver
#org.quartz.dataSource.qzDS.URL = jdbc:oracle:thin:@localhost:1521:ora9i
#org.quartz.dataSource.qzDS.user = stamen
#org.quartz.dataSource.qzDS.password = abc
#org.quartz.dataSource.qzDS.maxConnections = 30

转载于:https://my.oschina.net/douspeng/blog/397274

weixin_34220963
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Springboot Quartz定时任务的动态调度使用，实战详解
2303_77877769的博客
04-17 1089
针对最近很多人都在面试，我这边也整理了相当多的面试专题资料，也有其他大厂的面经。希望可以帮助到大家。下面的面试题答案都整理成文档笔记。也还整理了一些面试资料&最新2021收集的一些大厂的面试真题（都整理成文档，小部分截图）最新整理电子书《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取！定时任务，模拟多定时任务调度处理不同业务：/****/
Spring 中使用Quartz实现任务调度
08-31
在Spring中使用Quartz有两种主要方式： 1. **继承QuartzJobBean**： 这种方法要求作业类（Job）继承自`org.springframework.scheduling.quartz.QuartzJobBean`。`QuartzJobBean`是Spring为Quartz提供的一个抽象...
Spring中如何使用Quartz
我是你妹她哥的博客
07-20 4330
背景： 接着上一篇文章，项目当中有个需求需要定时去检测工单的状态，这时我就想到了使用quartz来做一个任务调度系统。本篇文章就是给大家介绍如何在spring中加入quartz。 spring集成Quartz： 首先第一步肯定是在pom文件中导入相关的包。pom.xml: &lt;dependency&gt; &lt;groupId&gt;org.apache.loggin...
Spring中使用Quartz两种实现方式
QZC78的博客
08-11 2360
spring+quartz
spring中使用quartz
程序员笔记
04-04 651
一、引入相关包 如果需要在web应用中使用quartz ，则将quartz-all-1.6.0.jar得到到WEB-INF/lib目录下，其它依赖的包根据情况引入（本地还需引入 jta-1.1.jar、commons-collections-3.2.1.jar）。 二、quartz简单介绍  1、quartz运行的基本属性 quartz提供了一个名为quartz.properties的配置...
quartz开源任务调度框架知识总结（一）
weixin_30915275的博客
02-19 254
1.1.1JDK Timer & TimerTask 如果是执行简单的有一定执行周期的，那么使用jdk自带的timer是最简单的。具体： ①、编写一个简单类继承 TimerTask，在这个新编写的类中重写父类中run方法，在run中执行要执行的操作； ②、编写一个简单类，在类中写一个方法，方法体中使用timer调用在①中创建的类...
在spring中使用quartz
12-12
在Quartz中，任务被称为“Job”，而执行时间的计划被称为“Trigger”。一个Job可以被多个Trigger触发，而一个Trigger也可以关联到多个Job。JobDetail代表了Job的具体实现，包含了Job类的信息和执行时所需的参数。...
Spring中使用Quartz(二)
03-16
本篇将深入探讨如何在Spring项目中使用Quartz，以及与TimerTask的区别。 1. **TimerTask vs Quartz** - **TimerTask**: 是Java标准库中的一个类，适用于简单定时任务的执行。它使用单线程模型，如果一个任务执行...
spring中使用Quartz完成时序调度工作
03-16
NULL 博文链接：https://liuxi1024.iteye.com/blog/345093
SpringQuartz的使用文档
09-17
Spring对Quartz进行了集成，使其更易于在Spring应用程序中使用。Spring提供了`FactoryBean`类，如`SchedulerFactoryBean`，用于创建和管理Quartz的`Scheduler`实例。这使得我们可以利用Spring的依赖注入（DI）和管理...
Spring中quartz的使用
人生所向，皆是美好
01-11 619
Quartz是一个丰富的特色，开放源码的作业调度库，可以集成在几乎任何应用程序-从最小的单机应用到最大的电子商务系统。Quartz 可以用来创建简单的或复杂的时间表，用于执行数，数百，甚至数万个工作岗位的任务，其任务被定义为标准的java组件，可以执行几乎任何你可以计划做。Quartz 调度包括很多企业级功能，如JTA事务支持和聚类。 那么在Spring中怎么使用quartz呢？ 1.导入jar
在Spring中使用quartz
漫步
01-08 2587
写了一个自动去moofeel网站签到领金币魔币的程序，想要每天早上九点自动运行，于是考虑在Spring中用quartz实现 用maven创建 web工程，可参考在ECLIPSE中使用maven插件创建webapp类型项目 引入spring 和 quartz包 org.springframework spring-core ${spring.version}
在 Spring 中使用 Quartz
weixin_30783629的博客
08-15 223
Spring 为创建 Quartz 的 Scheduler、Trigger 和 JobDetail 提供了便利的 FactoryBean 类，以便能够在 Spring 容器中享受注入的好处。此外，Spring 还提供了一些便利工具类，用于直接将 Spring 中的 Bean 包装成合法的任务。Spring 进一步降低了使用 Quartz 的难度，能以更具风格的方式使用 Quartz。概括...
quartz+spring使用
qq_26789867的博客
07-13 853
1.spring框架搭建（略：具体看ssm框架搭建） 2.配置quartz <?xml version="1.0" encoding="UTF-8"?> <!-- ~ #{copyright}# --> <beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://www.springframework.org/schema/beans" xmlns:conte
Spring+Quartz的定时器使用
最新发布
Artisan_w
06-08 412
Spring+Quartz的定时器使用
使用spring+quartz配置多个定时任务
pansanday的专栏
01-06 1万+
Spring被用在了越来越多的项目中, quartz也被公认为是比较好用的定时器设置工具, 在这里通过一个demo说明如何使用spring和quartz配置多个定时任务. 环境: eclipse + maven + spring 3.0.6.RELEASE版本 + quartz 1.8.6版本
Spring+Quartz实现定时任务的配置方法
tomorrow_fine的博客
07-09 301
出处:http://blog.csdn.net/l1028386804/article/details/46376093 1、Scheduler的配置 [html] view plain copy bean class="org.springframework.scheduling.quartz.SchedulerFactoryBean">   
spring4.1.5 配置quartz2.2.1
登高必自卑，涉远必自迩
11-04 953
一：需要的jar包如下： 二：spring 配置文件如下： autoRun 0 36 16 ? * *
springboot整合quartz项目使用（含完整代码）
热门推荐
gorylee的博客
11-28 3万+
学习quartz有两方面，首先xxl-Job，elastic-Job这些框架都是基于quartz的基础上二次开发的，学习quartz更有利于我们加强理解定时调度。第二方面就是工作需求，有一些传统互联网公司还是有很多项目是使用quartz来完成定时任务的开发的。
spring boot 使用Quartz
05-14
在 Spring Boot 中使用 Quartz 非常简单，只需要按照以下步骤： 1. 添加依赖 在 pom.xml 文件中添加 Quartz 依赖： ```xml <dependency> <groupId>org.quartz-scheduler</groupId> <artifactId>quartz</artifactId> <version>2.3.2</version> </dependency> ``` 2. 配置 Quartz 在 Spring Boot 应用程序中，可以通过 `@Bean` 注解将 Quartz 配置为 Spring Bean。在配置文件中，可以使用 `quartz.properties` 文件或者直接使用 Java 代码进行配置。 以下是使用 Java 代码配置 Quartz 的示例： ```java @Configuration public class QuartzConfig { @Bean public JobDetail jobDetail() { return JobBuilder.newJob().ofType(MyJob.class).storeDurably().withIdentity("MyJob").withDescription("My Job").build(); } @Bean public Trigger trigger(JobDetail job) { return TriggerBuilder.newTrigger().forJob(job).withIdentity("MyTrigger").withDescription("My Trigger").withSchedule(CronScheduleBuilder.cronSchedule("0 0/5 * * * ?")).build(); } @Bean public Scheduler scheduler(Trigger trigger, JobDetail job, DataSource dataSource) throws SchedulerException { StdSchedulerFactory factory = new StdSchedulerFactory(); factory.initialize(); Scheduler scheduler = factory.getScheduler(); scheduler.setJobFactory(springBeanJobFactory()); scheduler.getContext().put("dataSource", dataSource); scheduler.scheduleJob(job, trigger); scheduler.start(); return scheduler; } @Bean public SpringBeanJobFactory springBeanJobFactory() { return new SpringBeanJobFactory(); } } ``` 在上面的示例中，定义了一个 `MyJob` 类，该类实现了 `org.quartz.Job` 接口。然后使用 `JobBuilder` 创建 `JobDetail` 对象，并将 `MyJob` 类型指定为 Job 类型。接下来，使用 `TriggerBuilder` 创建 `Trigger` 对象，并将其与 `JobDetail` 绑定。最后，创建一个 `Scheduler` 对象，并将 `JobDetail` 和 `Trigger` 对象传递给它，并启动调度器。 3. 创建 Job 类 在上面的示例中，我们定义了一个 `MyJob` 类，用于执行需要定时执行的任务。以下是 `MyJob` 类的示例代码： ```java public class MyJob implements Job { private static final Logger logger = LoggerFactory.getLogger(MyJob.class); @Override public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException { logger.info("Executing My Job ..."); // 执行需要执行的任务 } } ``` 4. 测试 现在，我们已经完成了 Quartz 的配置和 Job 类的创建。我们可以启动应用程序并等待定时任务的执行。如果一切正常，应该会看到类似以下的输出： ``` INFO c.e.q.MyJob - Executing My Job ... ``` 这就是使用 Quartz 在 Spring Boot 中执行定时任务的方法。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值