RabbitMQ es actualmente un middleware de mensajes muy popular, que se usa ampliamente tanto en la industria de Internet como en las industrias tradicionales. RabbitMQ es favorecido por más y más empresas debido a su alta confiabilidad, fácil expansión, alta disponibilidad y características completas. Al realizar el desarrollo del proyecto, a menudo se utilizan datos en formato Json y Map. A continuación se presentará a RabbitMQ para realizar el envío y la recepción de datos en formato Json y Map.

(1) Cree el proyecto SpringBoot e integre el marco RabbitMQ

En el archivo de información de configuración pom.xml, agregue los archivos dependientes relacionados:

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

Configure el servicio RabbitMQ en el archivo de configuración 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) Clase de configuración RabbitMQ

En el proyecto, cree una clase de configuración, configure la confirmación del mensaje, el convertidor Json, el nombre de la cola, etc., y entregue la cola a la administración de IoC. el código se muestra a continuación:

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. Envío y recepción de datos en formato JSON

(1) Cree una clase de entidad (capa de entidad)

En el paquete com.pjb.entity, cree una clase UserInfo (clase de entidad de información del usuario).

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) Crear un remitente (capa de remitente)

En el paquete com.pjb.sender, cree un remitente y use el método rabbitTemplate.convertAndSend () para enviar el mensaje.

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) Cree un receptor (capa de receptor)

Método 1: use las anotaciones tradicionales @RabbitListener y @RabbitHandler para lograr la recepción del mensaje.

En el paquete com.pjb.receiver, cree un receptor y use las anotaciones tradicionales @RabbitListener y @RabbitHandler para lograr la recepción de mensajes. Entre los parámetros del método, RabbitMQ convertirá automáticamente los parámetros JSON en clases de objetos de entidad.

Tenga en cuenta que el nombre de la cola del remitente y el destinatario debe ser el mismo; de lo contrario, no se podrá recibir el mensaje.

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étodo 2: utilizar el mecanismo de reconocimiento de mensajes de RabbitMQ (ACK)

Si en el proyecto se utiliza el mecanismo de reconocimiento de mensajes (ACK) de RabbitMQ, el método para obtener datos en formato Json es el siguiente:

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

Resultados del:

2. Envío y recepción de datos en formato de mapa

(1) Crear un remitente (capa de remitente)

En el paquete com.pjb.sender, cree un remitente y use el método rabbitTemplate.convertAndSend () para enviar el mensaje.

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) Cree un receptor (capa de receptor)

Método 1: use las anotaciones tradicionales @RabbitListener y @RabbitHandler para lograr la recepción del mensaje.

En el paquete com.pjb.receiver, cree un receptor y use las anotaciones tradicionales @RabbitListener y @RabbitHandler para lograr la recepción de mensajes. En los parámetros del método, RabbitMQ encapsulará automáticamente los datos en formato de mapa.

Tenga en cuenta que el nombre de la cola del remitente y el destinatario debe ser el mismo; de lo contrario, no se podrá recibir el mensaje.

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étodo 2: utilizar el mecanismo de reconocimiento de mensajes de RabbitMQ (ACK)

Si se utiliza el mecanismo de reconocimiento de mensajes (ACK) de RabbitMQ en el proyecto, el método para obtener datos en formato de mapa es el siguiente:

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

Resultados del:

RabbitMQ realiza el envío y la recepción de datos en formato JSON y Map

1. Envío y recepción de datos en formato JSON

2. Envío y recepción de datos en formato de mapa

Supongo que te gusta