RabbitMQ Messaging & Async Systems · Leçon

Confirmations de publication pour la fiabilité

Confirmations de publication pour la fiabilité est une leçon RabbitMQ Messaging & Async Systems gratuite sur CoddyKit. Ceci est la leçon 2 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage RabbitMQ Messaging & Async Systems, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours RabbitMQ Messaging & Async Systems comprend 4 leçons au total.

Certaines parties de cette leçon n'ont pas encore été traduites et s'affichent en anglais.

Why Publisher Confirms?

When you send a message to RabbitMQ, how do you know if it actually arrived safely at the broker?

By default, producers send messages without waiting for any explicit confirmation from RabbitMQ. This is fast, but it means messages could be lost due to network issues or broker failures right after being sent.

Publisher Confirms are a mechanism that allows producers to receive acknowledgements (ACKs) from RabbitMQ when messages have been successfully received and processed by the broker.

The Unseen Gap in Delivery

Imagine sending an important order to a processing queue. Without publisher confirms, your application simply 'sends' the message and moves on.

What if the network connection drops the message mid-flight?
What if the RabbitMQ server crashes moments after receiving, but before persisting, your message?

Without a confirmation, your producer would assume success, potentially leading to data loss or inconsistent states in your system.

How Confirm Mode Works

To use publisher confirms, you enable 'confirm mode' on a channel. Once enabled, every message published on that channel is assigned a unique delivery tag.

ACK (Acknowledgement): The broker sends an ACK back to the producer when a message has been successfully received, routed to its queues, and persisted (if durable).
NACK (Negative Acknowledgement): The broker sends a NACK if it couldn't process the message (e.g., failed to route, internal error).

This feedback loop closes the 'delivery gap' between producer and broker.

Enabling Confirm Mode

Before publishing messages, you need to tell RabbitMQ that you want to use publisher confirms on your channel. This is a one-time setup for each channel.

Try running this example to see how to enable confirm mode:

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;

public class ConfirmSetup {
  public static void main(String[] args) throws Exception {
    ConnectionFactory factory = new ConnectionFactory();
    factory.setHost("localhost"); // Assumes RabbitMQ is running locally
    try (Connection connection = factory.newConnection();
         Channel channel = connection.createChannel()) {

      channel.confirmSelect(); // This line enables confirm mode
      System.out.println("Channel is now in confirm mode.");
      // Further publishing code would go here
    }
  }
}

Synchronous Confirms: `waitForConfirms`

One way to use publisher confirms is synchronously. After publishing one or more messages, the producer can call channel.waitForConfirms() or channel.waitForConfirmsOrDie().

This method blocks the producer until all messages published since the last call have been ACKed or NACKed.
It's simple to implement but can significantly slow down throughput, as the producer waits for each batch of messages.
Ideal for low-volume, critical messages where immediate confirmation is paramount.

Sync Confirm Code Example

This example shows a producer sending a single message and then waiting for its confirmation. If the message isn't confirmed within 5 seconds, it times out.

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import java.io.IOException;
import java.util.concurrent.TimeoutException;

public class SyncConfirmPublisher {
  private static final String QUEUE_NAME = "sync_confirm_queue";

  public static void main(String[] args) throws IOException, TimeoutException, InterruptedException {
    ConnectionFactory factory = new ConnectionFactory();
    factory.setHost("localhost");
    try (Connection connection = factory.newConnection();
         Channel channel = connection.createChannel()) {

      channel.queueDeclare(QUEUE_NAME, false, false, false, null);
      channel.confirmSelect(); // Enable confirm mode

      String message = "Hello, reliable world!";
      channel.basicPublish("", QUEUE_NAME, null, message.getBytes("UTF-8"));
      System.out.println(" [x] Sent '" + message + "'");

      // Wait for confirmation for up to 5 seconds
      if (channel.waitForConfirms(5000)) {
        System.out.println("Message confirmed by broker!");
      } else {
        System.out.println("Message not confirmed within timeout! It might be lost or delayed.");
      }
    }
  }
}

Asynchronous Confirms: Listeners

For higher throughput, you can use asynchronous publisher confirms. Instead of blocking, you register a ConfirmListener on the channel.

The listener has two methods: handleAck() for successful confirms and handleNack() for negative confirms.
RabbitMQ delivers ACKs and NACKs to this listener, allowing your producer to continue publishing messages without waiting.
This approach requires more complex logic to track unconfirmed messages, but offers superior performance for high-volume publishing.

Async Confirm Code Example

This example demonstrates an asynchronous publisher. It registers a listener to handle ACKs and NACKs without blocking the main thread.

Notice the Thread.sleep() to keep the program alive long enough to receive confirmations.

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.ConfirmListener;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import java.io.IOException;
import java.util.concurrent.ConcurrentNavigableMap;
import java.util.concurrent.ConcurrentSkipListMap;

public class AsyncConfirmPublisher {
  private static final String QUEUE_NAME = "async_confirm_queue";

  public static void main(String[] args) throws Exception {
    ConnectionFactory factory = new ConnectionFactory();
    factory.setHost("localhost");
    try (Connection connection = factory.newConnection();
         Channel channel = connection.createChannel()) {

      channel.queueDeclare(QUEUE_NAME, false, false, false, null);
      channel.confirmSelect(); // Enable confirm mode

      // Store unconfirmed messages by their delivery tag
      ConcurrentNavigableMap<Long, String> outstandingConfirms = new ConcurrentSkipListMap<>();

      channel.addConfirmListener(new ConfirmListener() {
        @Override
        public void handleAck(long deliveryTag, boolean multiple) throws IOException {
          if (multiple) {
            // Remove all messages up to this deliveryTag
            outstandingConfirms.headMap(deliveryTag + 1).clear();
          } else {
            outstandingConfirms.remove(deliveryTag);
          }
          System.out.println(" [x] Message with deliveryTag " + deliveryTag + " ACKed! Remaining: " + outstandingConfirms.size());
        }

        @Override
        public void handleNack(long deliveryTag, boolean multiple) throws IOException {
          String message = outstandingConfirms.get(deliveryTag);
          System.out.println(" [!] Message '" + message + "' (deliveryTag " + deliveryTag + ") NACKed! Re-sending or logging error.");
          // Handle NACK: re-publish, log, etc.
          if (multiple) {
             outstandingConfirms.headMap(deliveryTag + 1).clear();
          } else {
             outstandingConfirms.remove(deliveryTag);
          }
        }
      });

      String message = "Hello, async reliable world!";
      long nextPublishSeqNo = channel.getNextPublishSeqNo();
      outstandingConfirms.put(nextPublishSeqNo, message);
      channel.basicPublish("", QUEUE_NAME, null, message.getBytes("UTF-8"));
      System.out.println(" [x] Sent '" + message + "' (deliveryTag: " + nextPublishSeqNo + ")");

      // Keep main thread alive for a moment to receive confirms
      Thread.sleep(2000);
    }
  }
}

Sync vs. Async: Choosing Wisely

The choice between synchronous and asynchronous confirms depends on your application's needs:

Synchronous (waitForConfirms):
- Simpler to implement.
- Lower throughput, as it blocks.
- Good for low-volume, highly critical messages where immediate confirmation is essential.
Asynchronous (ConfirmListener):
- More complex implementation (requires tracking unconfirmed messages).
- Higher throughput, as it doesn't block.
- Ideal for high-volume message publishing where performance is key.

Confirm Check

You've learned about publisher confirms. Let's see if you can answer this question.

Recap: Reliable Publishing

Congratulations! You've learned how to make your RabbitMQ producers truly reliable using publisher confirms.

Publisher confirms ensure that messages sent by a producer are successfully received and processed by the RabbitMQ broker.
You enable confirm mode on a channel using channel.confirmSelect().
Synchronous confirms (waitForConfirms()) are simple but block, suitable for low volume.
Asynchronous confirms (addConfirmListener()) provide higher throughput for high-volume scenarios, requiring more complex tracking of messages.

By implementing publisher confirms, you can build robust systems that minimize message loss and ensure critical data integrity.

Questions Fréquemment Posées

La leçon « Confirmations de publication pour la fiabilité » est-elle gratuite ?

Oui — le texte complet de « Confirmations de publication pour la fiabilité » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours RabbitMQ Messaging & Async Systems, passe à CoddyKit PRO. Le cours RabbitMQ Messaging & Async Systems comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Confirmations de publication pour la fiabilité » ?

Implémentez les confirmations de publication afin de garantir que les messages ont bien été reçus et traités par le courtier. Créez des producteurs fiables capables de récupérer après des problèmes d… Tu pratiques RabbitMQ Messaging & Async Systems avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer RabbitMQ Messaging & Async Systems ?

Aucune expérience préalable n'est requise. RabbitMQ Messaging & Async Systems sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 2 sur 4.

Combien de temps prend la leçon « Confirmations de publication pour la fiabilité » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon RabbitMQ Messaging & Async Systems ?

Oui. Chaque leçon RabbitMQ Messaging & Async Systems inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

Messages et files d’attente persistants
Confirmations de publication pour la fiabilité
Accusés de réception et remise en file des consommateurs
Transactions ou confirmations de publication

← Retour à RabbitMQ Messaging & Async Systems