【RabbitMQ】- 基础原理及实战应用-优快云博客

本文链接：https://blog.youkuaiyun.com/weixin_44977377/article/details/131887088

文章目录

源码获取地址

文章前言

文末获取【RabbitMQ基础原理及实战应用】Github仓库实战源码
【RabbitMQ基础原理及实战应用】有概念有实战，考验动手能力，如果实战中有操作没有达到与本文同等效果的请先仔细检查个人操作与文中相关内容是否一致，如检查无误请私信或评论区留言~

在这里插入图片描述

简介

RabbitMQ是实现了高级消息队列协议（AMQP）的开源消息代理软件（亦称面向消息的中间件）。RabbitMQ服务器是用Erlang语言编写的，而集群和故障转移是构建在开放电信平台框架上的。所有主要的编程语言均有与代理接口通讯的客户端库。

由于RabbitMQ是基于AMQP协议开发，所以RabbitMQ支持很多基于AMQP协议的功能，比如SpringCloud Bus

AMQP协议

AMQP 0-9-1（高级消息队列协议）是一种符合客户端应用程序的消息传递协议与符合传递标准的消息中间件进行通信代理。

AMQP 0-9-1 模型

通过交换和队列发布从发布者到消费者的路径

根据AMQP 0-9-1 模型可得,我们首先得具备消息的发布者Publisher和消息消费方Consumer，然后由发布者将消息发布到RabiitMQ的交换机(Exchange)上，再由交换机根据某些路由规则(Routes)将消息发送到某一个队列(Queue)上，最后由监听这个队列的消费者对消息进行消费

RabbitMQ整体架构

在RabbitMQ服务中存在一个或多个Virtual Host，在每个Virtual Host中又存在一个/多个Exchange，Publisher要与Virtual Host建立连接，然后通过Channel将消息发送到这些Exchange交换机中，再由交换机通过不同的路由规则将消息递送到对应的消息队列中，最后由Consumer与Virtual Host建立连接，再通过Channel管道将它所监听的队列中的消息拿出来进行消费

七种通讯方式

Hello World

官网模型 :一个生产者，一个消费者，使用默认交换机，自行创建队列

示例代码

创建连接工具类

package com.rhys.rabbitmq.utils;

import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;

/**
 * @author Rhys.Ni
 * @version 1.0
 * @date 2022/11/22 3:02 AM
 */
public class ConnectionUtil {
    public static final String RABBITMQ_HOST = "127.0.0.1";

    public static final int RABBITMQ_PORT = 5672;

    public static final String RABBITMQ_USERNAME = "guest";

    public static final String RABBITMQ_PASSWORD = "guest";

    public static final String RABBITMQ_VIRTUAL_HOST = "/";

    /**
     * 构建RabbitMQ的连接对象
     *
     * @return Connection
     * @author Rhys.Ni
     * @date 2022/11/22
     */
    public static Connection getConnection() throws Exception {
        //1. 创建Connection工厂
        ConnectionFactory factory = new ConnectionFactory();

        //2. 设置RabbitMQ的连接信息
        factory.setHost(RABBITMQ_HOST);
        factory.setPort(RABBITMQ_PORT);
        factory.setUsername(RABBITMQ_USERNAME);
        factory.setPassword(RABBITMQ_PASSWORD);
        factory.setVirtualHost(RABBITMQ_VIRTUAL_HOST);

        //3. 返回连接对象
        Connection connection = factory.newConnection();
        return connection;
    }
}

Publisher

package com.rhys.rabbitmq.models.helloworld;

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rhys.rabbitmq.utils.ConnectionUtil;

import java.nio.charset.StandardCharsets;

/**
 * @author Rhys.Ni
 * @version 1.0
 * @date 2022/11/28 11:14 PM
 */
public class Publisher {
    public static final String QUEUE_NAME = "hello";

    public static void main(String[] args) throws Exception {
        //构建连接对象
        Connection connection = ConnectionUtil.getConnection();
        //构建channel
        Channel channel = connection.createChannel();
        //构建队列
         /*（队列名称,队列是否需要持久化
                    ,是否设置为排外队列(只能由一个消费者监听)
                    ,长时间未使用自动删除
                    ，其他参数（Auto expire | Message TTL | Overflow behaviour
                              Single active consumer | Dead letter exchange | Dead letter routing key
                              Max length | Max length bytes
                              Maximum priority | Lazy mode | Version | Master locator ））
        */
        channel.queueDeclare(QUEUE_NAME, false, false, false, null);
        //发布消息
        /*
         * (交换机名称(默认空字符串),队列名,其他参数,消息内容
         * */
        byte[] msg = "hello".getBytes(StandardCharsets.UTF_8);
        channel.basicPublish("", QUEUE_NAME, null, msg);

        System.out.println("消息发送成功");
    }
}

Consumer

package com.rhys.rabbitmq.models.helloworld;

import com.rabbitmq.client.*;
import com.rhys.rabbitmq.utils.ConnectionUtil;

import java.io.IOException;
import java.nio.charset.StandardCharsets;

/**
 * @author Rhys.Ni
 * @version 1.0
 * @date 2022/11/28 11:14 PM
 */
public class Consumer {
    public static void main(String[] args) throws Exception {
        //构建连接对象
        Connection connection = ConnectionUtil.getConnection();
        //构建channel
        Channel channel = connection.createChannel();
        //构建队列 参数要与发布消息时统一
        channel.queueDeclare(Publisher.QUEUE_NAME, false, false, false, null);
        //消费消息
        /*
         * (队列名称,自动确认,当消费者在对应队列中监听到有消息的时候就会执行这个回调)
         * 回调会执行`handleDelivery`方法，这个方法没有具体实现，所以由我们自己来重写一下这个方法即可
         * */
        channel.basicConsume(Publisher.QUEUE_NAME, true, new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) {
                System.out.println("消费到消息:" + new String(body, StandardCharsets.UTF_8));
            }
        });
        System.out.println("开始监听队列:" + Publisher.QUEUE_NAME);
    }
}

Work Queues

官网模型：在多个消费者之间分配任务

一个队列中的消息只会被一个消费者成功的消费
默认情况下，队列会将消息轮询交给不同的消费者进行消费
消费者拿到消息后需要给MQ一个ACK，代表消费者已经拿到消息

示例代码

Publisher

package com.rhys.rabbitmq.models.workqueues;

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rhys.rabbitmq.utils.ConnectionUtil;

import java.nio.charset.StandardCharsets;

/**
 * @author Rhys.Ni
 * @version 1.0
 * @date 2022/11/28 11:14 PM
 */
public class Publisher {
    public static final String QUEUE_NAME = "work";

    public static void main(String[] args) throws Exception {
        //构建连接对象
        Connection connection = ConnectionUtil.getConnection();
        //构建channel
        Channel channel = connection.createChannel();
        //构建队列
         /*（队列名称,队列是否需要持久化
                    ,是否设置为排外队列(只能由一个消费者监听)
                    ,长时间未使用自动删除
                    ，其他参数（Auto expire | Message TTL | Overflow behaviour
                              Single active consumer | Dead letter exchange | Dead letter routing key
                              Max length | Max length bytes
                              Maximum priority | Lazy mode | Version | Master locator ））
        */
        channel.queueDeclare(QUEUE_NAME, false, false, false, null);
        //发布消息
        /*
         * (交换机名称(默认空字符串),队列名,其他参数,消息内容
         * */
        for (int i = 0; i < 10; i++) {
            byte[] msg = ("work" + i).getBytes(StandardCharsets.UTF_8);
            channel.basicPublish("", QUEUE_NAME, null, msg);
            System.out.println("消息" + ("work" + i) + "发送成功");
        }
    }
}

Consumer

关闭消费者自动ACK并设置消息流控(Qos),最终实现消费快的消费者尽可能多的去消费

package com.rhys.rabbitmq.models.workqueues;

import com.rabbitmq.client.*;
import com.rhys.rabbitmq.utils.ConnectionUtil;
import org.junit.jupiter.api.Test;

import java.io.IOException;
import java.nio.charset.StandardCharsets;

/**
 * @author Rhys.Ni
 * @version 1.0
 * @date 2022/11/28 11:14 PM
 */
public class Consumer {

    @Test
    public void consumer1() throws Exception {
        //构建连接对象
        Connection connection = ConnectionUtil.getConnection();
        //构建channel
        Channel channel = connection.createChannel();
        //构建队列 参数要与发布消息时统一
        channel.queueDeclare(Publisher.QUEUE_NAME, false, false, false, null);
        //设置消息流控
        channel.basicQos(1);
        //消费消息
        channel.basicConsume(Publisher.QUEUE_NAME, false, new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                System.out.println("consumer1消费到消息:" + new String(body, StandardCharsets.UTF_8));
                channel.basicAck(envelope.getDeliveryTag(), false);
            }
        });
        System.out.println("consumer1开始监听队列:" + Publisher.QUEUE_NAME);
        System.in.read();
    }

    @Test
    public void consumer2() throws Exception {
        //构建连接对象
        Connection connection = ConnectionUtil.getConnection();
        //构建channel
        Channel channel = connection.createChannel();
        //构建队列 参数要与发布消息时统一
        channel.queueDeclare(Publisher.QUEUE_NAME, false, false, false, null);
        //设置消息流控
        channel.basicQos(1);
        //消费消息
        /*
         * 如果需要让性能高的消费者尽可能多的消费，就要关闭自动ACK:false，改为手动ACK
         * */
        channel.basicConsume(Publisher.QUEUE_NAME, false, new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                System.out.println("consumer2消费到消息:" + new String(body, StandardCharsets.UTF_8));
                channel.basicAck(envelope.getDeliveryTag(), false);
            }
        });
        System.out.println("consumer2开始监听队列:" + Publisher.QUEUE_NAME);
        System.in.read();
    }
}

运行结果

Publish/Subscribe

自定义一个交换机并制定交换机类型为FanOut

让交换机通过RoutingKey同时绑定多个队列，再由不同的消费者分别监听每个队列

示例代码

Publisher

package com.rhys.rabbitmq.models.fanout;

import com.rabbitmq.client.BuiltinExchangeType;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rhys.rabbitmq.utils.ConnectionUtil;

import java.nio.charset.StandardCharsets;

/**
 * @author Rhys.Ni
 * @version 1.0
 * @date 2022/11/29 1:12 AM
 */
public class Publisher {
    public static final String QUEUE_NAME1 = "fanoutQ1";
    public static final String QUEUE_NAME2 = "fanoutQ2";
    public static final String EXCHANGE_NAME = "fanoutExchange";

    public static void main(String[] args) throws Exception {
        //构建连接对象
        Connection connection = ConnectionUtil.getConnection();
        //构建channel
        Channel channel = connection.createChannel();
        //构建交换机
        channel.exchangeDeclare(EXCHANGE_NAME, BuiltinExchangeType.FANOUT);
        //构建队列（队列名称,队列是否需要持久化,是否设置为排外队列(只能由一个消费者监听),长时间未使用自动删除，其他参数）
        channel.queueDeclare(QUEUE_NAME1, false, false, false, null);
        channel.queueDeclare(QUEUE_NAME2, false, false, false, null);
        //绑定交换机和队列(队列名,交换机名,路由名)，因为使用的是fanout类型交换机，所以routingKey写什么无所谓了，已经直接绑定了
        channel.queueBind(QUEUE_NAME1, EXCHANGE_NAME, "");
        channel.queueBind(QUEUE_NAME2, EXCHANGE_NAME, "");
        //发送消息
        channel.basicPublish(EXCHANGE_NAME, "", null, "pubsub".getBytes(StandardCharsets.UTF_8));
        System.out.println("消息发送成功");
    }
}

图形界面展示

交换机创建成功

队列创建成功并成功发送消息

在这里插入图片描述

交换机与队列绑定成功

Consumer

package com.rhys.rabbitmq.models.fanout;

import com.rabbitmq.client.*;
import com.rhys.rabbitmq.utils.ConnectionUtil;
import org.junit.jupiter.api.Test;

import java.io.IOException;
import java.nio.charset.StandardCharsets;

/**
 * @author Rhys.Ni
 * @version 1.0
 * @date 2022/11/28 11:14 PM
 */
public class Consumer {

    @Test
    public void consumer1() throws Exception {
        //构建连接对象
        Connection connection = ConnectionUtil.getConnection();
        //构建channel
        Channel channel = connection.createChannel();
        //构建队列 参数要与发布消息时统一
        channel.queueDeclare(Publisher.QUEUE_NAME1, false, false, false, null);
        //设置消息流控
        channel.basicQos(1);
        //消费消息
        channel.basicConsume(Publisher.QUEUE_NAME1, false, new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("consumer1消费到消息:" + new String(body, StandardCharsets.UTF_8));
                channel.basicAck(envelope.getDeliveryTag(), false);
            }
        });
        System.out.println("consumer1开始监听队列:" + Publisher.QUEUE_NAME1);
        System.in.read();
    }

    @Test
    public void consumer2() throws Exception {
        //构建连接对象
        Connection connection = ConnectionUtil.getConnection();
        //构建channel
        Channel channel = connection.createChannel();
        //构建队列 参数要与发布消息时统一
        channel.queueDeclare(Publisher.QUEUE_NAME2, false, false, false, null);
        //设置消息流控
        channel.basicQos(1);
        //消费消息
        channel.basicConsume(Publisher.QUEUE_NAME2, false, new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("consumer2消费到消息:" + new String(body, StandardCharsets.UTF_8));
                channel.basicAck(envelope.getDeliveryTag(), false);
            }
        });
        System.out.println("consumer2开始监听队列:" + Publisher.QUEUE_NAME2);
        System.in.read();
    }
}

运行结果

Routing

Direct

将消息根据具体的RoutingKey发送到完全匹配的队列中，再由不同的消费者对各自监听的队列中消息进行消费

示例代码

publisher

在绑定交换机和队列时，需要指定好路由key，同时在发送消息时也制定具体的路由key，只有路由key完全一致时，才会把指定的消息路由到指定的队列中

package com.rhys.rabbitmq.models.direct;

import com.rabbitmq.client.BuiltinExchangeType;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rhys.rabbitmq.utils.ConnectionUtil;

import java.nio.charset.StandardCharsets;

/**
 * @author Rhys.Ni
 * @version 1.0
 * @date 2022/11/29 1:12 AM
 */
public class Publisher {
    public static final String QUEUE_NAME1 = "directQ1";
    public static final String QUEUE_NAME2 = "directQ2";
    public static final String EXCHANGE_NAME = "directExchange";

    public static void main(String[] args) throws Exception {
        //构建连接对象
        Connection connection = ConnectionUtil.getConnection();
        //构建channel
        Channel channel = connection.createChannel();
        //构建交换机
        channel.exchangeDeclare(EXCHANGE_NAME, BuiltinExchangeType.DIRECT);
        //构建队列（队列名称,队列是否需要持久化,是否设置为排外队列(只能由一个消费者监听),长时间未使用自动删除，其他参数）
        channel.queueDeclare(QUEUE_NAME1, false, false, false, null);
        channel.queueDeclare(QUEUE_NAME2, false, false, false, null);
        //绑定交换机和队列(队列名,交换机名,路由名)，因为使用的是fanout类型交换机，所以routingKey写什么无所谓了，已经直接绑定了
        channel.queueBind(QUEUE_NAME1, EXCHANGE_NAME, "error");
        channel.queueBind(QUEUE_NAME2, EXCHANGE_NAME, "error");
        channel.queueBind(QUEUE_NAME2, EXCHANGE_NAME, "info");
        channel.queueBind(QUEUE_NAME2, EXCHANGE_NAME, "warning");
        //发送消息
        channel.basicPublish(EXCHANGE_NAME, "error", null, "routingError".getBytes(StandardCharsets.UTF_8));
        channel.basicPublish(EXCHANGE_NAME, "info", null, "routingInfo".getBytes(StandardCharsets.UTF_8));
        channel.basicPublish(EXCHANGE_NAME, "warning", null, "routingWarning".getBytes(StandardCharsets.UTF_8));
        System.out.println("消息发送成功");
    }
}

consumer

package com.rhys.rabbitmq.models.direct;

import com.rabbitmq.client.*;
import com.rhys.rabbitmq.utils.ConnectionUtil;
import org.junit.jupiter.api.Test;

import java.io.IOException;
import java.nio.charset.StandardCharsets;

/**
 * @author Rhys.Ni
 * @version 1.0
 * @date 2022/11/28 11:14 PM
 */
public class Consumer {

    @Test
    public void consumer1() throws Exception {
        //构建连接对象
        Connection connection = ConnectionUtil.getConnection();
        //构建channel
        Channel channel = connection.createChannel();
        //构建队列 参数要与发布消息时统一
        channel.queueDeclare(Publisher.QUEUE_NAME1, false, false, false, null);
        //设置消息流控
        channel.basicQos(1);
        //消费消息
        /*
         * (队列名称,自动确认,当消费者在对应队列中监听到有消息的时候就会执行这个回调)
         * 回调会执行`handleDelivery`方法，这个方法没有具体实现，所以由我们自己来重写一下这个方法即可
         * */
        channel.basicConsume(Publisher.QUEUE_NAME1, false, new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("consumer1消费到消息:" + new String(body, StandardCharsets.UTF_8));
                channel.basicAck(envelope.getDeliveryTag(), false);
            }
        });
        System.out.println("consumer1开始监听队列:" + Publisher.QUEUE_NAME1);
        System.in.read();
    }

    @Test
    public void consumer2() throws Exception {
        //构建连接对象
        Connection connection = ConnectionUtil.getConnection();
        //构建channel
        Channel channel = connection.createChannel();
        //构建队列 参数要与发布消息时统一
        channel.queueDeclare(Publisher.QUEUE_NAME2, false, false, false, null);
        //设置消息流控
        channel.basicQos(1);
        //消费消息
        /*
         * (队列名称,自动确认,当消费者在对应队列中监听到有消息的时候就会执行这个回调)
         * 回调会执行`handleDelivery`方法，这个方法没有具体实现，所以由我们自己来重写一下这个方法即可
         *
         * 如果需要让性能高的消费者尽可能多的消费，就要关闭自动ACK:false，改为手动ACK
         * basicAck(消费者标识(不同消费者是不一样的),是否是批量操作)
         * */
        channel.basicConsume(Publisher.QUEUE_NAME2, false, new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("consumer2消费到消息:" + new String(body, StandardCharsets.UTF_8));
                channel.basicAck(envelope.getDeliveryTag(), false);
            }
        });
        System.out.println("consumer2开始监听队列:" + Publisher.QUEUE_NAME2);
        System.in.read();
    }
}

执行结果

Topics

Topic

根据模式（主题）接收消息

示例代码

publisher

根据*和#号来制定路由规则实现以下效果

让两个队列都能接收到第一条消息
让第二条消息只发送到队列二中
让第三条消息发送到队列二中

package com.rhys.rabbitmq.models.topic;

import com.rabbitmq.client.BuiltinExchangeType;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rhys.rabbitmq.utils.ConnectionUtil;

import java.nio.charset.StandardCharsets;

/**
 * @author Rhys.Ni
 * @version 1.0
 * @date 2022/11/29 1:12 AM
 */
public class Publisher {
    public static final String QUEUE_NAME1 = "topicQ1";
    public static final String QUEUE_NAME2 = "topicQ2";
    public static final String EXCHANGE_NAME = "topicExchange";

    public static void main(String[] args) throws Exception {
        //构建连接对象
        Connection connection = ConnectionUtil.getConnection();
        //构建channel
        Channel channel = connection.createChannel();
        //构建交换机
        channel.exchangeDeclare(EXCHANGE_NAME, BuiltinExchangeType.TOPIC);
        //构建队列（队列名称,队列是否需要持久化,是否设置为排外队列(只能由一个消费者监听),长时间未使用自动删除，其他参数）
        channel.queueDeclare(QUEUE_NAME1, false, false, false, null);
        channel.queueDeclare(QUEUE_NAME2, false, false, false, null);
        //绑定交换机和队列(队列名,交换机名,路由名)，*：占位符   #：通配符
        channel.queueBind(QUEUE_NAME1, EXCHANGE_NAME, "*.orange.*");
        channel.queueBind(QUEUE_NAME2, EXCHANGE_NAME, "*.*.rabbit");
        channel.queueBind(QUEUE_NAME2, EXCHANGE_NAME, "lazy.#");
        //发送消息
        channel.basicPublish(EXCHANGE_NAME, "rhys.orange.rabbit", null, "测试占位符*.orange.*和*.*.rabbit".getBytes(StandardCharsets.UTF_8));
        channel.basicPublish(EXCHANGE_NAME, "rhys.ni.rabbit", null, "测试占位符*.*.rabbit".getBytes(StandardCharsets.UTF_8));
        channel.basicPublish(EXCHANGE_NAME, "lazy.rhys", null, "测试通配符lazy.#".getBytes(StandardCharsets.UTF_8));
        System.out.println("消息发送成功");
    }
}

consumer

package com.rhys.rabbitmq.models.topic;

import com.rabbitmq.client.*;
import com.rhys.rabbitmq.utils.ConnectionUtil;
import org.junit.jupiter.api.Test;

import java.io.IOException;
import java.nio.charset.StandardCharsets;

/**
 * @author Rhys.Ni
 * @version 1.0
 * @date 2022/11/28 11:14 PM
 */
public class Consumer {

    @Test
    public void consumer1() throws Exception {
        //构建连接对象
        Connection connection = ConnectionUtil.getConnection();
        //构建channel
        Channel channel = connection.createChannel();
        //构建队列 参数要与发布消息时统一
        channel.queueDeclare(Publisher.QUEUE_NAME1, false, false, false, null);
        //设置消息流控
        channel.basicQos(1);
        //消费消息
        /*
         * (队列名称,自动确认,当消费者在对应队列中监听到有消息的时候就会执行这个回调)
         * 回调会执行`handleDelivery`方法，这个方法没有具体实现，所以由我们自己来重写一下这个方法即可
         * */
        channel.basicConsume(Publisher.QUEUE_NAME1, false, new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("consumer1消费到消息:" + new String(body, StandardCharsets.UTF_8));
                channel.basicAck(envelope.getDeliveryTag(), false);
            }
        });
        System.out.println("consumer1开始监听队列:" + Publisher.QUEUE_NAME1);
        System.in.read();
    }

    @Test
    public void consumer2() throws Exception {
        //构建连接对象
        Connection connection = ConnectionUtil.getConnection();
        //构建channel
        Channel channel = connection.createChannel();
        //构建队列 参数要与发布消息时统一
        channel.queueDeclare(Publisher.QUEUE_NAME2, false, false, false, null);
        //设置消息流控
        channel.basicQos(1);
        //消费消息
        /*
         * (队列名称,自动确认,当消费者在对应队列中监听到有消息的时候就会执行这个回调)
         * 回调会执行`handleDelivery`方法，这个方法没有具体实现，所以由我们自己来重写一下这个方法即可
         *
         * 如果需要让性能高的消费者尽可能多的消费，就要关闭自动ACK:false，改为手动ACK
         * basicAck(消费者标识(不同消费者是不一样的),是否是批量操作)
         * */
        channel.basicConsume(Publisher.QUEUE_NAME2, false, new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("consumer2消费到消息:" + new String(body, StandardCharsets.UTF_8));
                channel.basicAck(envelope.getDeliveryTag(), false);
            }
        });
        System.out.println("consumer2开始监听队列:" + Publisher.QUEUE_NAME2);
        System.in.read();
    }
}

运行结果

RPC

适用于需要完成两个服务调用并且有一定解耦的场景

客户端会发送一个消息到MQ队列
服务端会监听队列的消息拿到具体内容
再将响应交给另一个MQ队列，客户端会监听这个响应队列最终完成一个请求的闭环

示例代码

publisher

package com.rhys.rabbitmq.models.rpc;

import com.rabbitmq.client.*;
import com.rhys.rabbitmq.utils.ConnectionUtil;

import java.io.IOException;
import java.util.UUID;

/**
 * @author Rhys.Ni
 * @version 1.0
 * @date 2022/11/29 2:53 AM
 */
public class Publisher {
    public static final String PUBLISHER_QUEUE = "rpc_publisher";
    public static final String CONSUMER_QUEUE = "rpc_consumer";

    public static void main(String[] args) throws Exception {
        //构建连接对象
        Connection connection = ConnectionUtil.getConnection();
        //构建channel
        Channel channel = connection.createChannel();
        //构建队列
        // （队列名称,队列是否需要持久化,是否设置为排外队列(只能由一个消费者监听),长时间未使用自动删除,其他参数）
        channel.queueDeclare(PUBLISHER_QUEUE, false, false, false, null);
        channel.queueDeclare(CONSUMER_QUEUE, false, false, false, null);
        //发布消息(交换机名称(默认空字符串),队列名,其他参数,消息内容
        String message = "Hello RPC!";
        String uuid = UUID.randomUUID().toString();
        AMQP.BasicProperties props = new AMQP.BasicProperties()
                .builder()
                .replyTo(CONSUMER_QUEUE)
                .correlationId(uuid)
                .build();
        channel.basicPublish("",PUBLISHER_QUEUE,props,message.getBytes());

        channel.basicConsume(CONSUMER_QUEUE,false,new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                String id = properties.getCorrelationId();
                if(id != null && id.equalsIgnoreCase(uuid)){
                    System.out.println("接收到服务端的响应：" + new String(body,"UTF-8"));
                }
                channel.basicAck(envelope.getDeliveryTag(),false);
            }
        });
        System.out.println("消息发送成功！");

        System.in.read();
    }
}

consumer

package com.rhys.rabbitmq.models.rpc;

import com.rabbitmq.client.*;
import com.rhys.rabbitmq.utils.ConnectionUtil;

import java.io.IOException;

/**
 * @author Rhys.Ni
 * @version 1.0
 * @date 2022/11/28 11:14 PM
 */
public class Consumer {
    public static void main(String[] args) throws Exception {
        //构建连接对象
        Connection connection = ConnectionUtil.getConnection();
        //构建channel
        Channel channel = connection.createChannel();
        //构建队列 参数要与发布消息时统一
        channel.queueDeclare(Publisher.PUBLISHER_QUEUE, false, false, false, null);
        channel.queueDeclare(Publisher.CONSUMER_QUEUE, false, false, false, null);

        //消费消息(队列名称,自动确认,当消费者在对应队列中监听到有消息的时候就会执行这个回调)
        DefaultConsumer callback = new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("消费者获取到消息：" + new String(body,"UTF-8"));
                String resp = "获取到了client发出的请求，这里是响应的信息";
                String respQueueName = properties.getReplyTo();
                String uuid = properties.getCorrelationId();
                AMQP.BasicProperties props = new AMQP.BasicProperties()
                        .builder()
                        .correlationId(uuid)
                        .build();
                channel.basicPublish("",respQueueName,props,resp.getBytes());
                channel.basicAck(envelope.getDeliveryTag(),false);
            }
        };
        channel.basicConsume(Publisher.PUBLISHER_QUEUE,false,callback);
        System.out.println("开始监听队列");

        System.in.read();
    }
}

运行结果

Publisher Confirms

官网模型(保证消息可靠性)

发送途中消息丢失

生产者收到命令将消息发出，随机生产者认为已经将这条消息发送到了交换机中
但是由于网络原因导致消息在发送途中丢失了没有到达交换机

解决方案

保证消息成功发送到了交换机

利用Confirm机制，根据ConfirmListener的异步回调，进入handleAck方法确定消息发送成功

代码示例

//开启confirms
channel.confirmSelect();

//confirms异步回调
channel.addConfirmListener(new ConfirmListener() {
  @Override
  public void handleAck(long l, boolean b) {
    System.out.println("消息发送成功：" + msg);
  }

  @Override
  public void handleNack(long l, boolean b) throws IOException {
    System.out.println("消息发送失败，Retry...");
  }
});

服务宕机消息丢失

交换机不具备持久化消息的能力
当服务器宕机或MQ重启服务时就会导致没有路由到队列中的消息丢失
但是队列默认是不具备持久化消息的能力，需要手动开启(DeliveryMode)

解决方案1

保证消息成功路由到了队列中

利用return机制 ，确认消息是否路由到了队列
只有当消息没有路由到队列时才会回调return方法
需要手动将队列改为：QUEUE_NAME+“1111”，使其在我们现有的MQ服务中不存在即可

代码示例1

//return机制 （确认消息是否路由到了队列）
//消息没有路由到队列时会回调return方法
channel.addReturnListener((replyCode, replyText, exchange, routingKey, basicProperties, bytes) 
                          -> System.out.println("消息已送达到交换机，但未路由到指定队列，可做补偿机制..."));

解决方案2

保证队列支持消息持久化

DeliveryMode设置消息持久化:（设置为1：不持久化消息 | 设置为2：持久化消息）

代码示例2

//设置消息持久化
//服务器宕机/MQ服务重启消息依旧会存在队列中
AMQP.BasicProperties properties = new AMQP.BasicProperties().builder()
  //2:持久化消息 1:不持久化消息
  .deliveryMode(2)
  .build();

//在发送消息时需要将'mandatory'属性设置为ture,代表开启return机制
//basicPublish(交换机, 队列, mandatory值,属性, 消息内容)
//QUEUE_NAME+"111"，手动调整为不存在的队列，否则无法回调return方法
channel.basicPublish("", QUEUE_NAME, true, properties, msg.getBytes(StandardCharsets.UTF_8));

消费者消费失败

解决方案

保证消费者正常消费消息

设置手动ACK

//设置消息流控
channel.basicQos(1);
//消费消息
//如果需要让性能高的消费者尽可能多的消费，就要关闭自动ACK:false，改为手动ACK
channel.basicConsume(Publisher.QUEUE_NAME, false, new DefaultConsumer(channel) {
  @Override
  public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
    try {
      Thread.sleep(100);
    } catch (InterruptedException e) {
      throw new RuntimeException(e);
    }
    System.out.println("consumer2消费到消息:" + new String(body, StandardCharsets.UTF_8));
    channel.basicAck(envelope.getDeliveryTag(), false);
  }
});

上述案例完整代码

public class Publisher {
    public static final String QUEUE_NAME = "confirmsQueue";
    public static final String EXCHANGE_NAME = "confirmsExchange";

    public static void main(String[] args) throws Exception {
        //构建连接对象
        Connection connection = ConnectionUtil.getConnection();

        //构建channel
        Channel channel = connection.createChannel();

        //声明队列
        //queueDeclare(queue, durable, exclusive, autoDelete, arguments)
        //durable:true 队列持久化
        channel.queueDeclare(QUEUE_NAME, true, false, false, null);

        //准备消息
        String msg = "hello";

        //开启confirms
        channel.confirmSelect();

        //confirms异步回调
        channel.addConfirmListener(new ConfirmListener() {
            @Override
            public void handleAck(long l, boolean b) {
                System.out.println("消息发送成功：" + msg);
            }

            @Override
            public void handleNack(long l, boolean b) throws IOException {
                System.out.println("消息发送失败，Retry...");
            }
        });

        //return机制 （确认消息是否路由到了队列）
        //消息没有路由到队列时会回调return方法
        channel.addReturnListener((replyCode, replyText, exchange, routingKey, basicProperties, bytes) 
                                  -> System.out.println("消息已送达到交换机，但未路由到指定队列，可做补偿机制..."));

        //设置消息持久化
        //服务器宕机/MQ服务重启消息依旧会存在队列中
        AMQP.BasicProperties properties = new AMQP.BasicProperties().builder()
                .deliveryMode(2)
                .build();

        //在发送消息时需要将'mandatory'属性设置为ture,代表开启return机制
        //basicPublish(交换机, 队列, mandatory值,属性, 消息内容)
        //QUEUE_NAME+"111"，手动调整为不存在的队列，否则无法回调return方法
        channel.basicPublish("", QUEUE_NAME, true, properties, msg.getBytes(StandardCharsets.UTF_8));

        System.in.read();
    }
}

SpringBoot集成RabbitMQ

NEW PROJECT

勾选mq依赖

具体依赖如下

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

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

    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.amqp</groupId>
        <artifactId>spring-rabbit-test</artifactId>
        <scope>test</scope>
    </dependency>
</dependencies>

配置RabbitMQ

spring:
  rabbitmq:
    host: localhost
    port: 5672
    username: guest
    password: guest
    virtual-host: /
    listener:
      simple:
        #手动ACK
        acknowledge-mode: manual
        #每次接收多少条消息
        prefetch: 10

创建RabbitMQ配置类，声明交换机和队列信息

定义交换机(Exchange:topicExchange）
定义队列(Queue:durable：持久化队列、nonDurable：非持久化队列）
将交换机与队列通过RoutingKey建立绑定关系(Binding:bind,to,with)

@Configuration
public class RabbitMQConfig {
    public static final String EXCHANGE = "testExchange";
    public static final String QUEUE = "testQueue";
    public static final String ROUTING_KEY = "*.test.*";

    /**
     * 定义交换机
     *
     * @param
     * @return org.springframework.amqp.core.Exchange
     * @author Rhys.Ni
     * @date 2022/12/13
     */
    @Bean
    public Exchange exchange() {
        return ExchangeBuilder.topicExchange(EXCHANGE).build();
    }

    /**
     * 定义队列
     *
     * @param
     * @return org.springframework.amqp.core.Queue
     * @author Rhys.Ni
     * @date 2022/12/13
     */
    @Bean
    public Queue queue() {
        //durable：持久化队列
        //nonDurable：非持久化队列
        return QueueBuilder.durable(QUEUE).build();
    }

    /**
     * 将交换机与队列通过RoutingKey建立绑定关系
     *
     * @param exchange
     * @param queue
     * @return org.springframework.amqp.core.Binding
     * @author Rhys.Ni
     * @date 2022/12/13
     */
    @Bean
    public Binding binding(Exchange exchange, Queue queue) {
        return BindingBuilder.bind(queue).to(exchange).with(ROUTING_KEY).noargs();
    }
}

创建生产者

/**
 * @author Rhys.Ni
 * @version 1.0
 * @date 2022/12/13 11:54 PM
 */
@SpringBootTest
public class Publisher {
    @Autowired
    private RabbitTemplate rabbitTemplate;

    /**
     * 发送消息（不携带属性）
     *
     * @param
     * @return void
     * @author Rhys.Ni
     * @date 2022/12/14
     */
    @Test
    public void convertAndSend() {
        rabbitTemplate.convertAndSend(RabbitMQConfig.EXCHANGE, "RhysNi.test.Ni", "RhysNi RabbitMQ 实战手册");
        System.out.println("消息发送成功");
    }

    /**
     * 发送消息（携带属性）
     *
     * @param
     * @return void
     * @author Rhys.Ni
     * @date 2022/12/14
     */
    @Test
    public void convertAndSendWithProps() {
        rabbitTemplate.convertAndSend(RabbitMQConfig.EXCHANGE, "RhysNi.test.Ni", "RhysNi RabbitMQ 实战手册", new MessagePostProcessor() {
            @Override
            public Message postProcessMessage(Message message) throws AmqpException {
                message.getMessageProperties().setCorrelationId(UUID.randomUUID().toString());
                return message;
            }
        });
        System.out.println("消息发送成功");
    }
}

发送成功后查看RabbitMQ图形化界查看消息已经成功发送到对应的队列中，下面咱们就创建消费者去监听队列将这条消息消费掉

创建消费者监听

correlationId：消息唯一标识

import com.rabbitmq.client.Channel;
import com.rhys.rabbitmq.config.RabbitMQConfig;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

import java.io.IOException;


/**
 * @author Rhys.Ni
 * @version 1.0
 * @date 2022/12/13 11:54 PM
 */
@Component
public class ConsumerListener {

    @RabbitListener(queues = RabbitMQConfig.QUEUE)
    public void consumer(String msg, Channel channel, Message message) throws IOException {
        System.out.println("msg:" + msg);
        String correlationId = message.getMessageProperties().getCorrelationId();
        System.out.println("correlationId:" + correlationId);
        //手动确认消息
        channel.basicAck(message.getMessageProperties().getDeliveryTag(), false);
    }
}

重新启动可以看到消息已经被消费者接受并且消费

Springboot实现消息可靠传输

Confirm机制

配置

配置application.yml，开启confirm机制

spring:
  rabbitmq:
    host: localhost
    port: 5672
    username: guest
    password: guest
    virtual-host: /
    listener:
      simple:
        #手动ACK
        acknowledge-mode: manual
        #每次接收多少条消息
        prefetch: 10
    #开启confirm机制
    publisher-confirm-type: correlated

代码示例

@SpringBootTest
public class Publisher {
    @Autowired
    private RabbitTemplate rabbitTemplate;

    /**
     * Confirms机制
     * @author Rhys.Ni
     * @date 2023/1/5
     * @param
     * @return void
     */
    @Test
    public void convertAndSendConfirm() {
        rabbitTemplate.setConfirmCallback((correlationData, isAck, strCause) -> {
            if (isAck){
                System.out.println("消息成功发送到交换机中");
            }else{
                System.out.println("消息发送到交换机失败,进行补偿操作");
            }
        });
        rabbitTemplate.convertAndSend(RabbitMQConfig.EXCHANGE, "RhysNi.test.Ni", "RhysNi RabbitMQ 实战手册（Confirms机制）");
        System.out.println("消息发送成功（Confirms机制）");
    }
}

运行结果

Return机制

配置

spring:
  rabbitmq:
    host: localhost
    port: 5672
    username: guest
    password: guest
    virtual-host: /
    listener:
      simple:
        #手动ACK
        acknowledge-mode: manual
        #每次接收多少条消息
        prefetch: 10
    #开启confirm机制
    publisher-confirm-type: correlated
    #开启Return机制
    publisher-returns: true

代码示例

returnedMessage中可获取到交换机以及路由信息

@SpringBootTest
public class Publisher {
    @Autowired
    private RabbitTemplate rabbitTemplate;

    /**
     * Return机制
     * @author Rhys.Ni
     * @date 2023/1/5
     * @param
     * @return void
     */
    @Test
    public void convertAndSendReturn() {
        rabbitTemplate.setReturnsCallback(returnedMessage -> {
            String msg = new String(returnedMessage.getMessage().getBody());
            System.out.println("msg:"+msg+"路由到队列失败，进行补偿操作,returnedMessage中可获取到交换机以及路由信息，可重新发送到交换机等。。。");
        });
        //由于RabbitMQConfig中配置的路由规则是 *.test.* 所以这里需要手动将 Rhys.test.Ni 改为 Rhys.test1.Ni 模拟失败操作
        rabbitTemplate.convertAndSend(RabbitMQConfig.EXCHANGE, "Rhys.test1.Ni", "RhysNi RabbitMQ 实战手册（Return机制）");
        System.out.println("消息发送成功（Return机制）");
    }
}

运行结果

如果将路由Key改回正确的Rhys.test.Ni则不会进入此回调，代表路由到队列成功了

消息持久化

代码示例

new MessagePostProcessor()
MessageDeliveryMode.PERSISTENT(持久化)
MessageDeliveryMode.NON_PERSISTENT (不持久化)

    /**
     * 消息持久化(new MessagePostProcessor())
     * MessageDeliveryMode.PERSISTENT 持久化
     * MessageDeliveryMode.NON_PERSISTENT 不持久化
     *
     * @param
     * @return void
     * @author Rhys.Ni
     * @date 2023/1/5
     */
    @Test
    public void convertAndSendBasicProps() {
        rabbitTemplate.convertAndSend(RabbitMQConfig.EXCHANGE, "Rhys.test.Ni", "RhysNi RabbitMQ 实战手册（消息持久化）", message -> {
            message.getMessageProperties().setDeliveryMode(MessageDeliveryMode.PERSISTENT);
            return message;
        });
        System.out.println("消息发送成功（消息持久化）");
    }

死信队列

Dead Lettering

消费者拿到消息之后执行了nack或者reject，并且设置requeue为false，也就是说消费者拒绝消费这条消息，并且不让该条消息重新返回队列被别的消费者消费，则该消息为死信

消息在队列中生存时间(Message TTL)超时了还没被消费

可以针对某一个队列设置生存时间
也可以指定队列中所有消息的生存时间

队列已经到了消息的最大长度(x-max-length)后，后面再路由过来的消息直接为死信

应用场景

基于死信队列在队列消息已满的情况下，消息也不会被静默删除导致消息丢失
可以用于实现电商下单的延迟消费（5分钟付款时间）

死信队列实现

当生产者发布了一条消息到负责处理正常消息的交换机
消息成功路由到了正常队列中
如果监听正常队列的消费者拿到消息后执行了NACK或Reject，并且设置requeue=false拒绝消费这条消息同时不让该条消息重新返回队列被别的消费者消费，则该消息为死信
这时这条消息将由正常队列重新路由到死信交换机中
再由死信交换机根据路由Key路由到对应的死信队列中
最后由死信消费者监听这个死信队列并拿到消息进行消费

定义死信交换机和死信队列

@Configuration
public class DeadLetteringConfig {
    //正常交换机
    public static final String EXCHANGE = "test-exchange";
    //死信交换机
    public static final String DEAD_EXCHANGE = "dead-test-exchange";


    //正常队列
    public static final String QUEUE = "test-queue";
    //死信队列
    public static final String DEAD_QUEUE = "dead-test-queue";


    //正常路由key
    public static final String ROUTING_KEY = "*.test.#";
    //死信路由key
    public static final String DEAD_ROUTING_KEY = "dead.test.*";


    @Bean
    public Exchange testExchange() {
        return ExchangeBuilder.topicExchange(EXCHANGE).build();
    }

    /**
     * deadLetterRoutingKey消息变为死信时路由key需要被修改成什么
     * @author Rhys.Ni
     * @date 2023/1/10
     * @param
     * @return org.springframework.amqp.core.Queue
     */
    @Bean
    public Queue testQueue() {
        return QueueBuilder.durable(QUEUE).deadLetterExchange(DEAD_EXCHANGE).deadLetterRoutingKey("dead.test.ni").build();
    }

    @Bean
    public Binding testBinding(Queue testQueue, Exchange testExchange) {
        return BindingBuilder.bind(testQueue).to(testExchange).with(ROUTING_KEY).noargs();
    }



    @Bean
    public Exchange deadTestExchange() {
        return ExchangeBuilder.topicExchange(DEAD_EXCHANGE).build();
    }

    @Bean
    public Queue deadTestQueue() {
        return QueueBuilder.durable(DEAD_QUEUE).build();
    }

    @Bean
    public Binding deadBinding(Queue deadTestQueue, Exchange deadTestExchange) {
        return BindingBuilder.bind(deadTestQueue).to(deadTestExchange).with(DEAD_ROUTING_KEY).noargs();
    }
}

消费者拿到消息之后执行了nack或者reject，并且设置requeue为false

@Component
public class DeadConsumerListener {

    @RabbitListener(queues = DeadLetteringConfig.QUEUE)
    public void consumer(String msg, Channel channel, Message message) throws IOException {
        System.out.println("正常队列msg:" + msg);
        //tag,requeue
        channel.basicReject(message.getMessageProperties().getDeliveryTag(), false);
      	
      	//tag,multiple,requeue 二选一即可
        //channel.basicNack(message.getMessageProperties().getDeliveryTag(), false,false);
    }
}

针对某一个队列设置生存时间

/**
 * deadLetterRoutingKey消息变为死信时路由key需要被修改成什么
 * @author Rhys.Ni
 * @date 2023/1/10
 * @param
 * @return org.springframework.amqp.core.Queue
 */
@Bean
public Queue testQueue() {
  return QueueBuilder.durable(QUEUE).deadLetterExchange(DEAD_EXCHANGE).deadLetterRoutingKey("dead.test.ni")
    //3s过后没被消费被转入死信队列
    .ttl(3000).build();
}

指定队列中所有消息的生存时间

public void convertAndSendExpire() {
  rabbitTemplate.convertAndSend(DeadLetteringConfig.EXCHANGE, "Rhys.test.Ni", "RhysNi RabbitMQ 实战手册（死信测试）", 
                                message -> {
    //3s过后没被消费被转入死信队列
    message.getMessageProperties().setExpiration("3000");
    return message;
  });
  System.out.println("消息发送成功");
}

队列已经到了消息的最大长度(x-max-length)后，后面再路由过来的消息直接为死信

/**
 * deadLetterRoutingKey消息变为死信时路由key需要被修改成什么
 * @author Rhys.Ni
 * @date 2023/1/10
 * @param
 * @return org.springframework.amqp.core.Queue
 */
@Bean
public Queue testQueue() {
  return QueueBuilder.durable(QUEUE).deadLetterExchange(DEAD_EXCHANGE).deadLetterRoutingKey("dead.test.ni")
    //3s过后没被消费被转入死信队列
    // .ttl(3000)
    //设置队列最大长度为1模拟超出队列长度，后续路由过来的消息转死信场景
    .maxLength(1)
    .build();
}

延迟交换机

RabbitMQ只会监听队列最外侧的消息
如果出现最外侧消息生存时间比后面消息都长
就会导致后面的消息要等到最外侧消息生成时间到期进入死信队列后才能去监听后面消息的生存时间
这种情况就可能会导致Msg2的生存时间早就到期，却只能等待10s过后两条消息一起进了死信队列

总结：死信队列实现延迟消费时，如果延迟时间比较复杂，比较多，直接使用死信队列时，需要创建大量的队列还对应不同的时间，可以采用延迟交换机来解决这个问题

不过，如果刚好生产者发送了一个延时消息到交换机中，这时服务器宕机或服务重启消息就丢失了

延迟交换机安装

点击下载延迟交换机插件(rabbitmq_delayed_message_exchange)
移动到MQ服务的安装路径下的plugins目录

移动到plugins目录后，跳转到sbin目录

使用rabbitmq-plugins运行插件

rabbitmq-plugins enable rabbitmq_delayed_message_exchange

没有运行延迟交换机插件之前我们想创建一个交换机类型只有以下图中四种

当我们开启延迟交换机插件后发现可选择的交换机类型中多了一个x-delayed-message类型

代码案例

@Configuration
public class DelayedConfig {
    //正常交换机
    public static final String DELAYED_EXCHANGE = "delayed-exchange";
    //正常队列
    public static final String DELAYED_QUEUE = "delayed-queue";
    //正常路由key
    public static final String DELAYED_ROUTING_KEY = "delayed.test.#";

    @Bean
    public Exchange delayedExchange() {
        Map<String, Object> args = new HashMap<>(1);
        //指定延迟交换机类型
        args.put("x-delayed-type", "topic");

        Exchange exchange = new CustomExchange(DELAYED_EXCHANGE, "x-delayed-message", true, false, args);
        return exchange;
    }

    @Bean
    public Queue delayedQueue() {
        return QueueBuilder.durable(DELAYED_QUEUE).build();
    }

    @Bean
    public Binding delayedBinding(Queue delayedQueue, Exchange delayedExchange) {
        return BindingBuilder.bind(delayedQueue).to(delayedExchange).with(DELAYED_ROUTING_KEY).noargs();
    }
}

测试发送延时消息

@SpringBootTest
public class DelayedPublisher {
    @Autowired
    private RabbitTemplate rabbitTemplate;

    @Test
    public void convertAndSend() {
        rabbitTemplate.convertAndSend(DelayedConfig.DELAYED_EXCHANGE, "delayed.test.Ni", 
                                      "RhysNi RabbitMQ 实战手册（延迟交换机测试）");
        System.out.println("消息发送成功");
    }

    @Test
    public void convertAndSendExpire1() {
        rabbitTemplate.convertAndSend(DelayedConfig.DELAYED_EXCHANGE, "delayed.test.Ni", 
                                      "RhysNi RabbitMQ 实战手册（延迟交换机测试）", message -> {
            //3s过后没被消费被转入死信队列
            message.getMessageProperties().setDelay(30000);
            return message;
        });
        System.out.println("消息发送成功");
    }

    @Test
    public void convertAndSendExpire2() {
        rabbitTemplate.convertAndSend(DelayedConfig.DELAYED_EXCHANGE, "delayed.test.Ni",
                                      "RhysNi RabbitMQ 实战手册（延迟交换机测试）", message -> {
            //3s过后没被消费被转入死信队列
            message.getMessageProperties().setDelay(3000);
            return message;
        });
        System.out.println("消息发送成功");
    }
}

高可用集群

提供高可用服务的同时提升MQ效率

如果没有Nginx做负载均衡,则有可能会使请求不均匀的打到MQ服务上，
请求量过大的某一个服务处理消息就会非常繁忙，
而请求量少的服务相对空闲时长较多，导致消息消费速度下降

Docker yml安装配置

首先分别进入每台机器,创建对应目录文件夹/usr/local/docker/rabbitmq-cluster_docker

sudo mkdir -p  /usr/local/docker/rabbitmq-cluster_docker

第一台MQ配置

在/usr/local/docker/rabbitmq-cluster_docker目录下创建docker-compose.yml文件

vi docker-compose.yml

将docker脚本贴进去保存退出

version: '3.1'
services:
  rabbitmq1:
    image: rabbitmq:3.11.0-management-alpine
    container_name: rabbitmq1
    hostname: rabbitmq1
    extra_hosts:
      - "rabbitmq1:101.133.157.40"
      - "rabbitmq2:120.25.253.51"
    environment: 
      - RABBITMQ_ERLANG_COOKIE=RhysNi
    ports:
      - 5672:5672
      - 15672:15672
      - 4369:4369
      - 25672:25672

第二台MQ配置同上，将配置内容替换成以下内容即可

version: '3.1'
services:
  rabbitmq2:
    image: rabbitmq:3.11.0-management-alpine
    container_name: rabbitmq2
    hostname: rabbitmq2
    extra_hosts:
      - "rabbitmq1:101.133.157.40"
      - "rabbitmq2:120.25.253.51"
    environment: 
      - RABBITMQ_ERLANG_COOKIE=RhysNi
    ports:
      - 5672:5672
      - 15672:15672
      - 4369:4369
      - 25672:25672

最后分别在/usr/local/docker/rabbitmq-cluster_docker目录下执行以下命令启动容器

docker-compose up -d

特殊提示📢：如果docker-compose 命令报错-bash: docker-compose: command not found

yum -y install epel-release
yum -y install python-pip
pip install --upgrade pip==20.3.4
sudo pip install docker-compose

最后重新执行docker-compose up -d等待跑完即可

最后访问两个服务器的RabbitMQ服务

PS📢:如果用了云服务器安装完成发现访问不了管理页面的话，记得去安全组把涉及到的几个端口给添加一下，再检查一下防火墙，可放开相关端口或关闭防火墙

RabbitMQ实现服务Join

现在需要将rabbitmq2加入到rabbitmq1

首先进入rabbitmq2服务所在的docker容器内

docker exec -it rabbitmq2 bash

进入容器后执行以下命令停止当前mq服务

rabbitmqctl stop_app

重置mq服务

rabbitmqctl reset

执行以下命令将rabbitmq2加入到rabbitmq1组成集群，这个命令执行完要等待一会儿

PS📢:下方命令中rabbit@rabbimq1来自于要加入的目标服务的Overview下的Nodes节点表中的Name值

rabbitmqctl join_cluster rabbit@rabbitmq1

Join报错解决方案

如果当命令执行完以后可能会报错如图

没报错直接点击这里跳过以下步骤直接进行没报错的方案即可
退出容器
exit
clear
尝试关闭防火墙,先开启启后关闭确保万无一失
systemctl start firewalld
systemctl stop firewalld
重启docker
systemctl restart dockeshr
重启mq服务
docker restart 容器ID
最后再次进入容器进行以下操作
docker exec -it rabbitmq2 bash
rabbitmqctl stop_app
rabbitmqctl reset
rabbitmqctl join_cluster rabbit@rabbitmq1
rabbitmqctl start_app

正常Join后续操作流程

加入成功后应该可以在RabbitMQ1服的Overview > Nodes节点列表看到如下图所示结果

因为咱们RabbitMQ2服务被停止了，所以看不到节点信息，但是已经可以说明咱们RabbitMQ2服务已经加入到RabbitMQ1服务组成了一个MQ集群

这时咱们再重启一下RabbitMQ2服务就可以互相看到几点信息了

rabbitmqctl start_app

RabbitMQ镜像模式

通过以上一番操作下来之后，我们可以在两台mq中互相看到对方服务节点的信息了

如果RabbitMQ1创建了一个队列queue1，这时，在RabbitMQ2的队列表中也是可以看到这个队列的
只不过这个队列属于RabbitMQ1

所以，当RabbitMQ1宕机后，这个queue1队列状态也会变为down

所以我们需要创建镜像模式来让MQ集群真正具备在提供高可用服务的同时还能提升MQ效率

图形界面创建`Policy`

填写镜像同步策略基础信息

HA mode设置

all (镜像到集群中的所有节点)

exactly(镜像到一组节点)

nodes(镜像到显式节点列表)

如果选择后两者之一，必须设置HA-params

ha-mode	all

HA sync mode

设置手动同步还是自动同步

manul（手动同步）:已有的历史消息不同步，只同步后续接收到的新消息

automatic（自动同步）：同步所有的消息，不管新消息还是历史消息

为了保证安全不丢失，选用自动会更好

ha-sync-mode	automatic

点击Add按钮保存添加策略

这时咱们再点进queue1队列中查看详细信息就可以看到以下信息

完成RabbitMQ镜像同步之后，如果RabbitMQ1再次宕机，那么queue1在RabbitMQ2中仍然可用，但是所属节点则变成了RabbitMQ2

没有镜像节点是因为我们集群中只有两台机器，宕机一台没有其他机器可以做镜像了

如果在RabbitMQ1宕机后有了新消息进来

当RabbitMQ1再次启动后，则会将其作为镜像节点同步所有的交换机和队列信息过去

重启RabbitMQ1服务，查看队列中消息

如上图，队列中的一条消息是mq1宕机时候由mq2节点在queue1队列发布的一条消息，在mq1重启后，将mq1设置为了镜像节点，并且将队列消息同步到了mq1，这就是RabbitMQ的镜像模式

补充：Headers Exchange

类似于Topic，但Topic仅限于字符串的方式，且需要用.进行分割

而headers可以支持的规则形式更加丰富

根据Headers中携带的key-value参数进行匹配

适用于匹配值为对象或者hash值时使用

x-match

all

x-match = all如下图

由于下面Headers中携带的属性age = 23 与我们发送的属性age = 24匹配不上，所以无法路由到下面的队列中

any

x-match = any如下图

由于下方队列的x-match = any，所以Headers中携带的参数name = RhysNi与我们发布的消息中name = RhysNi相匹配，所以这条调戏可以同时被路由到两个队列

在这里插入图片描述

代码示例

public class Publisher {
    public static final String QUEUE_NAME1 = "headersQ1";
    public static final String QUEUE_NAME2 = "headersQ2";
    public static final String EXCHANGE_NAME = "headersExchange";

    public static void main(String[] args) throws Exception {
        //构建连接对象
        Connection connection = ConnectionUtil.getConnection();
        //构建channel
        Channel channel = connection.createChannel();
        //构建交换机
        channel.exchangeDeclare(EXCHANGE_NAME, BuiltinExchangeType.HEADERS);
        //构建队列（队列名称,队列是否需要持久化,是否设置为排外队列(只能由一个消费者监听),长时间未使用自动删除，其他参数）
        channel.queueDeclare(QUEUE_NAME1, false, false, false, null);
        channel.queueDeclare(QUEUE_NAME2, false, false, false, null);

        //构建交换机和队列绑定规则
        Map<String, Object> params1 = new HashMap<>();
        params1.put("x-match", "all");
        params1.put("name", "RhysNi");
        params1.put("age", "24");

        Map<String, Object> params2 = new HashMap<>();
        params2.put("x-match", "any");
        params2.put("name", "RhysNi");
        params2.put("age", "23");

        //绑定交换机和队列
        channel.queueBind(QUEUE_NAME1, EXCHANGE_NAME, "", params1);
        channel.queueBind(QUEUE_NAME2, EXCHANGE_NAME, "", params2);

        //构建headers
        Map<String, Object> headers = new HashMap<>();
        headers.put("name", "RhysNi");
        headers.put("age", "24");

        AMQP.BasicProperties properties = new AMQP.BasicProperties()
                .builder()
                .headers(headers)
                .build();

        //发送消息
        channel.basicPublish(EXCHANGE_NAME, "", properties, "测试Headers Exchange".getBytes(StandardCharsets.UTF_8));
        System.out.println("消息发送成功");
    }
}