Introduction to Spring Scheduled and monitoring the task with Spring Actuator ️🕛️📈️
Tags: tutorial, java, spring, backend
Published: 2024-02-03 00:37:30

In software development, task scheduling is a critical component for executing specific tasks periodically or according to the application’s needs. The Spring Framework provides a robust scheduling mechanism using the `@Scheduled` annotation. Additionally, for monitoring and managing application performance, Spring Actuator can be employed as an effective tool. This article will discuss how to combine task scheduling with Spring Actuator to create a reliable scheduling system and monitor task executions.

To begin using it, we first need to enable this feature in the configuration class or the main Spring class with an annotation `@EnableScheduling`.

```
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.scheduling.annotation.EnableScheduling;

@EnableScheduling
@SpringBootApplication
public class SpringAsyncApplication {

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

}
```

This allows the scheduling feature to run automatically when Spring is in operation. The scheduling feature itself is provided by the Spring Framework, so there is no need to manually register dependencies.

Next, we can create a method responsible for executing tasks either periodically or at specific times. Simply add the `@Scheduled` annotation at the method level.

```
import lombok.extern.slf4j.Slf4j;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;

@Slf4j
@Component
public class Job {

    @Scheduled
    public void cronJob() {
        log.info("run cron job");
    }
}
```

Is the `@Scheduled` annotation sufficient? It should be configured beforehand to specify when the task should be executed by adding arguments to the above-mentioned scheduled annotation. In that method, there is also a log implementation using SLF4j. To use it, first install the Lombok library in the pom.xml file.

```
<dependencies>
 ...
  <dependency>
   <groupId>org.projectlombok</groupId>
   <artifactId>lombok</artifactId>
   <version>1.18.30</version>
  </dependency>
 ...
 </dependencies>
```

There are numerous implementations for running a task periodically in Spring scheduling. As in the example below, the `cronJob()` method will output log information every 2 seconds with an initial delay of 3 seconds.

```
@Scheduled(timeUnit = TimeUnit.SECONDS, initialDelay = 3, fixedDelay = 2)
public void cronJob() {
  log.info("run cron job");
}
```

Initial delay is the delay time that occurs before the first task is executed after the Spring application is started or after the scheduler is activated. Fixed delay is the time between the completion of one task execution and the start of the next task execution. In addition to using the values of the above arguments, we can also use cron expressions. Cron expression is similar to time scheduling in Linux, aiming to determine the scheduling in as much detail as possible.

```
@Scheduled(cron = "*/2 * * * * *")
public void cronJob() {
  log.info("run cron job");
}
```
By default, a cron expression has six asterisks, each representing a specific unit of time. In the above expression, the `cronJob()` method will be executed every 2 seconds. For a more detailed explanation on how to read a cron expression, please visit the following website [Crontab](https://crontab.guru/). Then, if you want to delve into the detailed workings of how scheduling works in Spring, refer to the following documentation [Spring Scheduled](https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/scheduling/annotation/Scheduled.html?source=post_page-----b61aa38417eb--------------------------------)

Now, lets talk about monitoring. Monitoring is a crucial aspect to understand the performance and health of an application. Spring Actuator is part of the Spring framework project that provides a set of ready-to-use endpoints for monitoring Spring Boot applications, including the scheduling we discussed earlier. To enable the Actuator feature in Spring, simply add the following library to the pom.xml file:

```
<dependencies>
 ...
  <dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-actuator</artifactId>
  </dependency>
 ...
 </dependencies>
```

Then, in the application.properties file, add some configurations to view which schedulers are working in our Spring application.

```
management.endpoints.web.exposure.include=scheduledtasks
management.endpoint.scheduledtasks.enabled=true
```

Spring Actuator actually has many pre-defined endpoints that can be accessed through URLs. For more details, please visit the following documentation [Actuator](https://docs.spring.io/spring-boot/docs/current/reference/htmlsingle/?source=post_page-----b61aa38417eb--------------------------------#actuator)

Just access the endpoint **localhost:8080/actuator** and click on the available endpoints, then a JSON containing the running scheduled tasks in Spring will appear.

By combining task scheduling using the `@Scheduled` annotation from the Spring Framework and leveraging Spring Actuator, we can create an efficient and easily monitorable application. This provides better control over task execution and enables real-time monitoring of the application’s performance.

If you want to visualize Spring Actuator and monitor your application’s performance simultaneously, use [Micrometer](https://micrometer.io/) (maybe I will share about this in another time).

Micrometer.io is an efficient and reliable performance monitoring tool designed for Java-based applications. With easy integration, diverse features, and support for various monitoring systems, Micrometer.io provides a comprehensive solution for the performance monitoring needs of modern applications.

Visit another post in [Medium](https://ichwansholihin.medium.com/)
if you excited about this post, please follow and react for more tutorial.