SpringBoot集成RabbitMQ

最新推荐文章于 2024-03-18 13:39:46 发布

handbang

最新推荐文章于 2024-03-18 13:39:46 发布

阅读量133

点赞数

分类专栏： RabbitMq

本文链接：https://blog.csdn.net/qq_24848931/article/details/104468398

版权

RabbitMq 专栏收录该内容

3 篇文章 0 订阅

订阅专栏

spring boot版本

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.2.2.RELEASE</version>
    <relativePath/> <!-- lookup parent from repository -->
</parent>

首先创建一个生产者rabbitmq-provider，yml配置如下：

server:
  port: 8021
  servlet:
    application-display-name: rabbitmq-provider
    context-path: /rabbitmq-provider
    session:
      timeout: 30m
spring:
  application:
    name: ${server.servlet.application-display-name}
  rabbitmq:
    sys-name: ${server.servlet.application-display-name}
    host: 127.0.0.1
    port: 5672
    username: guest
    password: guest
    virtual-host: /
    publisher-confirms: true #支持发布确认
    publisher-returns: true  #支持发布返回
    listener:
      simple:
        acknowledge-mode: manual #采用手动应答
        retry:
          enabled: true #是否支持重试
          initial-interval: 1000 # 第一次和第二次 尝试发布或交付(此处是消费者交付,template.retry中是消费者发布)的 间隔时间
          max-interval: 10000   # 两次重试的最大间隔
          max-attempts: 1  # 尝试发布或交付的 最大次数(重试次数)
          multiplier: 1.0  # 每次重试都比上一次重试间隔时长大x倍
          stateless: true  # 重试是无状态还是有状态的

pom.xml:

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-amqp</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>
java版本:

```java
<properties>
    <java.version>1.8</java.version>
</properties>

创建一个消费者 rabbitmq-consumer：
yml文件

server:
  port: 8022
  servlet:
    application-display-name: rabbitmq-consumer
    context-path: /rabbitmq-consumer
    session:
      timeout: 30m
spring:
  application:
    name: ${server.servlet.application-display-name}
  rabbitmq:
    sys-name: ${server.servlet.application-display-name}
    host: 127.0.0.1
    port: 5672
    username: guest
    password: guest
    virtual-host: /
    publisher-confirms: true #支持发布确认
    publisher-returns: true  #支持发布返回
    listener:
      simple:
        acknowledge-mode: manual #采用手动应答
        retry:
          enabled: true #是否支持重试
          initial-interval: 1000 # 第一次和第二次 尝试发布或交付(此处是消费者交付,template.retry中是消费者发布)的 间隔时间
          max-interval: 10000   # 两次重试的最大间隔
          max-attempts: 1  # 尝试发布或交付的 最大次数(重试次数)
          multiplier: 1.0  # 每次重试都比上一次重试间隔时长大x倍
          stateless: true  # 重试是无状态还是有状态的

pom文件与jdk与生产者相同。

Direct Exchange例子：
创建配置文件：

import org.springframework.amqp.core.Binding;
import org.springframework.amqp.core.BindingBuilder;
import org.springframework.amqp.core.DirectExchange;
import org.springframework.amqp.core.Queue;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * 方法名:          DirectRabbitConfig
 * 方法功能描述:
 *
 * @param:
 * @return:
 * @Author: 
 * @Create Date:   2019/12/19
 */
@Configuration
public class DirectRabbitConfig {
    //队列 起名：TestDirectQueue
    @Bean
    public Queue TestDirectQueue() {
        return new Queue("TestDirectQueue",true);  //true 是否持久
    }

    //Direct交换机 起名：TestDirectExchange
    @Bean
    DirectExchange TestDirectExchange() {
        return new DirectExchange("TestDirectExchange");
    }

    //绑定  将队列和交换机绑定, 并设置用于匹配键：TestDirectRouting
    @Bean
    Binding bindingDirect() {
        return BindingBuilder.bind(TestDirectQueue()).to(TestDirectExchange()).with("TestDirectRouting");
    }

}

创建发送消息的Rest

import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.HashMap;
import java.util.Map;
import java.util.UUID;

/**
 * 方法名:          SendMessageController
 * 方法功能描述:
 *
 * @param:
 * @return:
 * @Author: 陈超
 * @Create Date:   2019/12/19
 */
@RestController
public class SendMessageController {

    @Autowired
    RabbitTemplate rabbitTemplate;  //使用RabbitTemplate,这提供了接收/发送等等方法

    @GetMapping("/sendDirectMessage")
    public String sendDirectMessage() {
        String messageId = String.valueOf(UUID.randomUUID());
        String messageData = "test message, hello!";
        String createTime = LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
        Map<String, Object> map = new HashMap<>();
        map.put("messageId", messageId);
        map.put("messageData", messageData);
        map.put("createTime", createTime);
        //将消息携带绑定键值：TestDirectRouting 发送到交换机TestDirectExchange
        rabbitTemplate.convertAndSend("TestDirectExchange", "TestDirectRouting", map);
        return "ok";
    }
}

在这里插入图片描述
启动项目运行，返回OK说明发送消息成功

打开http://localhost:15672/#/queues
队列TestDirectQueue已经加入到消息队列中。
现在使用消费者来消费消息，同样的创建DirectRabbitConfig类，与生产者的相同。
创建接收消息的类：

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

import java.util.Map;

/**
 * 方法名:          DirectReceiver
 * 方法功能描述:
 *
 * @param:
 * @return:
 * @Author: cc
 * @Create Date:   2019/12/20
 */

@Component
@RabbitListener(queues = "TestDirectQueue")//监听的队列名称 TestDirectQueue
public class DirectReceiver {

    @RabbitHandler
    public void process(Map testMessage) {
        System.out.println("DirectReceiver消费者收到消息  : " + testMessage.toString());
    }

}

现在已经将生产者与消费者都准备好，启动消费者rabbitmq-consumer，RabbitListener监听器会监听名称为“TestDirectQueue”的队列，将消息接收打印。
在这里插入图片描述
同时，生产者发送消息，消费者也会显示发送的消息。

Topic Exchange举例：

首先回顾，topic是按照通配符的方式来进行匹配的。
在生产者中加入配置文件TopicRabbitConfig：

import org.springframework.amqp.core.Binding;
import org.springframework.amqp.core.BindingBuilder;
import org.springframework.amqp.core.Queue;
import org.springframework.amqp.core.TopicExchange;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * 方法名:          TopicRabbitConfig
 * 方法功能描述:
 *
 * @param:
 * @return:
 * @Author: 陈超
 * @Create Date:   2019/12/20
 */
@Configuration
public class TopicRabbitConfig {

    //绑定键
    public static final String red = "topic.red";
    public static final String green = "topic.green";

    @Bean
    public Queue firstQueue() {
        return new Queue(TopicRabbitConfig.red);
    }

    @Bean
    public Queue secondQueue() {
        return new Queue(TopicRabbitConfig.green);
    }

    @Bean
    TopicExchange exchange() {
        return new TopicExchange("topicExchange");
    }


    //将firstQueue和topicExchange绑定,而且绑定的键值为topic.red
    //这样只要是消息携带的路由键是topic.red,才会分发到该队列
    @Bean
    Binding bindingExchangeMessage() {
        return BindingBuilder.bind(firstQueue()).to(exchange()).with(red);
    }

    //将secondQueue和topicExchange绑定,而且绑定的键值为用上通配路由键规则topic.#
    // 这样只要是消息携带的路由键是以topic.开头,都会分发到该队列
    @Bean
    Binding bindingExchangeMessage2() {
        return BindingBuilder.bind(secondQueue()).to(exchange()).with("topic.#");
    }

}

也就是secondQueue绑定了"topic.green"，而secondQueue绑定了bindingExchangeMessage2。那么green就可以按照topic的规则进行适配。
创建发送机：

@GetMapping("/sendTopicMessageRed")
public String sendTopicMessageRed() {
    String messageId = String.valueOf(UUID.randomUUID());
    String messageData = "红灯消息 RED";
    String createTime = LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
    Map<String, Object> redMap = new HashMap<>();
    redMap.put("messageId", messageId);
    redMap.put("messageData", messageData);
    redMap.put("createTime", createTime);
    rabbitTemplate.convertAndSend("topicExchange", "topic.red", redMap);
    return "ok";
}

@GetMapping("/sendTopicMessageGreen")
public String sendTopicMessageGreen() {
    String messageId = String.valueOf(UUID.randomUUID());
    String messageData = "绿灯与红灯消息 ";
    String createTime = LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
    Map<String, Object> greenMap = new HashMap<>();
    greenMap.put("messageId", messageId);
    greenMap.put("messageData", messageData);
    greenMap.put("createTime", createTime);
    rabbitTemplate.convertAndSend("topicExchange", "topic.green", greenMap);
    return "ok";
}
接下来在消费者中创建同样的配置类TopicRabbitConfig。创建接收机
@Component
@RabbitListener(queues = "topic.red")
public class TopicRedReceiver {

    @RabbitHandler
    public void process(Map testMessage) {
        System.out.println("TopicRedReceiver  : " + testMessage.toString());
    }
}

@Component
@RabbitListener(queues = "topic.green")
public class TopicGreenReceiver {

    @RabbitHandler
    public void process(Map testMessage) {
        System.out.println("TopicGreenReceiver  : " + testMessage.toString());
    }
}

接下来发送消息：
生产者发送红灯消息，调用
在这里插入图片描述
消费者接收到

可以看出绿灯的接收者也接受到红灯消息，这是因为我们在TopicRabbitConfig 配置中的

//将secondQueue和topicExchange绑定,而且绑定的键值为用上通配路由键规则topic.#
    // 这样只要是消息携带的路由键是以topic.开头,都会分发到该队列
    @Bean
    Binding bindingExchangeMessage2() {
        return BindingBuilder.bind(secondQueue()).to(exchange()).with("topic.#");
    }

发挥了作用。
现在发送绿灯消息
在这里插入图片描述

只接收到了绿灯消息，因为红灯的接收机没有进行适配。

Fanout Exchang 适配器

创建配置文件：

import org.springframework.amqp.core.Binding;
import org.springframework.amqp.core.BindingBuilder;
import org.springframework.amqp.core.FanoutExchange;
import org.springframework.amqp.core.Queue;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * 方法名:          FanoutRabbitConfig
 * 方法功能描述:
 *
 * @param:
 * @return:
 * @Author: 
 * @Create Date:   2019/12/20
 */

@Configuration
public class FanoutRabbitConfig {

    /**
     *  创建三个队列 ：fanout.A   fanout.B  fanout.C
     *  将三个队列都绑定在交换机 fanoutExchange 上
     *  因为是扇型交换机, 路由键无需配置,配置也不起作用
     */


    @Bean
    public Queue queueA() {
        return new Queue("fanout.A");
    }

    @Bean
    public Queue queueB() {
        return new Queue("fanout.B");
    }

    @Bean
    public Queue queueC() {
        return new Queue("fanout.C");
    }

    @Bean
    FanoutExchange fanoutExchange() {
        return new FanoutExchange("fanoutExchange");
    }

    @Bean
    Binding bindingExchangeA() {
        return BindingBuilder.bind(queueA()).to(fanoutExchange());
    }

    @Bean
    Binding bindingExchangeB() {
        return BindingBuilder.bind(queueB()).to(fanoutExchange());
    }

    @Bean
    Binding bindingExchangeC() {
        return BindingBuilder.bind(queueC()).to(fanoutExchange());
    }
}

在生产者中创建发送方法：

@GetMapping("/sendFanoutMessage")
public String sendFanoutMessage() {
    String messageId = String.valueOf(UUID.randomUUID());
    String messageData = "message: testFanoutMessage ";
    String createTime = LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
    Map<String, Object> map = new HashMap<>();
    map.put("messageId", messageId);
    map.put("messageData", messageData);
    map.put("createTime", createTime);
    rabbitTemplate.convertAndSend("fanoutExchange", null, map);
    return "ok";
}

交换机指向了创建的交换机fanoutExchange。
接下来是消费者
同样创建配置文件FanoutRabbitConfig ，与生产者的相同
创建接受类

@Component
@RabbitListener(queues = "fanout.A")
public class FanoutReceiverA {

    @RabbitHandler
    public void process(Map testMessage) {
        System.out.println("FanoutReceiverA消费者收到消息  : " +testMessage.toString());
    }
}

@Component
@RabbitListener(queues = "fanout.B")
public class FanoutReceiverB {

    @RabbitHandler
    public void process(Map testMessage) {
        System.out.println("FanoutReceiverB消费者收到消息  : " +testMessage.toString());
    }

}

@Component
@RabbitListener(queues = "fanout.C")
public class FanoutReceiverC {

    @RabbitHandler
    public void process(Map testMessage) {
        System.out.println("FanoutReceiverC消费者收到消息  : " +testMessage.toString());
    }

}

创建好之后调用生产者中的发送消息的方法sendFanoutMessage。
在这里插入图片描述

三个方法都接受到，说明扇形交换器成功

RabbirMQ消息的回调与消息的确认

在application.yml添加配置项

rabbitmq:
  sys-name: ${server.servlet.application-display-name}
  host: 127.0.0.1
  port: 5672
  username: guest
  password: guest
  virtual-host: /
  publisher-confirm-type: correlated #确认消息已发送到交换机
  publisher-returns: true  #确认消息已发送到队列(Queue)

在生产者中添加RabbitConfig配置

import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.connection.ConnectionFactory;
import org.springframework.amqp.rabbit.connection.CorrelationData;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * 方法名:          RabbitConfig
 * 方法功能描述:
 *
 * @param:
 * @return:
 * @Author: 
 * @Create Date:   2019/12/23
 */

@Configuration
public class RabbitConfig {

    @Bean
    public RabbitTemplate createRabbitTemplate(ConnectionFactory connectionFactory) {
        RabbitTemplate rabbitTemplate = new RabbitTemplate();
        rabbitTemplate.setConnectionFactory(connectionFactory);
        //设置开启Mandatory,才能触发回调函数,无论消息推送结果怎么样都强制调用回调函数
        rabbitTemplate.setMandatory(Boolean.TRUE);

        rabbitTemplate.setConfirmCallback(new RabbitTemplate.ConfirmCallback() {
            @Override
            public void confirm(CorrelationData correlationData, boolean b, String s) {
                System.out.println("ConfirmCallback:     " + "相关数据：" + correlationData);
                System.out.println("ConfirmCallback:     " + "确认情况：" + b);
                System.out.println("ConfirmCallback:     " + "原因：" + s);
            }
        });

        rabbitTemplate.setReturnCallback(new RabbitTemplate.ReturnCallback() {
            @Override
            public void returnedMessage(Message message, int replyCode, String replyText, String exchange, String routingKey) {
                System.out.println("ReturnCallback:     " + "消息：" + message);
                System.out.println("ReturnCallback:     " + "回应码：" + replyCode);
                System.out.println("ReturnCallback:     " + "回应信息：" + replyText);
                System.out.println("ReturnCallback:     " + "交换机：" + exchange);
                System.out.println("ReturnCallback:     " + "路由键：" + routingKey);
            }
        });
        return rabbitTemplate;
    }
}

到这里，生产者推送消息的消息确认调用回调函数已经完毕。
可以看到上面写了两个回调函数，一个叫 ConfirmCallback ，一个叫 RetrunCallback；
那么以上这两种回调函数都是在什么情况会触发呢？

先从总体的情况分析，推送消息存在四种情况：

①消息推送到server，但是在server里找不到交换机
②消息推送到server，找到交换机了，但是没找到队列
③消息推送到sever，交换机和队列啥都没找到
④消息推送成功

测试①消息推送到server，但是在server里找不到交换机这种情况：
写个测试接口，把消息推送到名为‘non-existent-exchange’的交换机上（这个交换机是没有创建没有配置的）

@GetMapping("/TestMessageAck")
public String TestMessageAck() {
    String messageId = String.valueOf(UUID.randomUUID());
    String messageData = "message: non-existent-exchange test message ";
    String createTime = LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
    Map<String, Object> map = new HashMap<>();
    map.put("messageId", messageId);
    map.put("messageData", messageData);
    map.put("createTime", createTime);
    rabbitTemplate.convertAndSend("non-existent-exchange", "TestDirectRouting", map);
    return "ok";
}

调用接口：
在这里插入图片描述
返回消息

报错未找到该交换机，ConfirmCallback发挥作用。

测试②消息推送到server，找到交换机了，但是没找到队列这种情况
这种情况就是需要新增一个交换机，但是不给这个交换机绑定队列，我来简单地在DirectRabitConfig里面新增一个直连交换机，名叫‘lonelyDirectExchange’，但没给它做任何绑定配置操作：

@Bean
DirectExchange lonelyDirectExchange() {
    return new DirectExchange("lonelyDirectExchange");
}

然后写个测试接口，把消息推送到名为‘lonelyDirectExchange’的交换机上（这个交换机是没有任何队列配置的）：

@GetMapping("/TestMessageAckLoneLy")
public String TestMessageAckLoneLy() {
    String messageId = String.valueOf(UUID.randomUUID());
    String messageData = "message: lonelyDirectExchange test message ";
    String createTime = LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
    Map<String, Object> map = new HashMap<>();
    map.put("messageId", messageId);
    map.put("messageData", messageData);
    map.put("createTime", createTime);
    rabbitTemplate.convertAndSend("lonelyDirectExchange", "TestDirectRouting", map);
    return "ok";
}

调用接口：

在这里插入图片描述
发挥了作用。这种情况下，消息是推送成功到服务器了的，所以ConfirmCallback对消息确认情况是true；
而在RetrunCallback回调函数的打印参数里面可以看到，消息是推送到了交换机成功了，但是在路由分发给队列的时候，找不到队列，所以报了错误 NO_ROUTE 。
结论：②这种情况触发的是 ConfirmCallback和RetrunCallback两个回调函数。

测试③消息推送到sever，交换机和队列啥都没找到
这种情况其实一看就觉得跟①很像，没错，③和①情况回调是一致的，所以不做结果说明了。
结论： ③这种情况触发的是 ConfirmCallback 回调函数。

测试④消息推送成功
在这里插入图片描述
结论： ④这种情况触发的是 ConfirmCallback 回调函数。
以上是生产者推送消息的消息确认回调函数的使用介绍（可以在回调函数根据需求做对应的扩展或者业务数据处理）。

接下来我们测试消费者接到消息的消息确认机制
和生产者的消息确认机制不同，因为消息接收本来就是在监听消息，符合条件的消息就会消费下来。
所以，消息接收的确认机制主要存在三种模式：

①自动确认，这也是默认的消息确认情况。 AcknowledgeMode.NONE
RabbitMQ成功将消息发出（即将消息成功写入TCP Socket）中立即认为本次投递已经被正确处理，不管消费者端是否成功处理本次投递。
所以这种情况如果消费端消费逻辑抛出异常，也就是消费端没有处理成功这条消息，那么就相当于丢失了消息。
一般这种情况我们都是使用try catch捕捉异常后，打印日志用于追踪数据，这样找出对应数据再做后续处理。

② 不确认，这个不做介绍
③ 手动确认，这个比较关键，也是我们配置接收消息确认机制时，多数选择的模式。
消费者收到消息后，手动调用basic.ack/basic.nack/basic.reject后，RabbitMQ收到这些消息后，才认为本次投递成功。
basic.ack用于肯定确认
basic.nack用于否定确认（注意：这是AMQP 0-9-1的RabbitMQ扩展）
basic.reject用于否定确认，但与basic.nack相比有一个限制:一次只能拒绝单条消息
消费者端以上的3个方法都表示消息已经被正确投递，但是basic.ack表示消息已经被正确处理，但是basic.nack,basic.reject表示没有被正确处理，但是RabbitMQ中仍然需要删除这条消息。

之前介绍用了很多个交换，现在我们就先给直连型交换机添加消息接收确认机制，
新建MessageListenerConfig.java上添加代码相关的配置代码（可以看到注释掉的代码，就是给扇型交换机配置消息确认，只用在这个里面继续添加对应的队列和对应的接收类即可，当然对应的接收类也需要跟后面介绍一样加上对应方法）：

import com.cc.mq.client.DirectReceiver;
import org.springframework.amqp.core.AcknowledgeMode;
import org.springframework.amqp.core.MessageListener;
import org.springframework.amqp.rabbit.connection.CachingConnectionFactory;
import org.springframework.amqp.rabbit.listener.SimpleMessageListenerContainer;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * 方法名:          MessageListenerConfig
 * 方法功能描述:
 *
 * @param:
 * @return:
 * @Author: 
 * @Create Date:   2019/12/23
 */
@Configuration
public class MessageListenerConfig {

    @Autowired
    private CachingConnectionFactory connectionFactory;
    @Autowired
    private DirectReceiver directReceiver;//Direct消息接收处理类
    @Autowired
    DirectRabbitConfig directRabbitConfig;
    @Bean
    public SimpleMessageListenerContainer simpleMessageListenerContainer() {
        SimpleMessageListenerContainer container = new SimpleMessageListenerContainer(connectionFactory);
        container.setConcurrentConsumers(1);
        container.setMaxConcurrentConsumers(1);
        container.setAcknowledgeMode(AcknowledgeMode.MANUAL); // RabbitMQ默认是自动确认，这里改为手动确认消息
        container.setQueues(directRabbitConfig.TestDirectQueue());
        container.setMessageListener(directReceiver);
        return container;
    }

}

这里的DirectReceiver 是我们之前创建的接受类。

然后在直连型交换机的消息接收处理类上需要添加相关的消息手动确认代码DirectReceiver.java：

@Component
@RabbitListener(queues = "TestDirectQueue")//监听的队列名称 TestDirectQueue
public class DirectReceiver implements ChannelAwareMessageListener {

    @RabbitHandler
    public void process(Map testMessage) {
        System.out.println("DirectReceiver消费者收到消息  : " + testMessage.toString());
    }

    @Override
    public void onMessage(Message message, Channel channel) throws Exception {
        long deliveryTag = message.getMessageProperties().getDeliveryTag();
        try {
            //因为传递消息的时候用的map传递,所以将Map从Message内取出需要做些处理
            String msg = message.toString();
            String[] msgArray = msg.split("'");//可以点进Message里面看源码,单引号直接的数据就是我们的map消息数据
            Map<String, String> msgMap = this.mapStringToMap(msgArray[1].trim());
            String messageId=msgMap.get("messageId");
            String messageData=msgMap.get("messageData");
            String createTime=msgMap.get("createTime");
            System.out.println("messageId:"+messageId+"  messageData:"+messageData+"  createTime:"+createTime);
            channel.basicAck(deliveryTag, true);
//       channel.basicReject(deliveryTag, true);//为true会重新放回队列
        } catch (Exception e) {
            channel.basicReject(deliveryTag, false);
            e.printStackTrace();
        }

    }
    
    //这种解析方式是有问题的，在生产的时候不要这样做
    private Map<String, String> mapStringToMap(String str) {
        str = str.substring(1, str.length() - 1);
        String[] strs = str.split(",");
        Map<String, String> map = new HashMap<String, String>();
        for (String string : strs) {
            String key = string.split("=")[0].trim();
            String value = string.split("=")[1];
            map.put(key, value);
        }
        return map;
    }

}

然后现在将rabbitmq-provider 、rabbitmq-consumer两个项目跑起来，调用下/sendDirectMessage接口往直连型交换机推送一条消息，看看监听到的消息结果：
在这里插入图片描述
手动的确认模式的投递效率略低于自动，但是可以弥补自动确认模式的不足，更加准确地去记录消息消费情况。

那么如果需要有些消息接收类设置自动确认，有些消息接收类设置手动确认的话，那只需要将需要设置手动确认的相关队列加到之前的MessageListenerConfig的SimpleMessageListenerContainer里面就行。

handbang

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
SpringBoot集成RabbitMQ

spring boot版本<parent> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-parent</artifactId> <version>2.2.2.RELEASE</versio...
复制链接

扫一扫

专栏目录