RabbitMQ学习笔记

跟着编程不良人视频学习
死信相关的是跟着尚硅谷学的

1.名词介绍

Broker: 接收和分发消息的应用，RabbitMQ Server就是Message Broker

Connection: publisher / consumer和 broker之间的TCP连接

Channel:如果每一次访问RabbitMQ都建立一个Connection，在消息量大的时候建立TCP
Connection的开销将是巨大的，效率也较低。Channel是在connection 内部建立的逻辑连接，如果应用程序支持多线程，通常每个thread创建单独的channel进行通讯，AMQP method包含了channel id 帮助客户端和message broker识别 channel，所以channel 之间是完全隔离的。Channel作为轻量级的Connection极大减少了操作系统建TCP connection的开销

Exchange: message 到达 broker 的第一站，根据分发规则，匹配查询表中的 routing key，分发消息到queue 中去。常用的类型有: direct (point-to-point), topic(publish-subscribe) and fanout(multicast)

Routing Key:生产者将消息发送到交换机时会携带一个key,来指定路由规则

binding Key:在绑定Exchange和Queue时，会指定一个BindingKey,生产者发送消息携带的RoutingKey会和bindingKey对比，若一致就将消息分发至这个队列

vHost 虚拟主机：每一个RabbitMQ服务器可以开设多个虚拟主机每一个vhost本质上是一个mini版的RabbitMQ服务器，拥有自己的 “交换机exchange、绑定Binding、队列Queue”，更重要的是每一个vhost拥有独立的权限机制，这样就能安全地使用一个RabbitMQ服务器来服务多个应用程序，其中每个vhost服务一个应用程序。

2.安装

2.1下载安装包

https://download.csdn.net/download/Fire_Sky_Ho/87765198

2.2 上传并安装

使用rpm -ivh 文件名.rpm安装上面那三个包

安装web管理插件rabbitmq-plugins enable rabbitmq-management

安装完，复制/usr/share/doc/rabbitmq-server-3.7.18/rabbitmq.config.example文件到/etc/rabbitmq/目录下
rabbitmq默认从这个目录读取配置文件
然后修改下配置文件，%% {loopback_users, []},改成{loopback_users, []}，注意原先的逗号去掉

开启web管理工具systemctl start rabbitmq-server
访问管理页面http://127.0.0.1:15672，默认账户和密码都是guest

3.消息模型

3.1第一种-Hello World!/基础队列（生产者-队列-消费者）

P：生产者，要发送消息的程序
C：消费者，等待接收消息的程序
Queue：消息队列，图中红色部分。实质上是一个大的消息缓冲区。类似一个邮箱，可以缓存消息；生产者向其中投递消息，消费者从其中取出消息。遵循先进先出原则

<dependency>
            <groupId>com.rabbitmqgroupId>
            <artifactId>amqp-clientartifactId>
            <version>5.10.0version>
        dependency>

生产者

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

import java.io.IOException;
import java.util.concurrent.TimeoutException;

/**
 * 消息生产者
 */
public class Producer {
    public static void main(String[] args) throws IOException, TimeoutException {
        //创建连接mq的连接工厂对象，重量级对象，类加载时创建一次即可
        ConnectionFactory connectionFactory = new ConnectionFactory();
        //设置连接rabbitmq的主机
        connectionFactory.setHost("192.168.80.131");
        //设置端口号
        connectionFactory.setPort(5672);
        //设置连接的虚拟主机
        connectionFactory.setVirtualHost("/");
        //设置访问虚拟主机的用户名和密码
        connectionFactory.setUsername("guest");
        connectionFactory.setPassword("guest");

        //获取连接对象
        Connection connection = connectionFactory.newConnection();
        //创建一个通道
        Channel channel = connection.createChannel();
        //通道绑定对应消息队列
        /*
         * 参数1 queue：队列名称(不存在自动创建)
         * 参数2 durable：用来定义队列特性是否需要持久化(为true该队列将在服务器重启后保留下来，持久化到硬盘中)
         * 参数3 exclusive：是否独占队列(为true仅限此连接)
         * 参数4 autoDelete：是否在消费完成后自动删除队列
         * 参数5 arguments：队列的其他属性（构造参数）
         * */
        channel.queueDeclare("hello",true,false,false,null);
        //发布消息
        /*
         * 参数1 exchange：要将消息发布到的交换机
         * 餐数2 routingKey：路由键，指定队列
         * 参数3 props：消息的其他属性
         * 参数4 body：消息具体内容
         * */
        channel.basicPublish("","hello",null,"hello world".getBytes());
        channel.close();
        connection.close();
    }
}

发现队列已经发布了3个消息

消费者

import com.rabbitmq.client.*;

import java.io.IOException;

public class Consumer {
    public static void main(String[] args) throws Exception {
        //创建连接mq的连接工厂对象，重量级对象，类加载时创建一次即可
        ConnectionFactory connectionFactory = new ConnectionFactory();
        //设置连接rabbitmq的主机
        connectionFactory.setHost("192.168.80.131");
        //设置端口号
        connectionFactory.setPort(5672);
        //设置连接的虚拟主机
        connectionFactory.setVirtualHost("/");
        //设置访问虚拟主机的用户名和密码
        connectionFactory.setUsername("guest");
        connectionFactory.setPassword("guest");

        //获取连接对象
        Connection connection = connectionFactory.newConnection();
        //创建一个通道
        Channel channel = connection.createChannel();
        //通道绑定对应消息队列
        /*
         * 参数1 queue：队列名称(不存在自动创建)
         * 参数2 durable：用来定义队列特性是否需要持久化(为true该队列将在服务器重启后保留下来，持久化到硬盘中)
         * 参数3 exclusive：是否独占队列(为true仅限此连接)
         * 参数4 autoDelete：是否在消费完成后自动删除队列
         * 参数5 arguments：队列的其他属性（构造参数）
         * */
        channel.queueDeclare("hello", true, false, false, null);

        channel.basicConsume("hello", true, new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("consumerTag:" + consumerTag);
                System.out.println("exchange:" + envelope.getExchange());
                System.out.println("routingKey:" + envelope.getRoutingKey());
                System.out.println("properties:" + properties);
                System.out.println("body" + new String(body));
            }
        });
        //channel.close();
        //connection.close();
        //阻塞防止还没消费完，就退出线程了
        while (true) {

        }

    }
}

输出了3次

consumerTag:amq.ctag-iKrA8vdEXX1oEzbEyeYqYA
exchange:
routingKey:hello
properties:#contentHeader(content-type=null, content-encoding=null, headers=null, delivery-mode=null, priority=null, correlation-id=null, reply-to=null, expiration=null, message-id=null, timestamp=null, type=null, user-id=null, app-id=null, cluster-id=null)
bodyhello world
consumerTag:amq.ctag-iKrA8vdEXX1oEzbEyeYqYA
exchange:
routingKey:hello
properties:#contentHeader(content-type=null, content-encoding=null, headers=null, delivery-mode=null, priority=null, correlation-id=null, reply-to=null, expiration=null, message-id=null, timestamp=null, type=null, user-id=null, app-id=null, cluster-id=null)
bodyhello world
consumerTag:amq.ctag-iKrA8vdEXX1oEzbEyeYqYA
exchange:
routingKey:hello
properties:#contentHeader(content-type=null, content-encoding=null, headers=null, delivery-mode=null, priority=null, correlation-id=null, reply-to=null, expiration=null, message-id=null, timestamp=null, type=null, user-id=null, app-id=null, cluster-id=null)
bodyhello world

提取公用代码，封装工具类

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

public class RabbitMQUtils {

    private static ConnectionFactory connectionFactory;

    static {
        //重量级资源  类加载执行之执行一次
        connectionFactory = new ConnectionFactory();
        connectionFactory.setHost("192.168.42.134");
        connectionFactory.setPort(5672);
        connectionFactory.setVirtualHost("/");
        connectionFactory.setUsername("admin");
        connectionFactory.setPassword("admin");

    }

    //定义提供连接对象的方法
    public static Connection getConnection() {
        try {
            return connectionFactory.newConnection();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    //关闭通道和关闭连接工具方法
    public static void closeConnectionAndChanel(Channel channel, Connection conn) {
        try {
            if (channel != null) {
                channel.close();
            }
            if (conn != null) {
                conn.close();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

持久化消息
生产者代码修改如下

//第二个参数填true
channel.queueDeclare("hello",true,false,false,null);
//第三个参数填MessageProperties.PERSISTENT_TEXT_PLAIN
channel.basicPublish("","hello", MessageProperties.PERSISTENT_TEXT_PLAIN,"hello world".getBytes());

此时重新运行生产者，重启mq，发现消息依旧存在

3.2第二种-Work Queues/工作队列/任务队列

Work queues，也被称为（Task queues），任务模型。
当消息处理比较耗时的时候，可能生产消息的速度会
远远大于消息的消费速度。长此以往，消息就会堆积
越来越多，无法及时处理。此时就可以使用work 模型：
让多个消费者绑定到一个队列，共同消费队列中的消息。
队列中的消息一旦消费，就会消失，因此任务是不会被重复执行的。

角色：
P：生产者：任务的发布者
C1：消费者-1，领取任务并且完成任务，假设完成速度较慢
C2：消费者-2：领取任务并完成任务，假设完成速度快

生产者

package Work_Queues;

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.MessageProperties;
import utils.RabbitMQUtils;

/**
 * 消息生产者
 */
public class Producer {
    public static void main(String[] args) throws Exception {
        Connection connection = RabbitMQUtils.getConnection();
        Channel channel = connection.createChannel();
        channel.queueDeclare("hello",true,false,false,null);
        for (int i = 0; i <10 ; i++) {
            channel.basicPublish("","hello", MessageProperties.PERSISTENT_TEXT_PLAIN,("hello world-"+i).getBytes());
        }
        RabbitMQUtils.closeConnectionAndChanel(channel,connection);
    }
}

消费者1

package Work_Queues;

import com.rabbitmq.client.*;
import utils.RabbitMQUtils;

import java.io.IOException;

/**
 * 消息消费者
 */
public class Consumer_1 {
    public static void main(String[] args) throws Exception {
        Connection connection = RabbitMQUtils.getConnection();
        Channel channel = connection.createChannel();
        channel.queueDeclare("hello",true,false,false,null);
        channel.basicConsume("hello", false,new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println(new String(body));
            }
        });
    }
}

消费者2

package Work_Queues;

import com.rabbitmq.client.*;
import utils.RabbitMQUtils;

import java.io.IOException;

/**
 * 消息消费者
 */
public class Consumer_1 {
    public static void main(String[] args) throws Exception {
        Connection connection = RabbitMQUtils.getConnection();
        Channel channel = connection.createChannel();
        channel.queueDeclare("hello",true,false,false,null);
        channel.basicConsume("hello", false,new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println(new String(body));
            }
        });
    }
}

生产者启动发布10个消息
消费者1收到消息

hello world-0
hello world-2
hello world-4
hello world-6
hello world-8

消费者2收到消息

hello world-1
hello world-3
hello world-5
hello world-7
hello world-9

总结
默认情况下，RabbitMQ将按顺序将每个消息发送给
下一个使用者。平均而言，每个消费者都会收到相同数量
的消息。这种分发消息的方式称为循环。

3.3消息确认机制

上面代码运行完，再去查看会发现Unacked为10，表示待应答的消息总数，即生产者并没有给生产者说我确认此条消息消费了，因为basicConsume方法第二个参数没设置为true自动确认。
如果此时没有其他消费者，只剩一个消费者，重启这个消费者，会重新接收到这些未确认的消息。
channel.basicAck(envelope.getDeliveryTag(),false);加入这串，basicConsume第二个参数autoAck改为false，即可手动确认消息
消费者1

public class Consumer_1 {
    public static void main(String[] args) throws Exception {
        Connection connection = RabbitMQUtils.getConnection();
        Channel channel = connection.createChannel();
        channel.basicQos(1);//每一次只能消费一个消息
        channel.queueDeclare("hello",true,false,false,null);
        channel.basicConsume("hello", false,new DefaultConsumer(channel) {
            @SneakyThrows
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                TimeUnit.SECONDS.sleep(1);
                System.out.println(new String(body));
                //参数1:手动确认消息标识 参数2:false 每次确认一个
                channel.basicAck(envelope.getDeliveryTag(),false);
            }
        });
    }
}

消费者2

public class Consumer_2 {
    public static void main(String[] args) throws Exception {
        Connection connection = RabbitMQUtils.getConnection();
        Channel channel = connection.createChannel();
        channel.queueDeclare("hello", true, false, false, null);
        channel.basicQos(1);
        channel.basicConsume("hello", false, new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println(new String(body));
                //参数1:手动确认消息标识 参数2:false 每次确认一个
                channel.basicAck(envelope.getDeliveryTag(), false);
            }
        });
    }
}

消费者1输出

hello world-0

消费者2输出

hello world-1
hello world-2
hello world-3
hello world-4
hello world-5
hello world-6
hello world-7
hello world-8
hello world-9

上面的结果因为消费者1，加了延时1秒，且channel.basicQos(1); 每次接收接收一条消息，直到确认返回，所以其他就被消费者2没加延迟消费完了，能者多劳

3.4第三种模式-Publish/Subscribe/发布订阅（交换机-fanout类型）

在广播模式下，消息发送流程是这样的：
可以有多个消费者
每个消费者有自己的queue（队列）
每个队列都要绑定到Exchange（交换机）
生产者发送的消息，只能发送到交换机，
交换机来决定要发给哪个队列，生产者无法决定。
交换机把消息发送给绑定过的所有队列
队列的消费者都能拿到消息。实现一条消息被多个消费者消费

生产者

public class Producer {
    public static void main(String[] args) throws Exception {
        Connection connection = RabbitMQUtils.getConnection();
        Channel channel = connection.createChannel();

        //将通道声明指定交换机
        //参数1: 交换机名称    参数2: 交换机类型  fanout 广播类型
        channel.exchangeDeclare("logs", BuiltinExchangeType.FANOUT);

        //发消息
        channel.basicPublish("logs","",null,"fanout type message".getBytes());

        RabbitMQUtils.closeConnectionAndChanel(channel,connection);
    }
}

消费者1

public class Consumer_1 {
    public static void main(String[] args) throws Exception {
        Connection connection = RabbitMQUtils.getConnection();
        Channel channel = connection.createChannel();
        //通道绑定交换机
        channel.exchangeDeclare("logs", "fanout");
        //获取临时队列名
        String queueName = channel.queueDeclare().getQueue();
        System.out.println("queueName:" + queueName);
        //绑定交换机和队列
        channel.queueBind(queueName, "logs", "");
        //自动确认关掉
        channel.basicConsume(queueName, true, new DefaultConsumer(channel) {
            @SneakyThrows
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("消费者1" + new String(body));
            }
        });
    }
}

消费者2

public class Consumer_2 {
    public static void main(String[] args) throws Exception {
        Connection connection = RabbitMQUtils.getConnection();
        Channel channel = connection.createChannel();
        //通道绑定交换机
        channel.exchangeDeclare("logs", "fanout");
        //获取临时队列名
        String queueName = channel.queueDeclare().getQueue();
        System.out.println("queueName:" + queueName);
        //绑定交换机和队列
        channel.queueBind(queueName, "logs", "");
        //自动确认关掉
        channel.basicConsume(queueName, true, new DefaultConsumer(channel) {
            @SneakyThrows
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("消费者2" + new String(body));
            }
        });
    }
}

生产者启动，发布消息
两个消费者收到消息

消费者1fanout type message

消费者2fanout type message

3.5第四种模式-Routing/路由（交换机-Direct类型）

P：生产者，向Exchange发送消息，发送消息时，
会指定一个routing key。
X：Exchange（交换机），接收生产者的消息，
然后把消息递交给 与routing key完全匹配的队列
C1：消费者，其所在队列指定了需要routing key 为 error 的消息
C2：消费者，其所在队列指定了需要routing key 为 info、
error、warning 的消息

在Fanout模式中，一条消息，会被所有订阅的队列都消费。
但是，在某些场景下，我们希望不同的消息被不同的队列消费。
这时就要用到Direct类型的Exchange。

在Direct模型下：队列与交换机的绑定，不能是任意绑定了，
而是要指定一个RoutingKey（路由key）
消息的发送方在 向 Exchange发送消息时，
也必须指定消息的 RoutingKey。
Exchange不再把消息交给每一个绑定的队列，
而是根据消息的Routing Key进行判断，
只有队列的Routingkey与消息的 Routing key完全一致，
才会接收到消息

生产者

public class Producer {
    public static void main(String[] args) throws Exception {
        Connection connection = RabbitMQUtils.getConnection();
        Channel channel = connection.createChannel();

        String exchangeName = "logs_direct";
        //将通道声明指定交换机
        //参数1: 交换机名称    参数2: 交换机类型  fanout 广播类型
        channel.exchangeDeclare(exchangeName, BuiltinExchangeType.DIRECT);

        String routingKey = "info";
//        String routingKey = "error";
        //发消息
        channel.basicPublish(exchangeName, routingKey, null, ("这是direct模型发布的基于route key: [" + routingKey + "] 发送的消息").getBytes());

        RabbitMQUtils.closeConnectionAndChanel(channel, connection);
    }
}

消费者1

public class Consumer_1 {
    public static void main(String[] args) throws Exception {
        Connection connection = RabbitMQUtils.getConnection();
        Channel channel = connection.createChannel();
        String exchangeName = "logs_direct";
        //通道绑定交换机
        channel.exchangeDeclare(exchangeName, BuiltinExchangeType.DIRECT);
        //获取临时队列名
        String queueName = channel.queueDeclare().getQueue();

        String routingKey = "error";

        //绑定交换机和队列
        channel.queueBind(queueName, exchangeName, routingKey);
        //自动确认关掉
        channel.basicConsume(queueName, true, new DefaultConsumer(channel) {
            @SneakyThrows
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("消费者1" + new String(body));
            }
        });
    }
}

消费者2

public class Consumer_2 {
    public static void main(String[] args) throws Exception {
        Connection connection = RabbitMQUtils.getConnection();
        Channel channel = connection.createChannel();
        String exchangeName = "logs_direct";
        //通道绑定交换机
        channel.exchangeDeclare(exchangeName, BuiltinExchangeType.DIRECT);
        //获取临时队列名
        String queueName = channel.queueDeclare().getQueue();


        //绑定交换机和队列
        //临时队列和交换机绑定
        channel.queueBind(queueName, exchangeName, "info");
        channel.queueBind(queueName, exchangeName, "error");
        channel.queueBind(queueName, exchangeName, "warning");
        //自动确认关掉
        channel.basicConsume(queueName, true, new DefaultConsumer(channel) {
            @SneakyThrows
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("消费者2" + new String(body));
            }
        });
    }
}

消费者1接收routingKey为error的消息，消费者2接收info,error,warning三种routingKey

首先启动生产者，routingKey为info，此时消费者2能收到消息

消费者2这是direct模型发布的基于route key: [info] 发送的消息

生产者，routingKey为error，消费者1和2都能收到消息

消费者1这是direct模型发布的基于route key: [error] 发送的消息

消费者2这是direct模型发布的基于route key: [error] 发送的消息

3.6第五种模式-Topic/主题（交换机-topic类型）

Topic类型的Exchange与Direct相比，都是可以根据RoutingKey
把消息路由到不同的队列。只不过Topic类型Exchange可以让
队列在绑定Routing key的时候使用通配符！这种模型Routingkey
一般都是由一个或多个单词组成，多个单词之间以”.”分割，
例如： item.insert

在Direct模型下：队列与交换机的绑定，不能是任意绑定了，
而是要指定一个RoutingKey（路由key）
消息的发送方在 向 Exchange发送消息时，
也必须指定消息的 RoutingKey。
Exchange不再把消息交给每一个绑定的队列，
而是根据消息的Routing Key进行判断，
只有队列的Routingkey与消息的 Routing key完全一致，
才会接收到消息

P：生产者，向Exchange发送消息，发送消息时，
会指定一个routing key。
X：Exchange（交换机），接收生产者的消息，
然后把消息递交给 与routing key完全匹配的队列
C1：消费者，其所在队列指定了需要routing key 为 error 的消息
C2：消费者，其所在队列指定了需要routing key 为 info、
error、warning 的消息

生产者

public class Producer {
    public static void main(String[] args) throws Exception {
        Connection connection = RabbitMQUtils.getConnection();
        Channel channel = connection.createChannel();

        String exchangeName = "topics";
        //将通道声明指定交换机
        //参数1: 交换机名称    参数2: 交换机类型  TOPIC 主题类型
        channel.exchangeDeclare(exchangeName, BuiltinExchangeType.TOPIC);

        String routingKey = "user.save";
        //发消息
        channel.basicPublish(exchangeName, routingKey, null, ("这是topic模型发布的基于route key: [" + routingKey + "] 发送的消息").getBytes());
        channel.basicPublish(exchangeName, "a.pp", null, ("这是topic模型发布的基于route key: [" + "a.pp" + "] 发送的消息").getBytes());

        RabbitMQUtils.closeConnectionAndChanel(channel, connection);
    }
}

消费者1

public class Consumer_1 {
    public static void main(String[] args) throws Exception {
        Connection connection = RabbitMQUtils.getConnection();
        Channel channel = connection.createChannel();
        String exchangeName = "topics";
        //通道绑定交换机
        channel.exchangeDeclare(exchangeName, BuiltinExchangeType.TOPIC);
        //获取临时队列名
        String queueName = channel.queueDeclare().getQueue();

        String routingKey = "user.*";

        //绑定交换机和队列
        channel.queueBind(queueName, exchangeName, routingKey);
        //自动确认关掉
        channel.basicConsume(queueName, true, new DefaultConsumer(channel) {
            @SneakyThrows
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("消费者1" + new String(body));
            }
        });
    }
}

消费者2

public class Consumer_2 {
    public static void main(String[] args) throws Exception {
        Connection connection = RabbitMQUtils.getConnection();
        Channel channel = connection.createChannel();
        String exchangeName = "topics";
        //通道绑定交换机
        channel.exchangeDeclare(exchangeName, BuiltinExchangeType.TOPIC);
        //获取临时队列名
        String queueName = channel.queueDeclare().getQueue();

        String routingKey = "a.*";

        //绑定交换机和队列
        channel.queueBind(queueName, exchangeName, routingKey);
        //自动确认关掉
        channel.basicConsume(queueName, true, new DefaultConsumer(channel) {
            @SneakyThrows
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("消费者2" + new String(body));
            }
        });
    }
}

生产者发布了routingKey为user.save和a.pp的消息
消费者1使用routingKey 通配符 user.*接收,所以收到了以下消息

消费者1这是topic模型发布的基于route key: [user.save] 发送的消息

消费者2使用routingKey 通配符 a.*接收,所以收到了以下消息

消费者2这是topic模型发布的基于route key: [a.pp] 发送的消息

4.SpringBoot中使用RabbitMQ

4.1 环境搭建

pom

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0modelVersion>
    <groupId>com.examplegroupId>
    <artifactId>springboot-rabbitmqartifactId>
    <version>0.0.1-SNAPSHOTversion>
    <name>springboot-rabbitmqname>
    <description>springboot-rabbitmqdescription>
    <properties>
        <java.version>1.8java.version>
        <project.build.sourceEncoding>UTF-8project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8project.reporting.outputEncoding>
        <spring-boot.version>2.4.2spring-boot.version>
    properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-webartifactId>
        dependency>
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-testartifactId>
            <scope>testscope>
        dependency>
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-amqpartifactId>
        dependency>
    dependencies>
    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework.bootgroupId>
                <artifactId>spring-boot-dependenciesartifactId>
                <version>${spring-boot.version}version>
                <type>pomtype>
                <scope>importscope>
            dependency>
        dependencies>
    dependencyManagement>

project>

yml

spring:
  application:
    name: springboot_rabbitmq
  rabbitmq:
    host: 127.0.0.1
    port: 5673
    username: root
    password: 123
    virtual-host: /

4.1第一种-Hello World!/基础队列（生产者-队列-消费者）

生产者

@SpringBootTest
public class Producer {

    @Autowired
    private RabbitTemplate rabbitTemplate;

    /**
     * 生产端没有指定交换机只有routingKey和Object。
     * 消费方产生hello队列，放在默认的交换机(AMQP default)上。
     * 而默认的交换机有一个特点，只要你的routerKey的名字与这个
     * 交换机的队列有相同的名字，他就会自动路由上。
     * 生产端routingKey 叫hello ，消费端生产hello队列。
     * 他们就路由上了
     */
    @Test
    void producer() {
        rabbitTemplate.convertAndSend("hello", "hello world");
    }

}

消费者

/**
 * 生产端没有指定交换机只有routingKey和Object。
 * 消费方产生hello队列，放在默认的交换机(AMQP default)上。
 * 而默认的交换机有一个特点，只要你的routerKey的名字与这个
 * 交换机的队列有相同的名字，他就会自动路由上。
 * 生产端routingKey 叫hello ，消费端生产hello队列。
 * 他们就路由上了
 */
@Component
@RabbitListener(queuesToDeclare = @Queue(value = "hello"))
public class ConsumerHelloWord {

    @RabbitHandler
    public void receive(String message) {
        System.out.println("message = " + message);
    }

}

先运行消费者，在运行生产者

4.2第二种-Work Queues/工作队列/任务队列

生产者

/**
 * 生产端没有指定交换机只有routingKey和Object。
 * 消费方产生work队列，放在默认的交换机(AMQP default)上。
 * 而默认的交换机有一个特点，只要你的routerKey的名字与这个
 * 交换机的队列有相同的名字，他就会自动路由上。
 * 生产端routingKey 叫work ，消费端生产work队列。
 * 他们就路由上了
 */
@Component
public class ConsumerWorkQueues {

    @RabbitListener(queuesToDeclare = @Queue("work"))
    public void receive1(String message) {
        System.out.println("work message1 = " + message);
    }


    @RabbitListener(queuesToDeclare = @Queue("work"))
    public void receive2(String message) {
        System.out.println("work message2 = " + message);
    }
}

消费者

/**
 * 生产端没有指定交换机只有routingKey和Object。
 * 消费方产生work队列，放在默认的交换机(AMQP default)上。
 * 而默认的交换机有一个特点，只要你的routerKey的名字与这个
 * 交换机的队列有相同的名字，他就会自动路由上。
 * 生产端routingKey 叫work ，消费端生产work队列。
 * 他们就路由上了
 */
@Component
public class ConsumerWorkQueues {

    @RabbitListener(queuesToDeclare = @Queue("work"))
    public void receive1(String message) {
        System.out.println("work message1 = " + message);
    }


    @RabbitListener(queuesToDeclare = @Queue("work"))
    public void receive2(String message) {
        System.out.println("work message2 = " + message);
    }
}

4.3第三种模式-Publish/Subscribe/发布订阅（交换机-fanout类型）

生产者

@SpringBootTest
public class Producer {

    @Autowired
    private RabbitTemplate rabbitTemplate;

    @Test
    void producer() {
        for (int i = 0; i < 10; i++) {
            //参数1为交换机
            //参数2为路由key,“”表示为任意路由
            //参数3为消息内容
            rabbitTemplate.convertAndSend("logs","","这是日志广播");
        }
    }

}

消费者

@Component
public class ConsumerWorkQueuesFanout {

    //使用@RabbitListener注解中的bindings声明并绑定交换机和队列
    @RabbitListener(bindings = @QueueBinding(value = @Queue, // 创建临时队列
            exchange = @Exchange(name = "logs", type = ExchangeTypes.FANOUT)
    ))
    public void receive1(String message) {
        System.out.println("message1 = " + message);
    }

    @RabbitListener(bindings = @QueueBinding(value = @Queue, // 创建临时队列
            exchange = @Exchange(name = "logs", type = ExchangeTypes.FANOUT)
    ))
    public void receive2(String message) {
        System.out.println("message2 = " + message);
    }
}

4.4第四种模式-Routing/路由（交换机-Direct类型）

生产者

@SpringBootTest
public class Producer {

    @Autowired
    private RabbitTemplate rabbitTemplate;

    @Test
    void producer() {
        for (int i = 0; i < 10; i++) {
            //参数1为交换机
            //参数2为路由key,“”表示为任意路由
            //参数3为消息内容
            rabbitTemplate.convertAndSend("directs","error","error 的日志信息");
        }
    }

}

消费者

@Component
public class ConsumerRouting {

    //使用@RabbitListener注解中的bindings声明并绑定交换机和队列
    @RabbitListener(bindings = @QueueBinding(value = @Queue("directsQueue"),//指定队列名
            key = {"info", "error"},
            exchange = @Exchange(name = "directs", type = ExchangeTypes.DIRECT)
    ))
    public void receive1(String message) {
        System.out.println("message1 = " + message);
    }

    @RabbitListener(bindings = @QueueBinding(value = @Queue("directsQueue"),
            key = {"error"},
            exchange = @Exchange(name = "directs", type = ExchangeTypes.DIRECT)
    ))
    public void receive2(String message) {
        System.out.println("message2 = " + message);
    }
}

4.5第五种模式-Topic/主题（交换机-topic类型）

生产者

@SpringBootTest
public class Producer {

    @Autowired
    private RabbitTemplate rabbitTemplate;

    @Test
    void producer() {
        for (int i = 0; i < 10; i++) {
            //参数1为交换机
            //参数2为路由key,“”表示为任意路由
            //参数3为消息内容
            rabbitTemplate.convertAndSend("topics","user.save.findAll","user.save.findAll 的消息");
        }
    }

}

消费者

@Component
public class ConsumerTopics {

    @RabbitListener(bindings = {
            @QueueBinding(
                    value = @Queue,
                    key = {"user.*"},
                    exchange = @Exchange(type = ExchangeTypes.TOPIC, name = "topics")
            )
    })
    public void receive1(String message) {
        System.out.println("message1 = " + message);
    }

    @RabbitListener(bindings = {
            @QueueBinding(
                    value = @Queue,
                    key = {"user.#"},
                    exchange = @Exchange(type = ExchangeTypes.TOPIC, name = "topics")
            )
    })
    public void receive2(String message) {
        System.out.println("message2 = " + message);
    }
}

5.死信队列，延迟队列

5.1 死信概念

先从概念解释上搞清楚这个定义，死信，顾名思义就是无法被消费的消息，字面意思可以这样理解，一般来说，producer 将消息投递到
broker 或者直接到queue 里了，consumer 从 queue 取出消息进行消费，但某些时候由于特定的原因导致 queue
中的某些消息无法被消费，这样的消息如果没有 后续的处理，就变成了死信，有死信自然就有了死信队列。

应用场景:为了保证订单业务的消息数据不丢失，需要使用到
RabbitMQ的死信队列机制，当消息消费发生异常时，将消息投入死信队列中.还有比如说:用户在商城下单成功并点击去支付后在指定时间未支付时自动失效

5.2死信的来源

1. 消息 TTL 过期
2. 队列达到最大长度(队列满了，无法再添加数据到 mq 中)
3. 消息被拒绝(basic.reject 或 basic.nack)并且 requeue=false.

5.3入门实战

5.3.1 架构图

5.3.2 代码

生产者

public class Producer {
    private static final String NORMAL_EXCHANGE = "normal_exchange";

    public static void main(String[] argv) throws Exception {
        try (Channel channel = RabbitMQUtils.getConnection().createChannel()) {
            channel.exchangeDeclare(NORMAL_EXCHANGE,
                    BuiltinExchangeType.DIRECT);
            //设置消息的 TTL 时间
            AMQP.BasicProperties properties = new AMQP.BasicProperties().builder().expiration("10000").build();
            //该信息是用作演示队列个数限制
            for (int i = 1; i < 11; i++) {
                String message = "info" + i;
                channel.basicPublish(NORMAL_EXCHANGE, "zhangsan", properties, message.getBytes());
                System.out.println("生产者发送消息:" + message);
            }
        }
    }
}

消费者1

public class Consumer01 {
    //普通交换机名称
    private static final String NORMAL_EXCHANGE = "normal_exchange";
    //死信交换机名称
    private static final String DEAD_EXCHANGE = "dead_exchange";

    public static void main(String[] argv) throws Exception {
        Channel channel = RabbitMQUtils.getConnection().createChannel();
        //声明死信和普通交换机 类型为 direct
        channel.exchangeDeclare(NORMAL_EXCHANGE, BuiltinExchangeType.DIRECT);
        channel.exchangeDeclare(DEAD_EXCHANGE, BuiltinExchangeType.DIRECT);

        //声明死信队列
        String deadQueue = "dead-queue";
        channel.queueDeclare(deadQueue, false, false, false, null);
        //死信队列绑定死信交换机与 routingKey
        channel.queueBind(deadQueue, DEAD_EXCHANGE, "lisi");

        Map<String, Object> params = new HashMap<>();
        //正常队列设置死信交换机 参数 key 是固定值
        params.put("x-dead-letter-exchange", DEAD_EXCHANGE);
        //正常队列设置死信 routing-key 参数 key 是固定值
        params.put("x-dead-letter-routing-key", "lisi");
        String normalQueue = "normal-queue";
        //正常队列绑定死信队列信息
        channel.queueDeclare(normalQueue, false, false, false, params);
        channel.queueBind(normalQueue, NORMAL_EXCHANGE, "zhangsan");

        System.out.println("等待接收消息........... ");

        DeliverCallback deliverCallback = (consumerTag, delivery) ->
        {
            String message = new String(delivery.getBody(), StandardCharsets.UTF_8);
            System.out.println("Consumer01 接收到消息" + message);
        };
        channel.basicConsume(normalQueue, true, deliverCallback, consumerTag -> {
        });
    }
}

消费者2

public class Consumer02 {
    //死信交换机名称
    private static final String DEAD_EXCHANGE = "dead_exchange";

    public static void main(String[] argv) throws Exception {
        Channel channel = RabbitMQUtils.getConnection().createChannel();
        channel.exchangeDeclare(DEAD_EXCHANGE, BuiltinExchangeType.DIRECT);

        //声明死信队列
        String deadQueue = "dead-queue";
        channel.queueDeclare(deadQueue, false, false, false, null);
        //死信队列绑定死信交换机与 routingKey
        channel.queueBind(deadQueue, DEAD_EXCHANGE, "lisi");

        System.out.println("等待接收消息........... ");

        DeliverCallback deliverCallback = (consumerTag, delivery) ->
        {
            String message = new String(delivery.getBody(), StandardCharsets.UTF_8);
            System.out.println("Consumer01 接收到消息" + message);
        };
        channel.basicConsume(deadQueue, true, deliverCallback, consumerTag -> {
        });
    }
}

流程
启动消费者1，生产交换机和队列

启动消费者，发现10条消息没被消费

等待10S后，发现没被消费就转移到死信队列

启动消费者2，消费者2去消费死信队列的消息

5.4 SpringBoot实现延迟队列

5.4.1 延迟队列概念

延时队列,队列内部是有序的，最重要的特性就体现在它的延时属性上，延时队列中的元素是希望在指定时间到了以后或之前取出和处理，简单来说，延时队列就是用来存放需要在指定时间被处理的元素的队列。

5.4.2 延迟队列使用场景

1.订单在十分钟之内未支付则自动取消
2.新创建的店铺，如果在十天内都没有上传过商品，则自动发送消息提醒。
3.用户注册成功后，如果三天内没有登陆则进行短信提醒。
4.用户发起退款，如果三天内没有得到处理则通知相关运营人员。
5.预定会议后，需要在预定的时间点前十分钟通知各个与会人员参加会议

这些场景都有一个特点，需要在某个事件发生之后或者之前的指定时间点完成某一项任务

5.4.3 RabbitMQ 中的 TTL

TTL 是什么呢？TTL 是 RabbitMQ 中一个消息或者队列的属性，表明一条消息或者该队列中的所有消息的最大存活时间，单位是毫秒。

换句话说，如果一条消息设置了 TTL 属性或者进入了设置TTL 属性的队列，那么这条消息如果在TTL 设置的时间内没有被消费，则会成为"死信"。如果同时配置了队列的TTL 和消息的TTL，那么较小的那个值将会被使用，有两种方式设置 TTL。

如果设置了队列的 TTL 属性，那么一旦消息过期，就会被队列丢弃(如果配置了死信队列被丢到死信队 列中)，而第二种方式，消息即使过期，也不一定会被马上丢弃，因为消息是否过期是在即将投递到消费者 之前判定的，如果当前队列有严重的消息积压情况，则已过期的消息也许还能存活较长时间；另外，还需 要注意的一点是，如果不设置 TTL，表示消息永远不会过期，如果将 TTL 设置为 0，则表示除非此时可以 直接投递该消息到消费者，否则该消息将会被丢弃。

前一小节我们介绍了死信队列，刚刚又介绍了 TTL，至此利用 RabbitMQ 实现延时队列的两大要素已 经集齐，接下来只需要将它们进行融合，再加入一点点调味料，延时队列就可以新鲜出炉了。想想看，延 时队列，不就是想要消息延迟多久被处理吗，TTL 则刚好能让消息在延迟多久之后成为死信，另一方面， 成为死信的消息都会被投递到死信队列里，这样只需要消费者一直消费死信队列里的消息就完事了，因为 里面的消息都是希望被立即处理的消息。

5.4.3 架构图

创建两个队列 QA 和 QB，两者队列 TTL 分别设置为 10S 和 20S，然后在创建一个交换机 X 和死信交换机 Y，它们的类型都是direct，创建一个死信队列 QD，它们的绑定关系如下：

5.4.4 实现代码

用上面的springboot项目继续搞这个延迟队列
配置类 用于生命交换机、队列以及之间的绑定关系

@Configuration
public class DeadQueueConfig {
    public static final String EXCHANGE_X = "X";
    public static final String ROUTING_KEY_XA = "XA";
    public static final String ROUTING_KEY_XB = "XB";
    public static final String QUEUE_A = "QA";
    public static final String QUEUE_B = "QB";
    public static final String EXCHANGE_Y = "Y";
    public static final String QUEUE_D = "QD";
    public static final String ROUTING_KEY_YD = "YD";
    public static final int X_MESSAGE_TTL_QA = 10;
    public static final int X_MESSAGE_TTL_QB = 20;

    // 声明 交换机X
    @Bean
    public DirectExchange exchangeX() {
        return new DirectExchange(EXCHANGE_X);
    }

    //声明队列 A ttl 为 10s 并绑定到对应的死信交换机
    @Bean
    public Queue queueA() {
        return QueueBuilder.durable(QUEUE_A)
                //声明当前队列绑定的死信交换机
                .deadLetterExchange(EXCHANGE_Y)
                //声明当前队列的死信路由 key
                .deadLetterRoutingKey(ROUTING_KEY_YD)
                //声明队列的 TTL
                .ttl(X_MESSAGE_TTL_QA * 1000)
                .build();
    }

    // 声明队列 A 绑定 X 交换机
    @Bean
    public Binding queueABindExchangeX(Queue queueA, DirectExchange exchangeX) {
        return BindingBuilder.bind(queueA).to(exchangeX).with(ROUTING_KEY_XA);
    }

    //声明队列 B ttl 为 20s 并绑定到对应的死信交换机
    @Bean
    public Queue queueB() {
        return QueueBuilder.durable(QUEUE_B)
                .deadLetterExchange(EXCHANGE_Y)
                .deadLetterRoutingKey(ROUTING_KEY_YD)
                .ttl(X_MESSAGE_TTL_QB * 1000)
                .build();
    }

    //声明队列 B 绑定 X 交换机
    @Bean
    public Binding queueBBindExchangeX(Queue queueB, DirectExchange exchangeX) {
        return BindingBuilder.bind(queueB).to(exchangeX).with(ROUTING_KEY_XB);
    }

    // 声明 交换机Y
    @Bean
    public DirectExchange exchangeY() {
        return new DirectExchange(EXCHANGE_Y);
    }

    //声明死信队列 QD
    @Bean
    public Queue queueD() {
        return new Queue(QUEUE_D);
    }

    //声明死信队列 QD 绑定关系
    @Bean
    public Binding queueDBindExchangeX(Queue queueD, DirectExchange exchangeY) {
        return BindingBuilder.bind(queueD).to(exchangeY).with(ROUTING_KEY_YD);
    }

}

消费者

@Slf4j
@Component
public class DeadLetterQueueConsumer {

    @RabbitListener(queues = DeadQueueConfig.QUEUE_D)
    public void receiveD(Message message, Channel channel){
        String msg = StrUtil.str(message.getBody(), StandardCharsets.UTF_8);
        log.info("当前时间：{},收到死信队列信息{}", DateUtil.now(), msg);
    }
}

生产者

@Slf4j
@RequestMapping("ttl")
@RestController
public class SendMsgController {
    @Autowired
    private RabbitTemplate rabbitTemplate;

    @GetMapping("sendMsg/{message}")
    public void sendMsg(@PathVariable String message) {
        log.info("当前时间：{},发送一条信息给两个 TTL 队列:{}", DateUtil.now(), message);
        //第三个参数：要发送的消息
        rabbitTemplate.convertAndSend(DeadQueueConfig.EXCHANGE_X, DeadQueueConfig.ROUTING_KEY_XA, "消息来自 ttl 为 " + DeadQueueConfig.X_MESSAGE_TTL_QA + "S 的队列: " + message);
        rabbitTemplate.convertAndSend(DeadQueueConfig.EXCHANGE_X, DeadQueueConfig.ROUTING_KEY_XB, "消息来自 ttl 为 " + DeadQueueConfig.X_MESSAGE_TTL_QB + "S 的队列: " + message);
    }
}

发送请求 http://127.0.0.1:8080/ttl/sendMsg/姬霓太美

第一条消息在 10S 后变成了死信消息，然后被消费者消费掉，第二条消息在 40S 之后变成了死信消息， 然后被消费掉，这样一个延时队列就打造完成了。

不过，如果这样使用的话，岂不是每增加一个新的时间需求，就要新增一个队列，这里只有 10S 和 40S 两个时间选项，如果需要一个小时后处理，那么就需要增加TTL 为一个小时的队列，如果是预定会议室然 后提前通知这样的场景，岂不是要增加无数个队列才能满足需求？
0

5.4.5 优化，由生产者定义消息存活时间

5.4.5.1 代码架构图

在这里新增了一个队列 QC,绑定关系如下,该队列不设置TTL 时间,有生产者设定消息ttl

5.4.5.2 代码

配置类新增

    //声明队列C，ttl为生产者设置，并绑定到对应的死信交换机
    @Bean
    public Queue queueC() {
        return QueueBuilder.durable(QUEUE_C)
                //声明当前队列绑定的死信交换机
                .deadLetterExchange(EXCHANGE_Y)
                //声明当前队列的死信路由 key
                .deadLetterRoutingKey(ROUTING_KEY_YD)
                .build();
    }

    //声明队列 QC 绑定关系
    @Bean
    public Binding queueCBindExchangeX(Queue queueC, DirectExchange exchangeX) {
        return BindingBuilder.bind(queueC).to(exchangeX).with(ROUTING_KEY_XC);
    }

消费者新增

    @GetMapping("sendExpirationMsg/{message}/{ttlTimeMillisecond}")
    public void sendMsg(@PathVariable String message, @PathVariable String ttlTimeMillisecond) {
        rabbitTemplate.convertAndSend(DeadQueueConfig.EXCHANGE_X, DeadQueueConfig.ROUTING_KEY_XC, message, correlationData -> {
            correlationData.getMessageProperties().setExpiration(ttlTimeMillisecond);
            return correlationData;
        });
        log.info("当前时间：{},发送一条时长{}秒 TTL 信息给队列 C:{}", DateUtil.now(), TimeUnit.MILLISECONDS.toSeconds(Long.parseLong(ttlTimeMillisecond)), message);
    }

启动应用，按顺序请求以下接口
http://127.0.0.1:8080/ttl/sendExpirationMsg/姬霓太美/2000
http://127.0.0.1:8080/ttl/sendExpirationMsg/姬霓太美/20000
可以发现，正常消费，2秒后的消费了，20秒后的也消费了

此时看着正常，但是我们反顺序过来请求，先请求20秒的，在请求2秒的

http://127.0.0.1:8080/ttl/sendExpirationMsg/姬霓太美/20000
http://127.0.0.1:8080/ttl/sendExpirationMsg/姬霓太美/2000
结果如下，发现2秒的并没有先消费，而是消费完20秒的，再消费2秒的，因为mq底层就是FIFO，所以只能这样

结论
使用这种由生产者定义消息ttl的方式，如果第一个消息的延时时长很长，而第二个消息的延时时长很短，第二个消息并不会优先得到执行。

5.4.6 Rabbitmq 插件实现延迟队列

上文中提到的问题，确实是一个问题，如果不能实现在消息粒度上的 TTL，并使其在设置的TTL 时间及时死亡，就无法设计成一个通用的延时队列。那如何解决呢，接下来我们就去解决该问题。

5.4.6.1 安装延时队列插件

在官网上下载 https://www.rabbitmq.com/community-plugins.html，下载
rabbitmq_delayed_message_exchange 插件，注意对应当前mq版本，然后到 RabbitMQ 的插件目录。
可以使用搜索命令，查找插件目录

find / -name plugins

/usr/lib/rabbitmq/lib/rabbitmq_server-3.7.18/plugins

执行下面命令让该插件生效

rabbitmq-plugins enable rabbitmq_delayed_message_exchange

5.4.6.2 代码架构图

在这里新增了一个队列delayed.queue,一个自定义交换机delayed.exchange，绑定关系如下:

5.4.6.3 代码

在我们自定义的交换机中，这是一种新的交换类型，该类型消息支持延迟投递机制 消息传递后并不会立即投递到目标队列中，而是存储在 mnesia(一个分布式数据系统)表中，当达到投递时间时，才投递到目标队列中。

配置类

@Configuration
public class DelayedQueueConfig {
    public static final String DELAYED_QUEUE_NAME = "delayed.queue";
    public static final String DELAYED_EXCHANGE_NAME = "delayed.exchange";
    public static final String DELAYED_ROUTING_KEY = "delayed.routingkey";

    @Bean
    public Queue delayedQueue() {
        return new Queue(DELAYED_QUEUE_NAME);
    }

    //自定义交换机 我们在这里定义的是一个延迟交换机
    @Bean
    public CustomExchange delayedExchange() {
        Map<String, Object> args = new HashMap<>();
        //自定义交换机的类型
        args.put("x-delayed-type", ExchangeTypes.DIRECT);
        return new CustomExchange(DELAYED_EXCHANGE_NAME, "x-delayed-message", true, false,
                args);
    }

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

生产者

@Slf4j
@RequestMapping("ttl")
@RestController
public class DelayedQueueProducerController {


    @Autowired
    private RabbitTemplate rabbitTemplate;
    public static final String DELAYED_EXCHANGE_NAME = "delayed.exchange";
    public static final String DELAYED_ROUTING_KEY = "delayed.routingkey";

    @GetMapping("sendDelayMsg/{message}/{delayTime}")
    public void sendMsg(@PathVariable String message, @PathVariable Integer delayTime) {
        rabbitTemplate.convertAndSend(DELAYED_EXCHANGE_NAME, DELAYED_ROUTING_KEY, message,
                correlationData -> {
                    correlationData.getMessageProperties().setDelay(delayTime);
                    return correlationData;
                });
        log.info(" 当 前 时 间 ： {}, 发 送 一 条 延 迟 {} 秒的信息给队列 delayed.queue:{}", DateUtil.now(), TimeUnit.MILLISECONDS.toSeconds(delayTime), message);
    }
}

消费者

@Slf4j
@Component
public class DelayedQueueConsumer {
    public static final String DELAYED_QUEUE_NAME = "delayed.queue";

    @RabbitListener(queues = DELAYED_QUEUE_NAME)
    public void receiveDelayedQueue(Message message) {
        String msg = StrUtil.str(message.getBody(), StandardCharsets.UTF_8);
        log.info("当前时间：{},收到延时队列的消息：{}", DateUtil.now(), msg);
    }

}

启动应用，分别访问
http://localhost:8080/ttl/sendDelayMsg/come on baby1/20000
http://localhost:8080/ttl/sendDelayMsg/come on baby1/2000
结果如下，20秒的先访问，2秒后访问，但是还是2秒快的先消费了

5.4.7 总结

     延时队列在需要延时处理的场景下非常有用，使用 RabbitMQ 来实现延时队列可以很好的利用 RabbitMQ 的特性，如：消息可靠发送、消息可靠投递、死信队列来保障消息至少被消费一次以及未被正 确处理的消息不会被丢弃。另外，通过 RabbitMQ 集群的特性，可以很好的解决单点故障问题，不会因为 单个节点挂掉导致延时队列不可用或者消息丢失。
     当然，延时队列还有很多其它选择，比如利用 Java 的 DelayQueue，利用 Redis 的 zset，利用 Quartz 或者利用 kafka 的时间轮，这些方式各有特点,看需要适用的场景