RabbitMQ Messaging & Async Systems · Lección

Exchange Headers en profundidad

Descubra el exchange Headers para enrutar mensajes según los atributos de sus encabezados en lugar de las claves de enrutamiento. Implemente reglas de enrutamiento más complejas y dinámicas.

Exchange Headers en profundidad es una lección gratuita de RabbitMQ Messaging & Async Systems en CoddyKit. Esta es la lección 1 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.

Headers Exchange: New Routing

Meet the Headers exchange! Unlike Direct or Topic exchanges that use a simple routing_key string, Headers exchanges route messages based on their header attributes.

Think of it as a more flexible way to filter messages, using key-value pairs attached to the message itself.

Routing by Message Headers

When a producer sends a message, it includes a map of key-value pairs (headers). A consumer binds its queue to a Headers exchange with its own set of header rules.

The exchange then compares the message headers to the binding rules to decide where to deliver the message.

Matching Logic: 'all' or 'any'

Headers exchanges use a special argument called x-match in the binding to define the matching logic:

"all": The message's headers must contain all the key-value pairs specified in the binding.
"any": The message's headers must contain at least one of the key-value pairs specified in the binding.

This gives you powerful control over message delivery!

Producing with Custom Headers

Let's see how a producer adds custom headers to a message. We'll send a simple text message with format: json and type: report headers.

Run this code to send a message:

import com.rabbitmq.client.*;
import java.util.HashMap;
import java.util.Map;

public class HeadersProducer {
    private static final String EXCHANGE = "my_headers_exchange";

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

            channel.exchangeDeclare(EXCHANGE, "headers");

            Map<String, Object> headers = new HashMap<>();
            headers.put("format", "json");
            headers.put("type", "report"); // Add headers

            String msg = "Report Data (JSON)";
            AMQP.BasicProperties props = new AMQP.BasicProperties.Builder()
                                            .headers(headers)
                                            .build();
            channel.basicPublish(EXCHANGE, "", props, msg.getBytes("UTF-8"));
            System.out.println(" [x] Sent: '" + msg + "' with headers: " + headers);
        }
    }
}

Consumer 'All' Match Example

This consumer will only receive messages if all its specified headers (format: json AND type: report) are present in the incoming message.

Run this consumer first, then the producer from the previous scene.

import com.rabbitmq.client.*;
import java.util.HashMap;
import java.util.Map;

public class HeadersConsumerAll {
    private static final String EXCHANGE = "my_headers_exchange";

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

        channel.exchangeDeclare(EXCHANGE, "headers");
        String queueName = channel.queueDeclare().getQueue();

        Map<String, Object> bindHeaders = new HashMap<>();
        bindHeaders.put("x-match", "all");
        bindHeaders.put("format", "json");
        bindHeaders.put("type", "report"); // Requires both

        channel.queueBind(queueName, EXCHANGE, "", bindHeaders);
        System.out.println(" [*] Waiting for msgs with ALL: " + bindHeaders);

        DeliverCallback dc = (ct, delivery) -> {
            String msg = new String(delivery.getBody(), "UTF-8");
            System.out.println(" [x] Received '" + msg + "' Headers: " + delivery.getProperties().getHeaders());
        };
        channel.basicConsume(queueName, true, dc, ct -> {});
    }
}

Consumer 'Any' Match Example

Now, let's create a consumer that receives messages if any of its specified headers (format: xml OR priority: high) are present.

Run this consumer. Then, try sending messages with different header combinations.

import com.rabbitmq.client.*;
import java.util.HashMap;
import java.util.Map;

public class HeadersConsumerAny {
    private static final String EXCHANGE = "my_headers_exchange";

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

        channel.exchangeDeclare(EXCHANGE, "headers");
        String queueName = channel.queueDeclare().getQueue();

        Map<String, Object> bindHeaders = new HashMap<>();
        bindHeaders.put("x-match", "any");
        bindHeaders.put("format", "xml"); // Matches if format is xml
        bindHeaders.put("priority", "high"); // OR if priority is high

        channel.queueBind(queueName, EXCHANGE, "", bindHeaders);
        System.out.println(" [*] Waiting for msgs with ANY: " + bindHeaders);

        DeliverCallback dc = (ct, delivery) -> {
            String msg = new String(delivery.getBody(), "UTF-8");
            System.out.println(" [x] Received '" + msg + "' Headers: " + delivery.getProperties().getHeaders());
        };
        channel.basicConsume(queueName, true, dc, ct -> {});
    }
}

More on `x-match` Values

While "all" and "any" are the primary x-match values, you can also omit x-match. If x-match is not provided, it defaults to "all".

Remember that the header values must match exactly. For example, "type": "report" won't match "type": "Report".

When to Use Headers Exchange

Headers exchanges are great for:

Dynamic Routing: When routing logic changes often without code deployments.
Complex Filtering: Routing based on multiple, non-hierarchical attributes.
Policy-Based Routing: For example, routing high-priority messages to a dedicated queue.

It adds flexibility where routing keys might be too rigid.

Headers vs. Other Exchanges

How does Headers compare?

Direct: Routes by exact routing_key match.
Topic: Routes by routing_key patterns (wildcards).
Headers: Routes by arbitrary message header key-value pairs, offering more attribute-based flexibility.

Choose the exchange type that best fits your message routing needs!

Headers Exchange Quiz

A producer sends a message with headers {"color": "red", "size": "large"}.

Which consumer binding configuration(s) will receive this message?

Lesson Summary

In this lesson, we explored the powerful Headers exchange. You learned:

It routes messages based on header key-value pairs.
The x-match argument ("all" or "any") controls the matching logic.
How to use it for flexible, attribute-based message routing.

This exchange offers a robust alternative to routing keys for complex filtering scenarios.

Preguntas frecuentes

¿La lección «Exchange Headers en profundidad» es gratis?

Sí — el texto completo de «Exchange Headers en profundidad» 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 Headers en profundidad»?

Descubra el exchange Headers para enrutar mensajes según los atributos de sus encabezados en lugar de las claves de enrutamiento. Implemente reglas de enrutamiento más complejas y dinámicas. 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 1 de 4.

¿Cuánto tiempo toma la lección «Exchange Headers en profundidad»?

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 Headers en profundidad
Bindings entre exchanges
Exchanges de mensajes no entregables (DLX)
Exchanges alternativos para mensajes no enroutables

← Volver a RabbitMQ Messaging & Async Systems