Playframework 玩框架：我可以重新安排工作吗？

我在玩！版本1.2.4的框架
在我的应用程序中，我实现了许多计划作业（play.jobs.Job的后代）

问题: 我可以在运行时更改这些作业的计划吗

我自己的发现 乍一看，作业调度在起作用！通过

play.jobs.JobsPlugin

完成，后者又使用公开的JDK的

java.util.concurrent.ScheduledThreadPoolExecutor

实例。到目前为止，我提出了以下方法：当需要更改计划时，我只需迭代执行器的计划作业，取消需要重新计划的作业，并使用新设置计划相同的作业（更准确地说，相同类的作业）。大概是这样的：

for（最终对象o:JobsPlugin.executor.getQueue（））
{
ScheduledFuture任务=（ScheduledFuture）o；
Job Job=（Job）Java.extractUnderlyingCallable（（FutureTask）任务）；
如果（MyJob.class==job.getClass（））
{
任务。取消（true）；
new MyJob（）。每（“2h”）；
打破
}
}

有没有更好的解决办法？

---

谢谢

我不确定您的解决方案是否有效，因为当您查看JobsPlugin调用时，它会在每个作业执行结束时重新计算作业下一个计划执行日期

这是我的解决方案，我重新创建了一个JobScheduler类，以便能够根据作业的cron属性计算作业执行日期。由于可见性规则，我不得不重新声明一些作业属性

所以我的职业课是

package jobs;

import java.util.Date;
import java.util.concurrent.ExecutorService;

import play.jobs.Job;

public class MyJob extends Job<Object> {

    public Date nextPlannedExecution = null;
    public String cron = null;

    @Override
    public void _finally() {
        // cron is null if we force job execution
        if (cron != null) {
            // As the job don't have a Cron annotation, super call does nothing
            super._finally();
            JobScheduler.scheduleForCRON(this, cron);
        }
    }

    void setExecutor(ExecutorService executor) {
        this.executor = executor;
    }
}

打包作业；
导入java.util.Date；
导入java.util.concurrent.ExecutorService；
导入play.jobs.Job；
公共类MyJob扩展了Job{
公共日期nextPlannedExecution=null；
公共字符串cron=null；
@凌驾
公共空间(u finally){
//如果强制执行作业，则cron为null
if（cron！=null）{
//由于作业没有Cron注释，super调用什么都不做
太好了；
JobScheduler.scheduleForCRON（this，cron）；
}
}
作废setExecutor（executor服务executor）{
this.executor=执行人；
}
}

我的调度程序类是 一揽子工作

import java.util.Date;
import java.util.concurrent.Callable;
import java.util.concurrent.TimeUnit;

import models.Partner;
import play.Logger;
import play.jobs.Job;
import play.jobs.JobsPlugin;
import play.libs.Expression;
import play.libs.Time.CronExpression;

public class JobScheduler {

    public static synchronized void scheduleCsvExportJob(String cron) {
        MyJob myJob = null;
        for (Job<?> job : JobsPlugin.scheduledJobs) {
            if (job instanceof MyJob) {
                myJob = (MyJob) job;
            }
        }
        if (myJob == null) {
            myJob = new MyJob();
            JobsPlugin.scheduledJobs.add(myJob);
        }
        myJob.cron = cron;
        scheduleForCRON(myJob, myJob.cron);
    }

    public static void scheduleForCRON(MyJob job, String cron) {
        try {
            Date now = new Date();
            cron = Expression.evaluate(cron, cron).toString();
            CronExpression cronExp = new CronExpression(cron);
            Date nextDate = cronExp.getNextValidTimeAfter(now);
            if (nextDate != null && !nextDate.equals(job.nextPlannedExecution)) {
                job.nextPlannedExecution = nextDate;
                JobsPlugin.executor.schedule((Callable<?>) job, nextDate.getTime() - now.getTime(),
                        TimeUnit.MILLISECONDS);
                job.setExecutor(JobsPlugin.executor);
            }
        } catch (Exception ex) {
            Logger.error(ex, "Cannot schedule job %s", job);
        }
    }
}

import java.util.Date；
导入java.util.concurrent.Callable；
导入java.util.concurrent.TimeUnit；
进口型号。合作伙伴；
导入play.Logger；
导入play.jobs.Job；
导入play.jobs.JobsPlugin；
导入play.libs.Expression；
导入play.libs.Time.CronExpression；
公共类作业调度器{
公共静态同步的void scheduleCsvExportJob（字符串cron）{
MyJob MyJob=null；
for（作业：JobsPlugin.scheduledJobs）{
if（MyJob的作业实例）{
myJob=（myJob）job；
}
}
if（myJob==null）{
myJob=新建myJob（）；
JobsPlugin.scheduledJobs.add（myJob）；
}
myJob.cron=cron；
scheduleForCRON（myJob，myJob.cron）；
}
公共静态void scheduleForCRON（MyJob作业，字符串cron）{
试一试{
现在日期=新日期（）；
cron=Expression.evaluate（cron，cron.toString（）；
CronExpression cronExp=新的CronExpression（cron）；
datenextdate=cronExp.getNextValidTimeAfter（现在）；
if（nextDate！=null&！nextDate.equals（job.nextPlannedExecution））{
job.nextPlannedExecution=nextDate；
JobsPlugin.executor.schedule（（可调用）作业，nextDate.getTime（）-now.getTime（），
时间单位（毫秒）；
job.setExecutor（JobsPlugin.executor）；
}
}捕获（例外情况除外）{
Logger.错误（例如，“无法计划作业%s”，作业）；
}
}
}

使用此代码，您可以调用JobScheduler.scheduleMyJob，通过传递正确的调度表达式来更改作业的调度：0 2**？每两小时一次

当作业终止时，_finally方法将调用scheduleForCRON方法，该方法设置新的调度时间

---

如果您想强制执行作业，例如通过gui按钮，您可以创建一个不带cron属性define的实例，并且该实例不会在最后重新调度自己

我不确定您的解决方案是否有效，因为当您查看jobslugin调用时，它在每个作业执行结束时重新计算作业下一个计划执行日期

这是我的解决方案，我重新创建了一个JobScheduler类，以便能够根据作业的cron属性计算作业执行日期。由于可见性规则，我不得不重新声明一些作业属性

所以我的职业课是

package jobs;

import java.util.Date;
import java.util.concurrent.ExecutorService;

import play.jobs.Job;

public class MyJob extends Job<Object> {

    public Date nextPlannedExecution = null;
    public String cron = null;

    @Override
    public void _finally() {
        // cron is null if we force job execution
        if (cron != null) {
            // As the job don't have a Cron annotation, super call does nothing
            super._finally();
            JobScheduler.scheduleForCRON(this, cron);
        }
    }

    void setExecutor(ExecutorService executor) {
        this.executor = executor;
    }
}

打包作业；
导入java.util.Date；
导入java.util.concurrent.ExecutorService；
导入play.jobs.Job；
公共类MyJob扩展了Job{
公共日期nextPlannedExecution=null；
公共字符串cron=null；
@凌驾
公共空间(u finally){
//如果强制执行作业，则cron为null
if（cron！=null）{
//由于作业没有Cron注释，super调用什么都不做
太好了；
JobScheduler.scheduleForCRON（this，cron）；
}
}
作废setExecutor（executor服务executor）{
this.executor=执行人；
}
}

我的调度程序类是 一揽子工作

import java.util.Date;
import java.util.concurrent.Callable;
import java.util.concurrent.TimeUnit;

import models.Partner;
import play.Logger;
import play.jobs.Job;
import play.jobs.JobsPlugin;
import play.libs.Expression;
import play.libs.Time.CronExpression;

public class JobScheduler {

    public static synchronized void scheduleCsvExportJob(String cron) {
        MyJob myJob = null;
        for (Job<?> job : JobsPlugin.scheduledJobs) {
            if (job instanceof MyJob) {
                myJob = (MyJob) job;
            }
        }
        if (myJob == null) {
            myJob = new MyJob();
            JobsPlugin.scheduledJobs.add(myJob);
        }
        myJob.cron = cron;
        scheduleForCRON(myJob, myJob.cron);
    }

    public static void scheduleForCRON(MyJob job, String cron) {
        try {
            Date now = new Date();
            cron = Expression.evaluate(cron, cron).toString();
            CronExpression cronExp = new CronExpression(cron);
            Date nextDate = cronExp.getNextValidTimeAfter(now);
            if (nextDate != null && !nextDate.equals(job.nextPlannedExecution)) {
                job.nextPlannedExecution = nextDate;
                JobsPlugin.executor.schedule((Callable<?>) job, nextDate.getTime() - now.getTime(),
                        TimeUnit.MILLISECONDS);
                job.setExecutor(JobsPlugin.executor);
            }
        } catch (Exception ex) {
            Logger.error(ex, "Cannot schedule job %s", job);
        }
    }
}

import java.util.Date；
导入java.util.concurrent.Callable；
导入java.util.concurrent.TimeUnit；
进口型号。合作伙伴；
导入play.Logger；
导入play.jobs.Job；
导入play.jobs.JobsPlugin；
导入play.libs.Expression；
导入play.libs.Time.CronExpression；
公共类作业调度器{
公共静态同步的void scheduleCsvExportJob（字符串cron）{
MyJob MyJob=null；
for（作业：JobsPlugin.scheduledJobs）{
if（MyJob的作业实例）{
myJob=（myJob）job；
}
}
if（myJob==null）{
myJob=新建myJob（）；
JobsPlugin.scheduledJobs.add（myJob）；
}
myJob.cron=cr