Agréger des API REST et SOAP sans sacrifier la résilience
Adaptateurs, appels parallèles, Resilience4j, réponses partielles, cache Redis et tests de contrat : construire une agrégation bancaire qui tient.
Dans une banque, la vue complète d’un client est rarement stockée au même endroit. Ses comptes, ses cartes, ses crédits et ses coordonnées vivent dans des systèmes différents, parfois récents et exposés en REST, parfois anciens et accessibles uniquement en SOAP. Une couche d’agrégation doit tout réunir en une seule réponse, sans que la lenteur d’un système ne fasse tomber les autres.
Le contexte
Sur une plateforme d’agrégation d’API bancaires, le besoin était de consolider les données client de plusieurs systèmes hétérogènes derrière une API unique, sécurisée et documentée. Le piège classique : la qualité de service de l’API agrégée devient celle du système le plus lent ou le moins disponible.
Le flux d’une requête ressemble à ceci :
Client ──► API d'agrégation
├─► Adaptateur REST ──► Système des comptes
├─► Adaptateur SOAP ──► Système des cartes
├─► Adaptateur SOAP ──► Système des crédits
└─► Cache Redis ──► Référentiel client
◄── Réponse consolidée (complète ou partielle)
Isoler chaque système derrière un adaptateur
Chaque système amont a son propre modèle, ses propres conventions et ses propres erreurs. Plutôt que de laisser ces détails se propager, chaque intégration passe par un adaptateur dédié, une couche anti-corruption au sens du DDD. Le cœur de l’agrégation ne connaît qu’une interface du domaine :
public interface CardsPort {
List<Card> findByCustomer(CustomerId customerId);
}
L’adaptateur SOAP implémente ce port. Il génère son client à partir du WSDL (par exemple avec le plugin Maven cxf-codegen-plugin), traduit les messages XML et les SOAP faults en objets et exceptions du domaine, et ne laisse rien fuiter d’autre. Remplacer un système amont ne touche alors qu’un seul adaptateur.
Des timeouts explicites, partout
Sans timeout, un appel bloqué consomme un thread indéfiniment, et sous charge c’est toute l’application qui s’arrête. Chaque client a donc un délai de connexion et un délai de lecture.
Côté REST, avec le RestClient de Spring :
@Bean
RestClient accountsClient(RestClient.Builder builder) {
var http = HttpClient.newBuilder().connectTimeout(Duration.ofSeconds(2)).build();
var factory = new JdkClientHttpRequestFactory(http);
factory.setReadTimeout(Duration.ofSeconds(3));
return builder.baseUrl("https://accounts.internal").requestFactory(factory).build();
}
Côté SOAP, avec Apache CXF :
HTTPConduit conduit = (HTTPConduit) ClientProxy.getClient(cardsPort).getConduit();
HTTPClientPolicy policy = new HTTPClientPolicy();
policy.setConnectionTimeout(2_000); // ms
policy.setReceiveTimeout(3_000); // ms
conduit.setClient(policy);
Les valeurs se fixent à partir des temps de réponse observés de chaque système (le 99e centile, pas la moyenne), pas au hasard.
Appeler en parallèle
Les systèmes amont sont indépendants : les appeler l’un après l’autre additionne leurs latences. En parallèle, la réponse arrive au rythme du plus lent, borné par son timeout. Avec Java 21, les virtual threads rendent ce parallélisme bon marché :
private final ExecutorService executor = Executors.newVirtualThreadPerTaskExecutor();
public CustomerView aggregate(CustomerId id) {
var accounts = CompletableFuture.supplyAsync(() -> accountsPort.findByCustomer(id), executor);
var cards = CompletableFuture.supplyAsync(() -> cardsPort.findByCustomer(id), executor);
var loans = CompletableFuture.supplyAsync(() -> loansPort.findByCustomer(id), executor);
CompletableFuture.allOf(accounts, cards, loans).join();
return CustomerView.of(accounts.join(), cards.join(), loans.join());
}
Chaque appel est protégé individuellement (section suivante) : un échec ne fait pas échouer les autres.
Resilience4j : trois protections par système
Autour de chaque adaptateur, Resilience4j ajoute trois mécanismes complémentaires :
@CircuitBreaker(name = "cards", fallbackMethod = "cardsUnavailable")
@Retry(name = "cards")
@Bulkhead(name = "cards")
public SectionResult<List<Card>> cards(CustomerId id) {
return SectionResult.ok(cardsAdapter.findByCustomer(id));
}
private SectionResult<List<Card>> cardsUnavailable(CustomerId id, Throwable cause) {
log.warn("Cartes indisponibles pour {} : {}", id, cause.toString());
return SectionResult.unavailable("cards");
}
resilience4j:
circuitbreaker:
instances:
cards:
sliding-window-type: COUNT_BASED
sliding-window-size: 20
minimum-number-of-calls: 10
failure-rate-threshold: 50
slow-call-duration-threshold: 2s
slow-call-rate-threshold: 80
wait-duration-in-open-state: 30s
permitted-number-of-calls-in-half-open-state: 3
retry:
instances:
cards:
max-attempts: 2
wait-duration: 200ms
enable-exponential-backoff: true
retry-exceptions:
- java.net.SocketTimeoutException
- java.io.IOException
bulkhead:
instances:
cards:
max-concurrent-calls: 25
Quelques points qui comptent en production :
- Le circuit breaker compte aussi les appels lents, pas seulement les erreurs. Un système qui répond en 10 secondes est presque aussi nuisible qu’un système en panne.
- Le retry ne s’applique qu’aux lectures idempotentes et aux erreurs techniques transitoires. On ne rejoue jamais une erreur fonctionnelle (un 4xx, un fault métier), et jamais une écriture sans clé d’idempotence.
- L’ordre compte. Par défaut, Resilience4j applique le retry à l’extérieur du circuit breaker : chaque tentative est comptée par le circuit, qui s’ouvre plus vite si le système est vraiment en panne.
- Le bulkhead limite le nombre d’appels simultanés vers un système : un système lent ne peut pas monopoliser toutes les ressources de l’agrégateur.
Accepter une réponse partielle
Le choix le plus structurant est fonctionnel : mieux vaut une réponse partielle et honnête qu’une erreur globale. Si le système des cartes est indisponible, l’API renvoie les comptes et les crédits, et le signale explicitement :
{
"customerId": "C-1029",
"accounts": [ { "iban": "CI93 …", "balance": 1250000 } ],
"loans": [ { "id": "L-77", "remaining": 3400000 } ],
"cards": null,
"status": {
"complete": false,
"unavailable": ["cards"]
}
}
Le client de l’API décide ensuite quoi afficher. Ce contrat doit être documenté dans l’OpenAPI et accepté par les consommateurs dès le départ : une réponse partielle découverte en production est un bug, pas une fonctionnalité.
Un cache Redis pour ce qui change peu
Les données peu volatiles, comme les référentiels ou les coordonnées, passent par un cache Redis avec une durée de vie adaptée à chaque type de donnée :
@Bean
RedisCacheManagerBuilderCustomizer cacheTtl() {
return builder -> builder
.withCacheConfiguration("customerProfile",
RedisCacheConfiguration.defaultCacheConfig().entryTtl(Duration.ofMinutes(15)))
.withCacheConfiguration("referenceData",
RedisCacheConfiguration.defaultCacheConfig().entryTtl(Duration.ofHours(12)));
}
@Cacheable(cacheNames = "customerProfile", key = "#id.value")
public CustomerProfile profile(CustomerId id) { … }
Deux précautions avec des données bancaires : ne jamais mettre en cache les soldes ou les mouvements, qui doivent rester frais, et protéger Redis comme une base de données (réseau privé, authentification, chiffrement en transit), puisqu’il contient des données personnelles.
Tester les contrats et les pannes
Avec autant d’intégrations, les régressions viennent rarement du code de l’agrégateur, mais d’un changement de format côté amont ou côté consommateur.
Les tests de contrat avec Pact. Chaque consommateur publie ce qu’il attend de l’API dans un Pact Broker. Avant chaque livraison, l’agrégateur vérifie qu’il respecte tous ces contrats :
@Provider("customer-aggregation-api")
@PactBroker
@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
class ConsumerContractsTest {
@TestTemplate
@ExtendWith(PactVerificationInvocationContextProvider.class)
void verify(PactVerificationContext context) {
context.verifyInteraction();
}
}
Les tests d’intégration avec Testcontainers. Une vraie instance Redis démarre pour les tests, branchée automatiquement par Spring Boot :
@Container
@ServiceConnection(name = "redis")
static GenericContainer<?> redis = new GenericContainer<>("redis:7-alpine").withExposedPorts(6379);
Les tests de panne avec WireMock. On simule un système SOAP lent pour vérifier que le timeout, le circuit breaker et la réponse partielle se déclenchent comme prévu :
stubFor(post(urlEqualTo("/ws/cards"))
.willReturn(aResponse().withStatus(200).withFixedDelay(5_000)));
Observer chaque appel aval
Le traçage distribué OpenTelemetry suit chaque requête dans tous les appels aval : on voit immédiatement quel système ralentit une réponse. Les métriques Resilience4j, exportées vers Prometheus via Micrometer, donnent l’état de chaque circuit (fermé, ouvert, semi-ouvert) et le taux d’appels lents. Une alerte sur l’ouverture d’un circuit prévient l’équipe avant les utilisateurs.
Une agrégation résiliente ne cherche pas à ne jamais échouer : elle échoue partiellement, vite et de façon visible.
Ce que j’en retiens
- Un adaptateur par système amont, pour isoler leurs modèles et leurs erreurs.
- Des timeouts calibrés sur les temps de réponse réels, et des appels en parallèle.
- Circuit breaker, retry limité aux lectures et bulkhead, système par système.
- Une réponse partielle documentée dans le contrat plutôt qu’une erreur globale.
- Des tests de contrat, d’intégration et de panne, plus un traçage de bout en bout.
Cet article vous a été utile ? Partagez-le.

Architecte et développeur backend senior Java / Spring Boot, 14 ans sur des systèmes critiques en télécoms, banque et mobilité. Basé à Dakar.