Exchange Direct para el enrutamiento
Aprenda a usar el exchange Direct para enrutar mensajes con precisión según una clave de enrutamiento. Dirija los mensajes a colas específicas para procesarlos de forma selectiva.
Exchange Direct para el enrutamiento es una lección gratuita de RabbitMQ Messaging & Async Systems en CoddyKit. Esta es la lección 2 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de RabbitMQ Messaging & Async Systems, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de RabbitMQ Messaging & Async Systems incluye 4 lecciones en total.
Partes de esta lección aún no han sido traducidas y se muestran en inglés.
Introduction to Direct Exchange
Welcome! In this lesson, we'll explore the Direct Exchange in RabbitMQ. It's a powerful tool for sending messages to specific queues based on a routing key.
Think of it like a postal service that delivers letters only to the exact address specified on the envelope.
What is a Routing Key?
A routing key is a string attribute that producers attach to messages. It's essentially an "address" for the message.
- Producers specify a routing key when publishing.
- Queues bind to an exchange with one or more routing keys.
- Messages are delivered to queues whose binding key exactly matches the message's routing key.
How Direct Exchange Works
When a message arrives at a Direct Exchange, it looks at the message's routing key. The exchange then delivers the message to all queues that are bound to it with an identical routing key.
If no queue is bound with that specific routing key, the message is simply discarded by the exchange.
Producer's Role: Sending with Keys
As a producer, you decide the routing key for each message you send. This key determines which consumer (via its bound queue) will receive the message.
This allows for precise control over message delivery, ensuring only relevant consumers get specific types of messages.
Consumer's Role: Binding with Keys
Consumers define their interest in messages by binding their queues to a Direct Exchange using specific routing keys.
A single queue can be bound with multiple routing keys, allowing it to receive messages matching any of those keys.
Code: Producer Setup & Declare
Let's set up a basic producer that uses a Direct Exchange. We'll declare an exchange named "direct_logs" with type "direct".
This code establishes a connection and channel, then declares the exchange.
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
public class DirectProducerSetup {
private static final String EXCHANGE_NAME = "direct_logs";
public static void main(String[] argv) throws Exception {
ConnectionFactory factory = new ConnectionFactory();
factory.setHost("localhost"); // Assuming RabbitMQ is local
try (Connection connection = factory.newConnection();
Channel channel = connection.createChannel()) {
channel.exchangeDeclare(EXCHANGE_NAME, "direct");
System.out.println("Exchange '" + EXCHANGE_NAME + "' declared.");
// In a real app, you'd send messages here
// For this setup example, we just declare.
}
}
}Code: Producer Sending Message
Now, let's send a message to our "direct_logs" exchange. We'll specify a routing key, for example, "error".
Run this code after ensuring your RabbitMQ server is running. It will publish a message with the specified key.
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import java.nio.charset.StandardCharsets;
public class DirectProducerSend {
private static final String EXCHANGE_NAME = "direct_logs";
public static void main(String[] argv) throws Exception {
ConnectionFactory factory = new ConnectionFactory();
factory.setHost("localhost"); // Assuming RabbitMQ is local
try (Connection connection = factory.newConnection();
Channel channel = connection.createChannel()) {
channel.exchangeDeclare(EXCHANGE_NAME, "direct"); // Ensure exchange exists
String routingKey = "error";
String message = "A critical error occurred!";
channel.basicPublish(EXCHANGE_NAME, routingKey, null, message.getBytes(StandardCharsets.UTF_8));
System.out.println(" [x] Sent '" + routingKey + ":'" + message + "'");
}
}
}Code: Consumer Setup & Binding
On the consumer side, we'll create a queue and bind it to the "direct_logs" exchange using the routing key "error".
This consumer will only receive messages published with the "error" routing key. Run this consumer first, then the producer.
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import com.rabbitmq.client.DeliverCallback;
public class DirectConsumerError {
private static final String EXCHANGE_NAME = "direct_logs";
public static void main(String[] argv) throws Exception {
ConnectionFactory factory = new ConnectionFactory();
factory.setHost("localhost"); // Assuming RabbitMQ is local
Connection connection = factory.newConnection();
Channel channel = connection.createChannel();
channel.exchangeDeclare(EXCHANGE_NAME, "direct");
String queueName = channel.queueDeclare().getQueue(); // Create a non-durable, exclusive, auto-delete queue
String bindingKey = "error";
channel.queueBind(queueName, EXCHANGE_NAME, bindingKey);
System.out.println(" [*] Waiting for messages with routing key '" + bindingKey + "'. To exit press CTRL+C");
DeliverCallback deliverCallback = (consumerTag, delivery) -> {
String message = new String(delivery.getBody(), "UTF-8");
System.out.println(" [x] Received '" + delivery.getEnvelope().getRoutingKey() + ":'" + message + "'");
};
channel.basicConsume(queueName, true, deliverCallback, consumerTag -> {});
}
}Multiple Bindings & Use Cases
A single queue can bind to the same Direct Exchange with multiple routing keys. For instance, a "critical alerts" queue might bind to both "error" and "warning" keys to receive both types of messages.
Direct exchanges are perfect for scenarios like:
- Distributing logs based on severity (e.g., info, warn, error).
- Routing internal system events to specific processing modules.
- Targeting updates to particular user segments.
Quick Check: Direct Routing
Consider a Direct Exchange named "my_exchange".
- Queue A is bound with routing key
"report". - Queue B is bound with routing key
"alert". - Queue C is bound with routing keys
"report"and"update".
A producer sends a message to "my_exchange" with the routing key "report".
Recap: Direct Exchange
Great job! You've learned about the Direct Exchange in RabbitMQ.
- It routes messages based on an exact match of the routing key.
- Producers attach a routing key to each message.
- Consumers bind their queues to the exchange with specific routing keys to receive relevant messages.
- This pattern allows for precise, targeted message delivery.
Next, we'll explore the Fanout Exchange, which broadcasts messages to all bound queues, regardless of routing key!
Preguntas frecuentes
¿La lección «Exchange Direct para el enrutamiento» es gratis?
Sí — el texto completo de «Exchange Direct para el enrutamiento» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de RabbitMQ Messaging & Async Systems, actualiza a CoddyKit PRO. El curso de RabbitMQ Messaging & Async Systems incluye 4 lecciones en total.
¿Qué aprenderé en «Exchange Direct para el enrutamiento»?
Aprenda a usar el exchange Direct para enrutar mensajes con precisión según una clave de enrutamiento. Dirija los mensajes a colas específicas para procesarlos de forma selectiva. Practicas RabbitMQ Messaging & Async Systems con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.
¿Necesito experiencia previa para empezar RabbitMQ Messaging & Async Systems?
No se requiere experiencia previa. RabbitMQ Messaging & Async Systems en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 2 de 4.
¿Cuánto tiempo toma la lección «Exchange Direct para el enrutamiento»?
La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.
¿Puedo escribir y ejecutar código en esta lección de RabbitMQ Messaging & Async Systems?
Sí. Cada lección de RabbitMQ Messaging & Async Systems incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.
Todas las lecciones de este curso
- Exchange Fanout para Pub/Sub
- Exchange Direct para el enrutamiento
- Exchange Topic para un enrutamiento flexible
- Exchange predeterminado y bindings implícitos