java 38 lines · 7 steps

Resilient payment calls with Spring Retry

A Spring service retries transient payment failures with exponential backoff and falls back gracefully when retries run out.

Explained by highlit

Spring Intermediate retry backoff fault-tolerance http-client fallback

1@Service
2public class PaymentGatewayClient {
3 
  private static final Logger log = LoggerFactory.getLogger(PaymentGatewayClient.class);
5 
  private final RestTemplate restTemplate;
7 
  public PaymentGatewayClient(RestTemplate restTemplate) {
      this.restTemplate = restTemplate;
  }
11 
  @Retryable(
      retryFor = { ResourceAccessException.class, HttpServerErrorException.class },
      noRetryFor = HttpClientErrorException.class,
      maxAttempts = 4,
      backoff = @Backoff(delay = 500, multiplier = 2.0, maxDelay = 5000, random = true)
  )
  public ChargeResult charge(ChargeRequest request) {
      log.debug("Submitting charge for order {}", request.orderId());
      ResponseEntity<ChargeResult> response = restTemplate.postForEntity(
          "/v1/charges", request, ChargeResult.class);
      return response.getBody();
  }
24 
  @Recover
  public ChargeResult recoverCharge(RemoteAccessException ex, ChargeRequest request) {
      log.error("Charge for order {} failed after retries: {}", request.orderId(), ex.getMessage());
      return ChargeResult.pending(request.orderId(),
          "Gateway unavailable, charge queued for reconciliation");
  }
31 
  @Recover
  public ChargeResult recoverCharge(HttpServerErrorException ex, ChargeRequest request) {
      log.error("Gateway returned {} for order {}", ex.getStatusCode(), request.orderId());
      throw new PaymentProcessingException(
          "Payment gateway rejected charge for order " + request.orderId(), ex);
  }
38}

01 / 01

STEP 01

Walkthrough

Space play ←→ step click any line

Three takeaways

1Retry only errors that might succeed next time — server and network faults — and never client errors like 4xx that will always fail.
2Randomized exponential backoff spreads retries out and prevents a thundering herd against a struggling downstream service.
3Distinct @Recover methods let you shape different outcomes — a safe fallback versus a rethrown exception — based on which failure exhausted the retries.

Related explainers

java

public interface GitHubClient {
 
    @GetExchange("/users/{username}")
    GitHubUser getUser(@PathVariable String username);

Declarative HTTP clients in Spring

http-client declarative-api proxy

Intermediate 8 steps

java

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

Building a trie for autocomplete in Java

trie prefix-tree recursion

Intermediate 8 steps

java

@RestController
@RequestMapping("/api/products")
public class ProductSearchController {

Binding collection query params in Spring

rest-api query-parameters dependency-injection

Intermediate 6 steps

java

import java.util.ArrayDeque;
import java.util.Deque;
import java.util.Map;

Evaluating math expressions with two stacks

stacks parsing operator-precedence

Intermediate 9 steps

ruby

require "timeout"
require "net/http"
 
class RemoteInventoryClient

Bounding a slow HTTP call with Timeout in Ruby

timeout error-handling http

Intermediate 6 steps

java

@Entity
@Table(name = "orders")
@SQLDelete(sql = "UPDATE orders SET deleted = true, deleted_at = now() WHERE id = ?")
@Where(clause = "deleted = false")