How to implement retry logic using resilience4j in Spring

Resilience4j is a lightweight fault tolerance library designed for Java 8 and functional programming that can help to build more robust systems. It has a variety of modules that you can use including RateLimiter, Retry, Bulkhead, and CircuitBreaker.

To implement retry logic using Resilience4j in Spring microservices, you can follow these steps:

  1. Add dependencies to pom.xml file: Make sure you have the necessary dependencies in your project. Include the Resilience4j and Spring Retry dependencies in your build file.

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-actuator</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-aop</artifactId>
    </dependency>
    <dependency>
        <groupId>io.github.resilience4j</groupId>
        <artifactId>resilience4j-spring-boot2</artifactId>
        <version>1.7.0</version> <!-- This version might differ based on the current release -->
    </dependency>
    <dependency>
        <groupId>io.github.resilience4j</groupId>
        <artifactId>resilience4j-reactor</artifactId>
        <version>1.7.0</version> <!-- This version might differ based on the current release -->
    </dependency>
</dependencies>

  1. Configure the Resilience4j instance: You need to enable the resilience4j aspect by adding this to your main configuration file (application.yml):

resilience4j:
  retry:
    configs:
      default:
        maxRetryAttempts: 3
        waitDuration: 1000
    instances:
      myBackend:
        baseConfig: default

This configuration sets the maximum retry attempts to 3 and the wait duration between each retry to 1 second. The myBackend instance uses these default settings.

  1. Apply retry logic: In your service class, annotate the method where you want to apply the retry logic using @Retry annotation from Resilience4j.

import io.github.resilience4j.retry.annotation.Retry;
@Service
public class MyService {
    @Retry(name = "myBackend")
    public String callExternalService() {
        // your logic to call an external service
        // let's assume it throws an exception when failed
        throw new RuntimeException("External Service Failed");
    }
}

With the @Retry annotation, the callExternalService() method will be retried when it throws an exception. The maximum retry attempts and the wait duration are according to the settings we've defined in the application.yml file.

  1. Handle retry events: To handle retry events, you can implement an event consumer:

import io.github.resilience4j.retry.Retry;
import io.github.resilience4j.retry.RetryRegistry;
import io.github.resilience4j.retry.event.RetryEvent;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;
import javax.annotation.PostConstruct;
import java.util.function.Consumer;
@Component
public class RetryEventsConsumer {
    private static final Logger logger = LoggerFactory.getLogger(RetryEventsConsumer.class);
    private final RetryRegistry retryRegistry;
    public RetryEventsConsumer(RetryRegistry retryRegistry) {
        this.retryRegistry = retryRegistry;
    }
    @PostConstruct
    public void postConstruction() {
        Retry retry = retryRegistry.retry("myBackend");
        retry.getEventPublisher().onEvent(consumeRetryEvent());
    }
    private Consumer<RetryEvent> consumeRetryEvent() {
        return retryEvent -> logger.info("Retry attempt: {}", retryEvent.getNumberOfRetryAttempts());
    }
}

This RetryEventsConsumer class logs the retry attempts when the callExternalService() method fails and is retried. You can customize this to handle retry events according to your requirements

Free Resources

Copyright ©2025 Educative, Inc. All rights reserved