RabbitMQ Messaging & Async Systems · レッスン

信頼性を高めるPublisher Confirms

Publisher Confirmsを実装し、メッセージがブローカーで正常に受信・処理されたことを確認できるようにします。ネットワークやブローカーの問題から復旧できる、信頼性の高いプロデューサーを構築します。

レッスン 2/411 ステップ

「信頼性を高めるPublisher Confirms」はCoddyKit上の無料RabbitMQ Messaging & Async Systemsレッスンです。これはレッスン2/4です。下記で完全なレッスンを無料で読むことができます。その後、ブラウザ内の組み込みコードエディタと24時間対応のAIチューターでハンズオン演習できます。これはRabbitMQ Messaging & Async Systems学習パスの一部であり、ウェブとCoddyKitアプリ全体で進捗が同期されます。 RabbitMQ Messaging & Async Systemsコースには全4レッスンが含まれています。

このレッスンの一部はまだ翻訳されておらず、英語で表示されています。

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.

無料で開始

AI チューターと学ぶ RabbitMQ Messaging & Async Systems — 無料

ブラウザでリアルコードを書いて実行し、24/7 の AI チューターから瞬時にサポートを受け、ウェブまたはアプリで続きから学習できます。

コース: 11
レッスン: 44

無料で学習を始めるコース全体を表示

よくある質問

「信頼性を高めるPublisher Confirms」レッスンは無料ですか？

はい。「信頼性を高めるPublisher Confirms」の完全なテキストはこのウェブで無料で読めます。インタラクティブに演習し（組み込みコードエディタと24時間対応のAIチューター）、RabbitMQ Messaging & Async Systemsコースの残りをアンロックするには、CoddyKit PROにアップグレードしてください。 RabbitMQ Messaging & Async Systemsコースには全4レッスンが含まれています。

「信頼性を高めるPublisher Confirms」で何を学びますか？

Publisher Confirmsを実装し、メッセージがブローカーで正常に受信・処理されたことを確認できるようにします。ネットワークやブローカーの問題から復旧できる、信頼性の高いプロデューサーを構築します。ブラウザで直接実行するハンズオンコードでRabbitMQ Messaging & Async Systemsを演習し、24時間対応のAIチューターがレッスンを進める中での質問に答えます。

RabbitMQ Messaging & Async Systemsを始めるのに経験は必要ですか？

事前経験は必要ありません。CoddyKitのRabbitMQ Messaging & Async Systemsは初級者から上級者向けに構成されているため、ここから始めるか最初から始めて、自分のペースで進むことができます。これはレッスン2/4です。

「信頼性を高めるPublisher Confirms」レッスンにはどのくらい時間がかかりますか？

ほとんどのCoddyKitレッスンは約5～10分かかります。各レッスンはコンパクトでインタラクティブなので、着実に進歩し、ウェブとアプリ全体で正確に前回の場所から再開できます。

このRabbitMQ Messaging & Async Systemsレッスンでコードを書いて実行できますか？

はい。すべてのRabbitMQ Messaging & Async Systemsレッスンに組み込みコードエディタが含まれているため、ブラウザでリアルコードを書いて実行し、即座のAIフィードバックを取得できます。ローカル設定は不要です。

このコースのすべてのレッスン

← RabbitMQ Messaging & Async Systemsに戻る