Rôle des files d'attente de messages (Message Queues)

L'utilisation d'un courtier de messages comme RabbitMQ apporte plusieurs avantages architecturaux majeurs par rapport à une communication synchrone classique :

• Traitement Asynchrone : Permet de libérer les ressources immédiatement après l'envoi d'une requête, sans attendre la fin du traitement long par un service tiers.
• Fiabilité : Le système garantit que les messages ne sont pas perdus même si un service est temporairement indisponible.
• Lissage de charge (Peak Shaving) : En cas de pic de trafic, les messages sont stockés dans la file et consommés au rythme que le système peut supporter, évitant ainsi la saturation.
• Découplage Applicatif : Les services n'ont pas besoin de se connaître directement ; ils communiquent via des interfaces de messages standardisées.

Concepts Fondamentaux de RabbitMQ

• Message : Composé d'un en-tête (métadonnées comme la priorité ou la clé de routage) et d'un corps (le contenu réel).
• Publisher : L'application qui produit et envoie les messages vers un échangeur (Exchange).
• Exchange : Reçoit les messages et les dirige vers les files d'attente selon des règles précises (Binding).
• Queue : Le contaneur final qui stocke les messages jusqu'à ce qu'un consommaetur les traite.
• Binding : La règle de liaison entre un Exchange et une Queue.
• Channel : Canal virtuel au sein d'une connexion TCP. Créer des connexions TCP est coûteux, les canaux permettent donc de multiplexer les communications.
• Virtual Host : Un environnement isolé logiquement au sein d'un même serveur RabbitMQ.

Types d'Exchange et Routage

1. Direct : Le message est acheminé vers la file si la routing-key correspond exactement.
2. Fanout : Diffusion massive. Le message est envoyé à toutes les files liées à l'échangeur, sans distinction.
3. Topic : Routage basé sur des motifs. Utilise des jokers :
   • * : Remplace exactement un mot.
   • # : Remplace zéro ou plusieurs mots.

Intégration avec Spring Boot

Pour démarrer, il est nécessaire d'inclure la dépendance spring-boot-starter-amqp et d'activer le support avec l'annotation @EnableRabbit sur votre classe de configuration.

Configuration Programmatique avec RabbitAdmin

Voici comment déclarer dynamiquement des composants RabbitMQ :

@Test
void setupInfrastructure() {
    // Déclaration d'un échangeur de type Direct
    DirectExchange mainExchange = new DirectExchange("service.main.exchange", true, false);
    rabbitAdmin.declareExchange(mainExchange);

    // Déclaration d'une file d'attente
    Queue logQueue = new Queue("service.log.queue", true);
    rabbitAdmin.declareQueue(logQueue);

    // Liaison entre l'échangeur et la file
    Binding logBinding = BindingBuilder.bind(logQueue)
            .to(mainExchange)
            .with("log.critical");
    rabbitAdmin.declareBinding(logBinding);
}

Envoi de Messages et Sérialisation JSON

Par défaut, Spring utilise la sérialisation Java. Pour interagir avec d'autres langages, le JSON est préférable :

@Bean
public MessageConverter jsonConverter() {
    return new Jackson2JsonMessageConverter();
}

public void pushEvent(Object eventData) {
    rabbitTemplate.convertAndSend("service.main.exchange", "log.critical", eventData);
}

Gestion de la Consommation et Fiabilité

L'utilisation de @RabbitListener au niveau de la classe combinée à @RabbitHandler sur les méthodes permet de router automatiquement les messages selon leur type.

Accusé de Réception Manuel (Manual ACK)

Pour garantir qu'un message n'est supprimé de la file qu'après un traitement réussi, on configure le mode de confirmation manuel :

spring.rabbitmq.listener.simple.acknowledge-mode=manual

@RabbitHandler
public void processOrder(Message msg, OrderDTO order, Channel channel) throws IOException {
    long tag = msg.getMessageProperties().getDeliveryTag();
    try {
        // Logique métier ici
        System.out.println("Traitement de la commande : " + order.getId());
        
        // Confirmation de réception
        channel.basicAck(tag, false);
    } catch (Exception e) {
        // En cas d'erreur, on refuse le message sans le remettre en file (requeue=false)
        channel.basicNack(tag, false, false);
    }
}

Garantir la Livraison de bout en bout

Pour assurer une fiabilité totale, RabbitMQ propose des mécanismes de retour d'information :

• Publisher Confirm : Le broker informe le producteur que le message est bien arrivé à l'échangeur.
  spring.rabbitmq.publisher-confirm-type=correlated
• Publisher Return : Si un message arrive à l'échangeur mais qu'aucune règle de routage ne permet de l'envoyer vers une file, le broker renvoie le message au producteur.
  spring.rabbitmq.publisher-returns=true

@PostConstruct
public void configureCallbacks() {
    rabbitTemplate.setConfirmCallback((data, ack, cause) -> {
        if (ack) {
            System.out.println("Message reçu par le broker : " + data.getId());
        } else {
            System.err.println("Échec de réception : " + cause);
        }
    });

    rabbitTemplate.setReturnsCallback(returned -> {
        System.err.println("Message non routé vers une file : " + returned.getMessage());
    });
}