EIP (Enterprise Integration Patterns)
Les patterns d’intégration enterprise implémentés dans GoCamel.
Split
Divise un message en plusieurs parties traitées individuellement.
Traitement parallèle :
Propriétés de l’Exchange:
CamelSplitIndex— Index actuel (0-based)CamelSplitSize— Nombre total de partiesCamelSplitComplete— Dernière partie ?
Ces propriétés sont limitées à la branche
Elles décrivent une partie, pas le message entier, et sont retirées au
moment où le résultat agrégé est publié sur l’exchange parent. Un
processeur placé après le Split ne voit donc pas un CamelSplitComplete=true
résiduel de la dernière partie, et un Split imbriqué n’écrase pas la
comptabilité de celui qui l’englobe. La même règle s’applique à
CamelMulticast*, CamelRecipientList* et CamelRoutingSlip*.
Un corps []byte n’est pas une collection
Découper un corps []byte produit une seule partie, comme Apache Camel
qui ne découpe pas les byte[]. Le traiter comme une liste produisait un
exchange par octet — une charge utile de 10 Ko devenait 10 000 exchanges.
Pour découper délibérément du contenu binaire, découpez sur une valeur
décodée :
Avec agrégation :
Aggregate
Combine plusieurs messages en un seul.
Au moins une condition de complétion est obligatoire : SetCompletionSize,
SetCompletionTimeout ou SetCompletionPredicate. Sans cela, Process
retourne une erreur au lieu de bufferiser indéfiniment.
Stratégie personnalisée:
Conditions de complétion :
| Méthode | Description |
|---|---|
SetCompletionSize(n) | Compléter après n messages |
SetCompletionTimeout(ms) | Compléter après un délai (timeout) |
SetCompletionPredicate(fn) | Compléter quand le prédicat retourne vrai |
Options de stockage :
Au démarrage d’une route avec un timeout de complétion, les groupes déjà
présents dans le dépôt reçoivent à nouveau un CompletionTimeout complet : un
groupe laissé en attente par une route arrêtée, ou persisté en SQL lors d’un
redémarrage du processus, expire au lieu d’attendre indéfiniment sa taille ou
son prédicat. Un dépôt personnalisé en bénéficie en implémentant
ListableAggregationRepository (Keys).
Multicast
Envoie une copie à plusieurs destinations.
Options:
ParallelProcessing()— Exécute les branches en parallèleAggregationStrategy— Fusionne les résultats
Propriétés:
CamelMulticastIndexCamelMulticastSizeCamelMulticastComplete
Wire Tap
Envoie une copie de l’exchange à un endpoint secondaire de manière asynchrone (fire-and-forget), sans bloquer la route principale. La copie est indépendante : les modifications sur l’exchange tapé n’affectent pas la route principale et vice-versa.
Fonctionnement :
- Crée une copie profonde (deep copy) de l’exchange.
- Lance un goroutine qui envoie la copie à l’endpoint spécifié.
- Retourne immédiatement — la route principale continue sans attendre.
- L’exchange tapé utilise un contexte indépendant (
context.Background()) : il n’est pas annulé quand la route principale se termine. - Les erreurs lors du tap sont loggées mais ne sont pas propagées à la route principale.
Notes :
- Idéal pour l’audit, la journalisation ou la surveillance sans impact sur les performances.
Route.Stop()attend que tous les taps en cours soient terminés avant de s’arrêter (aucun message n’est perdu lors du shutdown).- Disponible également dans les contextes
Multicast,Pipeline,SplitetLoop.
Pipeline
Chaîne séquentielle de processors.
Choice
Content-Based Router - route les messages vers différentes destinations selon des conditions sur le contenu.
EndChoice() accroche le Choice au container courant (la route, ou un
Split / Loop / Multicast englobant, pour que chaque partie soit évaluée).
Expressions supportées :
| Expression | Description | Exemple |
|---|---|---|
${header.name} | Valeur d’en-tête | ${header.Content-Type == 'json'} |
${body} | Corps du message | ${body == 'active'} |
${body['key']} | Accès par clé map | ${body['status'] == 'pending'} |
${body[0]} | Accès par index | ${body[0] > 50} |
${exchangeProperty.prop} | Propriété Exchange | ${exchangeProperty.userId != ''} |
${date:now} | Date/heure actuelle | — |
${random(100)} | Nombre aléatoire | — |
${uuid} | UUID unique | — |
Opérateurs de comparaison :
==— Égal à!=— Différent de>— Supérieur à<— Inférieur à>=— Supérieur ou égal<=— Inférieur ou égal
Méthodes disponibles dans When/Otherwise :
Ordre d’évaluation
Les clauses When sont évaluées dans l’ordre. La première condition vraie déclenche son processor, les autres sont
ignorées. Si aucune condition ne correspond et qu’Otherwise est présent, il est exécuté.
Filter
Filtre les messages selon une condition. Les exchanges qui ne correspondent pas sont silencieusement supprimés (
ErrStopRouting). La suppression ne termine que la route courante : si cette route a été appelée
via direct:, l’appelant continue (comme pour un Aggregator incomplet ou un Resequencer).
Utilisez Stop() pour arrêter l’exchange partout.
Throttle
Limite le débit de traitement à N messages maximum par fenêtre de temps. Les exchanges excédentaires sont retardés ( jamais perdus) jusqu’à ce que la fenêtre se réinitialise.
Notes :
- Utilise un compteur à fenêtre fixe — pour un lissage plus fin, réduire la durée de la fenêtre
- Bloquant : le goroutine attend que la fenêtre autorise le passage
maxRequestsettimePerioddoivent être supérieurs à zéro ; les valeurs invalides retournent une erreur au lieu de bloquer indéfiniment- Si le contexte de l’exchange est annulé pendant l’attente de la fenêtre suivante,
Processretourne une erreur
Sample
Ne laisse passer qu’un échantillon des exchanges. Contrairement à Throttle, qui retarde les exchanges, Sample écarte silencieusement les autres, quel que soit leur contenu.
Notes :
- Les exchanges écartés s’arrêtent avec
ErrStopRouting: ils ne sont pas traités comme des échecs - Aucune goroutine en arrière-plan : seul un mutex protège l’horodatage ou le compteur
Sampleconserve le premier exchange de chaque période, pas le dernier- Une période ou un compteur non positif est signalé par
Route.Validate();Processretourne une erreur au lieu de tout laisser passer
Delay
Met le traitement de l’exchange en pause pour une durée fixe ou calculée dynamiquement. Le sleep respecte l’annulation du contexte.
Notes :
- Bloquant : le goroutine dort pendant la durée calculée
- Si le contexte de l’exchange est annulé pendant le sleep,
Processretourne une erreur - Retourner
0depuisDelayFuncpour ignorer le délai pour un exchange donné - Passer
nilàDelayFuncfait échouer la construction de la route ;NewDelayerFunc(nil)reste constructible mais retourne une erreur de traitement au lieu de paniquer
Content Enricher
Enrichit l’exchange courant avec des données provenant d’une source externe.
Fonctionnement :
- Une copie de l’exchange courant est envoyée à l’URI d’enrichissement
- La réponse est récupérée
AggregationStrategy.Aggregate(original, réponse)fusionne les deux- Sans stratégie, le corps de la réponse remplace le corps original
PollEnrich
Consommation ponctuelle à la demande depuis un endpoint consommateur (avec timeout et stratégie d’agrégation).
Les endpoints pris en charge sont seda, chan et les implémentations personnalisées de PollingEndpoint. Chaque appel reçoit au plus un échange et laisse la file ouverte avec ses autres messages. Un endpoint sans ce contrat, ou une file ayant déjà un consommateur ou une réception ponctuelle en cours, renvoie une erreur avant toute consommation. Un timeout nul est non bloquant ; un timeout négatif attend un message ou l’annulation du contexte. Un timeout positif laisse le message initial inchangé si aucun message n’arrive.
Message Validator
Valide les messages en cours de transit selon un prédicat, interrompant l’échange avec ErrValidationFailed si la condition n’est pas remplie.
Idempotent Consumer
Empêche le traitement de messages en double.
Fonctionnement :
- Évalue l’expression pour obtenir une clé unique.
- Vérifie si la clé existe déjà dans le dépôt (repository).
- Si elle n’est pas présente, ajoute la clé immédiatement (bloquant les doublons concurrents) et continue le traitement.
- Si elle est déjà présente, arrête le routage (
ErrStopRouting). - Si l’exchange échoue ensuite en aval, la clé est retirée du dépôt (via une
Synchronizationde l’exchange) : une relivraison du même message sera donc traitée au lieu d’être perdue — sémantique at-least-once.
Dépôts (Repositories) :
NewMemoryIdempotentRepository(): Stockage en mémoire vive (par défaut).NewRedisIdempotentRepository(): Stockage distribué via Redis.- Des dépôts basés sur SQL peuvent être implémentés via l’interface
IdempotentRepository.
Circuit Breaker
Protège les routes contre les pannes en cascade lors de l’appel de services externes instables.
États :
- Closed (Fermé) : Les requêtes passent normalement. Les échecs sont comptabilisés.
- Open (Ouvert) : Les requêtes échouent immédiatement ou passent par le fallback.
- Half-Open (Semi-ouvert) : Après le
OpenTimeout, une seule requête d’essai à la fois sonde le service aval ; les requêtes concurrentes sont redirigées vers le fallback comme si le circuit était encore ouvert. QuandSuccessThresholdsondes réussissent, le circuit se referme. Si une sonde échoue, il s’ouvre à nouveau.
ErrStopRouting (Filter, agrégation incomplète, Stop EIP) n’est pas un
échec : il n’incrémente pas le compteur et n’ouvre pas le circuit.
Load Balancer
Répartit les messages sur plusieurs endpoints.
Stratégies :
RoundRobin(): Distribution circulaire (par défaut).Random(): Distribution aléatoire.Custom(strategy): Fournir une implémentation personnalisée de l’interfaceLoadBalancerStrategy.
SEDA
Staged Event-Driven Architecture. Découple les producteurs et les consommateurs via une file d’attente interne (Go channel).
Fonctionnement :
- Le producteur envoie une copie de l’exchange dans une file d’attente interne.
- Le producteur rend la main immédiatement (asynchrone).
- Un ou plusieurs workers lisent la file et traitent l’exchange de manière indépendante.
Paramètres :
size: La capacité de la file d’attente (défaut 1000).concurrentConsumers: Le nombre de goroutines esclaves traitant la file (défaut 1).shutdownTimeout: Durée pendant laquelleStopcontinue de traiter les exchanges en file, en ms (défaut 30000 ;0les abandonne immédiatement).
Les valeurs invalides (size négatif, concurrentConsumers non positif) retombent sur
les valeurs par défaut avec un avertissement. Les paramètres sont appliqués à la
première création de l’endpoint ; les références ultérieures au même nom de file
réutilisent l’endpoint existant, et une référence avec des options différentes émet un
avertissement.
Contexte. Les workers traitent chaque exchange sous le contexte du consumer, et non
celui de l’émetteur. Une route comme From("http://...").To("seda:travail") rend la
main dès que le message est en file, ce qui annule le contexte de la requête HTTP ; la
partie asynchrone n’est pas affectée et ses appels HTTP, délais et requêtes SQL
s’exécutent normalement.
Arrêt. Stop refuse d’abord les nouveaux envois (et débloque les producteurs en
attente sur une file pleine), puis laisse les workers terminer les exchanges déjà en
file, pendant au plus shutdownTimeout. Il annule ensuite le contexte du consumer ; les
exchanges restant en file sont complétés en échec. CamelContext.GracefulStop annule
le contexte d’emblée et n’attend donc pas la file.
Resequencer
Remet dans l’ordre les messages arrivés de manière désordonnée en se basant sur un numéro de séquence ou un horodatage.
Fonctionnement :
- Évalue l’expression pour obtenir le numéro de séquence.
- Si la séquence est celle attendue, elle est traitée immédiatement.
- S’il s’agit d’une séquence future, elle est mise en tampon et triée.
- Si un trou (gap) persiste plus longtemps que le
Timeout, le resequenceur saute la séquence manquante et continue avec la suivante disponible.
Notes :
- Les messages sont délivrés en aval via le pipeline interne du resequenceur (les étapes
entre
Resequence(...)etEnd()). L’exchange original s’arrête là (ErrStopRouting) : les étapes placées aprèsEnd()ne voient jamais de messages hors ordre. - La livraison est sérialisée pour garantir l’ordre ; les étapes en aval ne doivent pas rerouter vers le même resequenceur.
- Les numéros de séquence dupliqués ou obsolètes sont ignorés (avec un avertissement dans les logs).
- Un exchange mis en tampon est délivré plus tard, par un autre message ou par le timeout : il s’exécute en aval sous le contexte de cycle de vie de la route, pas sous celui de la requête qui l’a apporté (généralement terminée à ce moment-là).
- Un message n’échoue que pour sa propre erreur en aval. L’échec d’un autre exchange du tampon délivré dans le même lot est journalisé ; il n’est pas remonté au message qui a déclenché la livraison et ne passe pas par l’error handler de la route.
Claim Check
Réduit la taille des messages en stockant le contenu (payload) dans un dépôt externe et en ne faisant circuler qu’une référence (une clé).
Opérations :
ClaimCheckPush: Stocke le corps et le remplace par une clé. Si aucune clé n’est fournie, elle est générée.ClaimCheckPop: Récupère les données par clé, restaure le corps et les supprime du dépôt.ClaimCheckGet: Récupère les données par clé et restaure le corps (les garde dans le dépôt).ClaimCheckDiscard: Supprime les données du dépôt sans les restaurer.
Stop
Arrête le routage actuel sans erreur.
Contrairement à Filter, Stop() termine l’exchange entier (il positionne la propriété
CamelRouteStop) : une route qui a appelé celle-ci via direct: s’arrête aussi, et son
Send renvoie ErrStopRouting.
ToD (Dynamic To)
URI résolue dynamiquement à l’exécution.
Expressions supportées:
${header.<name>}— Valeur d’en-tête${property.<name>}— Valeur de propriété${body}— Corps du message
Échappement. Les valeurs de l’exchange sont des données, pas de la syntaxe
d’URI. Chaque valeur est échappée selon la position de son placeholder dans le
template (InterpolateURI) :
- dans la query string, elle est échappée comme valeur de requête : un header
comme
a&allowHeaderOverride=truereste dans son option et ne peut pas en activer une autre ; - dans le chemin,
?et#sont échappés : une valeur ne peut pas ouvrir une query string.
Un placeholder qui représente l’URI entière ou son schéma (ToD("${header.dest}"))
est inséré tel quel : la route laisse explicitement les données de l’exchange
choisir l’endpoint, ces données doivent donc provenir d’une source de confiance.
Chaque URI distincte conserve un producer démarré dans le cache de producers du
contexte, borné à DefaultProducerCacheSize (1000) producers. Au-delà, les
producers inactifs les moins récemment utilisés sont arrêtés. Modifiez la borne
avec CamelContext.SetProducerCacheSize(n) (n <= 0 = illimité).
Recipient List
Envoie un message à plusieurs destinataires calculés dynamiquement à l’exécution.
Dynamic Router
Route un exchange à travers une séquence d’endpoints résolus dynamiquement en appelant une fonction de contrôle après
chaque étape. Le routage s’arrête quand la fonction retourne une chaîne vide ou nil.
Fonctionnement :
- Appelle la fonction ou l’expression de contrôle.
- Si le résultat n’est pas vide, envoie l’exchange à cet URI.
- Propage la sortie vers l’entrée et recommence à l’étape 1.
Routing Slip
Route un exchange à travers une séquence dynamique d’endpoints. Contrairement à Recipient List, chaque étape reçoit la sortie de l’étape précédente.
Propriétés Exchange pendant Routing Slip :
| Propriété | Type | Description |
|---|---|---|
CamelRoutingSlipIndex | int | Index de l’étape courante (base 0) |
CamelRoutingSlipSize | int | Nombre total d’étapes |
CamelRoutingSlipComplete | bool | Indique la dernière étape |
Headers & Properties
Set/Remove Headers
Set/Remove Properties
Gestion des erreurs
Do-Try-Catch-Finally
Gestion structurée des erreurs au sein d’une route.
Fonctionnement :
- Exécute les processeurs du bloc
DoTry. - Si une erreur survient, recherche un bloc
DoCatchcorrespondant (une chaîne vide intercepte tout). - Si une correspondance est trouvée, l’erreur est considérée comme “gérée” et le routage continue après le bloc
DoTry(sauf si le bloc catch échoue lui-même). - Le bloc
DoFinallyest toujours exécuté, qu’il y ait eu une erreur ou non.
Error handler de route et Dead Letter Channel
Un ErrorHandler de route reçoit chaque erreur renvoyée par une étape. Sa
valeur de retour pilote la route :
nildemande à la route de rejouer l’étape en échec (redelivery). Cela ne veut pas dire « ignorer l’erreur et continuer » : la route abandonne aprèsMaxErrorHandlerRetries(10000) rejeux consécutifs de la même étape et renvoie une erreur qui enveloppeErrTooManyRetries.- une erreur qui enveloppe
ErrStopRoutingarrête le routage sans mettre l’exchange en échec. - toute autre erreur met l’exchange en échec.
DeadLetterChannel réessaie jusqu’à MaxRedeliveries, envoie ensuite
l’exchange vers l’endpoint dead letter et, par défaut, renvoie quand même
l’erreur d’origine au consumer (le consumer HTTP répond 500). Avec
DeadLetterHandled(true), un exchange envoyé en dead letter est considéré comme
traité, comme dans Apache Camel :
OnException
OnException déclare des gestionnaires de route sélectionnés par type
d’erreur, comme le onException d’Apache Camel. Chaque clause liste une ou
plusieurs cibles :
- une valeur d’erreur (une sentinelle comme
io.EOF) correspond viaerrors.Is; - un pointeur non nil vers un type d’erreur ou d’interface correspond via
errors.As:gocamel.ErrorType[*MonErreur]()(équivalent ànew(*MonErreur)),&MonErreurValeur{}pour une erreur à récepteur valeur,gocamel.ErrorType[net.Error](). Un&MonErreur{}dont la méthodeErrora un récepteur pointeur est une valeur d’erreur et ne correspond qu’à elle-même.
Une cible absente, nil ou non supportée fait échouer Build().
Fonctionnement :
- Quand une étape de premier niveau échoue, les clauses sont essayées dans l’ordre de déclaration et la première qui correspond l’emporte : déclarez d’abord les clauses spécifiques.
- Une clause qui correspond remplace l’
ErrorHandlerde la route pour cette erreur. L’étape en échec est rejouée jusqu’àMaximumRedeliveriesfois (0 par défaut), en attendantRedeliveryDelay(1 s par défaut) multiplié parBackOffMultiplier(2 par défaut, 1 pour un délai fixe) à chaque tentative, plafonné parMaximumRedeliveryDelay(60 s par défaut). L’attente s’interrompt si le contexte de l’exchange est annulé. - Si l’étape échoue encore, les processeurs de la clause (
Process,ProcessFunc,To,SetBody,SetHeader,Log) s’exécutent sur le message reçu par l’étape, avec les propriétésCamelExceptionCaught,CamelRedeliveryCounteretCamelFailureRouteId. - Ensuite :
Handled(true): le routage s’arrête (aucune étape suivante) et aucune erreur n’atteint le consumer ni l’émetteur, qui reçoit l’exchange tel que laissé par le gestionnaire. La route renvoie une erreur qui enveloppeErrStopRoutinget l’erreur d’origine.Continued(true): le routage continue avec l’étape suivante comme si l’erreur n’avait pas eu lieu ; cette étape reçoit la sortie du gestionnaire.Continuedl’emporte surHandled.- aucun des deux (par défaut) : l’erreur d’origine est propagée.
- Si un processeur du gestionnaire échoue, son erreur (qui enveloppe l’erreur d’origine) est renvoyée à la place.
Les erreurs sans clause correspondante gardent le comportement
ErrorHandler/DeadLetterChannel. Un exchange déjà envoyé en dead letter
(IsDeadLettered), par exemple par une route appelée via direct: qui propage
l’erreur d’origine, ne déclenche jamais de clause : son échec a déjà été pris
en charge.
Limites : les clauses sont propres à la route (pas encore d’OnException
global au contexte), ne s’appliquent qu’aux erreurs des étapes de premier
niveau — un rejeu relance toute l’étape, par exemple un bloc Split entier —
et n’ont pas de prédicat OnWhen.
Process
Exécute un processeur personnalisé.
Loop
Répète un segment de route un nombre de fois statique ou dynamique.
Propriétés de l’Exchange pendant la boucle :
| Propriété | Type | Description |
|---|---|---|
CamelLoopIndex | int | Index de l’itération actuelle (commence à 0) |
CamelLoopSize | int | Nombre total d’itérations de la boucle |
CamelLoopComplete | bool | Booléen indiquant s’il s’agit de la dernière itération |
Note : Stop() dans une boucle termine le routage de l’exchange : les étapes placées après
End() ne s’exécutent pas. Tout autre signal d’arrêt levé dans le corps de la boucle (Filter,
Sample…) ne termine que la boucle, et le routage reprend après End().
Saga
Le pattern Saga fournit un mécanisme pour coordonner une série de transactions locales à travers des services distribués sans verrouiller les bases de données. Il définit un ensemble d’actions et leurs actions de compensation correspondantes (annulations).
Si une action dans le bloc Saga échoue ou retourne une erreur, l’orchestrateur de la Saga déclenche automatiquement les étapes de compensation pour toutes les actions terminées, dans l’ordre inverse (LIFO - Last In, First Out). Les panics d’action sont récupérés et traités comme des échecs (les compensations s’exécutent quand même). Un ErrStopRouting provenant d’une action arrête la saga sans compensation — c’est un signal de contrôle, pas un échec.
Vous pouvez également utiliser des fonctions Go personnalisées pour les actions et les compensations directement avec ActionFunc :
Une compensation nil dans ActionFunc signifie que l’étape n’a rien à annuler.
État persistant et reprise
Chaque saga s’exécute sous un identifiant lu dans l’en-tête CamelSagaId (un UUID est généré et placé dans l’en-tête s’il est absent). Après chaque action dont l’étape a une compensation, la saga enregistre un point de reprise dans un SagaRepository : la liste des compensations en attente et un instantané du message In (corps et en-têtes). Elle enregistre de nouveau après chaque compensation, et supprime l’état une fois la saga terminée ou entièrement compensée. Une compensation en échec reste dans le dépôt pour qu’une reprise ultérieure la retente.
| Option | Défaut | Effet |
|---|---|---|
Repository(repo) | MemorySagaRepository | Où l’état est persisté. SQLSagaRepository (module racine, database/sql uniquement — le driver est fourni par l’appelant) survit à un crash du processus. |
Timeout(d) | 0 (aucun) | Limite chaque action et chaque compensation. Une action qui la dépasse échoue avec ErrSagaStepTimeout (qui enveloppe context.DeadlineExceeded) et les étapes terminées sont compensées ; l’étape expirée ne l’est pas, comme toute étape en échec. L’étape s’exécute sur une copie de l’échange dont le Context porte l’échéance : une étape qui ignore son contexte continue en arrière-plan après l’expiration et son résultat est ignoré. |
RecoverIncomplete(true) | désactivé | Au CamelContext.Start, une fois toutes les routes démarrées, les sagas incomplètes trouvées dans le dépôt sont compensées de la dernière étape à la première. Désactivé, chaque saga incomplète est seulement journalisée en avertissement, avec la manière d’activer la reprise. |
La reprise envoie chaque compensation à son URI via le cache de producteurs du contexte, avec un échange reconstruit à partir du message du dernier point de reprise et de l’en-tête CamelSagaId. SagaProcessor.Recover(ctx, camelCtx) la déclenche à la demande. Les sagas encore en cours dans le processus courant ne sont jamais reprises.
Avertissement
Seules les compensations déclarées par URI d’endpoint survivent à un redémarrage du processus. Une compensation passée à ActionFunc est une fonction Go : elle ne peut pas être sérialisée, donc après un redémarrage rien ne permet de la reconstruire. Ces étapes sont tout de même persistées (avec InProcessCompensation), et lorsque la reprise en rencontre une, elle signale ErrSagaCompensationNotRecoverable dans une ligne de log ERROR qui nomme la saga et l’étape — elle ne l’ignore jamais silencieusement — et la conserve dans le dépôt, au statut COMPENSATING, pour un traitement manuel. Les autres compensations par URI de cette saga s’exécutent quand même. Déclarez les étapes qui doivent pouvoir être reprises avec Action(actionURI, compensationURI).
Garanties de livraison. Le point de reprise est écrit après le retour de l’action et avant le début de l’action suivante. Un crash entre une action et son point de reprise perd cette étape (sa compensation ne s’exécute pas à la reprise) ; un crash après une compensation et avant la mise à jour de l’état ré-exécute cette compensation. La compensation à la reprise est donc au moins une fois pour les étapes enregistrées : les compensations doivent être idempotentes. Si un point de reprise ne peut pas être enregistré, la saga échoue et compense ses étapes terminées, y compris celle qui vient de se terminer.
Format de persistance. SQLSagaRepository stocke l’état en JSON (saga_id, status, state, updated_at en nanosecondes Unix) : le corps et les valeurs d’en-têtes doivent être sérialisables en JSON et reviennent sous forme de types JSON (nombres en float64, []byte en chaîne base64). ListIncomplete renvoie au plus DefaultSagaListLimit (1000) sagas, les plus anciennes d’abord ; les suivantes sont reprises à un démarrage ultérieur, une fois les premières résolues.
Limites. Une saga imbriquée dans l’action d’une autre saga reçoit son propre identifiant (l’en-tête de la saga englobante est restauré ensuite) ; les sagas ne sont ni propagées ni jointes entre routes. La reprise ne coordonne pas plusieurs processus partageant une même base : activez RecoverIncomplete sur une seule instance, sinon un processus peut compenser une saga qu’un autre exécute encore.
Transformer
Transforme le contenu du message.
Transform
Un EIP dédié à la transformation de message qui modifie dynamiquement le corps (body) du message à l’aide d’une fonction Go ou d’une expression Simple Language.
Message History
L’EIP Message History permet de retracer le parcours chronologique d’un message lorsqu’il traverse les différents nœuds et processeurs de la route.
Pour activer le suivi d’une route, appelez .EnableMessageHistory() sur votre route builder. Vous pouvez ensuite récupérer et inspecter l’historique des messages à l’aide de gocamel.GetMessageHistory(exchange).
Récapitulatif des patterns EIP
| Pattern | Catégorie | Description |
|---|---|---|
| Choice | Routage | Routage basé sur le contenu |
| Filter | Routage | Filtrage conditionnel |
| Idempotent Consumer | Routage | Empêche les messages en double |
| Circuit Breaker | Routage | Pattern de résilience pour les pannes |
| Load Balancer | Routage | Répartition de charge entre endpoints |
| Dynamic Router | Routage | Routage dynamique basé sur décision |
| Resequencer | Routage | Réordonnancer les messages par séquence |
| Claim Check | Routage | Stocker le payload et passer une référence |
| Throttle | Routage | Limitation de débit |
| Delay | Routage | Pause avant la prochaine étape |
| Sample | Routage | Garder un échantillon, écarter le reste |
| Multicast | Routage | Destinations multiples |
| Recipient List | Routage | Routage dynamique vers plusieurs destinataires |
| Routing Slip | Routage | Routage séquentiel dynamique |
| Wire Tap | Routage | Copie asynchrone fire-and-forget |
| Split | Transformation | Découpage de message |
| Aggregate | Transformation | Agrégation de messages |
| Content Enricher | Transformation | Enrichissement avec données externes |
| Transform | Transformation | Transformation de contenu |
| ToD | Endpoint | Endpoint dynamique |
| Stop | Contrôle | Arrêter le routage |
| DoTry | Contrôle | Gestion d’erreurs Try-Catch-Finally |
| SetHeader | En-têtes | Manipulation d’en-têtes |
| SetProperty | Propriétés | Propriétés d’exchange |
| Loop | Contrôle | Itération avec compteur statique/dynamique |
| Saga | Contrôle | Pattern transactionnel Saga |
| Message History | Diagnostics | Suivi du parcours de traitement des messages |
Fin des branches et agrégation
Split, Multicast et RecipientList terminent chaque branche traitée, en succès comme en échec, notamment ses callbacks de rollback d’idempotence. Avant de lancer les workers parallèles, ils copient les corps mutables pris en charge, y compris chaque élément du Split. Les types mutables personnalisés exigent toujours une copie applicative ou un usage immuable. L’agrégation commence après la fin des workers ; la stratégie est appelée séquentiellement dans l’ordre d’entrée et ses panics deviennent des erreurs ErrProcessorPanic. Le traitement séquentiel s’arrête à la première branche en échec. Un Split ou une RecipientList en parallèle traite au plus MaxConcurrency(n) branches à la fois (défaut DefaultMaxConcurrency, 10) : leur nombre de branches dépend du contenu du message, et sans borne chaque élément lançait sa propre goroutine. Un Multicast parallèle lance toutes ses branches à la fois, leur nombre étant fixé par la route.
Une expression Resequence invalide accumule une erreur de construction tout en laissant la chaîne DSL utilisable ; Timeout, Capacity et End ne paniquent pas à cause de cette erreur antérieure.