使用 Spring 以编程方式调度作业(使用 fixedRate 动态设置)

目前我有这个:

@Scheduled(fixedRate=5000)
public void getSchedule(){
System.out.println("in scheduled job");
}

我可以更改它以使用对属性的引用

@Scheduled(fixedRateString="${myRate}")
public void getSchedule(){
System.out.println("in scheduled job");
}

然而，我需要使用一个值获得的编程，以便日程可以改变，而不重新部署应用程序。最好的办法是什么？我知道使用注释可能不太可能..。

117800 次浏览
小开
最佳答案

Using a Trigger you can calculate the next execution time on the fly.

Something like this should do the trick (adapted from the Javadoc for @EnableScheduling):

@Configuration
@EnableScheduling
public class MyAppConfig implements SchedulingConfigurer {


@Autowired
Environment env;


@Bean
public MyBean myBean() {
return new MyBean();
}


@Bean(destroyMethod = "shutdown")
public Executor taskExecutor() {
return Executors.newScheduledThreadPool(100);
}


@Override
public void configureTasks(ScheduledTaskRegistrar taskRegistrar) {
taskRegistrar.setScheduler(taskExecutor());
taskRegistrar.addTriggerTask(
new Runnable() {
@Override public void run() {
myBean().getSchedule();
}
},
new Trigger() {
@Override public Date nextExecutionTime(TriggerContext triggerContext) {
Calendar nextExecutionTime =  new GregorianCalendar();
Date lastActualExecutionTime = triggerContext.lastActualExecutionTime();
nextExecutionTime.setTime(lastActualExecutionTime != null ? lastActualExecutionTime : new Date());
nextExecutionTime.add(Calendar.MILLISECOND, env.getProperty("myRate", Integer.class)); //you can get the value from wherever you want
return nextExecutionTime.getTime();
}
}
);
}
}
小开

Also you can use this simple approach:

private int refreshTickNumber = 10;
private int tickNumber = 0;


@Scheduled(fixedDelayString = "${some.rate}")
public void nextStep() {
if (tickNumber < refreshTickNumber) {
tickNumber++;
return;
}
else {
tickNumber = 0;
}
// some code
}

refreshTickNumber is fully configurable at runtime and can be used with @Value annotation.

小开

you can manage restarting scheduling using TaskScheduler and ScheduledFuture :

@Configuration
@EnableScheduling
@Component
public class CronConfig implements SchedulingConfigurer , SchedulerObjectInterface{


@Autowired
private ScheduledFuture<?> future;


@Autowired
private TaskScheduler scheduler;


@Bean
public SchedulerController schedulerBean() {
return new SchedulerController();
}


@Bean(destroyMethod = "shutdown")
public Executor taskExecutor() {
return Executors.newScheduledThreadPool(100);
}


@Override
public void start() {
future = scheduler.schedule(new Runnable() {
@Override
public void run() {
//System.out.println(JOB + "  Hello World! " + new Date());
schedulerBean().schedulerJob();
}
}, new Trigger() {
@Override public Date nextExecutionTime(TriggerContext triggerContext) {
Calendar nextExecutionTime =  new GregorianCalendar();
Date lastActualExecutionTime = triggerContext.lastActualExecutionTime();
nextExecutionTime.setTime(convertExpresssiontoDate());//you can get the value from wherever you want
return nextExecutionTime.getTime();
}
});


}




@Override
public void stop() {
future.cancel(true);


}


@Override
public void configureTasks(ScheduledTaskRegistrar taskRegistrar) {
// TODO Auto-generated method stub
start();
}


}

interface for start stop :

public interface SchedulerObjectInterface {
void start();
void stop();
}

now you can stop and start again (restarting) Scheduling using @Autowired SchedulerObjectInterface

小开

Simple Spring Boot example restricted to second, minute, and hourly intervals. Intent of this example is to demonstrate conditional handling of two properties, TimeUnit and interval.

Properties:

snapshot.time-unit=SECONDS
snapshot.interval=5

Scheduled method:

@Scheduled(cron = "*/1 * * * * *")
protected void customSnapshotScheduler()
{
LocalDateTime now = LocalDateTime.now();
TimeUnit timeUnit = TimeUnit.valueOf(snapshotProperties.getSnapshot().getTimeUnit());
int interval = snapshotProperties.getSnapshot().getInterval();


if (TimeUnit.SECONDS == timeUnit
&& now.getSecond() % interval == 0)
{
this.camService.writeSnapshot(webcam.getImage());
}


if (TimeUnit.MINUTES == timeUnit
&& now.getMinute() % interval == 0)
{
this.camService.writeSnapshot(webcam.getImage());
}


if (TimeUnit.HOURS == timeUnit
&& now.getHour() % interval == 0)
{
this.camService.writeSnapshot(webcam.getImage());
}
}
小开

You can also use Spring Expression Language (SpEL) for this.

Once this value is initialized, you won't be able to update this value.

@Scheduled(fixedRateString = "#{@applicationPropertyService.getApplicationProperty()}")
public void getSchedule(){
System.out.println("in scheduled job");
}


@Service
public class ApplicationPropertyService {


public String getApplicationProperty(){
//get your value here
return "5000";
}
}
小开

To create and manage multiple dynamically scheduled tasks,

Schedular configuration and bean:

import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.Trigger;
import org.springframework.scheduling.TriggerContext;
import org.springframework.scheduling.annotation.SchedulingConfigurer;
import org.springframework.scheduling.config.ScheduledTaskRegistrar;


import java.util.Calendar;
import java.util.Date;
import java.util.GregorianCalendar;


@Configuration
@EnableScheduling
public class SchedulingConfigs implements SchedulingConfigurer {


@Override
public void configureTasks(ScheduledTaskRegistrar taskRegistrar) {
taskRegistrar.addTriggerTask(new Runnable() {
@Override
public void run() {
// Do not put @Scheduled annotation above this method, we don't need it anymore.
System.out.println("Running Schedular..." + Calendar.getInstance().getTime());
}
}, new Trigger() {
@Override
public Date nextExecutionTime(TriggerContext triggerContext) {
Calendar nextExecutionTime = new GregorianCalendar();
Date lastActualExecutionTime = triggerContext.lastActualExecutionTime();
nextExecutionTime.setTime(lastActualExecutionTime != null ? lastActualExecutionTime : new Date());
nextExecutionTime.add(Calendar.MILLISECOND, getNewExecutionTime());
return nextExecutionTime.getTime();
}
});
}


private int getNewExecutionTime() {
//Load Your execution time from database or property file
return 1000;
}


@Bean
public TaskScheduler poolScheduler() {
ThreadPoolTaskScheduler scheduler = new ThreadPoolTaskScheduler();
scheduler.setThreadNamePrefix("ThreadPoolTaskScheduler");
scheduler.setPoolSize(1);
scheduler.initialize();
return scheduler;
}
}

Scheduler service code:

package io.loadium.resource.service;


import org.springframework.context.event.ContextRefreshedEvent;
import org.springframework.context.event.EventListener;
import org.springframework.scheduling.TaskScheduler;
import org.springframework.stereotype.Service;


import java.util.Date;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.ScheduledFuture;


@Service
public class ScheduleTaskService {


// Task Scheduler
TaskScheduler scheduler;


// A map for keeping scheduled tasks
Map<Integer, ScheduledFuture<?>> jobsMap = new HashMap<>();


public ScheduleTaskService(TaskScheduler scheduler) {
this.scheduler = scheduler;
}




// Schedule Task to be executed every night at 00 or 12 am
public void addTaskToScheduler(int id, Runnable task, Date runningDate) {
ScheduledFuture<?> scheduledTask = scheduler.schedule(task, runningDate);
jobsMap.put(id, scheduledTask);
}


// Remove scheduled task
public void removeTaskFromScheduler(int id) {
ScheduledFuture<?> scheduledTask = jobsMap.get(id);
if (scheduledTask != null) {
scheduledTask.cancel(true);
jobsMap.put(id, null);
}
}


// A context refresh event listener
@EventListener({ContextRefreshedEvent.class})
void contextRefreshedEvent() {
// Get all tasks from DB and reschedule them in case of context restarted
}
}

Sample usage:

// Add a new task with runtime after 10 seconds
scheduleTaskService.addTaskToScheduler(1, () -> System.out.println("my task is running -> 1"), , Date.from(LocalDateTime.now().plusSeconds(10).atZone(ZoneId.systemDefault()).toInstant()));
// Remove scheduled task
scheduleTaskService.removeTaskFromScheduler(1);
小开

i created dynamic tasks using ThreadPoolTaskScheduler from org.springframework.scheduling.concurrent.ThreadPoolTaskScheduler and scheduleWithFixedDelay method. i also added a redisson lock inorder to prevent duplicated jobs in distributed environment here is my code:

public class TaskRunnerService {


private final ThreadPoolTaskScheduler taskScheduler;
private final RedissonClient redissonClient;




public TaskRunnerService(ThreadPoolTaskScheduler taskScheduler, RedissonClient redissonClient) {
this.taskScheduler = taskScheduler;
this.redissonClient = redissonClient;
}


@PostConstruct
public void runTasks() {
List<TaskDTO> taskDTOS = TaskHolder.createTasks();
for (TaskDTO taskDTO : taskDTOS) {
RLock lock = this.redissonClient.getFairLock("LoadAndRunScheduleService-" + taskDTO.getId());


if (lock.tryLock()) {
try {
this.taskScheduler.scheduleWithFixedDelay(() -> {
System.out.println(" running task " + taskDTO.getId() + " with delay " + taskDTO.getDelay() + " at " + new Date());
}, taskDTO.getDelay() * 1000L);
}finally {
lock.unlock();
}
}
}
}


}

i created a TaskDTO class to be able to get delay at runtime:

import lombok.AllArgsConstructor;
import lombok.Getter;
import lombok.NoArgsConstructor;
import lombok.Setter;


@AllArgsConstructor
@NoArgsConstructor
@Getter
@Setter
public class TaskDTO {
    

private int id;
private int delay;
}

and configuration class is:

    @Configuration
public class AppConfig {
    

@Bean
ThreadPoolTaskScheduler taskScheduler(){
ThreadPoolTaskScheduler scheduler = new ThreadPoolTaskScheduler();
scheduler.setThreadNamePrefix("ThreadPoolTaskScheduler");
scheduler.setPoolSize(2);
scheduler.initialize();
return scheduler;
}
    

}
小开

See How we are calling "#{@getIntervalTime}" in MySchedularService Class and taking the time interval for next scheduled call from @Bean annotate class

Main Class

package com;


import java.util.Calendar;


import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;
import org.springframework.scheduling.annotation.EnableScheduling;


@SpringBootApplication
@EnableScheduling
public class SbootSchedularApplication {


public static void main(String[] args) {
SpringApplication.run(SbootSchedularApplication.class, args);
}
    

@Value("${schedular3Timing}")
String schedular3Timing;
    

@Bean
public String getIntervalTime()
{
long startSchedulerAfterMiliSec = setSchedule(schedular3Timing);


return ""+startSchedulerAfterMiliSec;
}
    

public long setSchedule(String key)
{
int hour = Integer.parseInt(key.substring(0, key.indexOf(":")));
int min = Integer.parseInt(key.substring(key.indexOf(":") + 1));


Calendar schedulerCal = Calendar.getInstance();
schedulerCal.set(Calendar.HOUR, hour);
schedulerCal.set(Calendar.MINUTE, min);
schedulerCal.set(Calendar.SECOND, 0);
        

Calendar localCal = Calendar.getInstance();
Long currentTimeInMilliSec = localCal.getTime().getTime();
String currentDayTime = localCal.getTime().toString();


if (schedulerCal.getTime().getTime() < currentTimeInMilliSec) {         // Means calculating time reference from time 00:00, if current time is 1000 mili-sec and scheduled time is 800 mili-sec -> then that time is already happened, so better add one more day in that same timing.
schedulerCal.add(Calendar.DATE, 1);         // add 1 day more in the Schedular, if scheduled-MiliSec is less than the current-MiliSec.
}


long scheduledTimeInMilliSec = schedulerCal.getTime().getTime();
String scheduledTime = schedulerCal.getTime().toString();
System.out.println("** Scheduled start time for the task    : " + scheduledTime + " *** " + scheduledTimeInMilliSec);
System.out.println("** Current time of the day      : " + currentDayTime + " *** " + currentTimeInMilliSec);


long startScheduler = scheduledTimeInMilliSec - currentTimeInMilliSec;      // eg: scheduledTime(5pm) - currentTime(3pm) = (2hr)startSchedulerAfter
return startScheduler;


}


}

MySchedularService Class : See the JOB-3

package com.service;


import java.util.Date;


import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Service;


@Service
public class MySchedularService {


private static final Logger logger = LoggerFactory.getLogger(MySchedularService.class);


//  @Scheduled(fixedRate = 2000, initialDelay = 5000L)
@Scheduled(fixedRateString = "${schedular1.fixedRateInMS}", initialDelay = 1000L)
public void job() {
logger.info("Job1 Run Time : " + new Date());
}
    

//  @Scheduled(fixedRateString = "${schedular2.fixedRateInMS}", initialDelay = 5000L)
//  public void job2() {
//      logger.info("Job2 Run Time : " + new Date());
//  }


@Scheduled(fixedRate = 10000 , initialDelayString = "#{@getIntervalTime}")      // we can change the fixedRate = 86400000L miliseconds (i.e, one day interval)
public void job3() {
logger.info("**Job2 Run Time : " + new Date());
}
    

    



}

Application.properties File

spring.task.scheduling.pool.size=10
schedular1.fixedRateInMS=3000
schedular2.fixedRateInMS=10000
schedular3Timing=01:07

提交答案