Quartz-JobDataMap 参数传递

最新推荐文章于 2024-07-18 09:02:47 发布
最新推荐文章于 2024-07-18 09:02:47 发布
阅读量3w 收藏 23
点赞数 4
分类专栏： 【Quartz任务调度】 文章标签： spring quartz jobdatamap
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yangshangwei/article/details/78515685
版权

文章目录


在这里插入图片描述

概述

我们在Quartz-Job 详解中，讲解了纯Quartz的参数传递，这里我们将通过与Spring结合的方式再次讲解一下Quartz中的参数传递。

JobDataMap

JobDataMap可用于保存任何数量的（可序列化的）数据对象，我们希望在执行时可以将其提供给作业实例。JobDataMap是Java Map接口的一个实现，并且有一些用于存储和检索原始类型的数据的方便方法。

我们来温习下纯Quartz的写法

// 具体任务 JobDetail
JobDetail job = JobBuilder.newJob(HelloJob.class)
        .withIdentity("job1", "group1")
        .usingJobData("jobSays", "Hello World!")
        .usingJobData("myFloatValue", 3.141f)
        .build();

HelloJob如下

/**
 * 具体执行的任务
 */
public class HelloJob implements Job {

    @Override
    public void execute(JobExecutionContext context) throws JobExecutionException {
        JobKey key = context.getJobDetail().getKey();
        JobDataMap dataMap = context.getJobDetail().getJobDataMap();
        String jobSays = dataMap.getString("jobSays");
        float myFloatValue = dataMap.getFloat("myFloatValue");
        System.out.println("Instance " + key + " of DumbJob says: " + jobSays + ", and val is: " + myFloatValue);
    }
}

运行结果

Instance group1.job1 of DumbJob says: Hello World!, and val is: 3.141
Instance group1.job1 of DumbJob says: Hello World!, and val is: 3.141

如果在Job类中定义与JobDataMap中键值一致的set和get方法，那么Quartz会自动将这些属性注入。如：

// 具体任务 JobDetail
JobDetail job = JobBuilder.newJob(HelloJob.class)
    .withIdentity("job1", "group1")
    .usingJobData("name", "artisan")
    .usingJobData("age", 24).build();

HelloJob

import org.quartz.*;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * 具体执行的任务
 */
public class HelloJob implements Job {

    private String name;
    private int age;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public void execute(JobExecutionContext context) throws JobExecutionException {
        JobKey key = context.getJobDetail().getKey();
        System.out.println("Instance " + key + ",姓名：" + name + ",年龄：" + age);
    }
}

运行结果

Instance group1.job1,姓名：artisan,年龄：24
Instance group1.job1,姓名：artisan,年龄：24
Instance group1.job1,姓名：artisan,年龄：24

另外Trigger中也可以设置JobDataMap属性，这是为了在多个Trigger中使用相同的Job。

JobExecutionContext 将会合并JobDetail与Trigger的JobDataMap，如果其中属性名相同，后者将覆盖前者。

可以使用JobExecutionContext.getMergedJobDataMap()方法来获取合并后的JobDataMap。

Xml 配置方式的值的传递

在spring中，如果HelloJob的方法有参数，那么需要指定一些设定才可以，否则会在运行时有NoSuchMethodException异常发生。

简单示例

public class HelloJob {

    public void execute(String args){
        System.out.println("------ " + args + "------ ");
    }
}

xml配置

<!-- 配置JobDetail -->
<bean id="springQtzJobMethod" class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean">
    <!-- 执行目标job -->
    <property name="targetObject" ref="helloJob"></property>

    <!-- 要执行的方法 -->
    <property name="targetMethod" value="execute"></property>

    <!-- 设置参数-->
    <property name="arguments" value="artisan"></property>
</bean>

增加一个arguments的变量，设置一个value即可，如果你点进去观察源代码，会发现，它其实是一个 Object[] 类型的参数

执行结果

------ artisan------ 
------ artisan------

如果你想传递2个参数，示例如下

public void execute(String name, int age) {
    System.out.println("------ " + name + ":" + age + "------ ");
}

<!-- 设置参数-->
<property name="arguments">
   <list>
       <value>artisan</value>
       <value>23</value>
   </list>
</property>

当然，我们也可以传递Map，Set，JavaBean对象等等，这里只是抛砖引玉。

Quartz官方示例

第4个案例

http://www.quartz-scheduler.org/documentation/quartz-2.2.x/examples/Example4.html

示例演示了静态变量和非静态变量的修改，只有静态成员才能改变

package com.xgj.quartz.quartzItself.jobDataMapOfficalDemo;

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

import org.quartz.DisallowConcurrentExecution;
import org.quartz.Job;
import org.quartz.JobDataMap;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.quartz.JobKey;
import org.quartz.PersistJobDataAfterExecution;

@PersistJobDataAfterExecution
@DisallowConcurrentExecution
public class ColorJob implements Job {

	public static final String FAVORITE_COLOR = "favorite color";
	public static final String EXECUTION_COUNT = "count";

	// 由于Quartz会在每次执行时重新实例化一个类，因此成员非静态成员变量不能用于维护状态！
	private int _counter = 1;

	public void execute(JobExecutionContext context)
			throws JobExecutionException {

		JobKey jobKey = context.getJobDetail().getKey();

		JobDataMap data = context.getJobDetail().getJobDataMap();
		String favoriteColor = data.getString(FAVORITE_COLOR);
		int count = data.getInt(EXECUTION_COUNT);

		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");

		System.out.println("任务Key: " + jobKey + " ,执行时间:  "
				+ sdf.format(new Date()) + "\n" + "  传递参数(favorite color): "
				+ favoriteColor + "\n" + "  传递参数(count):  " + count + "\n"
				+ "  ColorJob非静态变量值: " + _counter + "\n");

		count++;
		data.put(EXECUTION_COUNT, count);
		data.put(FAVORITE_COLOR, "黄色");

		_counter++;
	}

}


package com.xgj.quartz.quartzItself.jobDataMapOfficalDemo;

import static org.quartz.DateBuilder.nextGivenSecondDate;
import static org.quartz.JobBuilder.newJob;
import static org.quartz.SimpleScheduleBuilder.simpleSchedule;
import static org.quartz.TriggerBuilder.newTrigger;

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

import org.quartz.JobDetail;
import org.quartz.Scheduler;
import org.quartz.SchedulerFactory;
import org.quartz.SchedulerMetaData;
import org.quartz.SimpleTrigger;
import org.quartz.impl.StdSchedulerFactory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class JobStateExample {

	public void run() throws Exception {
		Logger log = LoggerFactory.getLogger(JobStateExample.class);
		SchedulerFactory sf = new StdSchedulerFactory();
		Scheduler sched = sf.getScheduler();

		// 在当前时间10秒后运行
		Date startTime = nextGivenSecondDate(null, 10);
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");

		// 通过过JobDetail封装ColorJob，同时指定Job在Scheduler中所属组及名称，这里，组名为group1，而名称为job1。
		JobDetail job1 = newJob(ColorJob.class).withIdentity("job1", "group1")
				.build();

		// 创建一个SimpleTrigger实例，指定该Trigger在Scheduler中所属组及名称。
		// 接着设置调度的时间规则.当前时间10秒后运行，每10秒运行一次，共运行4次
		SimpleTrigger trigger1 = newTrigger()
				.withIdentity("trigger1", "group1")
				.startAt(startTime)
				.withSchedule(
						simpleSchedule().withIntervalInSeconds(10)
								.withRepeatCount(4)).build();

		// 将参数传递入任务的数据Map中
		job1.getJobDataMap().put(ColorJob.FAVORITE_COLOR, "绿色");
		job1.getJobDataMap().put(ColorJob.EXECUTION_COUNT, 1);

		// 注册并进行调度
		Date scheduleTime1 = sched.scheduleJob(job1, trigger1);

		log.error("任务key: " + job1.getKey() + ",执行运行时间: "
				+ sdf.format(scheduleTime1) + ",触发器重复执行次数: "
				+ trigger1.getRepeatCount() + ",触发器执行时间: "
				+ trigger1.getRepeatInterval() / 1000 + "秒");

		// 第二个任务
		JobDetail job2 = newJob(ColorJob.class).withIdentity("job2", "group1")
				.build();

		SimpleTrigger trigger2 = newTrigger()
				.withIdentity("trigger2", "group1")
				.startAt(startTime)
				.withSchedule(
						simpleSchedule().withIntervalInSeconds(10)
								.withRepeatCount(4)).build();

		// 传递数据
		job2.getJobDataMap().put(ColorJob.FAVORITE_COLOR, "红色");
		job2.getJobDataMap().put(ColorJob.EXECUTION_COUNT, 1);

		Date scheduleTime2 = sched.scheduleJob(job2, trigger2);

		log.error("第二个任务key: " + job2.getKey().toString() + ",执行运行时间: "
				+ sdf.format(scheduleTime2) + ",触发器重复执行次数: "
				+ trigger2.getRepeatCount() + ",触发器执行时间: "
				+ trigger2.getRepeatInterval() / 1000 + "秒");

		// 调度器启动
		sched.start();

		try {
			Thread.sleep(60L * 1000L);
		} catch (Exception e) {
		}

		// 调度器停止
		sched.shutdown(true);

		SchedulerMetaData metaData = sched.getMetaData();
		log.error("Executed " + metaData.getNumberOfJobsExecuted() + " jobs.");

	}

	public static void main(String[] args) throws Exception {

		JobStateExample example = new JobStateExample();
		example.run();
	}

}

执行结果如下

INFO  StdSchedulerFactory - Using default implementation for ThreadExecutor
INFO  SimpleThreadPool - Job execution threads will use class loader of thread: main
INFO  SchedulerSignalerImpl - Initialized Scheduler Signaller of type: class org.quartz.core.SchedulerSignalerImpl
INFO  QuartzScheduler - Quartz Scheduler v.2.2.3 created.
INFO  RAMJobStore - RAMJobStore initialized.
INFO  QuartzScheduler - Scheduler meta-data: Quartz Scheduler (v2.2.3) 'DefaultQuartzScheduler' with instanceId 'NON_CLUSTERED'
  Scheduler class: 'org.quartz.core.QuartzScheduler' - running locally.
  NOT STARTED.
  Currently in standby mode.
  Number of jobs executed: 0
  Using thread pool 'org.quartz.simpl.SimpleThreadPool' - with 10 threads.
  Using job-store 'org.quartz.simpl.RAMJobStore' - which does not support persistence. and is not clustered.

INFO  StdSchedulerFactory - Quartz scheduler 'DefaultQuartzScheduler' initialized from default resource file in Quartz package: 'quartz.properties'
INFO  StdSchedulerFactory - Quartz scheduler version: 2.2.3
ERROR JobStateExample - 任务key: group1.job1,执行运行时间: 2017-11-13 10:29:40,触发器重复执行次数: 4,触发器执行时间: 10秒
ERROR JobStateExample - 第二个任务key: group1.job2,执行运行时间: 2017-11-13 10:29:40,触发器重复执行次数: 4,触发器执行时间: 10秒
INFO  QuartzScheduler - Scheduler DefaultQuartzScheduler_$_NON_CLUSTERED started.
任务Key: group1.job2 ,执行时间:  2017-11-13 10:29:40
  传递参数(favorite color): 红色
  传递参数(count):  1
  ColorJob非静态变量值: 1

任务Key: group1.job1 ,执行时间:  2017-11-13 10:29:40
  传递参数(favorite color): 绿色
  传递参数(count):  1
  ColorJob非静态变量值: 1

任务Key: group1.job1 ,执行时间:  2017-11-13 10:29:50
  传递参数(favorite color): 黄色
  传递参数(count):  2
  ColorJob非静态变量值: 1

任务Key: group1.job2 ,执行时间:  2017-11-13 10:29:50
  传递参数(favorite color): 黄色
  传递参数(count):  2
  ColorJob非静态变量值: 1

任务Key: group1.job1 ,执行时间:  2017-11-13 10:30:00
  传递参数(favorite color): 黄色
  传递参数(count):  3
  ColorJob非静态变量值: 1

任务Key: group1.job2 ,执行时间:  2017-11-13 10:30:00
  传递参数(favorite color): 黄色
  传递参数(count):  3
  ColorJob非静态变量值: 1

任务Key: group1.job1 ,执行时间:  2017-11-13 10:30:10
  传递参数(favorite color): 黄色
  传递参数(count):  4
  ColorJob非静态变量值: 1

任务Key: group1.job2 ,执行时间:  2017-11-13 10:30:10
  传递参数(favorite color): 黄色
  传递参数(count):  4
  ColorJob非静态变量值: 1

任务Key: group1.job1 ,执行时间:  2017-11-13 10:30:20
  传递参数(favorite color): 黄色
  传递参数(count):  5
  ColorJob非静态变量值: 1

任务Key: group1.job2 ,执行时间:  2017-11-13 10:30:20
  传递参数(favorite color): 黄色
  传递参数(count):  5
  ColorJob非静态变量值: 1

INFO  QuartzScheduler - Scheduler DefaultQuartzScheduler_$_NON_CLUSTERED shutting down.
INFO  QuartzScheduler - Scheduler DefaultQuartzScheduler_$_NON_CLUSTERED paused.
INFO  QuartzScheduler - Scheduler DefaultQuartzScheduler_$_NON_CLUSTERED shutdown complete.
ERROR JobStateExample - Executed 10 jobs.

Job的状态与并发

@DisallowConcurrentExecution：同一时间将只有一个Job实例被执行。

@PersistJobDataAfterExecution：在Job被执行结束后，将会更新JobDataMap，这样下次Job执行后就会使用新的值而不是初始值。 上面的示例中，如果不用此注解，成员变量的值下次调用也不会有改变。

如果使用@PersistJobDataAfterExecution注解，推荐也使用@DisallowConcurrentExecution注解，这是为了避免并发问题导致数据紊乱。

其它属性

Durability，持久性；如果Job是非持久性的，一旦没有Trigger与其相关联，它就会从Scheduler中被删除。也就是说Job的生命周期和其Trigger是关联的。

RequestsRecovery，如果为true，那么在Scheduler异常中止或者系统异常关闭后，当Scheduler重启后，Job会被重新执行。

JobExecutionException

execute()方法只允许抛出JobExecutionException异常

示例源码

代码已托管到Github—> https://github.com/yangshangwei/SpringMaster

小小工匠
关注
专栏目录
Quartz2.2.1深入Job、JobDetail、JobDataMap、Trigger
05-15
Quartz2.2.1深入Job、JobDetail、JobDataMap、Trigger ，具体效果和过程看博文：http://blog.csdn.net/evankaka/article/details/45361759
Quartz定时器---JobDataMap的运用
lihuang319的专栏
08-26 1万+
<br />那么应该如何给一个任务提供属性或者配置呢？如何在任务的不同执行过程中保存或跟踪任务的状态呢？这是通过JobDetail的JobDataMap来实现。<br />JobDataMap<br />JobDataMap可以用来保存任何需要传递给任务实例的对象（这些对象要求是可序列化的），JobDataMap是java的Map接口的实现，添加了一些便利方法，下面的代码片断描述了如何使用JobDataMap保存数据：<br />Java代码 <br /> <br />package mypackage;<
Quartz定时任务配置参数的含义
最新发布
weixin_36873225的博客
07-18 584
例如，在一个分布式系统中，可以为每个节点的Quartz调度器设置不同的instanceName，以避免节点之间的任务冲突和重复执行。用于指定Quartz调度器的任务触发器的misfire阈值。例如，在一个分布式系统中，可以为每个节点的Quartz调度器设置不同的instanceId，以避免节点之间的任务冲突和重复执行。② AUTO:如果属性设置为Auto，则Quartz调度器会自动为每个实例分配一个唯一的instanceId，Quartz调度器会根据当前时间和随机数生成一个唯一的instanceId。
quartz详解2--jobDataMap
王小禾
07-30 5994
1. Job 和 JobDetail 1. Job 和 JobDetail
Quartz JobDataMap
baidu_32223873的博客
04-10 729
作用 quartz的job是无状态的，每次调度都会实例化一个新的job实例，如果要在记录job的状态，保留上一次调度的结果，就需要用jobdatamap。 使用方法 jobDataMap可以跟jobDetail绑定，也可以跟Trigger绑定 JobDetail jobDetail = JobBuilder.newJob(MyJob.class) .withIdentity("job1", "group1") .usingJobData("da
Quartz -JOB类型 与 动态设定Trigger参数
www.v5qq.com的技术博客
07-11 296
一 JOB State 在通过MethodInvokingJobDetailFactoryBean在运行中动态生成的Job，配置的xml文件有个concurrent属性，表示job是否可以并行运行：如果一个job的业务处理发费的时间超过了job的启动的间隔时间（repeatInterval)，这个属性非常有用。如果为false，那么，在这种情况下，当前job还在运行，那么下一个job只...
quartz触发器 JobDataMap
xdkb159的博客
02-10 1077
http://blog.csdn.net/a67474506/article/details/38317119JobDataMap可以用来保存任何需要传递给任务实例的对象（这些对象要求是可序列化的）作业类public class ColorJob implements Job{ private static final String FAVORITE_COLOR = "favorite c...
Quartz---JobDataMap使用的两种方式
weixin_53333436的博客
02-18 996
有两种方式可以从执行方法的上下文中取出参数：一种是直接从execute方法的上下文中取出，另一种是在作业类中定义参数名称，并完成相应的get和set方法。JobDataMap是Quartz调度器中的一个重要组件，主要用于存储和传递与作业（Job）相关的数据。这些对象在作业执行时可以被获取并使用。当任务详细类中的JobDataMap设置的key和调度器类设置的key一样的话，后者会覆盖前者的值。通过Job子类的set方法将属性赋值，在添加jobdata时将key值设为set方法中设置的属性名。
quartz—向job动态传递参数
langzixin1986的专栏
02-19 1644
首先在运行前传入参数： JobDetail类的getJobDataMap()方法，返回值JobDataMap，可以在此基础上进行Map操作。 例如： job.getJobDataMap().put("love", "I love you very much!");     其次在job中获得参数： 在execute方法中，传入上下文context，如下所示： public void...
quartz-2.2 以及关联jar包
03-27
1. **创建**：创建JobDetail实例，指定Job类和JobDataMap（用于传递参数）。 2. **调度**：创建Trigger实例，绑定到JobDetail，并设置执行时间。 3. **执行**：Scheduler根据Trigger调度Job执行。 4. **完成与...
quartz-2.4.0.zip
07-12
- **JobDetail**：包含了Job的信息，如Job类名、JobDataMap（用于传递参数）等。 - **Calendar**：可选地与Trigger结合使用，用于排除某些日期或时间。 在实际应用中，你可能需要配置一个数据库存储Job和Trigger的...
Quartz-demo
09-13
- **传递方法参数**: 为了在Job执行时传递参数，可以使用JobDataMap。这是一个键值对容器，可以将参数绑定到JobDetail中，然后在`execute`方法内获取。 在"spring-quartz"目录下，这个项目很可能是使用Spring框架...
quartz-all.zip
04-22
作业执行时可能需要一些参数，这些参数可以存储在JobDetail的JobDataMap中，Quartz会自动传递这些数据给作业执行。 10. **线程池和并发控制** Quartz允许自定义线程池大小，以控制并发执行的作业数量。合理的配置...
quartzjob传递传输_Quartz.NET 作业调度框架(3)-参数传递
weixin_39578674的博客
01-14 816
在Quartz.NET中可以用JobDataMap进行参数传递完整代码classProgram{staticvoidMain(string[]args){//TDO:安装方法:install-packageQuartz//实例化执行计划ISchedulerFactoryschedFact=newStdSchedulerFactory();//获取执行计划IScheduler...
【Quartz】深入Job、JobDetail、JobDataMap、Trigger
热门推荐
Evankaka的专栏
04-29 2万+
Quartz API核心接口有： Scheduler – 与scheduler交互的主要API； Job – 你通过scheduler执行任务，你的任务类需要实现的接口； JobDetail – 定义Job的实例； Trigger – 触发Job的执行； JobBuilder – 定义和创建JobDetail实例的接口; TriggerBuilder – 定义和创建Trigger实例的接口；
Quartz 之 Job参数 和 Job状态
我是小坏
03-24 2115
项目地址： https://github.com/yuleiqq/quartz_example/tree/master/quartz_study 此示例旨在演示如何将运行时参数传递给quartz作业，以及如何维护作业中的状态。 程序将执行以下操作: 启动Quartz调度器 调度两个作业，每个作业将执行总共10秒一次 调度程序将向第一个作业实例传...
quartzjob传递传输_quartz 动态JOB时参数的传递（特别是在多租户情况下很重要）...
weixin_33263633的博客
02-04 639
首先在运行前传入参数：在定义jobDetail时传入用户参数,当然如果jobDetail是通过spring 注入的，也可以通过JobDetail类的getJobDataMap()方法，返回值JobDataMap，可以在此基础上进行Map操作。例如：job.getJobDataMap().put("love", "I love you very much!");其次在job中获得参数：在execut...
Quartz入门实例4-通过JobDataMap实现数据的传输
胡小海丶
07-31 9919
 JobDataMap 通过它的超类 org.quartz.util.DirtyFlagMap 实现了 java.util.Map 接口，你可以向 JobDataMap 中存入键/值对，那些数据对可在你的 Job 类中传递和进行访问。这是一个向你的 Job 传送配置的信息便捷方法。
浅谈Quartz的JobExecutionContext和JobDataMap
实践求真知
11-16 5530
一 点睛 1 JobExecutionContext是什么 当Scheduler调用一个Job，就会将JobExecutionContext传递给Job的execute()方法 Job能通过JobExecutionContext对象访问到Quartz运行时候的环境以及Job对象的明细数据。 2 JobDataMap是什么 在进行任务调度时JobDataMap存储在Job...
java Quartz中Scheduler怎么传递参数给Job
07-12
在Java Quartz中，可以通过JobDataMap来传递参数给Job。 首先，在创建JobDetail时，可以使用JobDataMap来设置参数。示例如下： ```java JobDataMap jobDataMap = new JobDataMap(); jobDataMap.put("param1", "value1"); jobDataMap.put("param2", 123); JobDetail jobDetail = JobBuilder.newJob(MyJob.class) .withIdentity("myJob") .usingJobData(jobDataMap) .build(); ``` 然后，在实现Job接口的类中，可以通过JobExecutionContext来获取传递的参数。示例如下： ```java public class MyJob implements Job { @Override public void execute(JobExecutionContext context) throws JobExecutionException { JobDataMap jobDataMap = context.getMergedJobDataMap(); String param1 = jobDataMap.getString("param1"); int param2 = jobDataMap.getInt("param2"); // 执行任务逻辑 // ... } } ``` 在Job中，可以通过`context.getMergedJobDataMap()`方法获取到传递的参数，然后使用`getString`或`getInt`等方法来获取具体的参数值。 这样，你就可以通过Scheduler来传递参数给Job了。
评论 6
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

小小工匠

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值