Currently I have this :
@Scheduled(fixedRate=5000)
public void getSchedule(){
System.out.println("in scheduled job");
}
I could change this to use a reference to a property
@Scheduled(fixedRateString="${myRate}")
public void getSchedule(){
System.out.println("in scheduled job");
}
However I need to use a value obtained programmatically so the schedule can be changed without redeploying the app. What is the best way? I realize using annotations may not be possible...
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();
}
}
);
}
}
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";
}
}
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.
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);
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());
}
}
