Premiers pas avec RabbitMQ (Installation de RabbitMQ + Résoudre les problèmes tels que la version pendant le processus d'installation de RabbitMQ + Résoudre les problèmes tels que l'échec du démarrage du service RabbitMQ + Utilisation du client Java)

1. Avant-propos - reportez-vous au site officiel
- 1.1 Adresse du site officiel
- 1.2 Faites attention à la comparaison des versions
2. Téléchargez et installez
3. Démarrez le service
4. Accédez à l'interface de gestion
5. Démarrer, arrêter les services et autres commandes associées
6. Démarrage rapide

1. Avant-propos - reportez-vous au site officiel

1.1 Adresse du site officiel

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

1.2 Faites attention à la comparaison des versions

Notez les versions RabbitMQ prises en charge par la version Linux
Notez les versions Erlang supportées par Linux
Notez les versions Erlang supportées par RabbitMQ
- Pour plus de correspondance entre les versions, consultez le lien ci-dessous
  https://www.rabbitmq.com/which-erlang.html .

2. Téléchargez et installez

2.1 Téléchargez et installez Erlang

2.1.1 Vérifier la version de Linux

Mon côté est centos, la commande est la suivante :
```
cat /etc/centos-release
```

2.1.2 Vérifiez la version erlang prise en charge par le système actuel

La commande est la suivante :
```
uname -a
```

2.1.3 Télécharger Erlang

Adresse de téléchargement :
https://github.com/rabbitmq/erlang-rpm .
Selon la version Linux et la version erlang supportée par le système, téléchargez l'erlang correspondant, comme suit :
Donc, ce que j'ai téléchargé ici Erlang 23.3.4.18(remarque : si vous apprenez par vous-même, il est recommandé de passer à CenOS8, il est également préférable de passer directement à d'autres distributions, comme Ubuntu, etc.), comme suit :

2.1.4 Installer Erlang

La commande d'installation est la suivante :

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

2.1.5 Problèmes rencontrés

Explication : Ce problème est dû à l'installation erlang-23.3.4.18-1.el8.x86_64.rpm( ), mais il n'y a pas de problème avec l'installation ( ). Mon système Linux le prend en charge selon la vérification ci-dessus , donc je ne sais pas s'il s'agit d'un problème de version !el8erlang-23.3.4.18-1.el7.x86_64.rpmel7el7

comme suit:

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

Résoudre le problème :
De plus --nodeps --force, la fonction de cette commande : Ne plus analyser les dépendances entre les packages et les installer directement
```
rpm -ivh erlang-23.3.4.18-1.el8.x86_64.rpm --nodeps --force
```

2.2 Installer socat

La commande d'installation est la suivante :
```
yum install socat -y
```

2.3 Téléchargez et installez le serveur Rabbitmq

2.3.1 Télécharger le serveur Rabbitmq

Lors du téléchargement de RabbitMQ, faites attention à la version Erlang téléchargée ci-dessus ( Erlang 23.3.4.18), puis recherchez la version RabbitMQ correspondante
- Adresse de téléchargement 1 : Il est facile de trouver la nouvelle version, mais il est difficile de trouver l'ancienne version, comme suit :
  https://github.com/rabbitmq/rabbitmq-server/releases .
- Adresse de téléchargement 2 :entrepôt tr/min
  https://packagecloud.io/rabbitmq .
Selon le système Linux et la version Erlang, recherchez la version Rabbitmq correspondante comme suit :
- L'adresse de téléchargement de cette version est la suivante :
  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 Installer le serveur Rabbitmq

La commande d'installation est la suivante :

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

3. Démarrez le service

3.1 Démarrer le service

Après l'installation, recherchez le répertoire d'installation :
```
whereis rabbitmq
```
Entrez le sbinrépertoire d'installation :
Démarrer le service：
```
./rabbitmq-server start
```
Vérifiez si le service est démarré :
```
ps -ef | grep rabbitmq
```

3.2 Échec du démarrage du service

3.2.1 Problème de version

Si le démarrage échoue, vérifiez si erlang est installé ou si la version d'erlang est correcte. La commande check est la suivante :
```
rpm -qa|grep erlang
```
Si erlangla mauvaise version est installée, vous pouvez désinstaller et réinstaller (désinstaller RabbitMQ avant de désinstaller, car RabbitMQ dépend d'Erlang). La commande de désinstallation est la suivante :
```
# 1. 卸载rabbitmq-server
rpm -e rabbitmq-server
rm -rf /usr/lib/rabbitmq

# 2. 卸载erlang
rpm -e erlang
rm -rf /usr/lib64/erlang
```
Réinstallez ensuite la bonne version.

4. Accédez à l'interface de gestion

4.1 Ouvrir l'interface graphique de gestion

Si Rabbitmq démarre, arrêtez d'abord le service, puis installez le plug-in de l'interface Web. La commande est la suivante :
```
rabbitmq-plugins enable rabbitmq_management
```

4.2 Vérifiez les ports occupés

comme suit:

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

Insérer la description de l'image ici

4.3 Ouvrir le port 15672

Référez-vous aux articles suivants :
Vérifier l'état du pare-feu, désactiver le pare-feu, ouvrir et fermer les ports, etc. sous Linux .

4.4 Accéder à l'interface de gestion

adresse:
```
http://服务器IP:15672/
```

4.5 Problèmes de connexion

4.5.1 Problème

Connectez-vous, le nom d'utilisateur et le mot de passe sont tous deux : invité. Après la connexion, l'invite est la suivante

4.5.2 Dépannage - Créer un nouvel utilisateur

Entrez le répertoire d'installation et affichez les utilisateurs et les rôles :
```
cd /usr/lib/rabbitmq/lib/rabbitmq_server-3.9.13/sbin

./rabbitmqctl list_users
```
Créer un nouvel utilisateur
- Étape 1 : Ajoutez un utilisateur mqAdmin et définissez le mot de passe 123456
```
rabbitmqctl add_user mqAdmin 123456
```
- Étape 2 : Définir le rôle de l'utilisateur (définir l'utilisateur mqAdmin sur le rôle d'administrateur)
```
rabbitmqctl set_user_tags mqAdmin administrator
```
- Étape 3 : Définissez les autorisations utilisateur (spécifiez l'hôte virtuel et l'accès autorisé en écriture/lecture)
```
rabbitmqctl set_permissions -p "/" mqAdmin ".*" ".*" ".*"
```
- Étape 4, vérifiez :

4.6 Connexion - Utilisation d'un nouvel utilisateur

mqAdminConnectez-vous en utilisant l'utilisateur nouvellement créé ci-dessus , comme suit :

5. Démarrer, arrêter les services et autres commandes associées

5.1 Commande de démarrage

5.1.1 Méthode de démarrage

Voie 1: c'est ce qui est utilisé ci-dessus, entrez dans le répertoire sbin du répertoire d'installation et démarrez :
```
cd /usr/lib/rabbitmq/lib/rabbitmq_server-3.9.13/sbin/

./rabbitmq-server start
```
Voie 2:Configurez le démarrage, comme suit :
```
chkconfig rabbitmq-server on
```
Voie 3: La commande de service démarre (exécutable dans n'importe quel répertoire)
```
service rabbitmq-server start 
```

5.1.2 Problème de démarrage——La tâche pour Rabbitmq-server.service a échoué……

5.1.2.1 Questions

Lorsque vous utilisez service rabbitmq-server startla commande pour démarrer le problème de rapport d'erreurs, la description du problème est la suivante :

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 Résoudre le problème

5.1.2.2.1 Tentative 1 :

Exécutez journalctl -xela commande pour afficher les problèmes détaillés :
Résolvez le problème (modifiez le groupe et le propriétaire des deux fichiers journaux dans le répertoire /var/log/rabbitmq/ en lapinmq) :
```
cd /var/log/rabbitmq/

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

5.1.2.2.2 Tentative 2 :

Une fois le problème ci-dessus résolu, si l'erreur persiste après le redémarrage, exécutez journalctl -xeà nouveau la commande pour afficher le problème détaillé, comme suit :
La solution est la même que ci-dessus, comme suit :

exécutez service rabbitmq-server startà nouveau la commande sans signaler d'erreur, comme suit :

5.2 Résumé des commandes couramment utilisées

Démarrer le service
```
service rabbitmq-server start
```
Hors service
```
service rabbitmq-server stop
```
Redémarrer le service
```
service rabbitmq-server restart
```

6. Démarrage rapide

6.1 Simuler l'envoi de messages sur la console

Pour créer un commutateur, vous pouvez bien sûr utiliser le commutateur par défaut. J'utiliserai celui par défaut pour éviter les problèmes ici.amq.fanout。
Créer une file d'attente
Le commutateur lie la file d'attente comme suit :
envoyer le message
Vérifier

6.2 Client Java - code de base

6.2.1 fichier pom

comme suit:

<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 Producteur

test:
Vérifiez l'effet

Code ci-joint

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 Consommateurs

Avant de consommer, lisez d'abord les messages dans la file d'attente
Tester les messages de consommation des consommateurs
Après consommation, regardez les messages dans la file d'attente

Code ci-joint :

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 Problèmes rencontrés

6.2.4.1 Problème 1——La connexion a expiré

Description du problème : Opération expirée (Connexion expirée)
Résoudre le problème
Pour les services cloud, l'ouverture de ports dans le groupe de sécurité 5672peut résoudre le problème.

6.2.4.2 Question 2——Connexion refusée

Les questions sont les suivantes :

Connection refused (Connection refused)

Résoudre le problème
Si le pare-feu n'est pas fermé, 5672ouvrez simplement le port du pare-feu.
```
sudo firewall-cmd --add-port=5672/tcp --permanent

firewall-cmd --reload
```

6.3 Client Java——Spring AMQP

6.3.1 Présentation

AMQP (Advanced Message Queuing Protocol) est un standard ouvert permettant de transmettre des messages professionnels entre applications. Ce protocole n’a rien à voir avec les plateformes linguistiques et répond davantage aux exigences d’indépendance des microservices.
Spring AMQP est un ensemble de spécifications API basées sur le protocole AMQP, qui fournit des modèles pour envoyer et recevoir des messages.
- Spring AMQP se compose de spring-amqpdeux spring-rabbitparties : spring-amqp est l'abstraction de base et spring-rabbit est l'implémentation par défaut sous-jacente.
- Reportez-vous au site officiel :
  https://spring.io/projects/spring-amqp .

6.3.2 Structure du projet

Structure du répertoire

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 Services aux producteurs

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>

application.yml

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

Classe de test pour l'envoi de messages

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——消息发送成功！！！");
    }

}

Testez pour voir l'effet

6.3.4 Services aux consommateurs

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>

application.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  # 密码

Composant qui reçoit des messages

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

Démarrez le service et testez pour voir l'effet

6.4 Éléments supplémentaires

Télécharger le projet :
Rabbitmq-demo (code de base du client Java + client Java-Spring AMQP)
.