0Pricing
RabbitMQ Messaging & Async Systems · Aula

Exchange Headers em profundidade

Descubra a exchange Headers para rotear mensagens com base nos atributos dos cabeçalhos, em vez de chaves de roteamento. Implemente regras de roteamento mais complexas e dinâmicas.

Exchange Headers em profundidade é uma aula grátis de RabbitMQ Messaging & Async Systems no CoddyKit. Esta é a aula 1 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de RabbitMQ Messaging & Async Systems, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de RabbitMQ Messaging & Async Systems inclui 4 aulas no total.

Partes desta aula ainda não foram traduzidas e aparecem em 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.

Perguntas Frequentes

A aula “Exchange Headers em profundidade” é grátis?

Sim — o texto completo de “Exchange Headers em profundidade” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de RabbitMQ Messaging & Async Systems, atualize para CoddyKit PRO. O curso de RabbitMQ Messaging & Async Systems inclui 4 aulas no total.

O que vou aprender em “Exchange Headers em profundidade”?

Descubra a exchange Headers para rotear mensagens com base nos atributos dos cabeçalhos, em vez de chaves de roteamento. Implemente regras de roteamento mais complexas e dinâmicas. Você pratica RabbitMQ Messaging & Async Systems com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar RabbitMQ Messaging & Async Systems?

Nenhuma experiência prévia é necessária. RabbitMQ Messaging & Async Systems no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 1 de 4.

Quanto tempo leva a aula “Exchange Headers em profundidade”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de RabbitMQ Messaging & Async Systems?

Sim. Cada aula de RabbitMQ Messaging & Async Systems inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

  1. Exchange Headers em profundidade
  2. Associações entre exchanges
  3. Exchanges de mensagens não entregues (DLX)
  4. Exchanges alternativas para mensagens não roteáveis
← Voltar para RabbitMQ Messaging & Async Systems