Java 石英JobDataMap不'；不适用于非基元类型

我对QuartzJobDataMap有以下问题。我希望在使用simple Quartz作业并将非基本对象（例如StringBuilder的实例）传递到JobDateMap中时，应始终使用对象的不同副本调用方法execute（从我的作业）。不幸的是，我总是得到放入JobDateMap的对象实例（就像它是一个StatefulJob）

在下面的示例中，我希望每次调用都得到一个'*'，而每次调用都会得到一个'*'

public class MyJob implements Job {

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

        SchedulerFactory schedFact = new StdSchedulerFactory();
        Scheduler sched = schedFact.getScheduler();

        JobDetail jobDetail = new JobDetail("job", Scheduler.DEFAULT_GROUP, MyJob.class);
        jobDetail.getJobDataMap().put("param", new StringBuilder());

        Trigger trigger = TriggerUtils.makeImmediateTrigger("trigger", 10, 100);
        trigger.setGroup(Scheduler.DEFAULT_GROUP);

        sched.scheduleJob(jobDetail, trigger);
        sched.start();

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

        sched.shutdown(true);

    }

    @Override
    public void execute(JobExecutionContext context) throws JobExecutionException {
        StringBuilder sb = (StringBuilder) context.getMergedJobDataMap().get("param");
        sb.append("*");
        System.out.println(sb.toString());

    }
}

我想，我遗漏了一些石英是如何工作的。有人知道吗

“仅将JobDataMap中的基元数据类型（包括字符串）存储到 避免短期和长期的数据序列化问题。”

---

来源：

Quartz中还有其他功能，允许您以更优化的方式传递非原语。签出SchedulerContext类功能

using System;
using System.Text;
using Quartz;
using Quartz.Impl;

namespace QuartzNET.Samples
{
    class Program
    {
        static void Main(string[] args)
        {
            // Create RAMJobStore instance
            DirectSchedulerFactory.Instance.CreateVolatileScheduler(1);
            ISchedulerFactory factory = DirectSchedulerFactory.Instance;

            // Get scheduler and add object
            IScheduler scheduler = factory.GetScheduler();
            scheduler.Context.Add("History", new StringBuilder("Runtime History: "));

            // Create job and trigger
            IJobDetail job = JobBuilder.Create<MyJob>()
                                       .WithIdentity("MyJob")
                                       .Build();
            ITrigger trigger = TriggerBuilder.Create()
                                             .WithIdentity("Trigger")
                                             .StartNow()
                                             .WithSimpleSchedule(x => x
                                                .WithInterval(TimeSpan.FromMinutes(1))
                                                .RepeatForever())
                                             .Build();

            // Run it all
            scheduler.Start();
            scheduler.ScheduleJob(job, trigger);
        }
    }

    class MyJob : IJob
    {
        public void Execute(IJobExecutionContext context)
        {
            var history = context.Scheduler.Context["History"] as StringBuilder;
            history.AppendLine(context.NextFireTimeUtc.ToString());
            Console.WriteLine(context.NextFireTimeUtc);
        }
    }
}

使用系统；
使用系统文本；
使用石英；
使用Quartz.Impl；
名称空间QuartzNET.Samples
{
班级计划
{
静态void Main（字符串[]参数）
{
//创建RAMJobStore实例
DirectSchedulerFactory.Instance.CreateVolatileScheduler（1）；
isSchedulerFactory=DirectSchedulerFactory.Instance；
//获取调度程序并添加对象
isScheduler scheduler=factory.GetScheduler（）；
添加（“历史”，新的StringBuilder（“运行时历史”）；
//创建作业和触发器
IJobDetail job=JobBuilder.Create（）
.WithIdentity（“我的工作”）
.Build（）；
ITrigger trigger=TriggerBuilder.Create（）
.WithIdentity（“触发器”）
.StartNow（）
.使用SimpleSchedule（x=>x
.带间隔（时间跨度从分钟（1））
.RepeatForever（））
.Build（）；
//全部运行
scheduler.Start（）；
ScheduleJob（作业，触发器）；
}
}
我的职业类别：IJob
{
public void Execute（IJobExecutionContext上下文）
{
var history=context.Scheduler.context[“history”]作为StringBuilder；
AppendLine（context.NextFireTimeUtc.ToString（））；
Console.WriteLine（context.NextFireTimeUtc）；
}
}
}

我使用JSON将复杂对象发送到作业。这不是很聪明，但对我的钱包有用

在您的应用程序中：

jobDetail.getJobDataMap().put("YOUR_PARAM_NAME", yourObject.toJson());

在你的工作中：

JobDataMap dataMap = context.getJobDetail().getJobDataMap();
String jsonObject = dataMap.getString("YOUR_PARAM_NAME");
YourClass yourObject = YourClass.fromJson(jsonObject);

---

我在我们的项目中遇到了相同的错误，但意识到我有一个不同的设置阻止了它。如果配置了非“属性相关”对象，则可以使用该对象。您正在石英设置的配置文件中查找此值

<add key="quartz.jobStore.useProperties" value="false" />

False允许您使用除属性之外的其他对象。一旦我改变了这个（我的是真的），它就开始为我工作。

根据，我们不应该在JobDataMap中放置复杂的对象，以避免短期或长期问题。 （可能存在序列化问题，当然，通过修改复杂对象类来实现Serializable并不能解决这些问题。）

解决方法： 将复杂对象作为Json字符串传递，并在从JobDataMap检索后对其进行反序列化

比如说,

class OrderLine {
        private long orderLineId;
        private Item item;
    }
    class Item {
        private long itemId;
        private String itemName;
   }
//Putting OrderLine object in JobDataMap
    jobDetail.getJobDataMap().put("complexData", new Gson().toJson(new OrderLine()));
// Retrieving data from JobDataMap
    String complexDataString = 
        context.getJobDetail().getJobDataMap().getString("complexData");
    OrderLine orderLine = new Gson().fromJson(complexDataString, OrderLine.class);

---

太好了，谢谢！我有一堆taskz，它们共享需要传入的存储库的DI实例，这只是一张罚单！为什么这次投票没有通过？除了将gson作为工作环境的额外库之外，它是否实现了其他目的？