Explication détaillée de l'intégration de SpringBoot avec Apache RocketMQ

Annuaire d'articles

0. Préface
1. Spring Boot intègre les étapes détaillées d'Apache RocketMQ
2. Vérification des tests
3. Erreurs courantes
4. Documentation de référence
5. Adresse du code source

0. Préface

Dans le dernier chapitre, nous avons découvert l'installation de l'environnement d'apprentissage de RocketMQ et parlé de deux méthodes d'installation : 1. Installation de Docker à l'aide de l'image officielle, 2. Installation à l'aide de la méthode du code source. Le tutoriel d'installation est le suivant
Si vous avez déjà installé l'environnement d'apprentissage RocketMQ, vous pouvez ignorer ce chapitre."[Pratique (1)] Construction d'un environnement d'apprentissage pour démarrer avec RocketMQ"
Dans ce chapitre, nous apprenons comment Spring Boot intègre Apache RocketMQ. Et vérifiez comment utiliser le producteur Apache RocketMQ (Producer) pour envoyer des messages dans l'application SpringBoot.
Ce code implémente les types d'envoi de messages suivants :
Utiliser la bibliothèque de dépendances officielle Apache RocketMQ RocketMQTemplate, réalisant des messages synchrones, asynchrones et autres.

Message synchrone : grâce à syncSendcette méthode, le producteur attendra une réponse de confirmation du serveur de messages avant de continuer à envoyer le message suivant.

Message asynchrone : Grâce à asyncSendcette méthode, le producteur n'attend pas la réponse du serveur après l'envoi du message, mais envoie directement le message suivant.

Message unidirectionnel : grâce à sendOneWayla méthode, le producteur est uniquement responsable de l'envoi des messages, n'attend pas la réponse du serveur et ne prête pas attention aux résultats de l'envoi.

Messages séquentiels : utilisez sendOrderlyla méthode pour consommer les messages dans l'ordre dans lequel ils sont envoyés (First-In-First-Out).

Message retardé : grâce à sendDelayedcette méthode, une fois le message envoyé, il ne sera pas consommé immédiatement. Il attendra un délai spécifique avant de pouvoir être consommé.

Messages par lots : utilisez sendBatchcette méthode pour envoyer plusieurs messages en même temps, ce qui peut améliorer efficacement le débit d'envoi.

Concernant l'introduction et l'utilisation du modèle de message des messages RocketMQ, j'ai écrit un blog spécifiquement pour mieux comprendre le
"modèle de transmission de messages RocketMQ" https://blog.csdn.net/wangshuai6707/article/details/132863088

1. Spring Boot intègre les étapes détaillées d'Apache RocketMQ

1.1. Ajouter des dépendances

pom.xmlAjoutez la dépendance RocketMQ au fichier de projet SpringBoot :

<?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>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-parent</artifactId>
		<version>2.7.15</version>
		<relativePath/>
	</parent>
	<groupId>com.icepip.project</groupId>
	<artifactId>springboot-icepip-rocketMQ-example</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<name>springboot-icepip-rocketMQ-example</name>
	<description>Spring boot 集成rocketMQ 示例</description>
	<properties>
		<java.version>8</java.version>
	</properties>
	<dependencies>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-web</artifactId>
		</dependency>
		<dependency>
			<groupId>org.apache.rocketmq</groupId>
			<artifactId>rocketmq-spring-boot-starter</artifactId>
			<version>2.0.4</version>
		</dependency>

		<dependency>
			<groupId>org.projectlombok</groupId>
			<artifactId>lombok</artifactId>
			<optional>true</optional>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-test</artifactId>
			<scope>test</scope>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-actuator</artifactId>
		</dependency>

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

	</dependencies>

	<build>
		<plugins>
			<plugin>
				<groupId>org.springframework.boot</groupId>
				<artifactId>spring-boot-maven-plugin</artifactId>
				<configuration>
					<excludes>
						<exclude>
							<groupId>org.projectlombok</groupId>
							<artifactId>lombok</artifactId>
						</exclude>
					</excludes>
				</configuration>
			</plugin>
		</plugins>
	</build>

</project>

1.2.Configuration de RocketMQ

application.propertiesConfigurez les informations relatives à RocketMQ dans le fichier :

rocketmq.name-server=你的RocketMQ服务IP:9876
rocketmq.producer.group=my-producer
# 刚开始未配置 导致超时报错
rocketmq.producer.sendMessageTimeout=10000

1.3. Créer un producteur de message (Producteur)

package com.icepip.project.mqtt.controller;

import org.apache.rocketmq.client.producer.SendCallback;
import org.apache.rocketmq.client.producer.SendResult;
import org.apache.rocketmq.spring.core.RocketMQTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.messaging.support.MessageBuilder;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.ArrayList;
import java.util.List;
/**
 *  SpringBoot集成Apache RocketMQ详解
 * @author 冰点
 * @version 1.0.0
 * @date 2023/9/9 17:02
 */

@RestController
@RequestMapping("/producer")
public class ProducerController {
    
    

    @Autowired
    private RocketMQTemplate rocketMQTemplate;


    /**
     * 同步发送消息到指定主题
     * @param message
     * @return
     */
    @GetMapping("/syncSend")
    public String syncSend(String message) {
    
    
        // 同步发送消息到指定主题
        rocketMQTemplate.syncSend("test-topic", message);
        return "Sync message: " + message + " sent";
    }
    /**
     * 异步发送消息到指定主题
     * @param message
     * @return
     */
    @GetMapping("/asyncSend")
    public String asyncSend(String message) {
    
    
        // 异步发送消息到指定主题
        rocketMQTemplate.asyncSend("test-topic", MessageBuilder.withPayload(message).build(), new SendCallback() {
    
    
            @Override
            public void onSuccess(SendResult sendResult) {
    
    
                System.out.println("Async message sent successfully, result: " + sendResult);
            }

            @Override
            public void onException(Throwable throwable) {
    
    
                System.err.println("Failed to send async message: " + throwable.getMessage());
            }
        }, 3000, 3); // 3000 ms timeout, delay level 3

        return "Async message: " + message + " sent";
    }

    /**
     * 发送单向消息到指定主题，无需等待Broker的确认
     * @param message
     * @return
     */
    @GetMapping("/sendOneWay")
    public String sendOneWay(String message) {
    
    
        // 发送单向消息到指定主题，无需等待Broker的确认
        rocketMQTemplate.sendOneWay("test-topic", message);
        return "OneWay message: " + message + " sent";
    }

    // 发送顺序消息
    @GetMapping("/sendOrderly")
    public String sendOrderly(String message) {
    
    
        // 发送顺序消息到指定主题
        rocketMQTemplate.syncSendOrderly("test-topic", message, "order");
        return "Orderly message: " + message + " sent";
    }

    // 发送延迟消息
    @GetMapping("/sendDelayed")
    public String sendDelayed(String message) {
    
    
        // 发送延迟消息到指定主题，延迟级别为3
        rocketMQTemplate.syncSend("test-topic", MessageBuilder.withPayload(message).build(), 1000, 3);
        return "Delayed message: " + message + " sent";
    }

    // 发送批量消息
    @GetMapping("/sendBatch")
    public String sendBatch() {
    
    
        List<String> messages = new ArrayList<>();
        messages.add("message1");
        messages.add("message2");
        // 批量发送消息到指定主题
        rocketMQTemplate.syncSend("test-topic", messages);
        return "Batch messages sent";
    }
}

1.4. Créer un consommateur de messages (Consumer)

package com.icepip.project.mqtt.handler;

import org.apache.rocketmq.spring.annotation.RocketMQMessageListener;
import org.apache.rocketmq.spring.core.RocketMQListener;
import org.springframework.stereotype.Service;

/**
 * 定义一个消费者，监听test-topic主题的消息
 * @author 冰点
 * @version 1.0.0
 * @date 2023/9/9 16:29
 */

@Service
@RocketMQMessageListener(topic = "test-topic", consumerGroup = "my-consumer_test-topic")
public class MyConsumer implements RocketMQListener<String>{
    
    

    // 当收到消息时，该方法将被调用
    @Override
    public void onMessage(String message) {
    
    
        System.out.println("Received message: "+ message);
    }
}

2. Vérification des tests

Insérer la description de l'image ici

3. Erreurs courantes

Voir http://rocketmq.apache.org/docs/faq/ pour plus de détails. ; L'exception imbriquée est org.apache.rocketmq.client.exception.MQClientException : envoi [3] fois, toujours échoué, coût [6386] ms, sujet : test-topic, BrokersSent : [698f11314447, 698f11314447, 698f11314447] Voir http:
// rocketmq.apache.org/docs/faq/ pour plus de détails.] avec la cause première

org.apache.rocketmq.remoting.exception.RemotingConnectException : échec de la connexion à <172.17.0.8:10911>.
La solution consiste à modifier l'adresse IP du courtier en adresse IP de l'hôte,
à entrer dans le conteneur pour modifier le fichier de configuration et à démarrer le service après modification. . Avant de commencer, tuez le courtier d'origine dans le conteneur.
nohup sh mqbroker -c /home/rocketmq/rocketmq-4.9.2/broker.conf &
Insérer la description de l'image ici

4. Documentation de référence

Lien de documentation officielle : https://rocketmq.apache.org/docs/
Lien GitHub : https://github.com/apache/rocketmq-spring

5. Adresse du code source

Mon github https://github.com/wangshuai67/icepip-springboot-action-examples