Ni siquiera entiendo los 5 modos de mensajes principales de RabbitMQ y me atrevo a decir que usaré colas de mensajes.

Resumen

Los artículos sobre el modo de mensaje central de RabbitMQ que he leído antes están todos basados ​​en la API de Java. Recientemente leí el documento oficial y descubrí que estos modos de mensaje central se pueden implementar a través de Spring AMQP. Así que resumí las habilidades prácticas de RabbitMQ, incluida la instalación de RabbitMQ en Windows y Linux, y la implementación de Spring AMQP con 5 modos de mensajes principales. Creo que será útil para los amigos que quieran aprender y revisar RabbitMQ.

Introducción

RabbitMQ es uno de los middleware de mensajería de código abierto más populares, que se utiliza ampliamente en todo el mundo. RabbitMQ es liviano y fácil de implementar, y puede admitir múltiples protocolos de mensajería. RabbitMQ se puede implementar en un sistema distribuido para cumplir con los requisitos de alta disponibilidad y gran escala.

Conceptos relacionados

Primero entendamos los conceptos relacionados en RabbitMQ Aquí tomamos el modo de enrutamiento en los 5 modos de mensaje como ejemplo.

 

 

Instalacion y configuracion

A continuación, presentamos la instalación y configuración de RabbitMQ y proporcionamos dos métodos de instalación, Windows y Linux.

Instalación bajo Windows

• Instale Erlang, dirección de descarga: http: //erlang.org/download/ot ...

 

• Instale RabbitMQ, enlace de descarga: https: //dl.bintray.com/rabbit ...

 

• Una vez completada la instalación, ingrese el directorio sbin en el directorio de instalación de RabbitMQ;

 

• Ingrese cmd en la barra de direcciones y presione Enter para iniciar la línea de comando, y luego ingrese el siguiente comando para iniciar la función de administración.

rabbitmq-plugins enable rabbitmq_management

 

Instalación bajo Linux

• Descargue la imagen de Docker de rabbitmq 3.7.15;

docker pull rabbitmq:3.7.15

• Utilice el comando Docker para iniciar el servicio;

docker run -p 5672:5672 -p 15672:15672 --name rabbitmq \
-d rabbitmq:3.7.15

• Ingrese al contenedor y abra la función de gestión;

docker exec -it rabbitmq /bin/bash
rabbitmq-plugins enable rabbitmq_management

 

• Encienda el firewall para facilitar el acceso a la red externa.

firewall-cmd --zone=public --add-port=15672/tcp --permanent
firewall-cmd --zone=public --add-port=5672/tcp --permanent
firewall-cmd --reload

Acceso y configuración

• Visite la dirección de la página de administración de RabbitMQ para verificar si la instalación es exitosa (use la IP del servidor para acceder en Linux): http: // localhost: 15672 /

 

• Ingrese la contraseña de la cuenta e inicie sesión, aquí use la contraseña de cuenta predeterminada para iniciar sesión: invitado invitado
• Crea una cuenta y establece su rol como administrador: mall mall

 

• Cree un nuevo host virtual como: / mall

 

• Haga clic en el usuario del centro comercial para ingresar a la página de configuración del usuario;

 

• Configure los permisos del host virtual para los usuarios del centro comercial;

 

• En este punto, la configuración de RabbitMQ está completa.

5 modos de mensaje

Estos 5 modos de mensaje son la base para crear una aplicación de mensajes basada en RabbitMQ, y debemos comprenderlos firmemente. Los amigos que han estudiado RabbitMQ deberían haber conocido la implementación en Java de estos modos de mensaje, aquí usamos Spring AMQP para implementarlos.

Modo simple

El modo simple es el modo de mensaje más simple, contiene un productor, un consumidor y una cola. El productor envía un mensaje a la cola y el consumidor recibe el mensaje de la cola y lo consume.

Diagrama de modo

 

Implementación de Spring AMQP

• Primero, debe agregar las dependencias Spring AMQP en pom.xml;

<!--Spring AMQP依赖-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-amqp</artifactId>
</dependency>

• Luego modifique application.yml y agregue la configuración relevante de RabbitMQ;

spring:
  rabbitmq:
    host: localhost
    port: 5672
    virtual-host: /mall
    username: mall
    password: mall
    publisher-confirms: true #消息发送到交换器确认
    publisher-returns: true #消息发送到队列确认

• Agregue la configuración de Java relacionada con el modo simple, cree una cola llamada simple.hello, un productor y un consumidor;

/**
 * Created by macro on 2020/5/19.
 */
@Configuration
public class SimpleRabbitConfig {

    @Bean
    public Queue hello() {
        return new Queue("simple.hello");
    }

    @Bean
    public SimpleSender simpleSender(){
        return new SimpleSender();
    }

    @Bean
    public SimpleReceiver simpleReceiver(){
        return new SimpleReceiver();
    }

}

• El productor envía un mensaje a la cola simple.hello a través del método de envío;

/**
 * Created by macro on 2020/5/19.
 */
public class SimpleSender {

    private static final Logger LOGGER = LoggerFactory.getLogger(SimpleSender.class);

    @Autowired
    private RabbitTemplate template;

    private static final String queueName="simple.hello";

    public void send() {
        String message = "Hello World!";
        this.template.convertAndSend(queueName, message);
        LOGGER.info(" [x] Sent '{}'", message);
    }

}

• Los consumidores reciben mensajes de la cola simple.hello;

/**
 * Created by macro on 2020/5/19.
 */
@RabbitListener(queues = "simple.hello")
public class SimpleReceiver {

    private static final Logger LOGGER = LoggerFactory.getLogger(SimpleReceiver.class);

    @RabbitHandler
    public void receive(String in) {
        LOGGER.info(" [x] Received '{}'", in);
    }

}

• Agregue una interfaz de prueba al controlador y llame a esta interfaz para comenzar a enviar mensajes;

/**
 * Created by macro on 2020/5/19.
 */
@Api(tags = "RabbitController", description = "RabbitMQ功能测试")
@Controller
@RequestMapping("/rabbit")
public class RabbitController {

    @Autowired
    private SimpleSender simpleSender;

    @ApiOperation("简单模式")
    @RequestMapping(value = "/simple", method = RequestMethod.GET)
    @ResponseBody
    public CommonResult simpleTest() {
        for(int i=0;i<10;i++){
            simpleSender.send();
            ThreadUtil.sleep(1000);
        }
        return CommonResult.success(null);
    }
}

• Los resultados después de la ejecución son los siguientes: puede encontrar que el productor envía un mensaje a la cola y el consumidor recibe el mensaje de la cola y lo consume.

 

 

Modo operativo

El modo de trabajo es un modo en el que se envían mensajes a varios consumidores en competencia. Incluye un productor, dos consumidores y una cola. Dos consumidores están vinculados a una cola al mismo tiempo.Cuando los consumidores reciben mensajes para procesar tareas que requieren mucho tiempo, los consumidores inactivos obtienen y consumen mensajes de la cola.

Diagrama de modo

 

Implementación de Spring AMQP

• Agregue la configuración de Java relacionada con el modo de trabajo, cree una cola llamada work.hello, un productor y dos consumidores;

/**
 * Created by macro on 2020/5/19.
 */
@Configuration
public class WorkRabbitConfig {

    @Bean
    public Queue workQueue() {
        return new Queue("work.hello");
    }

    @Bean
    public WorkReceiver workReceiver1() {
        return new WorkReceiver(1);
    }

    @Bean
    public WorkReceiver workReceiver2() {
        return new WorkReceiver(2);
    }

    @Bean
    public WorkSender workSender() {
        return new WorkSender();
    }

}

• El productor envía un mensaje a la cola work.hello a través del método de envío, el mensaje contiene una cierta cantidad de números;

/**
 * Created by macro on 2020/5/19.
 */
public class WorkSender {

    private static final Logger LOGGER = LoggerFactory.getLogger(WorkSender.class);

    @Autowired
    private RabbitTemplate template;

    private static final String queueName = "work.hello";

    public void send(int index) {
        StringBuilder builder = new StringBuilder("Hello");
        int limitIndex = index % 3+1;
        for (int i = 0; i < limitIndex; i++) {
            builder.append('.');
        }
        builder.append(index+1);
        String message = builder.toString();
        template.convertAndSend(queueName, message);
        LOGGER.info(" [x] Sent '{}'", message);
    }

}

• Dos consumidores reciben mensajes de la cola work.hello, denominados instancia 1 e instancia 2, respectivamente. Cuantos más números haya en el mensaje, más tardará;

/**
 * Created by macro on 2020/5/19.
 */
@RabbitListener(queues = "work.hello")
public class WorkReceiver {

    private static final Logger LOGGER = LoggerFactory.getLogger(WorkReceiver.class);

    private final int instance;

    public WorkReceiver(int i) {
        this.instance = i;
    }

    @RabbitHandler
    public void receive(String in) {
        StopWatch watch = new StopWatch();
        watch.start();
        LOGGER.info("instance {} [x] Received '{}'", this.instance, in);
        doWork(in);
        watch.stop();
        LOGGER.info("instance {} [x] Done in {}s", this.instance, watch.getTotalTimeSeconds());
    }

    private void doWork(String in) {
        for (char ch : in.toCharArray()) {
            if (ch == '.') {
                ThreadUtil.sleep(1000);
            }
        }
    }

}

• Agregue una interfaz de prueba al controlador y llame a esta interfaz para comenzar a enviar mensajes;

/**
 * Created by macro on 2020/5/19.
 */
@Api(tags = "RabbitController", description = "RabbitMQ功能测试")
@Controller
@RequestMapping("/rabbit")
public class RabbitController {
    
    @Autowired
    private WorkSender workSender;

    @ApiOperation("工作模式")
    @RequestMapping(value = "/work", method = RequestMethod.GET)
    @ResponseBody
    public CommonResult workTest() {
        for(int i=0;i<10;i++){
            workSender.send(i);
            ThreadUtil.sleep(1000);
        }
        return CommonResult.success(null);
    }
}

• Los resultados después de la operación son los siguientes: Se puede encontrar que el productor envía mensajes que contienen diferentes números de números a la cola. Los consumidores de la instancia 1 y la instancia 2 compiten entre sí y consumen algunos de los mensajes respectivamente.

 

 

 

Modelo de publicación / suscripción

El modelo de publicación / suscripción se refiere al modelo que envía mensajes a múltiples consumidores al mismo tiempo (similar a la forma de transmisión), que incluye un productor, dos consumidores, dos colas y un conmutador. Dos consumidores están vinculados a diferentes colas al mismo tiempo, y las dos colas están vinculadas al intercambio. El productor envía un mensaje al intercambio y todos los consumidores reciben y consumen el mensaje.

Diagrama de modo

 

Implementación de Spring AMQP

• Agregue la configuración de Java relacionada con el modo de publicación / suscripción, cree un intercambio llamado exchange.fanout, un productor, dos consumidores y dos colas anónimas, y vincule ambas colas anónimas al intercambio;

/**
 * Created by macro on 2020/5/19.
 */
@Configuration
public class FanoutRabbitConfig {

    @Bean
    public FanoutExchange fanout() {
        return new FanoutExchange("exchange.fanout");
    }

    @Bean
    public Queue fanoutQueue1() {
        return new AnonymousQueue();
    }

    @Bean
    public Queue fanoutQueue2() {
        return new AnonymousQueue();
    }

    @Bean
    public Binding fanoutBinding1(FanoutExchange fanout, Queue fanoutQueue1) {
        return BindingBuilder.bind(fanoutQueue1).to(fanout);
    }

    @Bean
    public Binding fanoutBinding2(FanoutExchange fanout, Queue fanoutQueue2) {
        return BindingBuilder.bind(fanoutQueue2).to(fanout);
    }

    @Bean
    public FanoutReceiver fanoutReceiver() {
        return new FanoutReceiver();
    }

    @Bean
    public FanoutSender fanoutSender() {
        return new FanoutSender();
    }

}

• El productor envía un mensaje al exchange exchange.fanout a través del método de envío, y el mensaje contiene un cierto número de números;

/**
 * Created by macro on 2020/5/19.
 */
public class FanoutSender {
    private static final Logger LOGGER = LoggerFactory.getLogger(FanoutSender.class);
    @Autowired
    private RabbitTemplate template;

    private static final String exchangeName = "exchange.fanout";

    public void send(int index) {
        StringBuilder builder = new StringBuilder("Hello");
        int limitIndex = index % 3 + 1;
        for (int i = 0; i < limitIndex; i++) {
            builder.append('.');
        }
        builder.append(index + 1);
        String message = builder.toString();
        template.convertAndSend(exchangeName, "", message);
        LOGGER.info(" [x] Sent '{}'", message);
    }

}

• Los consumidores reciben mensajes de la cola anónima enlazada. Cuantos más números haya en el mensaje, más tiempo tardará. Dado que el consumidor puede obtener y consumir mensajes de dos colas, pueden considerarse como dos consumidores con nombres diferentes. Son la instancia 1 y la instancia 2;

/**
 * Created by macro on 2020/5/19.
 */
public class FanoutReceiver {

    private static final Logger LOGGER = LoggerFactory.getLogger(FanoutReceiver.class);

    @RabbitListener(queues = "#{fanoutQueue1.name}")
    public void receive1(String in) {
        receive(in, 1);
    }

    @RabbitListener(queues = "#{fanoutQueue2.name}")
    public void receive2(String in) {
        receive(in, 2);
    }

    private void receive(String in, int receiver) {
        StopWatch watch = new StopWatch();
        watch.start();
        LOGGER.info("instance {} [x] Received '{}'", receiver, in);
        doWork(in);
        watch.stop();
        LOGGER.info("instance {} [x] Done in {}s", receiver, watch.getTotalTimeSeconds());
    }

    private void doWork(String in) {
        for (char ch : in.toCharArray()) {
            if (ch == '.') {
                ThreadUtil.sleep(1000);
            }
        }
    }

}

• Agregue una interfaz de prueba al controlador y llame a esta interfaz para comenzar a enviar mensajes;

/**
 * Created by macro on 2020/5/19.
 */
@Api(tags = "RabbitController", description = "RabbitMQ功能测试")
@Controller
@RequestMapping("/rabbit")
public class RabbitController {
    
    @Autowired
    private FanoutSender fanoutSender;

    @ApiOperation("发布/订阅模式")
    @RequestMapping(value = "/fanout", method = RequestMethod.GET)
    @ResponseBody
    public CommonResult fanoutTest() {
        for(int i=0;i<10;i++){
            fanoutSender.send(i);
            ThreadUtil.sleep(1000);
        }
        return CommonResult.success(null);
    }
}

• Los resultados de la operación son los siguientes: se puede encontrar que el productor envía mensajes que contienen diferentes números de números a la cola, y la instancia 1 y la instancia 2 obtienen y consumen simultáneamente los mensajes.

 

 

 

Modo de enrutamiento

El modo de enrutamiento es un modo que puede enviar mensajes de manera selectiva a varios consumidores según la clave de enrutamiento. Incluye un productor, dos consumidores, dos colas y un conmutador. Dos consumidores están vinculados a diferentes colas al mismo tiempo, las dos colas están vinculadas al conmutador a través de la clave de enrutamiento, el productor envía mensajes al conmutador, el conmutador reenvía a diferentes colas a través de la clave de enrutamiento y el consumidor vinculado a la cola recibe y consume Noticias.

Diagrama de modo

 

Implementación de Spring AMQP

• Agregue la configuración de Java relacionada con el modo de enrutamiento, cree un conmutador llamado exchange.direct, un productor, dos consumidores y dos colas anónimas, las colas están vinculadas al conmutador a través de la clave de enrutamiento y las claves de enrutamiento de la cola 1 son naranja y negro , Las claves de enrutamiento de la cola 2 son verde y negro;

/**
 * Created by macro on 2020/5/19.
 */
@Configuration
public class DirectRabbitConfig {

    @Bean
    public DirectExchange direct() {
        return new DirectExchange("exchange.direct");
    }

    @Bean
    public Queue directQueue1() {
        return new AnonymousQueue();
    }

    @Bean
    public Queue directQueue2() {
        return new AnonymousQueue();
    }

    @Bean
    public Binding directBinding1a(DirectExchange direct, Queue directQueue1) {
        return BindingBuilder.bind(directQueue1).to(direct).with("orange");
    }

    @Bean
    public Binding directBinding1b(DirectExchange direct, Queue directQueue1) {
        return BindingBuilder.bind(directQueue1).to(direct).with("black");
    }

    @Bean
    public Binding directBinding2a(DirectExchange direct, Queue directQueue2) {
        return BindingBuilder.bind(directQueue2).to(direct).with("green");
    }

    @Bean
    public Binding directBinding2b(DirectExchange direct, Queue directQueue2) {
        return BindingBuilder.bind(directQueue2).to(direct).with("black");
    }

    @Bean
    public DirectReceiver receiver() {
        return new DirectReceiver();
    }


    @Bean
    public DirectSender directSender() {
        return new DirectSender();
    }

}

• El productor envía un mensaje al exchange exchange.direct a través del método de envío, utilizando diferentes claves de enrutamiento al enviar, y será reenviado a diferentes colas de acuerdo con la clave de enrutamiento;

/**
 * Created by macro on 2020/5/19.
 */
public class DirectSender {

    @Autowired
    private RabbitTemplate template;

    private static final String exchangeName = "exchange.direct";

    private final String[] keys = {"orange", "black", "green"};

    private static final Logger LOGGER = LoggerFactory.getLogger(DirectSender.class);

    public void send(int index) {
        StringBuilder builder = new StringBuilder("Hello to ");
        int limitIndex = index % 3;
        String key = keys[limitIndex];
        builder.append(key).append(' ');
        builder.append(index+1);
        String message = builder.toString();
        template.convertAndSend(exchangeName, key, message);
        LOGGER.info(" [x] Sent '{}'", message);
    }

}

• Los consumidores obtienen mensajes de la cola anónima vinculada a ellos. Dado que el consumidor puede obtener y consumir mensajes de dos colas, puede considerarse como dos consumidores, denominados instancia 1 e instancia 2 respectivamente;

/**
 * Created by macro on 2020/5/19.
 */
public class DirectReceiver {
    private static final Logger LOGGER = LoggerFactory.getLogger(DirectReceiver.class);

    @RabbitListener(queues = "#{directQueue1.name}")
    public void receive1(String in){
        receive(in, 1);
    }

    @RabbitListener(queues = "#{directQueue2.name}")
    public void receive2(String in){
        receive(in, 2);
    }

    private void receive(String in, int receiver){
        StopWatch watch = new StopWatch();
        watch.start();
        LOGGER.info("instance {} [x] Received '{}'", receiver, in);
        doWork(in);
        watch.stop();
        LOGGER.info("instance {} [x] Done in {}s", receiver, watch.getTotalTimeSeconds());
    }

    private void doWork(String in){
        for (char ch : in.toCharArray()) {
            if (ch == '.') {
                ThreadUtil.sleep(1000);
            }
        }
    }

}

• Agregue una interfaz de prueba al controlador y llame a esta interfaz para comenzar a enviar mensajes;

/**
 * Created by macro on 2020/5/19.
 */
@Api(tags = "RabbitController", description = "RabbitMQ功能测试")
@Controller
@RequestMapping("/rabbit")
public class RabbitController {

    @Autowired
    private DirectSender directSender;

    @ApiOperation("路由模式")
    @RequestMapping(value = "/direct", method = RequestMethod.GET)
    @ResponseBody
    public CommonResult directTest() {
        for(int i=0;i<10;i++){
            directSender.send(i);
            ThreadUtil.sleep(1000);
        }
        return CommonResult.success(null);
    }
}

• Los resultados después de la ejecución son los siguientes. Se puede encontrar que el productor envía mensajes que contienen diferentes claves de enrutamiento a la cola. La instancia 1 recibe mensajes naranjas y negros, y la instancia 2 recibe mensajes verdes y negros.

 

 

 

Patrón comodín

El patrón comodín es un patrón que puede enviar mensajes de forma selectiva a varios consumidores según las reglas de coincidencia de claves de enrutamiento. Incluye un productor, dos consumidores, dos colas y un conmutador. Dos consumidores están vinculados a diferentes colas al mismo tiempo, las dos colas están vinculadas al conmutador a través de reglas de coincidencia de claves de enrutamiento, el productor envía mensajes al conmutador y el conmutador reenvía a diferentes colas a través de las reglas de coincidencia de claves de enrutamiento y el consumo vinculado a la cola. La persona recibe y consume el mensaje.

Símbolo de coincidencia especial

• *: Solo se puede hacer coincidir una palabra;
• #: Puede coincidir con cero o más palabras.

Diagrama de modo

 

Implementación de Spring AMQP

• Agregue la configuración de Java relacionada con el patrón comodín, cree un intercambio llamado exchange.topic, un productor, dos consumidores y dos colas anónimas, combine * .orange. * Y *. *. Rabbit con la cola 1, combine lazy . # Enviar a la cola 2;

/**
 * Created by macro on 2020/5/19.
 */
@Configuration
public class TopicRabbitConfig {

    @Bean
    public TopicExchange topic() {
        return new TopicExchange("exchange.topic");
    }

    @Bean
    public Queue topicQueue1() {
        return new AnonymousQueue();
    }

    @Bean
    public Queue topicQueue2() {
        return new AnonymousQueue();
    }

    @Bean
    public Binding topicBinding1a(TopicExchange topic, Queue topicQueue1) {
        return BindingBuilder.bind(topicQueue1).to(topic).with("*.orange.*");
    }

    @Bean
    public Binding topicBinding1b(TopicExchange topic, Queue topicQueue1) {
        return BindingBuilder.bind(topicQueue1).to(topic).with("*.*.rabbit");
    }

    @Bean
    public Binding topicBinding2a(TopicExchange topic, Queue topicQueue2) {
        return BindingBuilder.bind(topicQueue2).to(topic).with("lazy.#");
    }

    @Bean
    public TopicReceiver topicReceiver() {
        return new TopicReceiver();
    }

    @Bean
    public TopicSender topicSender() {
        return new TopicSender();
    }

}

• El productor envía un mensaje al exchange exchange.topic a través del método de envío, y el mensaje contiene diferentes claves de enrutamiento;

/**
 * Created by macro on 2020/5/19.
 */
public class TopicSender {

    @Autowired
    private RabbitTemplate template;

    private static final String exchangeName = "exchange.topic";

    private static final Logger LOGGER = LoggerFactory.getLogger(TopicSender.class);


    private final String[] keys = {"quick.orange.rabbit", "lazy.orange.elephant", "quick.orange.fox",
            "lazy.brown.fox", "lazy.pink.rabbit", "quick.brown.fox"};

    public void send(int index) {
        StringBuilder builder = new StringBuilder("Hello to ");
        int limitIndex = index%keys.length;
        String key = keys[limitIndex];
        builder.append(key).append(' ');
        builder.append(index+1);
        String message = builder.toString();
        template.convertAndSend(exchangeName, key, message);
        LOGGER.info(" [x] Sent '{}'",message);
        System.out.println(" [x] Sent '" + message + "'");
    }

}

• Los consumidores obtienen mensajes de la cola anónima vinculada a ellos. Dado que el consumidor puede obtener y consumir mensajes de dos colas, puede considerarse como dos consumidores, denominados instancia 1 e instancia 2 respectivamente;

/**
 * Created by macro on 2020/5/19.
 */
public class TopicReceiver {

    private static final Logger LOGGER = LoggerFactory.getLogger(TopicReceiver.class);

    @RabbitListener(queues = "#{topicQueue1.name}")
    public void receive1(String in){
        receive(in, 1);
    }

    @RabbitListener(queues = "#{topicQueue2.name}")
    public void receive2(String in){
        receive(in, 2);
    }

    public void receive(String in, int receiver){
        StopWatch watch = new StopWatch();
        watch.start();
        LOGGER.info("instance {} [x] Received '{}'", receiver, in);
        doWork(in);
        watch.stop();
        LOGGER.info("instance {} [x] Done in {}s", receiver, watch.getTotalTimeSeconds());
    }

    private void doWork(String in){
        for (char ch : in.toCharArray()) {
            if (ch == '.') {
                ThreadUtil.sleep(1000);
            }
        }
    }

}

• Agregue una interfaz de prueba al controlador y llame a esta interfaz para comenzar a enviar mensajes;

/**
 * Created by macro on 2020/5/19.
 */
@Api(tags = "RabbitController", description = "RabbitMQ功能测试")
@Controller
@RequestMapping("/rabbit")
public class RabbitController {

    @Autowired
    private TopicSender topicSender;

    @ApiOperation("通配符模式")
    @RequestMapping(value = "/topic", method = RequestMethod.GET)
    @ResponseBody
    public CommonResult topicTest() {
        for(int i=0;i<10;i++){
            topicSender.send(i);
            ThreadUtil.sleep(1000);
        }
        return CommonResult.success(null);
    }
}

• Los resultados de la operación son los siguientes: se puede encontrar que el productor envía mensajes que contienen diferentes claves de enrutamiento a la cola, y la instancia 1 y la instancia 2 respectivamente obtienen mensajes coincidentes.

 

 

 

Referencia

Tutoriales de RabbitMQ: https: //www.rabbitmq.com/gets ...

Dirección de origen del proyecto

https: //github.com/macrozheng ...