Comenzando con RabbitMQ (Instalación de RabbitMQ + Resolver problemas como la versión durante el proceso de instalación de RabbitMQ + Resolver problemas como fallas al iniciar el servicio RabbitMQ + Uso del cliente Java)

1. Prólogo: consulte el sitio web oficial
- 1.1 Dirección del sitio web oficial
- 1.2 Preste atención a la comparación de versiones
2. Descargar e instalar
3. Inicie el servicio
4. Accede a la interfaz de gestión.
5. Iniciar, detener servicios y otros comandos relacionados
6. Inicio rápido

1. Prólogo: consulte el sitio web oficial

1.1 Dirección del sitio web oficial

https://www.rabbitmq.com/install-rpm.html .

1.2 Preste atención a la comparación de versiones

Tenga en cuenta las versiones de RabbitMQ compatibles con la versión de Linux
Tenga en cuenta las versiones de Erlang compatibles con Linux
Tenga en cuenta las versiones de Erlang compatibles con RabbitMQ
- Para obtener más correspondencia sobre versiones, consulte el siguiente enlace
  https://www.rabbitmq.com/ Which-erlang.html .

2. Descargar e instalar

2.1 Descargar e instalar erlang

2.1.1 Verificar la versión de Linux

Mi lado es centos, el comando es el siguiente:
```
cat /etc/centos-release
```

2.1.2 Verifique la versión de erlang compatible con el sistema actual

El comando es el siguiente:
```
uname -a
```

2.1.3 Descargar erlang

Dirección de descarga:
https://github.com/rabbitmq/erlang-rpm .
Según la versión de Linux y la versión de erlang admitida por el sistema, descargue el erlang correspondiente, de la siguiente manera:
Entonces, lo que descargué aquí es Erlang 23.3.4.18(nota: si está aprendiendo usted mismo, se recomienda cambiar a CenOS8, también es mejor cambiar directamente a otras distribuciones, como Ubuntu, etc.), de la siguiente manera:

2.1.4 Instalar erlang

El comando de instalación es el siguiente:

rpm -ivh erlang-23.3.4.18-1.el7.x86_64.rpm

2.1.5 Problemas encontrados

Explicación: Este problema es causado por la instalación erlang-23.3.4.18-1.el8.x86_64.rpm( ), pero no hay ningún problema con la instalación ( ). Mi sistema Linux lo admite de acuerdo con la verificación anterior , así que no sé si es un problema de versión.el8erlang-23.3.4.18-1.el7.x86_64.rpmel7el7

como sigue:

error: Failed dependencies:
        libtinfo.so.6()(64bit) is needed by erlang-23.3.4.18-1.el8.x86_64
        libz.so.1(ZLIB_1.2.7.1)(64bit) is needed by erlang-23.3.4.18-1.el8.x86_64

Resuelva el problema:
además --nodeps --force, la función de este comando: ya no analiza las dependencias entre paquetes e instálelos directamente
```
rpm -ivh erlang-23.3.4.18-1.el8.x86_64.rpm --nodeps --force
```

2.2 Instalar socat

El comando de instalación es el siguiente:
```
yum install socat -y
```

2.3 Descargar e instalar el servidor Rabbitmq

2.3.1 Descargar el servidor Rabbitmq

Al descargar RabbitMQ, preste atención a la versión de Erlang descargada arriba ( Erlang 23.3.4.18) y luego busque la versión de RabbitMQ correspondiente.
- Dirección de descarga 1: es fácil encontrar la nueva versión, pero es difícil encontrar la versión anterior, de la siguiente manera:
  https://github.com/rabbitmq/rabbitmq-server/releases .
- Descargar dirección 2:almacén de revoluciones
  https://packagecloud.io/rabbitmq .
Según el sistema Linux y la versión de Erlang, busque la versión de RabbitMQ correspondiente de la siguiente manera:
- La dirección de descarga de esta versión es la siguiente:
  https://packagecloud.io/rabbitmq/rabbitmq-server/packages/el/7/rabbitmq-server-3.9.13-1.el7.noarch.rpm?distro_version_id=140 .

2.3.2 Instalar el servidor Rabbitmq

El comando de instalación es el siguiente:

rpm -ivh rabbitmq-server-3.9.13-1.el7.noarch.rpm

3. Inicie el servicio

3.1 Iniciar el servicio

Después de la instalación, busque el directorio de instalación:
```
whereis rabbitmq
```
Ingrese al sbindirectorio de instalación:
Comienza el servicio:
```
./rabbitmq-server start
```
Compruebe si el servicio está iniciado:
```
ps -ef | grep rabbitmq
```

3.2 No iniciar el servicio

3.2.1 Problema de versión

Si el inicio falla, verifique si erlang está instalado o si la versión de erlang es correcta, el comando de verificación es el siguiente:
```
rpm -qa|grep erlang
```
Si erlangestá instalada la versión incorrecta, puede desinstalarla y reinstalarla (desinstale RabbitMQ antes de desinstalar, porque RabbitMQ depende de Erlang), el comando de desinstalación es el siguiente:
```
# 1. 卸载rabbitmq-server
rpm -e rabbitmq-server
rm -rf /usr/lib/rabbitmq

# 2. 卸载erlang
rpm -e erlang
rm -rf /usr/lib64/erlang
```
Luego reinstale la versión correcta.

4. Accede a la interfaz de gestión.

4.1 Abrir la interfaz gráfica de gestión

Si se está iniciando RabbitMQ, primero detenga el servicio y luego instale el complemento de la interfaz web. El comando es el siguiente:
```
rabbitmq-plugins enable rabbitmq_management
```

4.2 Verificar los puertos ocupados

como sigue:

ps -ef | grep rabbit
lsof -i | grep pid

Insertar descripción de la imagen aquí

4.3 Puerto abierto 15672

Consulte los siguientes artículos:
Verifique el estado del firewall, apague el firewall, abra y cierre puertos, etc. en Linux .

4.4 Acceder a la interfaz de gestión

DIRECCIÓN:
```
http://服务器IP:15672/
```

4.5 Problemas de inicio de sesión

4.5.1 Problema

Inicie sesión, el nombre de usuario y la contraseña son ambos: invitado. Después de iniciar sesión, el mensaje es el siguiente

4.5.2 Solución de problemas: crear un nuevo usuario

Ingrese al directorio de instalación y vea usuarios y roles:

cd /usr/lib/rabbitmq/lib/rabbitmq_server-3.9.13/sbin

./rabbitmqctl list_users

Crear nuevo usuario
- Paso 1: agregue el usuario mqAdmin y establezca la contraseña 123456
```
rabbitmqctl add_user mqAdmin 123456
```
- Paso 2: Establecer la función del usuario (establecer el usuario mqAdmin en la función de administrador)
```
rabbitmqctl set_user_tags mqAdmin administrator
```
- Paso 3: Establecer permisos de usuario (especifique vhost y acceso permitido de escritura/lectura)
```
rabbitmqctl set_permissions -p "/" mqAdmin ".*" ".*" ".*"
```
- Paso 4, verifique:

4.6 Iniciar sesión: utilizar un nuevo usuario

mqAdminInicie sesión con el usuario recién creado arriba , de la siguiente manera:

5. Iniciar, detener servicios y otros comandos relacionados

5.1 Comando de inicio

5.1.1 Método de inicio

Camino 1: es lo que se usa arriba, ingrese al directorio sbin del directorio de instalación y comience:
```
cd /usr/lib/rabbitmq/lib/rabbitmq_server-3.9.13/sbin/

./rabbitmq-server start
```
Camino 2:Configure el inicio, de la siguiente manera:
```
chkconfig rabbitmq-server on
```
Camino 3: Se inicia el comando de servicio (ejecutable en cualquier directorio)
```
service rabbitmq-server start 
```

5.1.2 Problema de inicio——Falló el trabajo para Rabbitmq-server.service……

5.1.2.1 Preguntas

Cuando se utiliza service rabbitmq-server startel comando para iniciar el problema de informe de errores, la descripción del problema es la siguiente:

Job for rabbitmq-server.service failed because the control process exited with error code. See "systemctl status rabbitmq-server.service" and "journalctl -xe" for details.

5.1.2.2 Resolver el problema

5.1.2.2.1 Intento 1:

Ejecute journalctl -xeel comando para ver los problemas detallados:
Resuelva el problema (modifique el grupo y el propietario de los dos archivos de registro en el directorio /var/log/rabbitmq/ a Rabbitmq):
```
cd /var/log/rabbitmq/

chown -R rabbitmq:rabbitmq rabbit@hello_TQ1*
```

5.1.2.2.2 Intento 2:

Una vez resuelto el problema anterior, si el error persiste después de reiniciar, ejecute journalctl -xeel comando nuevamente para ver el problema detallado, de la siguiente manera:
La solución es la misma que la anterior, la siguiente:

ejecute service rabbitmq-server startel comando nuevamente sin informar un error, de la siguiente manera:

5.2 Resumen de comandos de uso común

Comienza el servicio
```
service rabbitmq-server start
```
Fuera de servicio
```
service rabbitmq-server stop
```
Reiniciar servicio
```
service rabbitmq-server restart
```

6. Inicio rápido

6.1 Simular el envío de mensajes en la consola

Para crear un interruptor, por supuesto, puede usar el interruptor predeterminado. Yo usaré el predeterminado para evitar problemas aquí.amq.fanout。
Crear cola
El conmutador vincula la cola de la siguiente manera:
enviar mensaje
Controlar

6.2 Cliente Java: código básico

6.2.1 archivo pom

como sigue:

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>

  <groupId>com.liu.susu</groupId>
  <artifactId>rabbitmq-demo1</artifactId>
  <version>1.0-SNAPSHOT</version>
  <packaging>jar</packaging>

  <name>rabbitmq-demo1</name>
  <url>http://maven.apache.org</url>

  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  </properties>

  <dependencies>

<!--    rabbitmq依赖客户端-->
    <dependency>
      <groupId>com.rabbitmq</groupId>
      <artifactId>amqp-client</artifactId>
      <version>5.8.0</version>
    </dependency>
    <dependency>
      <groupId>commons-io</groupId>
      <artifactId>commons-io</artifactId>
      <version>2.6</version>
    </dependency>


    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>3.8.1</version>
      <scope>test</scope>
    </dependency>
  </dependencies>
    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <configuration>
                    <source>8</source>
                    <target>8</target>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

6.2.2 Productor

prueba:
comprobar el efecto

Código adjunto

package com.liu.susu.example;

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

/**
 * @Description 生产者
 * @Author susu
 */
public class Producer {
      
      
    // 队列名称
    public static  final  String QUEUE_NAME = "queue-hello";

    public static void main(String[] args) throws Exception{
      
      
        //1. 创建连接工厂
        ConnectionFactory factory = new ConnectionFactory();
        //2. 工厂IP连接rabbitmq的队列
        factory.setHost("服务IP地址");
        //3. 连接用户名和密码
        factory.setUsername("mqAdmin");
        factory.setPassword("123456");
        //4. 创建连接
        Connection connection = factory.newConnection();
        //5. 获取信道
        Channel channel = connection.createChannel();
        /**
         * 6. 创建一个队列
         */
        channel.queueDeclare(QUEUE_NAME,false,false,false,null);
        //7. 定义发送消息的内容
        String msg = "hello world!!!，我来之于Java程序";
        /**
         * 8. 发送消息
         *    1. 参数1：交换机（发送到哪个交换机上）
         *    2. 参数2：路由key的值（本次发送用的队列名称）
         *    3. 参数3：其他参数信息 （本次没有，直接null）
         *    4. 参数4：发送消息的消息体
         */
        channel.basicPublish("",QUEUE_NAME,null,msg.getBytes());
        System.out.println("=====消息发送成功=====");
    }
}

6.2.3 Consumidores

Antes de consumir, primero lee los mensajes en la cola.
Probar mensajes de consumo de los consumidores
Después del consumo, mira los mensajes en la cola.

Código adjunto:

package com.liu.susu.example;

import com.rabbitmq.client.*;


/**
 * @Description 消费者 接收消息
 * @Author susu
 */
public class Consumer {
      
      
    // 队列名称
    public static  final  String QUEUE_NAME = "queue-hello";

    public static void main(String[] args) throws Exception{
      
      
        //1. 创建连接工厂
        ConnectionFactory factory = new ConnectionFactory();
        //1.1. 工厂IP连接rabbitmq的队列
        factory.setHost("服务IP地址");
        //1.2. 连接用户名和密码
        factory.setUsername("mqAdmin");
        factory.setPassword("123456");
        //2. 创建连接
        Connection connection = factory.newConnection();
        //3. 获取信道
        Channel channel = connection.createChannel();

        // 接收消息后的回调
        DeliverCallback deliverCallback = (consumerTag,msg)->{
      
      
            byte[] msgBody = msg.getBody();
            System.out.println("消费的消息是：" + new String(msgBody));
        };

        // 取消消息时的回调
        CancelCallback cancelCallback = (consumerTag)->{
      
      
            System.out.println("===消息消费被取消====");
        };

        /**
         * 4. 消费者消费消息
         *    1. 参数1：消费哪个队列
         *    2. 参数2：消费成功之后是否要自定应答
         *             true——自动应答
         *             false——手动应答
         *    3. 参数3：消费者接收消息后的回调方法
         *    4. 参数4：消费者取消消费的回调（正常接收不调用）
         */
        channel.basicConsume(QUEUE_NAME,true,deliverCallback,cancelCallback);
    }

}

6.2.4 Problemas encontrados

6.2.4.1 Problema 1——Se agotó el tiempo de conexión

Descripción del problema: Se agotó el tiempo de espera de la operación (Se agotó el tiempo de espera de la conexión)
Resolviendo el problema
Para los servicios en la nube, abrir puertos en el grupo de seguridad 5672puede resolver el problema.

6.2.4.2 Pregunta 2——Conexión rechazada

Las preguntas son las siguientes:

Connection refused (Connection refused)

Resuelva el problema
Si el firewall no está cerrado, 5672simplemente abra el puerto en el firewall.
```
sudo firewall-cmd --add-port=5672/tcp --permanent

firewall-cmd --reload
```

6.3 Cliente Java——Spring AMQP

6.3.1 Introducción

AMQP (Protocolo avanzado de cola de mensajes) es un estándar abierto para entregar mensajes comerciales entre aplicaciones. Este protocolo no tiene nada que ver con plataformas lingüísticas y está más acorde con los requisitos de independencia en microservicios.
Spring AMQP es un conjunto de especificaciones API basadas en el protocolo AMQP, que proporciona plantillas para enviar y recibir mensajes.
- Spring AMQP consta de spring-amqpdos spring-rabbitpartes: spring-amqp es la abstracción básica y spring-rabbit es la implementación predeterminada subyacente.
- Consulte el sitio web oficial:
  https://spring.io/projects/spring-amqp .

6.3.2 Estructura del proyecto

Estructura de directorios

parentpom.xml

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>

  <groupId>com.liu.susu</groupId>
  <artifactId>rabbitmq-demo2</artifactId>
  <version>1.0-SNAPSHOT</version>
  <packaging>pom</packaging>

  <name>rabbitmq-demo2</name>
  <url>http://maven.apache.org</url>

  <modules>
    <module>producer</module>
    <module>consumer</module>
  </modules>

  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <maven.compiler.source>1.8</maven.compiler.source>
    <maven.compiler.target>1.8</maven.compiler.target>

    <junit.version>3.8.1</junit.version>
    <lombok.version>1.16.8</lombok.version>
    <spring-boot.version>2.7.16</spring-boot.version>
  </properties>

<dependencyManagement>
  <dependencies>

    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-dependencies</artifactId>
      <version>${spring-boot.version}</version>
      <type>pom</type>
      <scope>import</scope>
    </dependency>

<!--    AMQP依赖，包含RabbitMQ-->
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-amqp</artifactId>
      <version>2.7.14</version>
    </dependency>

    <dependency>
      <groupId>org.projectlombok</groupId>
      <artifactId>lombok</artifactId>
      <version>${lombok.version}</version>
    </dependency>

<!--    <dependency>-->
<!--      <groupId>junit</groupId>-->
<!--      <artifactId>junit</artifactId>-->
<!--      <version>${junit.version}</version>-->
<!--      <scope>test</scope>-->
<!--    </dependency>-->

  </dependencies>
</dependencyManagement>
</project>

6.3.3 Servicios al productor

pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>com.liu.susu</groupId>
        <artifactId>rabbitmq-demo2</artifactId>
        <version>1.0-SNAPSHOT</version>
    </parent>

    <artifactId>producer</artifactId>
    <packaging>jar</packaging>
    <name>producer</name>
    <description>producer</description>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>

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

        <!-- AMQP依赖，包含RabbitMQ-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-amqp</artifactId>
        </dependency>

        <!--单元测试-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>

    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-surefire-plugin</artifactId>
                <configuration>
                    <testFailureIgnore>true</testFailureIgnore>
                </configuration>
            </plugin>
        </plugins>
    </build>

</project>

aplicación.yml

spring:
  rabbitmq:
    host: 服务IP地址  # 服务IP
    port: 5672  # 端口（发送消息的端口5672  rabbitmq管理界面的端口15672）
#    virtual-host: /mqAdmin   # 虚拟主机
    username: mqAdmin  # 用户名
    password: 123456  # 密码

Clase de prueba para enviar mensajes.

package com.liu.susu.producer;

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;

/**
 * @Description
 * @Author susu
 */
@SpringBootTest
public class ProducerTest {
      
      

    @Autowired
    private RabbitTemplate rabbitTemplate;

    @Test
    public void publishMsg(){
      
      
        System.out.println("---------------------");
        String queueName = "queue-hello";
        String msg = "hello,I am from amqp!!!";
        //发送消息
        rabbitTemplate.convertAndSend(queueName,msg);
        System.out.println("amqp——消息发送成功！！！");
    }

}

Prueba para ver el efecto.

6.3.4 Servicios al consumidor

pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>com.liu.susu</groupId>
        <artifactId>rabbitmq-demo2</artifactId>
        <version>1.0-SNAPSHOT</version>
    </parent>

    <artifactId>consumer</artifactId>
    <packaging>jar</packaging>
    <version>0.0.1-SNAPSHOT</version>
    <name>consumer</name>
    <description>consumer</description>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>

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

        <!-- AMQP依赖，包含RabbitMQ-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-amqp</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

aplicación.yml

logging:
  pattern:
    dateformat: HH:mm:ss:SSSS
spring:
  rabbitmq:
    host: 服务IP地址  # 服务IP
    port: 5672  # 端口（发送消息的端口5672  rabbitmq管理界面的端口15672）
#    virtual-host: /mqAdmin   # 虚拟主机
    username: mqAdmin  # 用户名
    password: 123456  # 密码

Componente que recibe mensajes.

package com.liu.susu.consumer.listeners;

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

/**
 * @Description
 * @Author susu
 */

@Component
public class MqListener {
      
      

    @RabbitListener(queues = "queue-hello") //监听的队列
    public void listenQueues(String msg){
      
      
        System.out.println("消费者收到消息===>"+msg);
    }
}

Inicie el servicio y pruebe para ver el efecto.

6.4 Elementos adicionales

Descargar proyecto:
Rabbitmq-demo (cliente Java-código básico + cliente Java-Spring AMQP)
.