0Pricing
RabbitMQ Messaging & Async Systems · 강의

교환기 간 바인딩

교환기를 다른 교환기에 바인딩해 정교한 라우팅 체인과 메시지 팬아웃 패턴을 만드는 방법을 학습합니다. 시스템 내에서 복잡한 메시지 흐름을 구축합니다.

교환기 간 바인딩은(는) CoddyKit의 무료 RabbitMQ Messaging & Async Systems 강의입니다. 이것은 4개 중 2번째 강의입니다. 아래에서 전체 강의를 무료로 읽을 수 있으며, 내장 코드 에디터와 24/7 AI 튜터와 함께 브라우저에서 직접 실습할 수 있습니다. 이 강의는 RabbitMQ Messaging & Async Systems 학습 경로의 일부이며, 진행 상황이 웹과 CoddyKit 앱에 동기화됩니다. RabbitMQ Messaging & Async Systems 강의에는 총 4개의 강의가 포함되어 있습니다.

이 강의의 일부는 아직 번역되지 않았으며 영어로 표시됩니다.

Why Chain Exchanges?

In RabbitMQ, you've learned how producers send messages to exchanges, which then route them to queues. But what if you need more complex routing?

Sometimes, a message needs to go through multiple "decision points" before reaching its final destination. This is where Exchange-to-Exchange (E2E) bindings come in handy!

Chaining Exchanges Together

Think of E2E bindings as connecting pipelines. Instead of an exchange sending messages directly to a queue, it sends them to another exchange.

  • The first exchange receives a message.
  • It routes the message to a second exchange based on its type and the binding.
  • The second exchange then routes the message further, either to queues or yet another exchange.

This creates powerful routing flows!

Anatomy of an E2E Binding

An E2E binding connects a source exchange to a destination exchange. Messages arriving at the source exchange will be routed to the destination exchange.

Just like exchange-to-queue bindings, E2E bindings also use a routing key. This key determines how messages are routed from the source exchange to the destination exchange, based on the source exchange's type.

Example: Direct to Fanout Chain

Let's consider a practical scenario: You want to route a message to a specific category, and then broadcast it to multiple services interested in that category.

  • A producer sends a message to a Direct Exchange with a routing key like "alerts.critical".
  • This Direct Exchange is bound to a Fanout Exchange with the same routing key.
  • The Fanout Exchange is then bound to several queues, ensuring all services receive the "alerts.critical" message.

Declaring Exchanges for E2E

First, we need to declare our two exchanges: a 'source' Direct exchange and a 'destination' Fanout exchange. The producer will send messages to the 'source' exchange.

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

public class ExchangeDeclarer {
    private static final String SOURCE_EXCHANGE = "my_direct_source";
    private static final String DEST_EXCHANGE = "my_fanout_destination";

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

            channel.exchangeDeclare(SOURCE_EXCHANGE, "direct");
            System.out.println("Declared source direct exchange: " + SOURCE_EXCHANGE);

            channel.exchangeDeclare(DEST_EXCHANGE, "fanout");
            System.out.println("Declared destination fanout exchange: " + DEST_EXCHANGE);

        }
    }
}

Binding Exchanges Together

Now, let's create the actual E2E binding. We'll bind our 'source' direct exchange to our 'destination' fanout exchange. We'll use a routing key "my.route" for this specific binding.

Messages sent to my_direct_source with routing key my.route will be forwarded to my_fanout_destination.

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

public class ExchangeBinder {
    private static final String SOURCE_EXCHANGE = "my_direct_source";
    private static final String DEST_EXCHANGE = "my_fanout_destination";
    private static final String BINDING_KEY = "my.route";

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

            // Ensure exchanges are declared (or declare them here if not done)
            channel.exchangeDeclare(SOURCE_EXCHANGE, "direct");
            channel.exchangeDeclare(DEST_EXCHANGE, "fanout");

            // Bind source to destination with a routing key
            channel.exchangeBind(DEST_EXCHANGE, SOURCE_EXCHANGE, BINDING_KEY); // Note: bind(destination, source, key)
            System.out.println("Bound " + SOURCE_EXCHANGE + " to " + DEST_EXCHANGE + " with key: " + BINDING_KEY);

        }
    }
}

Sending Messages to the Source

Our producer will send a message to the my_direct_source exchange using the routing key my.route. This message will then be routed to our my_fanout_destination exchange due to the E2E binding.

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import java.nio.charset.StandardCharsets;

public class E2EProducer {
    private static final String SOURCE_EXCHANGE = "my_direct_source";
    private static final String BINDING_KEY = "my.route";

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

            // Ensure source exchange is declared
            channel.exchangeDeclare(SOURCE_EXCHANGE, "direct");

            String message = "Hello via E2E binding!";
            channel.basicPublish(SOURCE_EXCHANGE, BINDING_KEY, null, message.getBytes(StandardCharsets.UTF_8));
            System.out.println(" [x] Sent '" + message + "' with routing key '" + BINDING_KEY + "' to " + SOURCE_EXCHANGE);

        }
    }
}

Consuming from the Destination

Finally, a consumer will receive the message. Since my_fanout_destination is a fanout exchange, we'll bind a temporary queue to it. Any message arriving at the fanout exchange (from our E2E binding) will be delivered to this queue.

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

public class E2EConsumer {
    private static final String DEST_EXCHANGE = "my_fanout_destination";

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

        channel.exchangeDeclare(DEST_EXCHANGE, "fanout");

        String queueName = channel.queueDeclare().getQueue();
        channel.queueBind(queueName, DEST_EXCHANGE, ""); // Fanout ignores routing key

        System.out.println(" [*] Waiting for messages in queue '" + queueName + "'. To exit press CTRL+C");

        DeliverCallback deliverCallback = (consumerTag, delivery) -> {
            String message = new String(delivery.getBody(), "UTF-8");
            System.out.println(" [x] Received '" + message + "'");
        };
        channel.basicConsume(queueName, true, deliverCallback, consumerTag -> {});
    }
}

Routing Keys and E2E Flow

When a message is routed from a source exchange to a destination exchange via an E2E binding, its original routing key is preserved.

The source exchange uses the binding key of the E2E binding to decide if it should forward the message to the destination exchange. Once forwarded, the destination exchange then uses the message's original routing key (not the E2E binding key) to route it to its own bound queues.

  • Direct Source: Matches message's routing key exactly to E2E binding key.
  • Topic Source: Matches message's routing key against E2E binding key (with wildcards).
  • Fanout Source: Ignores E2E binding key, forwards all messages.

Test Your E2E Knowledge

A Direct Exchange 'Source' is bound to a Fanout Exchange 'Dest' with the routing key "alerts.high".

A producer sends a message to 'Source' with the routing key "alerts.high".

'Dest' is bound to two queues: 'Q1' and 'Q2'.

Which queues will receive the message?

E2E Bindings: Summary

You've explored Exchange-to-Exchange (E2E) bindings, a powerful feature for creating sophisticated message routing paths in RabbitMQ!

  • E2E bindings allow an exchange to forward messages to another exchange, creating routing chains.
  • They use a binding key, just like exchange-to-queue bindings, to define the routing logic between exchanges.
  • The message's original routing key is preserved and used by the destination exchange for further routing to queues.
  • E2E bindings enable complex patterns like filtering then fanning out, or cascading messages through multiple processing stages.

자주 묻는 질문

“교환기 간 바인딩” 강의는 무료인가요?

네 — “교환기 간 바인딩” 전체 내용을 이 웹사이트에서 무료로 읽을 수 있습니다. 인터랙티브하게 실습하려면(내장 코드 에디터와 24/7 AI 튜터), CoddyKit PRO로 업그레이드하면 RabbitMQ Messaging & Async Systems 강의 전체를 잠금 해제할 수 있습니다. RabbitMQ Messaging & Async Systems 강의에는 총 4개의 강의가 포함되어 있습니다.

“교환기 간 바인딩”에서 뭘 배우나요?

교환기를 다른 교환기에 바인딩해 정교한 라우팅 체인과 메시지 팬아웃 패턴을 만드는 방법을 학습합니다. 시스템 내에서 복잡한 메시지 흐름을 구축합니다. 브라우저에서 직접 실행하는 실습 코드로 RabbitMQ Messaging & Async Systems을(를) 배우며, 24/7 AI 튜터가 강의를 진행하면서 질문에 답변해줍니다.

RabbitMQ Messaging & Async Systems을(를) 시작하는 데 경험이 필요한가요?

사전 경험은 필요하지 않습니다. CoddyKit의 RabbitMQ Messaging & Async Systems은(는) 초급자부터 고급 학습자까지를 위해 구성되어 있으므로, 여기서 시작하거나 처음부터 시작할 수 있으며 자신의 속도대로 진행할 수 있습니다. 이것은 4개 중 2번째 강의입니다.

“교환기 간 바인딩” 강의는 얼마나 걸리나요?

대부분의 CoddyKit 강의는 약 5~10분이 소요됩니다. 각 강의는 간결하고 인터랙티브하여 꾸준한 진행이 가능하며, 웹과 앱에서 중단한 부분부터 바로 시작할 수 있습니다.

이 RabbitMQ Messaging & Async Systems 강의에서 코드를 작성하고 실행할 수 있나요?

네. 모든 RabbitMQ Messaging & Async Systems 강의에는 내장 코드 에디터가 포함되어 있으므로, 브라우저에서 바로 실제 코드를 작성하고 실행한 후 즉시 AI 피드백을 받을 수 있습니다 — 로컬 설정이 필요 없습니다.

이 강의의 모든 강의

  1. Headers 교환기 자세히 알아보기
  2. 교환기 간 바인딩
  3. 배달 못한 편지 교환기(DLX)
  4. 라우팅할 수 없는 메시지를 위한 대체 익스체인지
← RabbitMQ Messaging & Async Systems(으)로 돌아가기