RabbitMQ est actuellement un middleware de messages très populaire, largement utilisé à la fois dans l'industrie Internet et dans les industries traditionnelles. RabbitMQ est favorisé par de plus en plus d'entreprises en raison de sa fiabilité élevée, de sa facilité d'extension, de sa haute disponibilité et de ses fonctionnalités riches. Dans la réalisation du développement de projet, les données au format Json et Map sont souvent utilisées. Ce qui suit présentera RabbitMQ pour réaliser l'envoi et la réception de données au format Json et Map.

(1) Créer un projet SpringBoot et intégrer le framework RabbitMQ

Dans le fichier d'informations de configuration pom.xml, ajoutez les fichiers dépendants associés:

<!-- AMQP客户端 -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-amqp</artifactId>
</dependency>

Configurez le service RabbitMQ dans le fichier de configuration application.yml:

spring:
  # 项目名称
  application:
    name: rabbitmq-provider
  # RabbitMQ服务配置
  rabbitmq:
    host: 127.0.0.1
    port: 5672
    username: guest
    password: guest
    # 消息确认（ACK）
    publisher-confirm-type: correlated #确认消息已发送到交换机(Exchange)
    publisher-returns: true #确认消息已发送到队列(Queue)

(2) Classe de configuration RabbitMQ

Dans le projet, créez une classe de configuration, configurez la confirmation de message, le convertisseur Json, le nom de la file d'attente, etc., et remettez la file d'attente à la gestion IoC. code montrer comme ci-dessous:

package com.pjb.config;

import com.pjb.receiver.AckReceiver;
import org.springframework.amqp.core.*;
import org.springframework.amqp.rabbit.connection.CachingConnectionFactory;
import org.springframework.amqp.rabbit.connection.ConnectionFactory;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.amqp.rabbit.listener.SimpleMessageListenerContainer;
import org.springframework.amqp.support.converter.Jackson2JsonMessageConverter;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * RabbitMQ配置类
 * @author pan_junbiao
 **/
@Configuration
public class RabbitMqConfig
{
    public static final String DIRECT_QUEUE_NAME = "direct_queue_name"; //队列名称
    public static final String DIRECT_EXCHANGE_NAME = "direct_exchange_name"; //交换器名称
    public static final String DIRECT_ROUTING_KEY = "direct_routing_key"; //路由键

    @Bean
    public RabbitTemplate rabbitTemplate(ConnectionFactory connectionFactory)
    {
        final RabbitTemplate rabbitTemplate = new RabbitTemplate(connectionFactory);
        
        //设置Json转换器
        rabbitTemplate.setMessageConverter(jsonMessageConverter());
        
        return rabbitTemplate;
    }

    /**
     * Json转换器
     */
    @Bean
    public Jackson2JsonMessageConverter jsonMessageConverter()
    {
        return new Jackson2JsonMessageConverter();
    }

    /**
     * 队列
     */
    @Bean
    public Queue directQueue()
    {
        return new Queue(DIRECT_QUEUE_NAME, true, false, false, null);
    }

    /**
     * Direct交换器
     */
    @Bean
    public DirectExchange directExchange()
    {
        return new DirectExchange(DIRECT_EXCHANGE_NAME, true, false);
    }

    /**
     * 绑定
     */
    @Bean
    Binding bindingDirect(DirectExchange directExchange, Queue directQueue)
    {
        //将队列和交换机绑定, 并设置用于匹配键：routingKey
        return BindingBuilder.bind(directQueue).to(directExchange).with(DIRECT_ROUTING_KEY);
    }

    /********************配置客户端消息确认Ack********************/
    @Autowired
    private CachingConnectionFactory connectionFactory;

    @Autowired
    private AckReceiver ackReceiver;

    @Bean
    public SimpleMessageListenerContainer simpleMessageListenerContainer()
    {
        SimpleMessageListenerContainer container = new SimpleMessageListenerContainer(connectionFactory);
        container.setConcurrentConsumers(1);
        container.setMaxConcurrentConsumers(1);

        // RabbitMQ默认是自动确认，这里改为手动确认消息
        container.setAcknowledgeMode(AcknowledgeMode.MANUAL);

        //设置一个队列
        container.setQueueNames(DIRECT_QUEUE_NAME);

        container.setMessageListener(ackReceiver);

        return container;
    }
}

1. Envoi et réception de données au format JSON

(1) Créer une classe d'entité (couche d'entité)

Dans le package com.pjb.entity, créez une classe UserInfo (classe d'entité d'informations utilisateur).

package com.pjb.entity;

/**
 * 用户信息实体类
 * @author pan_junbiao
 **/
public class UserInfo
{
    private int userId; //用户编号
    private String userName; //用户姓名
    private String blogUrl; //博客地址
    private String blogRemark; //博客信息

    //省略getter与setter方法...
}

(2) Créer un expéditeur (couche expéditeur)

Dans le package com.pjb.sender, créez un expéditeur et utilisez la méthode rabbitTemplate.convertAndSend () pour envoyer le message.

package com.pjb.sender;

import com.pjb.config.RabbitMqConfig;
import com.pjb.entity.UserInfo;
import org.junit.jupiter.api.Test;
import org.springframework.amqp.AmqpException;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

/**
 * 发送JSON数据
 * @author pan_junbiao
 **/
@SpringBootTest
public class JsonSender
{
    @Autowired
    RabbitTemplate rabbitTemplate;

    @Test
    public void sender() throws AmqpException
    {
        //创建用户信息
        UserInfo userInfo = new UserInfo();
        userInfo.setUserId(1);
        userInfo.setUserName("pan_junbiao的博客");
        userInfo.setBlogUrl("https://blog.csdn.net/pan_junbiao");
        userInfo.setBlogRemark("您好，欢迎访问 pan_junbiao的博客");
        
        /**
         * 发送消息，参数说明：
         * String exchange：交换器名称。
         * String routingKey：路由键。
         * Object object：发送内容。
         */
        rabbitTemplate.convertAndSend(RabbitMqConfig.DIRECT_EXCHANGE_NAME, RabbitMqConfig.DIRECT_ROUTING_KEY, userInfo);
        System.out.println("消息发送成功！");
    }
}

(3) Créer un récepteur (couche récepteur)

Méthode 1: utilisez les annotations traditionnelles @RabbitListener et @RabbitHandler pour obtenir la réception des messages.

Dans le package com.pjb.receiver, créez un récepteur et utilisez les annotations traditionnelles @RabbitListener et @RabbitHandler pour obtenir la réception des messages. Parmi les paramètres de méthode, RabbitMQ convertira automatiquement les paramètres JSON en classes d'objets d'entité.

Notez que le nom de la file d'attente de l'expéditeur et du destinataire doit être le même, sinon le message ne peut pas être reçu.

package com.pjb.receiver;

import com.pjb.entity.UserInfo;
import org.springframework.amqp.rabbit.annotation.RabbitHandler;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;
import com.pjb.config.RabbitMqConfig;

import java.util.Map;

/**
 * 接收者
 * @author pan_junbiao
 **/
@Component
@RabbitListener(queues=RabbitMqConfig.DIRECT_QUEUE_NAME)
public class JsonReceiver
{
    @RabbitHandler
    public void process(UserInfo userInfo)
    {
        System.out.println("接收者收到JSON格式消息：");
        System.out.println("用户编号：" + userInfo.getUserId());
        System.out.println("用户名称：" + userInfo.getUserName());
        System.out.println("博客地址：" + userInfo.getBlogUrl());
        System.out.println("博客信息：" + userInfo.getBlogRemark());
    }
}

Méthode 2: utiliser le mécanisme d'accusé de réception de message RabbitMQ (ACK)

Si le mécanisme d'accusé de réception de message (ACK) RabbitMQ est utilisé dans le projet, la méthode d'obtention des données au format Json est la suivante:

package com.pjb.receiver;

import com.fasterxml.jackson.databind.ObjectMapper;
import com.pjb.entity.UserInfo;
import com.rabbitmq.client.Channel;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.listener.api.ChannelAwareMessageListener;
import org.springframework.stereotype.Component;

/**
 * Ack接收者
 * @author pan_junbiao
 **/
@Component
public class AckReceiver implements ChannelAwareMessageListener
{
    @Override
    public void onMessage(Message message, Channel channel) throws Exception
    {
        long deliveryTag = message.getMessageProperties().getDeliveryTag();
        try
        {
            //将JSON格式数据转换为实体对象
            ObjectMapper mapper = new ObjectMapper();
            UserInfo userInfo = mapper.readValue(message.getBody(), UserInfo.class);

            System.out.println("接收者收到JSON格式消息：");
            System.out.println("用户编号：" + userInfo.getUserId());
            System.out.println("用户名称：" + userInfo.getUserName());
            System.out.println("博客地址：" + userInfo.getBlogUrl());
            System.out.println("博客信息：" + userInfo.getBlogRemark());

            //确认消息
            channel.basicAck(deliveryTag, true);
        }
        catch (Exception e)
        {
            e.printStackTrace();

            //拒绝消息
            channel.basicReject(deliveryTag, true);
        }
    }
}

Résultats de la:

2. Envoi et réception de données au format Map

(1) Créer un expéditeur (couche expéditeur)

Dans le package com.pjb.sender, créez un expéditeur et utilisez la méthode rabbitTemplate.convertAndSend () pour envoyer le message.

package com.pjb.sender;

import com.pjb.config.RabbitMqConfig;
import org.junit.jupiter.api.Test;
import org.springframework.amqp.AmqpException;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

import java.util.HashMap;
import java.util.Map;

/**
 * 发送Map数据
 * @author pan_junbiao
 **/
@SpringBootTest
public class MapSender
{
    @Autowired
    RabbitTemplate rabbitTemplate;

    @Test
    public void sender() throws AmqpException
    {
        //创建用户信息Map
        Map<String, Object> userMap = new HashMap<>();
        userMap.put("userId", "1");
        userMap.put("userName", "pan_junbiao的博客");
        userMap.put("blogUrl", "https://blog.csdn.net/pan_junbiao");
        userMap.put("userRemark", "您好，欢迎访问 pan_junbiao的博客");

        /**
         * 发送消息，参数说明：
         * String exchange：交换器名称。
         * String routingKey：路由键。
         * Object object：发送内容。
         */
        rabbitTemplate.convertAndSend(RabbitMqConfig.DIRECT_EXCHANGE_NAME, RabbitMqConfig.DIRECT_ROUTING_KEY, userMap);
        System.out.println("消息发送成功！");
    }
}

(2) Créer un récepteur (couche récepteur)

Méthode 1: utilisez les annotations traditionnelles @RabbitListener et @RabbitHandler pour obtenir la réception des messages.

Dans le package com.pjb.receiver, créez un récepteur et utilisez les annotations traditionnelles @RabbitListener et @RabbitHandler pour obtenir la réception des messages. Dans les paramètres de la méthode, RabbitMQ encapsulera automatiquement les données au format Map.

Notez que le nom de la file d'attente de l'expéditeur et du destinataire doit être le même, sinon le message ne peut pas être reçu.

package com.pjb.receiver;

import com.pjb.config.RabbitMqConfig;
import org.springframework.amqp.rabbit.annotation.RabbitHandler;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

import java.util.Map;

/**
 * 接收者
 * @author pan_junbiao
 **/
@Component
@RabbitListener(queues= RabbitMqConfig.DIRECT_QUEUE_NAME)
public class MapReceiver
{
    @RabbitHandler
    public void process(Map message)
    {
        System.out.println("接收者收到Map消息：");
        System.out.println("用户编号：" + message.get("userId"));
        System.out.println("用户名称：" + message.get("userName"));
        System.out.println("博客地址：" + message.get("blogUrl"));
        System.out.println("博客信息：" + message.get("userRemark"));
    }
}

Méthode 2: utiliser le mécanisme d'accusé de réception de message RabbitMQ (ACK)

Si le mécanisme d'accusé de réception de message (ACK) RabbitMQ est utilisé dans le projet, la méthode d'obtention des données au format Map est la suivante:

package com.pjb.receiver;

import com.fasterxml.jackson.databind.JavaType;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.rabbitmq.client.Channel;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.listener.api.ChannelAwareMessageListener;
import org.springframework.stereotype.Component;

import java.util.Map;

/**
 * Ack接收者
 * @author pan_junbiao
 **/
@Component
public class AckReceiver implements ChannelAwareMessageListener
{
    @Override
    public void onMessage(Message message, Channel channel) throws Exception
    {
        long deliveryTag = message.getMessageProperties().getDeliveryTag();
        try
        {
            //将JSON格式数据转换为Map对象
            ObjectMapper mapper = new ObjectMapper();
            JavaType javaType = mapper.getTypeFactory().constructMapType(Map.class, String.class, Object.class);
            Map<String, Object> resultMap = mapper.readValue(message.getBody(),javaType);

            System.out.println("接收者收到Map格式消息：");
            System.out.println("用户编号：" + resultMap.get("userId"));
            System.out.println("用户名称：" + resultMap.get("userName"));
            System.out.println("博客地址：" + resultMap.get("blogUrl"));
            System.out.println("博客信息：" + resultMap.get("userRemark"));

            //确认消息
            channel.basicAck(deliveryTag, true);
        }
        catch (Exception e)
        {
            e.printStackTrace();

            //拒绝消息
            channel.basicReject(deliveryTag, true);
        }
    }
}

Résultats de la:

RabbitMQ réalise l'envoi et la réception de données au format JSON et Map

1. Envoi et réception de données au format JSON

2. Envoi et réception de données au format Map

Je suppose que tu aimes