RabbitMQ Messaging & Async Systems · Leçon

Échange Topic pour un routage flexible

Maîtrisez l’échange Topic pour créer des schémas de routage complexes à l’aide de caractères génériques. Concevez des topologies de routage des messages flexibles et évolutives.

Échange Topic pour un routage flexible est une leçon RabbitMQ Messaging & Async Systems gratuite sur CoddyKit. Ceci est la leçon 3 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage RabbitMQ Messaging & Async Systems, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours RabbitMQ Messaging & Async Systems comprend 4 leçons au total.

Certaines parties de cette leçon n'ont pas encore été traduites et s'affichent en anglais.

Topic Exchange: Flexible Routing

Welcome to the Topic Exchange! This exchange type offers the most flexible message routing, letting you send messages to queues based on complex patterns.

Unlike the simple Fanout or direct-match Direct exchange, Topic exchanges use special wildcards in routing keys to match messages dynamically.

Understanding Topic Routing Keys

With a Topic exchange, routing keys aren't exact matches. They are strings made of words separated by dots (.), much like parts of a filename or URL.

Example: animal.rabbit.fast
Example: log.error.database

Each word provides a level of detail, allowing for hierarchical routing.

The Single-Word Wildcard: `*`

The asterisk (*) wildcard matches exactly one word in a routing key segment.

Binding key: animal.*.fast matches animal.rabbit.fast
Binding key: animal.*.fast does not match animal.dog.lazy.fast (too many words)
Binding key: *.error.* matches log.error.database

It's great for matching a specific position in the key.

The Zero-or-More Wildcard: `#`

The hash (#) wildcard matches zero or more words in a routing key. It's much more powerful than *.

Binding key: log.# matches log.error, log.info.web, log.debug.cache.entry
Binding key: animal.# matches animal.rabbit, animal.cat.sleepy

Use # to capture all messages that start with a certain pattern.

Producer: Declaring Topic Exchange

First, our producer needs to declare the Topic exchange. The type is simply "topic".

Try running this snippet to set up the exchange:

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

public class TopicProducerSetup {
    private static final String EXCHANGE_NAME = "topic_logs";

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

            channel.exchangeDeclare(EXCHANGE_NAME, "topic");
            System.out.println("Topic exchange '" + EXCHANGE_NAME + "' declared.");
        }
    }
}

Producer: Sending Messages

Now, let's send some messages using different routing keys. The exchange will use these keys to decide which queues receive the messages.

Notice how the keys are dot-separated, allowing for detailed categories.

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

public class TopicMessageSender {
    private static final String EXCHANGE_NAME = "topic_logs";

    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(EXCHANGE_NAME, "topic");

            sendMessage(channel, "animal.rabbit.fast", "A fast rabbit runs.");
            sendMessage(channel, "animal.cat.sleepy", "A sleepy cat naps.");
            sendMessage(channel, "log.error.db", "Database connection failed!");
            sendMessage(channel, "log.info.web", "User logged in.");

            System.out.println("Sent various topic messages.");
        }
    }

    private static void sendMessage(Channel channel, String routingKey, String message) throws Exception {
        channel.basicPublish(EXCHANGE_NAME, routingKey, null, message.getBytes(StandardCharsets.UTF_8));
        System.out.println(" [x] Sent '" + routingKey + ":'" + message + "'");
    }
}

Consumer: Binding with `*`

Consumers bind their queues to the Topic exchange using binding keys that can contain wildcards. This consumer uses *.orange.*.

It will receive messages like animal.orange.fast but not fruit.apple.sweet or animal.orange.

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

public class TopicConsumerOrange {
    private static final String EXCHANGE_NAME = "topic_logs";

    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(EXCHANGE_NAME, "topic");
        String queueName = channel.queueDeclare().getQueue();

        String bindingKey = "*.orange.*"; // Matches e.g., 'animal.orange.fast'
        channel.queueBind(queueName, EXCHANGE_NAME, bindingKey);
        System.out.println(" [x] Waiting for messages matching: '" + bindingKey + "'");

        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 -> {});
    }
}

Consumer: Binding with `#`

This consumer uses the log.# binding key. This means it will receive all messages whose routing key starts with log., regardless of how many words follow.

This is extremely useful for systems like logging, where you might want a 'catch-all' listener for a category.

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

public class TopicConsumerLogs {
    private static final String EXCHANGE_NAME = "topic_logs";

    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(EXCHANGE_NAME, "topic");
        String queueName = channel.queueDeclare().getQueue();

        String bindingKey = "log.#"; // Matches e.g., 'log.error.db', 'log.info.web'
        channel.queueBind(queueName, EXCHANGE_NAME, bindingKey);
        System.out.println(" [x] Waiting for messages matching: '" + bindingKey + "'");

        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 -> {});
    }
}

Topic Exchange Use Cases

Topic exchanges shine in scenarios requiring flexible and hierarchical routing:

Logging Systems: Route logs based on severity, source, and component (e.g., app.error.auth, app.info.payment).
Real-time Data Streams: Filter sensor data (e.g., sensor.room1.temp, sensor.room2.humidity).
Content Distribution: Deliver news articles to subscribers interested in specific categories or regions.

They provide fine-grained control over message flow.

Topic Routing Challenge

Consider the following messages and binding keys. Which messages will be delivered to a queue bound with the key animal.*.#.fast?

Recap: Topic Exchange Power

You've mastered the Topic exchange! It's an incredibly powerful tool for building flexible and scalable messaging architectures.

Uses dot-separated routing keys.
* matches exactly one word.
# matches zero or more words.
Ideal for logging, real-time analytics, and content filtering.

By using wildcards, you can create sophisticated routing rules to ensure messages go exactly where they're needed.

Questions Fréquemment Posées

La leçon « Échange Topic pour un routage flexible » est-elle gratuite ?

Oui — le texte complet de « Échange Topic pour un routage flexible » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours RabbitMQ Messaging & Async Systems, passe à CoddyKit PRO. Le cours RabbitMQ Messaging & Async Systems comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Échange Topic pour un routage flexible » ?

Maîtrisez l’échange Topic pour créer des schémas de routage complexes à l’aide de caractères génériques. Concevez des topologies de routage des messages flexibles et évolutives. Tu pratiques RabbitMQ Messaging & Async Systems avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer RabbitMQ Messaging & Async Systems ?

Aucune expérience préalable n'est requise. RabbitMQ Messaging & Async Systems sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 3 sur 4.

Combien de temps prend la leçon « Échange Topic pour un routage flexible » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon RabbitMQ Messaging & Async Systems ?

Oui. Chaque leçon RabbitMQ Messaging & Async Systems inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

Échange Fanout pour la publication et l’abonnement
Échange Direct pour le routage
Échange Topic pour un routage flexible
Échange par défaut et liaisons implicites

← Retour à RabbitMQ Messaging & Async Systems