springboot 整合 rabbitmq

1. 什么是消息队列

消息（Message）是指在应用间传送的数据。消息可以非常简单，比如只包含文本字符串，也可以更复杂，可能包含嵌入对象。

消息队列（Message Queue）是一种应用间的通信方式，消息发送后可以立即返回，由消息系统来确保消息的可靠传递。消息发布者只管把消息发布到 MQ 中而不用管谁来取，消息使用者只管从 MQ 中取消息而不管是谁发布的。这样发布者和使用者都不用知道对方的存在。

市面上的消息队列产品有很多，比如老牌的 ActiveMQ、RabbitMQ、kafka，本文主要是讲rabbitMq。

2. rabbitmq 使用场景

3. rabbitmq 介绍

3.1 RabbitMQ 特点

RabbitMQ 是一个由 Erlang 语言开发的 AMQP 的开源实现。

AMQP ：Advanced Message Queue，高级消息队列协议。它是应用层协议的一个开放标准，为面向消息的中间件设计，基于此协议的客户端与消息中间件可传递消息，并不受产品、开发语言等条件的限制。

RabbitMQ 最初起源于金融系统，用于在分布式系统中存储转发消息，在易用性、扩展性、高可用性等方面表现不俗。具体特点包括：

1. 可靠性（Reliability）
   RabbitMQ 使用一些机制来保证可靠性，如持久化、传输确认、发布确认。

2. 灵活的路由（Flexible Routing）
   在消息进入队列之前，通过 Exchange 来路由消息的。对于典型的路由功能，RabbitMQ 已经提供了一些内置的 Exchange 来实现。针对更复杂的路由功能，可以将多个 Exchange 绑定在一起，也通过插件机制实现自己的 Exchange 。

3. 消息集群（Clustering）
   多个 RabbitMQ 服务器可以组成一个集群，形成一个逻辑 Broker 。

4. 高可用（Highly Available Queues）
   队列可以在集群中的机器上进行镜像，使得在部分节点出问题的情况下队列仍然可用。

5. 多种协议（Multi-protocol）
   RabbitMQ 支持多种消息队列协议，比如 STOMP、MQTT 等等。

6. 多语言客户端（Many Clients）
   RabbitMQ 几乎支持所有常用语言，比如 Java、.NET、Ruby 等等。

7. 管理界面（Management UI）
   RabbitMQ 提供了一个易用的用户界面，使得用户可以监控和管理消息 Broker 的许多方面。

8. 跟踪机制（Tracing）
   如果消息异常，RabbitMQ 提供了消息跟踪机制，使用者可以找出发生了什么。

9. 插件机制（Plugin System）
   RabbitMQ 提供了许多插件，来从多方面进行扩展，也可以编写自己的插件。

3.2 交换机类型

3.2.1 fanout

Fanout 不处理路由键。你只需要简单的将队列绑定到交换机上。一个发送到该类型交换机的消息都会被广播到与该交换机绑定的所有队列上。

3.2.2 direct

处理路由键，需要将一个队列绑定到交换机上，要求该消息与一个特定的路由键完全匹配。这是一个完整的匹配。如果一个队列绑定到该交换机上要求路由键为 “info”，则只有路由键为“info”的消息才被转发，不会转发路由键为"error"，只会转发路由键为"info"。

3.2.3 topic

动态路由。将路由键和某模式进行匹配。此时队列需要绑定要一个模式上。符号“#”匹配一个或多个词，符号“*”只能匹配一个词。

3.2.3 Headers

headers 类型的 Exchange 不依赖于 routing key 与 binding key 的匹配规则来路由消
息，而是根据发送的消息内容中的 headers 属性进行匹配。

4.springboot 下 rabbitmq的使用

首先需要导入的Maven包：

<dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-amqpartifactId>
        dependency>
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-testartifactId>
        dependency>
        <dependency>
            <groupId>org.projectlombokgroupId>
            <artifactId>lombokartifactId>
        dependency>

4.1 fanout

生产者

@Test
    public void springBootRabbitMqFanoutTest(){
        rabbitTemplate.convertAndSend("fanoutModel","","springboot fanout rabbitmq");
    }

fanout在消费者中定义：

@Component
public class RabbitMqFanoutListener {
    // rabbitMq监听
    @RabbitListener(bindings = {
            // 队列绑定
            @QueueBinding(
                    value = @Queue, // 队列名称，这里设置为临时队列
                    exchange = @Exchange(value = "fanoutModel",type = ExchangeTypes.FANOUT)  // 交换机定义
            )
    })
    public void receive1(String msg){
        System.out.println("msg1 = " + msg);
    }

    @RabbitListener(bindings = {
            @QueueBinding(
                    value = @Queue,
                    exchange = @Exchange(value = "fanoutModel",type = ExchangeTypes.FANOUT)
            )
    })
    public void receive2(String msg){
        System.out.println("msg2 = " + msg);
    }
}

4.2 direct

生产者：

@Test
    public void springBootRabbitMqDirectTest(){
        rabbitTemplate.convertAndSend("directModel","info","info 信息");
    }

消费者：

@Component
public class RabbitMqDirectListener {
    @RabbitListener(bindings = {
            @QueueBinding(
                    value = @Queue,
                    exchange = @Exchange(value = "directModel",type = ExchangeTypes.DIRECT),
                    key = {
                            "info"
                    }
            )
    })
    public void receive1(String msg){
        System.out.println("msg = " + msg);
    }

    @RabbitListener(bindings = {
            @QueueBinding(
                    value = @Queue,
                    exchange = @Exchange(value = "directModel",type = ExchangeTypes.DIRECT),
                    key = {
                            "warn",
                            "error"
                    }
            )
    })
    public void receive2(String msg){
        System.out.println("msg = " + msg);
    }

    @RabbitListener(bindings = {
            @QueueBinding(
                    value = @Queue,
                    exchange = @Exchange(value = "directModel",type = ExchangeTypes.DIRECT),
                    key = {
                            "debug"
                    }
            )
    })
    public void receive3(String msg){
        System.out.println("msg = " + msg);
    }
}

4.3 topic

生产者：

@Test
    public void springBootRabbitMqTopicTest(){
        rabbitTemplate.convertAndSend("topicModel","amqp.test.info","Topic 动态路由");
    }

消费者：

@Component
@Slf4j
public class RabbitMqTopicListener {
    @RabbitListener(bindings = {
            @QueueBinding(
                    value = @Queue,
                    exchange = @Exchange(value = "topicModel", type = ExchangeTypes.TOPIC),
                    key = {
                            "*.test.*"
                    }
            )
    })
    public void receive(String content, Channel channel, Message message) {
        log.info("content = {}", content);
    }
}

4.4 手动ack

新增SpringBoot配置文件YAML，这里主要将自动ACK修改为手工ACK并且开启消息确认模式与消息回退：

spring:
  rabbitmq:
    listener:
        acknowledge-mode: manual # MANUAL:手动处理 AUTO:自动处理
    # NONE值是禁用发布确认模式，是默认值
    # CORRELATED值是发布消息成功到交换器后会触发回调方法，如1示例
    # SIMPLE值经测试有两种效果，其一效果和CORRELATED值一样会触发回调方法，其二在发布消息成功后使用rabbitTemplate调用waitForConfirms或waitForConfirmsOrDie方法等待broker节点返回发送结果，根据返回结果来判定下一步的逻辑，要注意的点是waitForConfirmsOrDie方法如果返回false则会关闭channel，则接下来无法发送消息到broker;
    publisher-confirm-type: simple #消息确认机制
    publisher-returns: true # 消息回退确认机制

消费者：

@Component
@Slf4j
public class RabbitMqTopicListener {
    @RabbitListener(bindings = {
            @QueueBinding(
                    value = @Queue,
                    exchange = @Exchange(value = "topicModel", type = ExchangeTypes.TOPIC),
                    key = {
                            "*.test.*"
                    }
            )
    })

    /**
     * @param content:监听到的信息
     * @param channel:绑定的队列
     * @param message
     */
    public void receive(String content, Channel channel, Message message) throws IOException {
        try {
            log.info("content = {}", content);
            channel.basicAck(message.getMessageProperties().getDeliveryTag(),false);
        }catch (Exception e){
            channel.basicNack(message.getMessageProperties().getDeliveryTag(),false,true);
            e.printStackTrace();
        }
    }
}