Cree el servicio de mensajería RabbitMQ e integre SpringBoot para enviar y recibir mensajes

Página de inicio del autor : Diseñador Xiao Zheng
Sobre el autor : 3 años de experiencia en desarrollo de pila completa de JAVA, centrándose en la tecnología JAVA, personalización del sistema, guía remota, comprometido con la transformación digital empresarial, experto en blogs CSDN, instructor certificado del curso de nube Blue Bridge.

I. Introducción

1.1 ¿Qué es una cola de mensajes?

La cola de mensajes es un mecanismo de comunicación para transferir datos entre aplicaciones . Se basa en 发布-订阅patrones y desacopla a los remitentes (editores) y receptores (suscriptores) de mensajes para que puedan enviar y recibir mensajes de forma independiente.

En una cola de mensajes, el remitente del mensaje envía el mensaje a la cola y el receptor del mensaje recibe el mensaje de la cola para procesarlo . La cola de mensajes proporciona un método de comunicación asincrónica, es decir, el remitente no necesita esperar la respuesta del receptor después de enviar el mensaje, pero puede continuar realizando otras operaciones inmediatamente. Al mismo tiempo, la cola de mensajes también puede implementar un almacenamiento persistente de mensajes para garantizar la confiabilidad de los mensajes durante el proceso de envío y recepción.

Los escenarios de aplicación de la cola de mensajes son muy amplios, como por ejemplo:

• En un sistema distribuido, las colas de mensajes se pueden utilizar para lograr el desacoplamiento entre diferentes módulos;
• En sistemas de alta concurrencia, las colas de mensajes se pueden utilizar para aliviar la presión del sistema;
• En el procesamiento de datos en tiempo real, los datos pueden almacenarse en la cola de mensajes y luego procesarse mediante el módulo de procesamiento de datos.

1.2 ¿Qué es RabbitMQ?

RabbitMQ es un middleware de cola de mensajes de código abierto que implementa el protocolo avanzado de cola de mensajes y proporciona un mecanismo de entrega de mensajes confiable.

RabbitMQ está escrito en lenguaje Erlang y es altamente confiable, escalable, flexible y conectable, y se usa ampliamente en sistemas distribuidos, arquitectura de microservicios, procesamiento de tareas asincrónicas y otros escenarios.

RabbitMQ funciona según el modelo de productor y consumidor. Los productores envían mensajes a los intercambios de RabbitMQ, que luego los enrutan a una o más colas, y los consumidores obtienen mensajes de las colas y los procesan.

RabbitMQ admite una variedad de modos de entrega de mensajes y también proporciona funciones como persistencia de mensajes, prioridad de mensajes y mecanismo de confirmación de mensajes para garantizar la confiabilidad y la transmisión confiable del mensaje.

RabbitMQ es un middleware de cola de mensajes maduro y confiable que proporciona un potente mecanismo de mensajería y funciones ricas, y se usa ampliamente en sistemas distribuidos y procesamiento de mensajes asincrónicos.

1.3 ¿Por qué necesitas usar RabbitMQ?

1. Desacoplamiento : RabbitMQ realiza el desacoplamiento de productores y consumidores a través de colas de mensajes. Los productores envían mensajes a la cola y los consumidores obtienen mensajes de la cola y los procesan. Este desacoplamiento permite que diferentes módulos del sistema se desarrollen e implementen de forma independiente, mejorando la flexibilidad y la mantenibilidad del sistema.

2. Comunicación asincrónica : RabbitMQ proporciona un mecanismo de comunicación asincrónica. Una vez que el productor envía un mensaje a la cola, no necesita esperar a que el consumidor lo procese inmediatamente, pero puede continuar realizando otras operaciones. Esta comunicación asincrónica puede mejorar el rendimiento de concurrencia y la velocidad de respuesta del sistema.

3. Almacenamiento en búfer y afeitado : RabbitMQ se puede utilizar como búfer para almacenar mensajes de los productores. Esto puede evitar el acoplamiento directo entre productores y consumidores, y también puede hacer frente a solicitudes instantáneas de alta concurrencia y reducir la presión del sistema.

4. Fiabilidad y recuperabilidad : RabbitMQ proporciona la función de mensajes persistentes, incluso en caso de una cola de mensajes o una falla del consumidor, los mensajes se pueden retener y recuperar. Esta confiabilidad garantiza que los mensajes no se pierdan y se entreguen de manera confiable.

5. Escalabilidad : RabbitMQ es un middleware de cola de mensajes extensible que puede agregar más colas de mensajes y nodos consumidores cuando sea necesario para hacer frente a las crecientes necesidades comerciales.

6. Soporte multilingüe : RabbitMQ proporciona clientes en múltiples lenguajes de programación, como Java, Python, C#, etc., lo que permite a los desarrolladores elegir su propio lenguaje de programación para interactuar con RabbitMQ.

1.4 Ventajas de RabbitMQ frente a Kafka

RabbitMQ proporciona una API y una interfaz de administración simples y fáciles de usar, lo que permite a los desarrolladores comenzar a configurar y administrar rápidamente, mientras que la configuración y administración de Kafka son relativamente complejas.

RabbitMQ admite múltiples modos de entrega de mensajes y mecanismos de enrutamiento de mensajes, y puede realizar un procesamiento de mensajes flexible según las necesidades, mientras que Kafka es más adecuado para el procesamiento de transmisión de alto rendimiento a gran escala, generalmente utilizando el modelo de publicación-suscripción.

RabbitMQ tiene características como mensajes persistentes y mecanismos de confirmación de mensajes, que pueden garantizar una transmisión confiable de mensajes, mientras que Kafka proporciona una entrega de mensajes altamente confiable a través de mecanismos de copia múltiple y registros de mensajes.

RabbitMQ puede realizar el control de flujo y el procesamiento de reducción de picos estableciendo la estrategia de limitación de flujo de la cola y la tasa de consumo de los consumidores, lo que puede proteger a los consumidores de un envío excesivo de mensajes, mientras que Kafka controlará la tasa de consumo de los consumidores hacia los propios consumidores, lo que puede requerir procesamiento adicional en escenarios de alta concurrencia.

RabbitMQ proporciona clientes en múltiples lenguajes de programación. Los desarrolladores pueden elegir los clientes adecuados para interactuar de acuerdo con sus propias necesidades de programación. Los clientes de Kafka se centran principalmente en el lenguaje Java y el soporte para otros lenguajes es relativamente pequeño.

RabbitMQ tiene una enorme comunidad de código abierto y un ecosistema rico, y proporciona una gran cantidad de complementos y herramientas de integración para que los desarrolladores se expandan e integren. El ecosistema de Kafka es relativamente pequeño, pero tiene una amplia gama de aplicaciones y soporte en el campo de grandes datos.

---

2. Configure el entorno RabbitMQ

2.1 Instalar Erlang

Erlang es el entorno básico del servicio de mensajería RabbitMQ y, al igual que el JDK de Java, debe estar instalado.

2.1.1 Descargar

Dirección de descarga del sitio web oficial de Erlang: dirección de descarga .

Como queremos instalar el servicio RabbitMQ en el servidor, los estudiantes pueden descargar el paquete de instalación de Erlang en el servidor o cargarlo manualmente en el servidor después de descargarlo.

2.1.2 Instalación

Una vez completada la descarga, haga doble clic en el paquete de instalación y siga las instrucciones para instalarlo normalmente. La captura de pantalla se muestra a continuación.

2.1.3 Configuración de variables de entorno

El nombre de la variable es el siguiente y el valor de la variable es la ruta de instalación, como se muestra en la siguiente figura.

ERLANG_HOME

El comando de verificación es el siguiente:

erl -v

2.2 Instalar RabbitMQ

2.2.1 Descargar

RabbitMQ debe descargarse de Github, dirección de descarga .

La versión RabbitMQ debe corresponder a Erlang , este artículo instala 3.9.5la versión.

2.2.2 Instalación

El proceso de instalación se muestra en la siguiente figura.

2.2.3 Inicialización

Una vez completada la instalación, use la ventana cmd para ingresar al directorio sbin de RabbitMQ, como se muestra en la siguiente figura.

Luego ingrese el siguiente comando para completar la instalación inicial.

rabbitmq-plugins enable rabbitmq_management

2.2.4 Verificación

Abre tu navegador e ingresa:

http://localhost:15672

Las contraseñas de las cuentas son:

guest

2.3 Configurar el acceso a la red externa

2.3.1 Agregar nuevo usuario

El puerto predeterminado de RabbitMQ es 15672, el nombre de usuario y la contraseña son invitados y no se permite el acceso externo.

Por lo tanto, necesitamos agregar nuevos usuarios para lograr acceso a la red externa. El proceso de operación se muestra en la siguiente figura.

Después de hacer clic en Agregar, ingrese la cuenta y la contraseña del nuevo usuario, como se muestra en la siguiente figura.

2.3.2 Configuración del servidor virtual

El host virtual debe permitir el acceso al usuario agregado, como se muestra en la siguiente figura.

Después de ingresar a la subinterfaz, seleccione el usuario y envíelo, como se muestra en la siguiente figura.

Luego, completamos la configuración del acceso a la red externa.

---

3. Integre el servicio de mensajería RabbitMQ

3.1 Crear un nuevo proyecto SpringBoot

Abra la herramienta IDEA y cree un nuevo proyecto, como se muestra en la siguiente figura.

Una vez creado el nuevo proyecto, queda como se muestra en la siguiente figura.

3.2 Introduciendo dependencias

Primero, pom.xmlintroduzca las dependencias en, el código es el siguiente.

<dependency>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-starter-amqp</artifactId>
</dependency>

3.3 Archivo de configuración

application.yml está configurado de la siguiente manera.

spring:
  rabbitmq:
    host: 118.126.82.167
    port: 5672
    username: zwz
    password: 123456
    listener:
      simple:
        retry:
          enabled: true
          max-attempts: 5
          initial-interval: 2s

3.4 Crear clase de herramienta de envío de mensajes

Por favor, los estudiantes creen SimpleProduceruna clase de herramienta, el código es el siguiente.

package cn.zwz.send;

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

public class SimpleProducer {
    
    

    public static void main(String[] args) {
    
    
        //1. 创建连接工程
        ConnectionFactory connectionFactory = new ConnectionFactory();
        //1.1 设置连接IP
        connectionFactory.setHost("118.126.82.167");
        //1.2 设置连接端口
        connectionFactory.setPort(5672);
        //1.3 设置用户名
        connectionFactory.setUsername("zwz");
        //1.4 设置密码
        connectionFactory.setPassword("123456");
        //1.5 设置虚拟访问节点，就是消息发送的目标路径
        connectionFactory.setVirtualHost("/");

        Connection connection = null;
        Channel channel = null;
        try {
    
    
            //2. 创建连接Connection
            connection = connectionFactory.newConnection("ZWZ-Connection");
            //3. 通过连接获取通道Channel
            channel = connection.createChannel();
            //4. 通过通道创建交换机，声明队列，绑定关系，路由key，发送消息，接收消息
            String queueName = "ZWZ-TOPIC";
            /**
             * channel.queueDeclare有5个参数
             * params1: 队列的名称
             * params2: 是否要持久化， false：非持久化 true：持久化
             * params3: 排他性，是否独占队列
             * params4: 是否自动删除，如果为true，队列会随着最后一个消费消费完后将队列自动删除，false：消息全部消费完后，队列保留
             * params5: 携带的附加参数
             */
            channel.queueDeclare(queueName, true, false, false, null);
            //5. 消息内容
            String message = "HELLO World!";
            //6. 将消息发送到队列
            channel.basicPublish("", queueName, null, message.getBytes());
            System.out.println("消息发送成功");
        } catch (Exception e) {
    
    
            e.printStackTrace();
        } finally {
    
    
            //7. 关闭通道
            if (channel != null && channel.isOpen()) {
    
    
                try {
    
    
                    channel.close();
                } catch (Exception e) {
    
    
                    e.printStackTrace();
                }
            }
            //8. 关闭连接
            if (connection != null && connection.isOpen()) {
    
    
                try {
    
    
                    connection.close();
                } catch (Exception e) {
    
    
                    e.printStackTrace();
                }
            }
        }
    }
}

3.5 Prueba de la función de envío de mensajes

Enviar un mensaje es muy sencillo, mainbasta con ejecutar la función.

Una vez que la transmisión se realiza correctamente, los datos se pueden recibir en segundo plano, como se muestra en la siguiente figura.

3.6 Crear clase de herramienta de recepción de mensajes

Por favor, los estudiantes creen SimpleConsumeruna clase de herramienta, el código es el siguiente.

package cn.zwz.send;

import com.rabbitmq.client.*;

import java.io.IOException;

public class SimpleConsumer {
    
    

    public static void work() {
    
    
        //1. 创建连接工程
        ConnectionFactory connectionFactory = new ConnectionFactory();
        //1.1 设置连接IP
        connectionFactory.setHost("118.126.82.167");
        //1.2 设置连接端口
        connectionFactory.setPort(5672);
        //1.3 设置用户名
        connectionFactory.setUsername("zwz");
        //1.4 设置密码
        connectionFactory.setPassword("123456");
        //1.5 设置虚拟访问节点，就是消息发送的目标路径
        connectionFactory.setVirtualHost("/");

        Connection connection = null;
        Channel channel = null;
        try {
    
    
            //2. 创建连接Connection
            connection = connectionFactory.newConnection("ZWZ-Connection");
            //3. 通过连接获取通道Channel
            channel = connection.createChannel();
            //4. 通过通道创建交换机，声明队列，绑定关系，路由key，发送消息，接收消息
            String queueName = "ZWZ-TOPIC";
            //5. 接收消息并消费消息
            channel.basicConsume(queueName, true, new DeliverCallback() {
    
    
                @Override
                public void handle(String consumerTag, Delivery message) throws IOException {
    
    
                    System.out.println("接收到的消息内容是：" + new String(message.getBody(), "UTF-8"));
                }
            }, new CancelCallback() {
    
    
                @Override
                public void handle(String consumerTag) throws IOException {
    
    
                    System.out.println("消息接收失败。。。");
                }
            });
            System.out.println("开始接受消息。。。。");
            //阻断程序
            System.in.read();
        } catch (Exception e) {
    
    
            e.printStackTrace();
        } finally {
    
    
            //7. 关闭通道
            if (channel != null && channel.isOpen()) {
    
    
                try {
    
    
                    channel.close();
                } catch (Exception e) {
    
    
                    e.printStackTrace();
                }
            }
            //8. 关闭连接
            if (connection != null && connection.isOpen()) {
    
    
                try {
    
    
                    connection.close();
                } catch (Exception e) {
    
    
                    e.printStackTrace();
                }
            }
        }
    }
}

Luego configure y ejecute en la clase de inicio, el código es el siguiente.

package cn.zwz.send;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class SendApplication {
    
    

	public static void main(String[] args) {
    
    
		new SimpleConsumer().work();
		SpringApplication.run(SendApplication.class, args);
	}
}

3.7 Prueba de función de recepción de mensajes

Ejecute la clase de inicio SpringBoot y luego envíe el mensaje nuevamente y podrá ver el contenido del mensaje, como se muestra en la siguiente figura.

4. Resumen

Este artículo primero presenta brevemente RabbitMQ, luego lo compara con colas de mensajes populares como Kafka y finalmente demuestra el proceso completo de instalación, configuración e integración de RabbitMQ para ayudar a los principiantes de base cero a comenzar con el desarrollo de RabbitMQ.

---