RabbitMQ 应用

于 2024-09-02 14:52:52 发布
阅读量1k 收藏 18
点赞数 12
分类专栏： RabbitMQ 文章标签： rabbitmq ruby 分布式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_73888323/article/details/141016665
版权

在这里插入图片描述

文章目录

前言

前面我们学习了 RabbitMQ 的基本使用以及 RabbitMQ 的快速上手，那么这篇文章我将为大家介绍 RabbitMQ 提供的 7 种工作模式，我们上一篇快速入门实现的案例其实就是 7 种工作模式中的简单模式。

第一种：Simple 简单模式
在这里插入图片描述
第二种：Work Queue 工作队列模式
在这里插入图片描述
第三种：Publish/Subscribe 发布/订阅模式
在这里插入图片描述
第四种：Routing 路由模式
在这里插入图片描述
第五种：Topic 通配符模式
在这里插入图片描述
第六种：RPC 模式
在这里插入图片描述

第七种就是 Publisher Confirms 发布确认模式。

1. Simple 简单模式

在这里插入图片描述
简单模式主要由一个 Producer、一个 Queue和一个 Consumer 组成。

简单模式的特点就是：一个生产者 P，一个消费者 C，消息只能被消费一次，也称为点对点（Point-to-Point）模式。

这里的具体实现上一篇文章我就写了，这里就不写了，大家可以去看看。

2. Work Queue 工作队列模式

在这里插入图片描述
工作队列模式由一个生产者 P，一个队列 Queue 和多个消费者 C1、C2…组成，在这种模式下，Work Queue 会将消息分派给不同的消费者，每个消费者都会接收到不同的消息，意思就是 Work Queue 接收到了 10 条消息，那么 Work Queue 会将这 10 条消息分成两部分，每个部分 5 条消息，每条消息都不重复，然后将这五条消息分别发送给 C1 和 C2。

特点：消息不会重复，分配给不同的消费者。

适用场景：集群环境中做异步处理。比如我们平时在银行中办理业务取号的时候，当要办理业务的人取号（生产者）了之后，那么这些号码就会被存放在队列中，银行中的每个窗口（消费者）会给不同号的人办理业务。

在这里插入图片描述
那么我们看看通过 Java 代码如何实现一个工作队列模式。

对于这些经常使用到的变量，我们将其归到一个类中进行管理：

public class Constants {
    public static final String IP = "*.*.*.*";
    public static final Integer PORT = 5672;
    public static final String VIRTUAL_HOST = "test";
    public static final String USER_NAME = "admin";
    public static final String PASSWORD = "xxx";
    public static final String WORK_QUEUE = "work.queue";
}

生产者代码：

public class Producer {
    public static void main(String[] args) throws IOException, TimeoutException {
        //建立连接
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost(Constants.IP);
        factory.setPort(Constants.PORT);
        factory.setVirtualHost(Constants.VIRTUAL_HOST);
        factory.setUsername(Constants.USER_NAME);
        factory.setPassword(Constants.PASSWORD);
        Connection connection = factory.newConnection();
        //开启信道
        Channel channel = connection.createChannel();
        //声明队列
        channel.queueDeclare(Constants.WORK_QUEUE,true,false,false,null);
        //发送消息
        for (int i = 0; i < 10; i++) {
            String msg = "work queue" + i;
            channel.basicPublish("",Constants.WORK_QUEUE,null,msg.getBytes());
        }
        System.out.println("消息发送成功");
        channel.close();
        connection.close();
    }
}

消费者1 和消费者 2 的代码是一样的：

public class Consumer1 {
    public static void main(String[] args) throws IOException, TimeoutException {
        //建立连接
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost(Constants.IP);
        factory.setPort(Constants.PORT);
        factory.setVirtualHost(Constants.VIRTUAL_HOST);
        factory.setUsername(Constants.USER_NAME);
        factory.setPassword(Constants.PASSWORD);
        Connection connection = factory.newConnection();
        //开启信道
        Channel channel = connection.createChannel();
        //声明队列
        channel.queueDeclare(Constants.WORK_QUEUE,true,false,false,null);
        //消费消息
        Consumer consumer = new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("接受到消息:" + new String(body));
            }
        };
        channel.basicConsume(Constants.WORK_QUEUE,consumer);
        //释放资源
        //channel.close(); 我们这里可以先不释放资源，不然当我们先运行消费者的时候queue中没有消息，consumer的连接就会直接关闭了
        //connection.close();
    }
}

先启动两个消费者，然后再启动生产者：

在这里插入图片描述
在这里插入图片描述

可以看到 Consumer1 和 Consumer2 拿到的消息都是不重复的消息。

3. Pubulish/Subscribe 发布/订阅模式

在这里插入图片描述

Exchange 的类型

可以发现这个模式相较于前面两个模式，多出了一个 X，这个 X 指的是 Exchange 交换机。

交换机的作用是：生产者将消息发送到 Exchange，由交换机将消息按照一定的规则路由到一个或者多个队列中。

AMQP 协议中的交换机的类型有六种：fanout，direct，topic，headers，System和自定义，但是 RabbitMQ 中交换机的类型只有前四种。

  • Fanout：广播，将消息交给所有绑定到交换机的队列（Publish/Subcribe模式）
  • Direct：定向，把消息交给符合指定 routing key 的队列（Routing 模式）
  • Topic：通配符，把消息交给符合 routing pattern（路由模式）的队列（Topic 模式）
  • headers类型的交换器不依赖于路由键的匹配规则来路由消息，而是根据发送的消息内容中的 headers 属性进行匹配。headers 类型的交换机性能很差，而且也不实用，基本上不会看到它的存在

Exchaneg 只负责转发消息，不具备存储消息的能力，因此如果没有队列与 Exchange 绑定，或者没有符合路由规则的队列，那么消息就会丢失。

  • Routing Key：路由键。生产者将消息发送给转换机的时候，指定的一个字符串，用来告诉交换机应该如何处理这个消息
  • Binding Key：绑定。RabbitMQ 中通过 Binding 将交换机和队列关联起来，在绑定的时候一般会指定一个 Binding Key，这样 RabbitMQ 就知道如何正确的将消息路由到队列了。

在这里插入图片描述
当 Exchange 拿到生产者发送来的消息之后，会将消息中带的 Routing Key 和与该交换机绑定的队列的 Binding Key 进行匹配，然后将这个消息发送给 Routing Key 和 Binding Key 匹配的队列。

当知道了交换机的几种类型之后，我们来看看如何使用代码实现出来一个 Publish/Subscribe 模式。

生产者代码：

首先还是与 RabbitMQ-Server 建立连接，开启信道，与前面不同的操作是，前面我们声明交换机的时候因为使用的是默认的交换机，所以就没有显式的声明交换机，但是在涉及到交换机类型的时候，我们就需要显式的声明交换机，虽然 RabbitMQ 默认为我们提供了各个类型的交换机，但是名字可能不好记，所以不如我们自己实现一个：

在这里插入图片描述

Java 中声明一个交换机的方法主要是 exchangeDeclare() 方法，这个方法有很多个重载方法，但是我们主要使用下面的这种方法：

在这里插入图片描述

AMQP.Exchange.DeclareOk exchangeDeclare(String var1, BuiltinExchangeType var2, boolean var3) throws IOException;
  • String var1: 这个参数是交换机的名称。它是必须的，用于在RabbitMQ中唯一标识一个交换机。你可以根据需要为这个交换机命名。
  • BuiltinExchangeType var2: 这个参数指定了交换机的类型。该类是一个枚举类，内部枚举了交换器的类型
  • boolean var3: 这个布尔值参数指定交换机是否应该被标记为持久的（即，在RabbitMQ重启后仍然存在）。如果设置为true，交换机将持久化；如果设置为false，交换机则不会持久化。
public enum BuiltinExchangeType {
    DIRECT("direct"),
    FANOUT("fanout"),
    TOPIC("topic"),
    HEADERS("headers");

    private final String type;

    private BuiltinExchangeType(String type) {
        this.type = type;
    }

    public String getType() {
        return this.type;
    }
}

声明完成交换器后，就是声明队列，声明队列之后就是需要绑定交换器和队列了：

绑定交换器和队列使用的方法是 queueBind() 方法，该方法也是有两个重载的方法：

AMQP.Queue.BindOk queueBind(String var1, String var2, String var3) throws IOException;
    
AMQP.Queue.BindOk queueBind(String var1, String var2, String var3, Map<String, Object> var4) throws IOException;
  • String var1: 队列的名称。这是你想要绑定到交换机的队列的唯一标识符。
  • String var2: 交换机的名称。这是你想要将队列绑定到的交换机的名称。
  • String var3: 路由键。当消息发送到交换机时，交换机将使用路由键来确定哪些队列应该接收这个消息。路由键可以是任何字符串，其解释取决于交换机的类型。
  • Map<String, Object> var4: 绑定参数。这是一个可选参数，允许你为绑定指定额外的参数，这些参数将根据交换机和队列的特定需求进行解释。例如，对于某些交换机类型（如headers交换机），绑定参数可能用于定义消息头中的条件。对于大多数用途，这个参数可能为空或未使用。

我们这里没有使用到额外的参数，所以就使用三个参数的方法：

channel.queueBind(Constants.FANOUT_QUEUE1,Constants.FANOUT_EXCHANGE,"");
channel.queueBind(Constants.FANOUT_QUEUE2,Constants.FANOUT_EXCHANGE,"");

public class Producer {
    public static void main(String[] args) throws IOException, TimeoutException {
        //建立连接
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost(Constants.IP);
        factory.setPort(Constants.PORT);
        factory.setVirtualHost(Constants.VIRTUAL_HOST);
        factory.setUsername(Constants.USER_NAME);
        factory.setPassword(Constants.PASSWORD);
        Connection connection = factory.newConnection();
        //开启信道
        Channel channel = connection.createChannel();
        //声明交换机
        channel.exchangeDeclare(Constants.FANOUT_EXCHANGE, BuiltinExchangeType.FANOUT,true);
        //声明队列
        channel.queueDeclare(Constants.FANOUT_QUEUE1,true,false,false,null);
        channel.queueDeclare(Constants.FANOUT_QUEUE2,true,false,false,null);
        //绑定交换机和队列
        channel.queueBind(Constants.FANOUT_QUEUE1,Constants.FANOUT_EXCHANGE,"");
        channel.queueBind(Constants.FANOUT_QUEUE2,Constants.FANOUT_EXCHANGE,"");
        //生产消息
        for (int i = 0; i < 10; i++) {
            String msg = "fanout exchange" + i;
            channel.basicPublish(Constants.FANOUT_EXCHANGE,"",null,msg.getBytes());
        }
        System.out.println("消息发送成功");
        channel.close();
        connection.close();
    }
}

消费者代码：

public class Consumer1 {
    public static void main(String[] args) throws IOException, TimeoutException {
        //建立连接
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost(Constants.IP);
        factory.setPort(Constants.PORT);
        factory.setVirtualHost(Constants.VIRTUAL_HOST);
        factory.setUsername(Constants.USER_NAME);
        factory.setPassword(Constants.PASSWORD);
        Connection connection = factory.newConnection();
        //开启信道
        Channel channel = connection.createChannel();
        //声明队列
        channel.queueDeclare(Constants.FANOUT_QUEUE1,true,false,false,null);
        //消费消息
        Consumer consumer = new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("接收到消息:" + new String(body));
            }
        };
        channel.basicConsume(Constants.FANOUT_QUEUE1,consumer);
    }
}

两个消费者的代码基本上都一样，就是声明队列的时候声明的是两个不同的队列。

先启动两个消费者，然后再启动生产者：

在这里插入图片描述
在这里插入图片描述
可以看到，Exchange 将收到的生产者生产的消息复制为 N 份发送给了所有与其绑定的队列，然后消费者拿到的消息就是一样的消息。这就是 Publish/Subscribe 模式。

4. Routing 路由模式

在这里插入图片描述
路由模式其实和发布/订阅模式非常相似，它是在发布订阅模式的基础上，增加了路由 key，其实也不算增加，只不过发布/订阅模式交换器和队列的 Binding key 都是一样的，然后生产者发送的消息中携带的 Routing Key 也是和这些 Binding Key 是相匹配的，所有交换器会将收到的消息发送给所有与其绑定的队列。

而路由模式则是交换器和队列的 Binding Key 并不是完全相同的，而是存在差异，这样当交换器接收到 Routing Key 的时候，就会将消息发送给与之匹配的队列。那么我们看看如何使用代码来实现 路由模式。

生产者代码

public class Producer {
    public static void main(String[] args) throws IOException, TimeoutException {
        //建立连接
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost(Constants.IP);
        factory.setPort(Constants.PORT);
        factory.setVirtualHost(Constants.VIRTUAL_HOST);
        factory.setUsername(Constants.USER_NAME);
        factory.setPassword(Constants.PASSWORD);
        Connection connection = factory.newConnection();
        //开启信道
        Channel channel = connection.createChannel();
        //声明交换器
        channel.exchangeDeclare(Constants.ROUTING_EXCHANGE, BuiltinExchangeType.DIRECT,true);
        //声明队列
        channel.queueDeclare(Constants.ROUTING_QUEUE1,true,false,false,null);
        //绑定交换器和队列
        channel.queueBind(Constants.ROUTING_QUEUE1,Constants.ROUTING_EXCHANGE,"a");
        channel.queueBind(Constants.ROUTING_QUEUE1,Constants.ROUTING_EXCHANGE,"b");
        channel.queueBind(Constants.ROUTING_QUEUE2,Constants.ROUTING_EXCHANGE,"a");
        //生产消息
        String msg = "routing exchange a";
        channel.basicPublish(Constants.ROUTING_EXCHANGE,"a",null,msg.getBytes());
        msg = "routing exchange b";
        channel.basicPublish(Constants.ROUTING_EXCHANGE,"b",null,msg.getBytes());
        System.out.println("消息发送成功");
        channel.close();
        connection.close();
    }
}

消费者代码：

public class Consumer1 {
    public static void main(String[] args) throws IOException, TimeoutException {
        //建立连接
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost(Constants.IP);
        factory.setPort(Constants.PORT);
        factory.setVirtualHost(Constants.VIRTUAL_HOST);
        factory.setUsername(Constants.USER_NAME);
        factory.setPassword(Constants.PASSWORD);
        Connection connection = factory.newConnection();
        //开启信道
        Channel channel = connection.createChannel();
        //声明队列
        channel.queueDeclare(Constants.ROUTING_QUEUE1,true,false,false,null);
        //消费消息
        Consumer consumer = new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("接收到消息:" + new String(body));
            }
        };
        channel.basicConsume(Constants.ROUTING_QUEUE1,consumer);
    }
}

在这里插入图片描述
在这里插入图片描述

5. Topics 通配符模式

在这里插入图片描述
跟 Java、MySQL 一样，我们的 RabbitMQ 也是支持 通配符的，所以我们的 Routing Key 和 Binding Key 也是可以有通配符的。在 RabbitMQ 中的匹配字符有两个 * 和 #。

  • *匹配一个单词
  • #匹配0个或者多个单词

注意 RabbitMQ 中匹配字符匹配的不是字符，而是单词，RabbitMQ 中由 . 分隔一个单词。a.b.c，a b c 都叫做一个单词，aa.bb.cc，aa bb cc 也就做一个单词。

生产者代码：

public class Producer {
    public static void main(String[] args) throws IOException, TimeoutException {
        //建立连接
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost(Constants.IP);
        factory.setPort(Constants.PORT);
        factory.setVirtualHost(Constants.VIRTUAL_HOST);
        factory.setUsername(Constants.USER_NAME);
        factory.setPassword(Constants.PASSWORD);
        Connection connection = factory.newConnection();
        //开启信道
        Channel channel = connection.createChannel();
        //声明交换器
        channel.exchangeDeclare(Constants.TOPICS_EXCHANGE, BuiltinExchangeType.TOPIC,true);
        //声明队列
        channel.queueDeclare(Constants.TOPICS_QUEUE1,true,false,false,null);
        channel.queueDeclare(Constants.TOPICS_QUEUE2,true,false,false,null);
        //绑定交换器和队列
        channel.queueBind(Constants.TOPICS_QUEUE1,Constants.TOPICS_EXCHANGE,"*.a.*");
        channel.queueBind(Constants.TOPICS_QUEUE1,Constants.TOPICS_EXCHANGE,"c.#");
        channel.queueBind(Constants.TOPICS_QUEUE2,Constants.TOPICS_EXCHANGE,"*.a.*");
        //生产消息
        String msg = "topics exchange *.a.*";
        channel.basicPublish(Constants.TOPICS_EXCHANGE,"hello.a.r",null,msg.getBytes());
        msg = "topics exchange c.#";
        channel.basicPublish(Constants.TOPICS_EXCHANGE,"c.world",null,msg.getBytes());
        channel.close();
        connection.close();
    }
}

消费者代码：

public class Consumer1 {
    public static void main(String[] args) throws IOException, TimeoutException {
        //建立连接
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost(Constants.IP);
        factory.setPort(Constants.PORT);
        factory.setVirtualHost(Constants.VIRTUAL_HOST);
        factory.setUsername(Constants.USER_NAME);
        factory.setPassword(Constants.PASSWORD);
        Connection connection = factory.newConnection();
        //开启信道
        Channel channel = connection.createChannel();
        //声明队列
        channel.queueDeclare(Constants.TOPICS_QUEUE1,true,false,false,null);
        //消费消息
        Consumer consumer = new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("接收到消息:" + new String(body));
            }
        };
        channel.basicConsume(Constants.TOPICS_QUEUE1,consumer);
    }
}

在这里插入图片描述
在这里插入图片描述

6. RPC RPC通信

在这里插入图片描述

在 RPC 通信的过程中，没有生产者和消费者，比较像咱们的 RPC 远程调用，大概就是通过两个队列实现了一个可回调的过程。

在这里插入图片描述
RPC 通信的过程：

  1. 客户端发送消息到一个指定的队列，并在消息属性中设置 replyTo 字段，这个字段指定了一个回调队列，用于接收服务器的响应
  2. 服务端收到请求后，处理请求并发送响应消息到 replyTo 指定的回调队列
  3. 客户端在回调队列上等待消息，一旦收到响应，客户端会检查消息的 replyTo 属性，以确保它是所期望的响应

RPC 通信客户端代码：

public class RpcClient {
    public static void main(String[] args) throws IOException, TimeoutException, InterruptedException {
        //建立连接
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost(Constants.IP);
        factory.setPort(Constants.PORT);
        factory.setVirtualHost(Constants.VIRTUAL_HOST);
        factory.setUsername(Constants.USER_NAME);
        factory.setPassword(Constants.PASSWORD);
        Connection connection = factory.newConnection();
        //开启信道
        Channel channel = connection.createChannel();
        //声明交换器 我们这是使用默认的交换器
        //生命队列
        channel.queueDeclare(Constants.RPC_REQUEST_QUEUE,true,false,false,null);
        channel.queueDeclare(Constants.RPC_RESPONSE_QUEUE,true,false,false,null);
        //发送请求
        String msg = "rpc...";
        //设置请求的唯一标识
        String correlationId = UUID.randomUUID().toString();
        //设置请求的相关属性
        AMQP.BasicProperties properties = new AMQP.BasicProperties().builder()
                .correlationId(correlationId)
                .replyTo(Constants.RPC_RESPONSE_QUEUE)
                .build();
        channel.basicPublish("",Constants.RPC_REQUEST_QUEUE,properties,msg.getBytes());
        //接收响应
        //通过阻塞队列来接收响应
        BlockingQueue<String> blockingQueue = new ArrayBlockingQueue<>(1);
        Consumer consumer = new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                String response = new String(body);
                System.out.println("接收到回调消息:" + response);
                if (correlationId.equals(properties.getCorrelationId())) {
                    blockingQueue.offer(response);
                }
            }
        };
        channel.basicConsume(Constants.RPC_RESPONSE_QUEUE,consumer);
        String result = blockingQueue.take();
        System.out.println("[RPC Client 响应结果]:" + result);
    }
}

RPC 服务端代码：

public class RpcServer {
    public static void main(String[] args) throws IOException, TimeoutException {
        //建立连接
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost(Constants.IP);
        factory.setPort(Constants.PORT);
        factory.setVirtualHost(Constants.VIRTUAL_HOST);
        factory.setUsername(Constants.USER_NAME);
        factory.setPassword(Constants.PASSWORD);
        Connection connection = factory.newConnection();
        //开启信道
        Channel channel = connection.createChannel();
        //声明队列
        channel.queueDeclare(Constants.RPC_REQUEST_QUEUE,true,false,false,null);
        channel.queueDeclare(Constants.RPC_RESPONSE_QUEUE,true,false,false,null);
        //接收请求
        channel.basicQos(1); //这个的作用后面再为大家介绍
        Consumer consumer = new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                String request = new String(body);
                System.out.println("接收到请求:" + request);
                String response = "针对request:" + request + "，相应成功";
                AMQP.BasicProperties properties1 = new AMQP.BasicProperties().builder()
                        .correlationId(properties.getCorrelationId())
                        .build();
                channel.basicPublish("",Constants.RPC_RESPONSE_QUEUE,properties1,response.getBytes());
                //envelope.getDeliveryTag() 每个消息都有一个唯一的deliveryTag
                //false表示是否批量确认消息
                channel.basicAck(envelope.getDeliveryTag(), false);
            }
        };
        channel.basicConsume(Constants.RPC_REQUEST_QUEUE,consumer);
    }
}

在这里插入图片描述
在这里插入图片描述

7. Publisher Confirms 发布确认

RabbitMQ的Publisher Confirms（发布确认）机制是一种确保消息从生产者（Publisher）安全发送到RabbitMQ服务器的机制。当生产者向RabbitMQ发送消息时，它可能希望知道消息是否已经被RabbitMQ服务器成功接收并存储起来，以确保消息的可靠性。Publisher Confirms机制就是为了满足这一需求而设计的。

  1. 生产者将 Channel 设置为 confirm 模式 （通过调用 channel.confirmSelect()完成）后，发布的每一条消息都会获得一个唯一的 ID，生产者可以将这些序列号与消息关联起来，以便跟踪消息的状态
  2. 当消息被 RabbitMQ 服务器接收并处理之后，服务器会异步的像生产者发送一个确认 ACK 给生产者（包含消息的唯一ID），表明消息已经送达

通过这个 Publisher Confirms 模式，可以避免消息的丢失问题。

消息丢失大概分为三种情况：

  1. 生产者问题，因为程序故障，网络抖动等原因，生产者没有向 Broker 发送消息
  2. 消息中间价问题，也就是我们的 RabbitMQ Broker 出现问题，生产者将消息成功的发送给了 Broker，但是 Broker 没有将消息保存好，导致消息丢失
  3. 消费者问题，Broker 将消息成功发送给了消费者，但是消费者在消费的时候，因为没有处理好，导致消费者这里的消息丢失了，并且 broker 也将消费者失败的消息从队列中删除了

RabbitMQ 对于上面可能出现的三种问题都给出了解决，问题 2 可以通过持久化机制解决，问题 3 可以通过消息应答机制解决。针对问题 1，则可以通过 Publisher Confirms 机制解决。

RabbitMQ 发布确认是 0.9.1 协议的扩展，默认情况下他不会被启用，生产者可以通过 channel.confirmSelect() 将信道设置为 confirm 模式。

RabbitMQ 提供的发布确认有三种策略，那么接下来我们来了解一下这三种策略的优劣。

1. 单独确认

它要求生产者（Publisher）在发送每一个消息后，都等待RabbitMQ服务器的确认（Confirm），确保消息已经被RabbitMQ成功接收并处理，然后再继续发送下一个消息。

2. 批量确认

在 RabbitMQ 的发布确认（Publisher Confirms）机制中，批量确认（Batch Acknowledgment）是一个重要的特性，它允许 RabbitMQ 在一次确认消息中同时确认多个消息。这对于提高性能和减少网络开销非常有帮助。

3. 异步确认

RabbitMQ 发布确认中的异步确认策略是一种高效且可靠的机制，用于在消息发送过程中异步地接收确认回调，以提高生产者的吞吐量和性能。

public class PublisherConfirms {
    private static final Integer MESSAGE_COUNT = 1000;
    static Connection createConnection() throws IOException, TimeoutException {
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost(Constants.IP);
        factory.setPort(Constants.PORT);
        factory.setVirtualHost(Constants.VIRTUAL_HOST);
        factory.setUsername(Constants.USER_NAME);
        factory.setPassword(Constants.PASSWORD);
        return factory.newConnection();
    }
    public static void main(String[] args) throws IOException, TimeoutException, InterruptedException {
        //Strategy #1: Publishing Messages Individually
        //单独确认
        publishingMessagesIndividually();
        //Strategy #2: Publishing Messages in Batches
        //批量确认
        publishingMessagesInBatches();

        //Strategy #3: Handling Publisher Confirms Asynchronously
        //异步确认
        handlingPublisherConfirmsAsynchronously();
    }

    /**
     * 单独确认
     * @throws IOException
     * @throws TimeoutException
     * @throws InterruptedException
     */
    private static void publishingMessagesIndividually() throws IOException, TimeoutException, InterruptedException {
        try (Connection connection = createConnection()) {
            //1. 开启信道
            Channel channel = connection.createChannel();
            //2. 设置信道为confirm模式
            channel.confirmSelect();
            //3. 声明队列
            channel.queueDeclare(Constants.PUBLISHER_CONFIRMS_QUEUE1, true, false, false, null);
            //4. 发送消息, 并等待确认
            long start = System.currentTimeMillis();
            for (int i = 0; i < MESSAGE_COUNT; i++) {
                String msg = "publisher confirms"+i;
                channel.basicPublish("",Constants.PUBLISHER_CONFIRMS_QUEUE1, null, msg.getBytes());
                //等待确认
                channel.waitForConfirmsOrDie(5000);
            }
            long end = System.currentTimeMillis();
            System.out.printf("单独确认策略, 消息条数: %d, 耗时: %d ms \n",MESSAGE_COUNT, end-start);
        }
    }


    /**
     * 批量确认
     * @throws IOException
     * @throws TimeoutException
     * @throws InterruptedException
     */
    private static void publishingMessagesInBatches() throws IOException, TimeoutException, InterruptedException {
        try(Connection connection = createConnection()) {
            //1. 开启信道
            Channel channel = connection.createChannel();
            //2. 设置信道为confirm模式
            channel.confirmSelect();
            //3. 声明队列
            channel.queueDeclare(Constants.PUBLISHER_CONFIRMS_QUEUE2, true, false, false, null);
            //4. 发送消息, 并进行确认
            long start = System.currentTimeMillis();
            int batchSize = 100;
            int outstandingMessageCount = 0;
            for (int i = 0; i < MESSAGE_COUNT; i++) {
                String msg = "hello publisher confirms"+i;
                channel.basicPublish("",Constants.PUBLISHER_CONFIRMS_QUEUE2, null, msg.getBytes());
                outstandingMessageCount++;
                if (outstandingMessageCount==batchSize){
                    channel.waitForConfirmsOrDie(5000);
                    outstandingMessageCount = 0;
                }
            }
            if (outstandingMessageCount>0){
                channel.waitForConfirmsOrDie(5000);
            }
            long end = System.currentTimeMillis();
            System.out.printf("批量确认策略, 消息条数: %d, 耗时: %d ms \n",MESSAGE_COUNT, end-start);

        }
    }

    /**
     * 异步确认
     * @throws IOException
     * @throws TimeoutException
     */
    private static void handlingPublisherConfirmsAsynchronously() throws IOException, TimeoutException {
        try (Connection connection = createConnection()) {
            //开启信道
            Channel channel = connection.createChannel();
            //设置信道为confirm模式
            channel.confirmSelect();
            //声明转换器 这里我们使用默认的转换器
            //声明队列
            channel.queueDeclare(Constants.PUBLISHER_CONFIRMS_QUEUE3,true,false,false,null);
            //监听confirm
            //记录开始时间
            long start= System.currentTimeMillis();
            //该集合用来存放未确认的消息的ID
            SortedSet<Long> confirmSeqNo = Collections.synchronizedSortedSet(new TreeSet<>());
            channel.addConfirmListener(new ConfirmListener() {
                @Override
                public void handleAck(long deliveryTag, boolean multiple) throws IOException {
                    //deliveryTag 是消息的唯一ID multiple 表示是否批量确认
                    if (multiple) {
                        //如果是批量确认，则将deliveryTag之前的消息ID都删除了
                        confirmSeqNo.headSet(deliveryTag + 1).clear();
                    }else {
                        confirmSeqNo.remove(deliveryTag);
                    }
                }

                @Override
                public void handleNack(long deliveryTag, boolean multiple) throws IOException {
                    //这里为了简单，当RabbitMQ Broker无法正确处理消息的话，我们也认为它处理了
                    if (multiple) {
                        confirmSeqNo.headSet(deliveryTag + 1).clear();
                    }else {
                        confirmSeqNo.remove(deliveryTag);
                    }
                }
            });
            //发送消息
            for (int i = 0; i < MESSAGE_COUNT; i++) {
                String msg = "pulisher confirms" + i;
                long seqNo = channel.getNextPublishSeqNo();
                channel.basicPublish("",Constants.PUBLISHER_CONFIRMS_QUEUE3,null,msg.getBytes());
                confirmSeqNo.add(seqNo);
            }
            while (!confirmSeqNo.isEmpty()) {
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
            long end = System.currentTimeMillis();
            System.out.printf("异步确认策略，消息条数：%d，耗时：%d ms \n",MESSAGE_COUNT,end - start);
        }
    }
}

在这里插入图片描述
可以看到单独确认策略所需要的时间是比较多的，而异步策略则能够快速的处理这些。

不能再留遗憾了
关注
专栏目录
RabbitMQ 使用指南
weixin_47531845的博客
10-12 155
消息中间件利用高效可靠的消息传递机制进行平台无关的数据交流，并基于数据通信来进行分布式系统的集成。通过提供消息传递和消息排队模型，它可以在分布式环境下扩展进程间的通信。对于消息中间件，常见角色大致也就有 Producer（生产者）、Consumer（消费者）。 常见的消息中间件产品: 1). ActiveMQ ActiveMQ 是 Apache 出品，最流行的，能力强劲的开源消息总线。ActiveMQ 是一个完全支持 JMS1.1 和 J2EE 1.4 规范的 JMS Provider 实现。我们..
RabbitMQ应用
最新发布
m0_75227031的博客
09-26 776
路由模式的升级版, 在routingKey的基础上,增加了通配符的功能, 使之更加灵活.Topics和Routing的基本原理相同，即：⽣产者将消息发给交换机，交换机根据RoutingKey将消息转发给与RoutingKey匹配的队列. 类似于正则表达式的⽅式来定义Routingkey的模式.⼀个⽣产者P, 多个消费者C1, C2, X代表交换机消息复制多份，每个消费者接收相同的消息⽣产者发送⼀条消息，经过交换机转发到多个不同的队列，多个不同的队列就有多个不同的消费者。
RabbitMQ的应用总结
art_code的博客
09-01 676
RabbitMQ是一个由erlang开发的AMQP（Advanced Message Queue ）的开源实现。AMQP 的出现其实也是应了广大人民群众的需求，虽然在同步消息通讯的世界里有很多公开标准（如 COBAR的 IIOP ，或者是 SOAP 等），但是在异步消息处理中却不是这样，只有大企业有一些商业实现（如微软的 MSMQ ，IBM 的 Websphere MQ 等），因此，在 ...
RabbitMQ 使用教程
白白白鲤鱼的博客
08-11 2411
RabbitMQ使用教程
RabbitMQ的深入理解和最简单的用途说明
谭青海
08-01 2569
RabbitMQ 在上一家公司已经接触过了, 但是懵懵懂懂的. 不是很清楚. 具体怎么个逻辑.  这次公司打算搭建新的系统. 领导要求研究一下MQ.  经过研究得出的结论是. MSMQ的设计理念不适合做系统的底层框架. 他不适合做分布式系统. 最主要的是. MSMQ如果没有消费者, 默认消息是一直存在的.  而RabbitMQ的设计理念是.只要有接收消息的队列. 邮件就会存放到队列里. 直到订阅人...
RabbitMQ使用
lunge1234的博客
12-21 1178
一、引言 模块之间的耦合度过高，一旦一个模块宕机后，全部功能都不能用了，并且同步通讯的成本过高，用户体验差。 RabbitMQ引言 二、RabbitMQ介绍 市面上比较火爆的几款MQ： ActiveMQ，RocketMQ，Kafka，RabbitMQ。 语言的支持：ActiveMQ，RocketMQ只支持Java语言，Kafka可以支持多门语言，RabbitMQ支持多种语言。 效率方面：ActiveMQ，RocketMQ，Kafka效率都是毫秒级别，RabbitM
RabbitMq应用
weixin_59868842的博客
12-13 498
rabbit 的模式与高可用
Linux 安装 RabbitMQ 应用 / RabbitMQ 延时队列
11-16
Linux 安装 RabbitMQ 应用 / RabbitMQ 延时队列
RabbitMQ应用场景与实例
JinXYan的博客
05-25 5522
Publisher：是Message的生产者，Publisher这个Clients产生了一些Message。 Consumer：Message的消费者，Publisher产生的Message，最终要到达Consumer这个Clients，进行消费。 Exchange： 指定消息按什么规则，路由到哪个Queue，Message消息先要到达Exchange，在Server中承担着从Produce接...
rabbitmq应用实战.ppt
09-06
rabbitmq应用实战
【RabbitMQ】应用
bit me的博客
08-28 1296
七种工作模式以及springboot整合
花了3天总结的RabbitMQ实用技巧，有点东西
weixin_50666791的博客
10-14 138
以前看过的关于RabbitMQ核心消息模式的文章都是基于Java API的，最近看了下官方文档，发现这些核心消息模式都可以通过Spring AMQP来实现。于是总结了下RabbitMQ的实用技巧，包括RabbitMQ在Windows和Linux下的安装、5种核心消息模式的Spring AMQP实现，相信对于想要学习和回顾RabbitMQ的朋友都会有所帮助。 简介 RabbitMQ是最受欢迎的开源消息中间件之一，在全球范围内被广泛应用。RabbitMQ是轻量级且易于部署的，能支持多种消息协议。Rabb.
rabbitmq的使用（一）
风明水漾的博客
09-05 299
由于初次使用，官方文档是个不错的参考，于是打开文档，看了一下介绍，写了一个demo。很简单，目录结构如下： 为了方便起见，我这里直接创建的maven项目，为使看着方便，详细注释已经加在了代码中。首先添加pom依赖： &lt;dependency&gt; &lt;groupId&gt;org.springframework.amqp&lt;/groupId&gt; &lt;artif...
RabbitMQ简单应用
成长中の稻草人
07-19 226
最近在网上学习了RabbitMQ，做一下简单的记录，主要实现功能：1、生产者（将待处理任务放入RabbitMQ）2、消费者（将MQ中的数据进行消费） 该案例基于.NET5的控制台应用程序,开发工具VS2019。 在使用RabbitMQ前需要先从Nuget包添加RabbitMQ引用！！！！ 然后导入引用： using RabbitMQ.Client; using RabbitMQ.Client.Events; 生产者代码： static void Main(string[] args)
RabbitMQ在实际项目中的应用
weixin_67601403的博客
05-29 5513
RabbitMQ简介 以商品订单场景为例， 如果商品服务和订单服务是两个不同的微服务，在下单的过程中订单服务需要调用商品服务进行扣库存操作。按照传统的方式，下单过程要等到调用完毕之后才能返回下单成功，如果网络产生波动等原因使得商品服务扣库存延迟或者失败，会带来较差的用户体验，如果在高并发的场景下，这样的处理显然是不合适的，那怎么进行优化呢？这就需要消息队列登场了。 消息队列提供一个异步通信机制，消息的发送者不必一直等待到消息被成功处理才返回，而是立即返回。消息中间件负责处理网络通信，如果网络连接不可用
RabbitMQ的使用
qwq1518346864的博客
06-13 1307
目录 RabbitMQ的使用 一.Java连接RabbitMQ 1.1创建Maven项目 1.2导入依赖 1.3创建工具类连接RabbitMQ 二.通讯方式 1.Hello-World 2.Work 3.Publish/Subscribe 4.Routing 5.Topic RabbitMQ的使用 一.Java连接RabbitMQ 1.1创建Maven项目 pass 。。。。 1.2导入依赖 <dependencies> <dependen.
rabbitmq应用解耦
03-10
以下是RabbitMQ应用解耦的一些常见场景和方法： 1. 发布/订阅模式：发布/订阅模式是一种常见的解耦方式，其中一个应用程序（发布者）将消息发送到RabbitMQ的交换机，而其他应用程序（订阅者）则从交换机订阅并接收...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

不能再留遗憾了

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值