menu

Let's understand Retries in Spring Boot

posted 1 min read

What’s a Retry?
A retry means trying an operation again if it fails the first time. For example:

Your app calls a weather API. It fails because of a slow connection. You try again after 1 second — and it works! ️
Retries help your app become more reliable, especially when dealing with temporary issues.

⚙️ Doing Retries in Spring Boot (The Simple Way)

Step 1 :

Spring Boot has a library called Spring Retry that makes this super easy.Let’s add it first.

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

Step 2 :

Enable retries in your main class

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

Step 3 :

Use @Retryable, so wherever a method might fail (for example, calling an external API), you can tell Spring to retry automatically.

@Service
public class WeatherService {

    @Retryable(maxAttempts = 3, backoff = @Backoff(delay = 2000))
    public String callWeatherAPI() {
        System.out.println("Calling weather API...");
        if (Math.random() < 0.7) {
            throw new RuntimeException("API failed!");
        }
        return "Weather is Sunny ☀️";
    }

    @Recover
    public String recover(RuntimeException e) {
        return "Weather service is temporarily unavailable ️";
    }
}

What’s Happening Here

@Retryable → Tells Spring to retry this method up to 3 times.
@Backoff(delay = 2000) → Wait 2 seconds between retries.
@Recover → If all retries fail, this method is called instead of crashing the app.

Retries are like giving your app a second chance to succeed. With just two annotations — @Retryable and @Recover — you can make your Spring Boot app much more reliable.

1 Comment

•

Nice walkthrough on retries. It’s cool how a couple of annotations can make failure handling feel so effortless. Could this approach cause issues if the API keeps failing for longer periods though?

2 votes
•

@[Andrew Mewborn] Nice followup.
This article covers how retries can be implemented in spring in scenarios where target api fails for a short period of time. But In real life applications, mishaps occur all the time and apis might not respond for hours or even days. For covering such scenarios we can use exponential backoffs instead of fixed backoffs.

@Retryable(
    maxAttempts = 10,
    backoff = @Backoff(delay = 2000, multiplier = 2, maxDelay = 15000)
)

Exponential backoff improves the situation by:

  1. Spacing out retries to reduce load on the target system.
  2. Avoiding a retry storm.
  3. Giving the remote API some time to recover.

But if the remote service is down for long, retrying — even slowly — becomes wasteful. It keeps your threads busy waiting. At that point, you need a different solution altogether.
You should switch from retrying → circuit breaking . A Circuit Breaker pattern detects continuous failures and stops retrying temporarily.

I will soon cover circuit breaker in my upcoming posts, stay tuned and stay curious.

1

More Posts

Upgrading JJWT on Spring Boot 3.3.x for GraalVM and Cloud Native

Ricardo Campos - Sep 3

Power Up Java with AI: Integrate LLaMA 3 Using Spring Boot

Mandeep Dhakal - Jul 30

Creating RESTful API Using Spring Boot for The First Time

didikts - Oct 14, 2024

Integrating Kafka Test Container for Local Development Environment

Amol Gote - Jun 8, 2024

Handling Different Types of Data in Express.js

Riya Sharma - Jun 26
chevron_left