@EnableRetry – Spring Retry

Spring Retry is a powerful framework in the Spring ecosystem that provides the ability to add retry logic to your methods, making your applications more resilient to failures. To use Spring Retry, you can use the @EnableRetry annotation at the configuration level to enable retry support for your Spring application.

Here’s an example of how to use @EnableRetry in a Spring Boot application:

First, make sure you have the required dependencies in your pom.xml or build.gradle:

For Maven:

<dependency>
    <groupId>org.springframework.retry</groupId>
    <artifactId>spring-retry</artifactId>
</dependency>

For Gradle:

implementation 'org.springframework.retry:spring-retry'

Create a Spring Boot application class, and annotate it with @SpringBootApplication to enable Spring Boot features. Also, annotate the class with @EnableRetry to enable Spring Retry functionality:

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.retry.annotation.EnableRetry;

@SpringBootApplication
@EnableRetry
public class MyApplication {
    public static void main(String[] args) {
        SpringApplication.run(MyApplication.class, args);
    }
}

Create a service or a component where you want to add retry logic. In this example, we’ll create a service with a method that retries when an exception occurs:

import org.springframework.retry.annotation.Backoff;
import org.springframework.retry.annotation.Retryable;
import org.springframework.stereotype.Service;

@Service
public class MyService {

    private int retryCount = 0;

    @Retryable(value = { RuntimeException.class }, maxAttempts = 3, backoff = @Backoff(delay = 1000))
    public void myRetryableMethod() {
        retryCount++;
        if (retryCount < 3) {
            System.out.println("Retry attempt #" + retryCount);
            throw new RuntimeException("Simulated exception");
        } else {
            System.out.println("Successful execution after " + retryCount + " retries.");
        }
    }
}

In the above code:

@Retryable annotation is used to specify which exceptions should trigger retries (RuntimeException in this case), the maximum number of retry attempts (maxAttempts = 3), and the backoff configuration (retry delay of 1000 milliseconds).

You can now use the MyService in your application and call the myRetryableMethod method. Spring Retry will automatically handle retries when a RuntimeException is thrown.

Here’s an example of calling the retryable method in a controller:

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class MyController {

    private final MyService myService;

    @Autowired
    public MyController(MyService myService) {
        this.myService = myService;
    }

    @GetMapping("/retry")
    public void retryExample() {
        myService.myRetryableMethod();
    }
}

With this setup, when you access the /retry endpoint, you will see that the myRetryableMethod method is retried up to three times before succeeding.

That’s how you can use @EnableRetry and @Retryable in a Spring Boot application to add retry logic to your methods.

224vinod Tech