El modo de enrutamiento en RabbitMQ dirige mensajes a colas específicas mediante claves de enrutamiento en un intercambio directo. A continuación, se detalla la implementación con Spring Boot, incluyendo la configuración, el consumidor y el productor.

Configuración del Intercambio y Colas

Primero, se define una clase de configuración para establecer el intercambio directo, las colas y los anlaces con claves de enrutamiento personalizadas.

import org.springframework.amqp.core.Binding;
import org.springframework.amqp.core.BindingBuilder;
import org.springframework.amqp.core.Exchange;
import org.springframework.amqp.core.ExchangeBuilder;
import org.springframework.amqp.core.Queue;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * Configuración de RabbitMQ para el modo de enrutamiento
 */
@Configuration
public class RabbitConfig {
    
    /**
     * Define un intercambio directo para el enrutamiento
     * @return instancia del intercambio
     */
    @Bean
    public Exchange routingExchange(){
        return ExchangeBuilder.directExchange("direct_exchange").build();
    }

    /**
     * Crea una cola para recibir mensajes enrutados
     * @return objeto de cola
     */
    @Bean
    public Queue messageQueue(){
        return new Queue("message_queue");
    }

    /**
     * Enlaza la cola al intercambio con una clave de enrutamiento primaria
     * @param exchange intercambio configurado
     * @param queue cola definida
     * @return relación de enlace
     */
    @Bean
    public Binding primaryBinding(@Qualifier("routingExchange") Exchange exchange,
                                  @Qualifier("messageQueue") Queue queue){
        return BindingBuilder
                .bind(queue)
                .to(exchange)
                .with("custom_routing_key1")
                .noargs();
    }
    
    /**
     * Enlaza la misma cola con una segunda clave de enrutamiento
     * @param exchange intercambio configurado
     * @param queue cola definida
     * @return relación de enlace
     */
    @Bean
    public Binding secondaryBinding(@Qualifier("routingExchange") Exchange exchange,
                                    @Qualifier("messageQueue") Queue queue){
        return BindingBuilder
                .bind(queue)
                .to(exchange)
                .with("custom_routing_key2")
                .noargs();
    }
}

Definición del Consumidor

El consumidor escucha la cola configurada para procesar los mensajes entrantes.

import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

/**
 * Listener para consumir mensajes de la cola enrutada
 */
@Component
public class MessageListener {

    /**
     * Procesa los mensajes recibidos de la cola
     * @param payload contenido del mensaje
     */
    @RabbitListener(queues = "message_queue")
    public void processMessage(String payload) {
        System.out.println("Mensaje recibido en la cola: " + payload);
    }
}

Definición del Productor

El productor envía mensajes al intercambio con diferentes claves de enrutamiento para demostrar el enrutamiento.

import org.junit.jupiter.api.Test;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

@SpringBootTest
class RabbitMQTest {

    /**
     * Inyección de RabbitTemplate para operaciones de mensajería
     */
    @Autowired
    private RabbitTemplate rabbitTemplate;

    /**
     * Envía mensajes de prueba al intercambio con claves de enrutamiento variadas
     */
    @Test
    void sendTestMessage()  {
        rabbitTemplate.convertAndSend("direct_exchange", "custom_routing_key1", "Contenido del mensaje 1");
        rabbitTemplate.convertAndSend("direct_exchange", "custom_routing_key2", "Contenido del mensaje 2");
    }
}

Al ejecutar el productor, los mensajes con claves de enrutamiento diferentes se enruten a la misma cola, donde el consumidor los procesa secuencialmente.