I want a spring scheduled task, that runs every 10 seconds, however for some reason the task runs only once and is never repeated again.
Please do not suggest me to use other types of tasks, because I need specifically to use spring tasks.
#Scheduled(fixedRate = 10000, initialDelay = 1000)
public void myTask() {
...
}
In my main config class I have #EnableScheduling added as well.
Scheduling is a process of executing the tasks for a specific time period, but you looking to make it asynchrounslly so there will be a couple of changes
create a config class that will manage the Async operations so you make use of ThreadPoolTaskExecutor:
#EnableScheduling
#Configuration
public class TaskConfig implements SchedulingConfigurer {
#Override
public void configureTasks(ScheduledTaskRegistrar scheduledTaskRegistrar)
{
ThreadPoolTaskScheduler threadPoolTaskScheduler = new ThreadPoolTaskScheduler();
threadPoolTaskScheduler.setPoolSize(10);
threadPoolTaskScheduler.setThreadNamePrefix("your-scheduler-");
threadPoolTaskScheduler.initialize();
scheduledTaskRegistrar.setTaskScheduler(threadPoolTaskScheduler);
}
}
then you can run jobs asynchrounslly as the below :
#Component
public class HelloSender {
#Scheduled(fixedRate = 10000)
public void myTask() {
System.out.println("im running asynchronous with Worker : " + Thread.currentThread().getName());
}
}
for further information about ThreadPoolTaskExecutor please have look here: https://docs.spring.io/spring-framework/docs/3.0.x/spring-framework-reference/html/scheduling.html
I want to send a post request within a period. I created my method like this ;
#Scheduled(cron = "0 0 */6 * *")
#PostMapping
public List<TagsRes> getTags(Date date) {
return null;
}
#Scheduled(cron = "0 0 5 * * ?")
#PostMapping
public List<TagsRes> getAll() {
return null;
}
Should i use #Scheduled in my controller ? Is there any better way to do it?
Thanks!
Controllers are meant to receive web requests, not to post anything.
You can think about them as endpoints exposed by your application and called by external service from time to time.
Now, the Controller abstraction by itself should do any business logic. You may want to validate some parameters received in the request, maybe convert the request parameters to java object with some customization and then call the class (usually mentioned as Service in spring universe) that actually executes your business logic.
Now back to your question.
I suspect you should not "POST a request" but should invoke some piece of code "as if someone called the controller's method (endpoint)". But this time not the external "user" will cause the code execution but an internal scheduler.
If so you can slightly refactor your code to achieve the better clarity:
Create a service that will execute the code
Do not put any scheduling related stuff on controller
From controller call the service
Create a bean and put a "#Scheduled" method on it. The bean will have the service injected and will call it just like the controller does.
Don't forget to put #EnableScheduling annotation - otherwise the scheduled code won't run.
public class MyService {
public void doBusinessLogic(){ ... }
}
#RestController
public class MyController {
#Autowired
private MyService service;
public void myPostMethod(...) {
service.doBusinessLogic(...);
}
}
public class MyScheduledInvoker {
#Autowired
private MyService service;
#Scheduled(...cron expression or whatever...)
public void invokeScheduled() {
service.doBusinessLogic(...);
}
}
#SpringBootApplication
#EnableScheduling
public class MyApp {
public static void main(String [] args) { .... run the app ...}
}
To schedule a job in spring boot application to run periodically, spring boot provides #EnableScheduling and #Scheduled annotations. In my opinion, since spring boot provides the annotation and functionality for scheduler using it will make more sense
Add #EnableScheduling annotation to your spring boot application class.#EnableScheduling is a Spring Context module annotation. It internally imports the SchedulingConfiguration via the #Import(SchedulingConfiguration.class) instruction
#SpringBootApplication
#EnableScheduling
public class SpringBootWebApplication {
}
Now you can add #Scheduled annotations on methods that you want to schedule. The only condition is that methods should be without arguments.
ScheduledAnnotationBeanPostProcessor that will be created by the
imported SchedulingConfiguration scans all declared beans for the
presence of the #Scheduled annotations.
For every annotated method without arguments, the appropriate executor thread pool will be created. This thread pool will manage the scheduled invocation of the annotated method.
#Scheduled(initialDelay = 1000, fixedRate = 10000)
public void run() {
logger.info("Current time is :: " + Calendar.getInstance().getTime());
}
Source: https://howtodoinjava.com/spring-boot/enable-scheduling-scheduled-job-example/
We have to bind the scheduler Thread to application context.
I tried using #PostConstruct but it starts the scheduler once application is up but it keeps running in the background even if application is down and server is up.
If application is down then the scheduler should also stop.
The way I used Scheduler in Spring (i.e. Spring Boot) is by having two classes inside my project (& therefore included in my .jar after build).
1 - SchedulerConfig (necessary for the configuration)
#Configuration
public class SchedulerConfig implements SchedulingConfigurer {
private final int POOL_SIZE = 10;
#Override
public void configureTasks(ScheduledTaskRegistrar scheduledTaskRegistrar) {
ThreadPoolTaskScheduler threadPoolTaskScheduler = new ThreadPoolTaskScheduler();
threadPoolTaskScheduler.setPoolSize(POOL_SIZE);
threadPoolTaskScheduler.setThreadNamePrefix("my-scheduled-task-pool-");
threadPoolTaskScheduler.initialize();
scheduledTaskRegistrar.setTaskScheduler(threadPoolTaskScheduler);
}
}
2 - ScheduledTasks (the actual scheduled tasks with frequency defined by the cron expression)
#Component
public class ScheduledTasks {
private static final Logger LOG = Logger.getLogger(ScheduledTasks.class);
#Scheduled(cron = "0 0 * ? * *")
public void doSomething() {
// Do something
}
}
Therefore, as everything is included in the running .jar, when the application is not deployed any more, scheduled tasks will not run as well.
See also https://www.baeldung.com/spring-scheduled-tasks
I use a Spring Schedule in my application. Now I will configure the cron expression externally. This one at the bottom does not work. Has anyone an idee how to do this?
#EnableConfigurationProperties
#ConfigurationProperties(locations = "classpath:application.properties", ignoreUnknownFields = true, prefix = "myProject.prefix")
public class MyClass{
#Scheduled(cron = "${myProperty}")
public void myMethod() {
Have you activated scheduling in your configuration?
#Configuration
#EnableScheduling
public class AppConfig {
[...]
}
When I run my unit tests, it invokes my scheduled tasks. I want to prevent this behaviour, which is caused by the fact that I have #EnableScheduling on my main app configuration.
How can I disable this on my unit tests?
I have come across this question/answer which suggests setting up profiles?
Not sure how I would go about that? or if its an overkill? I was thinking of having a separate AppConfiguration for my unit tests but it feels like im repeating code twice when I do that?
#Configuration
#EnableJpaRepositories(AppConfiguration.DAO_PACKAGE)
#EnableTransactionManagement
#EnableScheduling
#ComponentScan({AppConfiguration.SERVICE_PACKAGE,
AppConfiguration.DAO_PACKAGE,
AppConfiguration.CLIENT_PACKAGE,
AppConfiguration.SCHEDULE_PACKAGE})
public class AppConfiguration {
static final String MAIN_PACKAGE = "com.etc.app-name";
static final String DAO_PACKAGE = "com.etc.app-name.dao";
private static final String ENTITIES_PACKAGE = "com.etc.app-name.entity";
static final String SERVICE_PACKAGE = "com.etc.app-name.service";
static final String CLIENT_PACKAGE = "com.etc.app-name.client";
static final String SCHEDULE_PACKAGE = "com.etc.app-name.scheduling";
#Bean
public LocalContainerEntityManagerFactoryBean entityManagerFactory(){
// stripped code for question readability
}
// more app config code below etc
}
Unit test example.
#RunWith(SpringJUnit4ClassRunner.class)
#ContextConfiguration(classes={AppConfiguration.class})
#Transactional
#TransactionConfiguration(defaultRollback = true)
#WebAppConfiguration
public class ExampleDaoTest {
#Autowired
ExampleDao exampleDao;
#Test
public void testExampleDao() {
List<Example> items = exampleDao.findAll();
Assert.assertTrue(items.size()>0);
}
}
If you don't want to use profiles, you can add flag that will enable/disable scheduling for the application
In your AppConfiguration add this
#ConditionalOnProperty(
value = "app.scheduling.enable", havingValue = "true", matchIfMissing = true
)
#Configuration
#EnableScheduling
public static class SchedulingConfiguration {
}
and in your test just add this annotation to disable scheduling
#TestPropertySource(properties = "app.scheduling.enable=false")
I just parameterized my #Scheduled annotation with configurable delay times:
#Scheduled(fixedRateString = "${timing.updateData}", initialDelayString = "${timing.initialDelay}")
In my test application.yaml:
timing:
updateData: 60000
initialDelay: 10000000000
And main application.yaml:
timing:
updateData: 60000
initialDelay: 1
It's not turning it off but creating such a long delay, the tests will be long over before it runs. Not the most elegant solution but definitely one of the easiest I've found.
One more solution without any change in production code, using the #MockBean.
#RunWith(SpringRunner.class)
#SpringBootTest
#MockBean(MyScheduledClass.class)
public class MyTest {
Which will eventually replace active scheduled job or create a mocked one.
From the documentation
Mocks can be registered by type or by {#link #name() bean name}. Any existing single
bean of the same type defined in the context will be replaced by the mock, if no
existing bean is defined a new one will be added.
An alternative would be to unregister the bean post processor that schedules the events. This can be done by simply putting the following class on the classpath of your tests:
public class UnregisterScheduledProcessor implements BeanFactoryPostProcessor {
#Override
public void postProcessBeanFactory(final ConfigurableListableBeanFactory beanFactory) throws BeansException {
for (String beanName : beanFactory.getBeanNamesForType(ScheduledAnnotationBeanPostProcessor.class)) {
((DefaultListableBeanFactory)beanFactory).removeBeanDefinition(beanName);
}
}
}
While this is quite simple and seems to do the job, beware that I did not test this very much or check for possible implications of removing a defined bean from the registry or making sure that ordering of PostProcessors won't be an issue...
With Spring Boot and cron expression you can enable or disable scheduling.
For example you can define an test application.yml and set
scheduler:
cron-expr: '-'
See also disable scheduling with '-'.
In your scheduler class you can pass the expression.
#Scheduled(cron = "${scheduler.cron-expr}")
Discovered that adding
app.scheduling.enable=false
in test application.properties along with
#ConditionalOnProperty(value = "app.scheduling.enable", havingValue = "true", matchIfMissing = true)
#EnableScheduling
to scheduling configuration class annotations like in Marko Vranjkovic's answer works for all tests without need to annotate each of them!
In each Test you define which spring configuration should be used, currently you have:
#ContextConfiguration(classes={AppConfiguration.class})
Common practice is to define separate spring configuration for your normal application and for your tests.
AppConfiguration.java
TestConfiguration.java
Then in your test you simply refference TestConfiguration instead of your current AppConfiguration using #ContextConfiguration(classes={TestConfiguration.class})
#RunWith(SpringJUnit4ClassRunner.class)
#ContextConfiguration(classes={TestConfiguration.class})
#Transactional
#TransactionConfiguration(defaultRollback = true)
#WebAppConfiguration
public class ExampleDaoTest
This way you can configure any setting for your tests differently than in production code. You can for example use in-memory database for your tests instead of regular one and much more.
I was able to solve this problem by creating a method that removes the scheduled tasks during unit tests.
Here is an example:
import org.springframework.scheduling.annotation.ScheduledAnnotationBeanPostProcessor;
import org.springframework.context.ApplicationContext;
public static void removeScheduledTasks(ScheduledAnnotationBeanPostProcessor postProcessor, ApplicationContext appContext) {
postProcessor.setApplicationContext(appContext);
postProcessor.getScheduledTasks().forEach(ScheduledTask::cancel);
}
}
Use example:
import org.springframework.context.ApplicationContext;
import org.springframework.scheduling.annotation.ScheduledAnnotationBeanPostProcessor;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;
import com.example.Utils;
#RunWith(SpringRunner.class)
#SpringBootTest
public class TestRemoveScheduller {
#Autowired
private ScheduledAnnotationBeanPostProcessor postProcessor;
#Autowired
private ApplicationContext appContext;
#Before
public void init(){
//Some init variables
//Remove scheduled tasks method
Utils.removeScheduledTasks(postProcessor, appContext);
}
//Some test methods
}
Hope this helps.
I was looking to do this in a normal class (not a unit test). I have my main Spring Boot application but needed a small utility class to do some bulk data cleanup. I wanted to use the full application context of my main app but turn off any scheduled tasks. The best solution for me was similar to Gladson Bruno:
scheduledAnnotationBeanPostProcessor.getScheduledTasks().forEach(ScheduledTask::cancel);
Another advantage of this approach is you can get a list of all scheduled tasks, and you could add logic to cancel some tasks but not others.
create TestTaskScheduler Bean in test class
public class TestTaskScheduler implements TaskScheduler {
private static final NullScheduledFuture NULL_SCHEDULED_FUTURE = new NullScheduledFuture();
#Override
public ScheduledFuture<?> schedule(Runnable task, Trigger trigger) {
return NULL_SCHEDULED_FUTURE;
}
#Override
public ScheduledFuture<?> schedule(Runnable task, Date startTime) {
return NULL_SCHEDULED_FUTURE;
}
#Override
public ScheduledFuture<?> scheduleAtFixedRate(Runnable task, Date startTime, long period) {
return NULL_SCHEDULED_FUTURE;
}
#Override
public ScheduledFuture<?> scheduleAtFixedRate(Runnable task, long period) {
return NULL_SCHEDULED_FUTURE;
}
#Override
public ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, Date startTime, long delay) {
return NULL_SCHEDULED_FUTURE;
}
#Override
public ScheduledFuture<?> scheduleWithFixedDelay(Runnable task, long delay) {
return NULL_SCHEDULED_FUTURE;
}
private static class NullScheduledFuture implements ScheduledFuture {
#Override
public long getDelay(TimeUnit unit) {
return 0;
}
#Override
public int compareTo(Delayed o) {
return 0;
}
#Override
public boolean cancel(boolean mayInterruptIfRunning) {
return false;
}
#Override
public boolean isCancelled() {
return false;
}
#Override
public boolean isDone() {
return false;
}
#Override
public Object get() throws InterruptedException, ExecutionException {
return null;
}
#Override
public Object get(long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException {
return null;
}
}
}
I would go for TestExecutionListener,
example:
public class SchedulerExecutionListener implements TestExecutionListener {
#Override
public void beforeTestClass(#NonNull TestContext testContext) {
try {
ScheduledAnnotationBeanPostProcessor schedulerProcessor = testContext.getApplicationContext().getBean(ScheduledAnnotationBeanPostProcessor.class);
schedulerProcessor.destroy();
} catch (Exception ignored) {
ignored.printStackTrace();
System.out.println(ignored.getMessage());
}
}
And then you add it to ur testClass
#TestExecutionListeners(listeners = SchedulerExecutionListener .class, mergeMode = TestExecutionListeners.MergeMode.MERGE_WITH_DEFAULTS)
class Test {}
The way that I have solved this is for spring boot applications is by disabling the #EnableScheduling configuration for the test profile:
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Profile;
import org.springframework.scheduling.annotation.EnableScheduling;
#Configuration
#Profile({"!test"})
#EnableScheduling
public class SchedulingConfiguration {
}
My application properties are stored in application.yml so simple add ConditionalOnProperty to scheduler:
#ConditionalOnProperty(value = "scheduling.enabled", havingValue = "true", matchIfMissing = true)
#EnableScheduling
And disable develop environment in application.yml:
environments:
development:
scheduling:
enabled: false