Java uses @Retryable annotation to implement HTTP request retry

1. Introduction

In an application, network requests may fail due to various reasons (such as network instability, server failure, etc.). To improve the reliability of the system, a retry mechanism is usually required.

HTTP calls are one of the important ways to access Java applications when interacting with external APIs. To ensure that we can automatically retry when encountering temporary problems, we can design a flexible retry mechanism.

In Java, we can implement this function through annotations, which simplifies the code and enhances readability. This article will introduce how to use annotations@RetryableTo implement the retry mechanism of HTTP calls to deal with uncertainties in network interaction.

2. Core code analysis

2.1 POM dependencies

<!-- Spring Retry-->
<dependency>
    <groupId></groupId>
    <artifactId>spring-retry</artifactId>
</dependency>

2.2 SpringBoot startup class annotation

Here are a few common annotations. Not the focus of this introduction. Just follow the @EnableRetry annotation.

@SpringBootApplicationProvide basic configuration for applications,@EnableApolloConfigand@EnableConfigurationPropertiesFor configuration management,@EnableRetryEnhances the stability of network requests, and@EnableAsyncThis provides asynchronous processing capability.

import ;
import ;
import ;
import ;
import ;
import ;

@SpringBootApplication
@EnableApolloConfig
@EnableConfigurationProperties
@EnableRetry
@EnableAsync
public class BootApplication {

    public static void main(String[] args) {
        (, args);
    }

}

• @SpringBootApplication is a combination annotation, usually used for the main class of Spring Boot applications. Including the following three notes.

@Configuration: Indicates that this class is a configuration class, and Spring will read configuration information from this class.

@EnableAutoConfiguration: Enable Spring Boot's automatic configuration function to automatically configure Spring applications based on added dependencies.

@ComponentScan: Enable component scanning, allowing Spring to find the right components, configurations, and services.

• @EnableApolloConfig

@EnableApolloConfigis annotation of the Apollo configuration center for enabling Apollo configuration management in Spring Boot applications. Apollo is an open source configuration management center that can help developers manage application configurations, support dynamic updates and multi-environment configurations. Using this annotation automatically loads the properties configured in Apollo.

• @EnableConfigurationProperties

@EnableConfigurationPropertiesUsed to convert external configurations into Java objects. By using@ConfigurationPropertiesNote: Spring Boot can map configuration properties in properties or YAML files into POJO (Plain Old Java Object), making configurations more type-safe and easy to manage. Use this annotation to enable support for specific configuration classes.

• @EnableRetry

@EnableRetryis an annotation in the Spring Retry module to enable the retry mechanism. With this annotation, the application can automatically handle failed requests during the call process with the help of Spring's retry mechanism. This helps improve the reliability of the system, especially when calling external services over the network, which can effectively handle temporary errors.

• @EnableAsync

@EnableAsyncAsynchronous method execution for enabling Spring. By adding to a method@AsyncAnnotation, you can mark this method asynchronous execution. This means that the calling thread will not be blocked and the caller can continue to perform other tasks. This is very useful when handling IO-intensive operations or time-consuming processing tasks. After enabling this annotation, you need to make sure that there is a corresponding thread pool configuration to avoid thread resources exhaustion.

2.3 Core Code

import ;
import ;
import .slf4j.Slf4j;
import ;
import ;
import ;
import ;
import ;
import ;
import ;

@Slf4j
@Service
public class HttpRetryService {

    @Retryable(maxAttempts = 3, backoff = @Backoff(delay = 1000, multiplier = 2))
    public Response execute(OkHttpClient client, Request request) throws BusinessException{
        try {
            Response response = (request).execute();
            ("service res:{}", ());
            if (() != 200){
                ("service code not is 200");
                throw new BusinessException(ErrorCode.HTTP_ERROR);
            }
            return response;
        }catch (Exception e){
            ("Service call exception", e);
            throw new BusinessException(ErrorCode.HTTP_ERROR);
        }
    }
}

@Retryable(maxAttempts = 3, backoff = @Backoff(delay = 1000, multiplier = 2))

This annotation indicates that when the method call fails, retry up to 3 times, and the waiting time between each retry gradually increases. The initial delay is 1000ms, multiplied by 2 after each retry, which means a delay of 2 seconds after the second retry and 4 seconds after the third retry.

Summarize

• Http call:existexecuteIn the method, useOkHttpClientto send HTTP request. If the request is successful and the return code is 200, the response is returned. If the return code is not 200, throw a customBusinessException。

• Exception handling: If any exception occurs during the call process, the error log will be logged and an exception will be thrown so that the retry mechanism can recognize and perform retry.

3. Spring annotation description

3.1 @Retryable annotation

import ;
import ;
import ;
import ;
import ;

@Target()
@Retention()
public @interface Retryable {
    int maxAttempts() default 3; // Maximum number of retry    Backoff backoff() default @Backoff; // Retry interval and multiple}

3.2 @Backoff annotation

import ;
import ;

@Retention()
public @interface Backoff {
    long delay() default 1000; // Delay time    double multiplier() default 1; // Multiple of each retry}

4. How to use

Use directly in the code@RetryableAnnotation marks need to be retryed, such as the previous oneexecuteJust the method. When the method is called, if an exception occurs, it will automatically retry based on the configuration.

5. Summary

This article shows how to implement the retry mechanism of HTTP calls in Java using Spring annotations. pass@RetryableAnnotation, we can easily add retry function to HTTP calls in any method, which not only realizes the simplicity of the code, but also improves the reliability of the system. With this design pattern, developers can focus more on business logic and strip the complexity of error handling and retry mechanisms from business code.

The above is the detailed content of Java using @Retryable annotation to implement HTTP request retry. For more information about Java @Retryable HTTP request retry, please follow my other related articles!