【RabbitMQ-工作模式】

最新推荐文章于 2023-09-18 14:23:45 发布
最新推荐文章于 2023-09-18 14:23:45 发布
阅读量263 收藏 2
点赞数 1
分类专栏： 【应用框架】 文章标签： rabbitmq
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_58419935/article/details/120377497
版权

一、Simple Queue：简单队列模式

1.1 基础

介绍

最简单的工作队列，其中一个生产者，一个消费者，一个队列，也称为点对点模式。（用的是默认交换机）

图示

1.2 代码 

生产者

public static void main(String[] args) throws Exception {
    // 创建ConnectionFactory
    ConnectionFactory connectionFactory = new ConnectionFactory();
    connectionFactory.setHost("127.0.0.1");
    connectionFactory.setPort(5672);
    connectionFactory.setUsername("guest");
    connectionFactory.setPassword("guest");
    // 设置虚拟主机
    connectionFactory.setVirtualHost("/");
    // 创建Connection
    Connection connection = connectionFactory.newConnection();
    // 创建Channel
    Channel channel = connection.createChannel();
    // 通过通道创建队列，后续所有的操作都是基于channel实现。（队列也可以由消费方创建）
    channel.queueDeclare("queueName",false,false,false,null);
    // 发送消息
    String msg = "RabbitMQ Simple Queue TEST";
    // 向队列中发送消息：
    // 参数1：为" "表示为default exchange
    // 参数2：（当声明为默认交换机时）队列的名称（因为当使用默认交换机时，生产者是通过指定队列的名称直接发送的）
    channel.basicPublish("","queueName",null,msg.getBytes());
    channel.close();
    connection.close();
}

 消费者

public static void main(String[] args) throws Exception {
    ConnectionFactory connectionFactory = new ConnectionFactory();
    connectionFactory.setHost("127.0.0.1");
    connectionFactory.setPort(5672);
    connectionFactory.setVirtualHost("/");
    connectionFactory.setUsername("guest");
    connectionFactory.setPassword("guest");
    connectionFactory.setAutomaticRecoveryEnabled(true);
    connectionFactory.setNetworkRecoveryInterval(3000);
    Connection connection = connectionFactory.newConnection();
    Channel channel = connection.createChannel();
    // 监听队列中的消息（消费的是队列，而不是交换机）
    channel.basicConsume("queueName", true, 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"));
        }
    });
    // 消费方不需要关闭连接，保持一直监听队列状态。
    //connection.close();
}

二、Work Queues：工作队列模式

2.1 基础

介绍

一个生产者，一个消息队列，多个消费者。同样也称为点对点模式。（用的是默认交换机）

一个消息只能被一个消费者消费，资源的竞争。（通过轮询或其他方式分配给消费者）

默认情况下，rabbitmq将会按顺序派发每个任务给下一个消费者，平均而言，每个消费者将获得相同数量的消息，这种分发消息的方式称为轮询。

图示

 特点

 Work Queue相比于简单队列模式，在于工作队列模式有多个消费者，但是一个消息只能被一个消费者消费，而简单队列模式只有一个消费者。

2.2 代码

生产者

public static void main(String[] args) throws Exception {
    // 创建ConnectionFactory
    ConnectionFactory connectionFactory = new ConnectionFactory();
    connectionFactory.setHost("127.0.0.1");
    connectionFactory.setPort(5672);
    connectionFactory.setUsername("guest");
    connectionFactory.setPassword("guest");
    // 设置虚拟主机
    connectionFactory.setVirtualHost("/");
    // 创建Connection
    Connection connection = connectionFactory.newConnection();
    // 创建Channel
    Channel channel = connection.createChannel();
    // 通过通道创建队列，后续所有的操作都是基于channel实现。（队列也可以由消费方创建）
    channel.queueDeclare("queueName", false, false, false, null);
    // 向队列中发送消息：
    // 参数1：为" "表示为default exchange
    // 参数2：（当声明为默认交换机时）队列的名称（因为当使用默认交换机时，生产者是通过指定队列的名称直接发送的）
    for (int i = 1; i <= 10; i++) {
        channel.basicPublish("", "queueName", null, ("Hello RabbitMQ!!!" + i).getBytes());
    }
    channel.close();
    connection.close();
}

消费者1

public static void main(String[] args) throws Exception {
    ConnectionFactory connectionFactory = new ConnectionFactory();
    connectionFactory.setHost("127.0.0.1");
    connectionFactory.setPort(5672);
    connectionFactory.setVirtualHost("/");
    connectionFactory.setUsername("guest");
    connectionFactory.setPassword("guest");
    connectionFactory.setAutomaticRecoveryEnabled(true);
    connectionFactory.setNetworkRecoveryInterval(3000);
    Connection connection = connectionFactory.newConnection();
    Channel channel = connection.createChannel();
    // 监听队列中的消息（消费的是队列，而不是交换机）
    channel.basicConsume("queueName", true, new DefaultConsumer(channel) {
        @Override
        public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
            System.out.println("消费者1获得消息为：" + new String(body, "utf-8"));
        }
    });
    // 消费方不需要关闭连接，保持一直监听队列状态。
    //connection.close();
}

消费者2

public static void main(String[] args) throws Exception {
    ConnectionFactory connectionFactory = new ConnectionFactory();
    connectionFactory.setHost("127.0.0.1");
    connectionFactory.setPort(5672);
    connectionFactory.setVirtualHost("/");
    connectionFactory.setUsername("guest");
    connectionFactory.setPassword("guest");
    connectionFactory.setAutomaticRecoveryEnabled(true);
    connectionFactory.setNetworkRecoveryInterval(3000);
    Connection connection = connectionFactory.newConnection();
    Channel channel = connection.createChannel();
    // 监听队列中的消息（消费的是队列，而不是交换机）
    channel.basicConsume("queueName", true, new DefaultConsumer(channel) {
        @Override
        public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
            System.out.println("消费者1获得消息为：" + new String(body, "utf-8"));
        }
    });
    // 消费方不需要关闭连接，保持一直监听队列状态。
    //connection.close();
}

三、Publish/Subscribe：发布与订阅模式

3.1 基础

介绍

将消息发送给不同类型的消费者。做到发布一次，消费多个。（用的是Fanout Exchange交换机）

场景举例

用户注册：用户在注册完后一般都会发送消息通知用户注册成功（失败）。如果在一个系统中，用户注册信息有邮箱、手机号，那么在注册完后会向邮箱和手机号都发送注册完成信息。利用MQ实现业务异步处理，如果是用工作队列的话，就会声明一个注册信息队列。注册完成之后生产者会向队列提交一条注册数据，消费者取出数据同时向邮箱以及手机号发送两条消息。但是实际上邮箱和手机号信息发送实际上是不同的业务逻辑，不应该放在一块处理。这个时候就可以利用发布/订阅模式将消息发送到转换机（EXCHANGE），声明两个不同的队列（邮箱、手机），并绑定到交换机。这样生产者只需要发布一次消息，两个队列都会接收到消息发给对应的消费者。

图示

3.2 代码 

生产者

public static void main(String[] args) throws Exception {
    // 创建ConnectionFactory
    ConnectionFactory connectionFactory = new ConnectionFactory();
    connectionFactory.setHost("127.0.0.1");
    connectionFactory.setPort(5672);
    connectionFactory.setUsername("guest");
    connectionFactory.setPassword("guest");
    // 设置虚拟主机
    connectionFactory.setVirtualHost("/");
    // 创建Connection
    Connection connection = connectionFactory.newConnection();
    // 创建Channel
    Channel channel = connection.createChannel();
    // 创建交换机（交换机没有存储数据的能力，数据存储在队列上。如果有交换机没队列的情况下，数据会丢失。）  
    // 参数一：交换机名称；参数二：交换机类型。
    channel.exchangeDeclare("fanout_exchange_name", "fanout");
    // 向队列中发送消息
    for (int i = 1; i <= 10; i++) {
        // 因为fanout exchange与routing key无关，所以设置为空字符串。
        channel.basicPublish("fanout_exchange_name", "", null, ("Hello RabbitMQ!!!" + i).getBytes());
    }
    channel.close();
    connection.close();
}

 消费者1

public static void main(String[] args) throws Exception {
    ConnectionFactory connectionFactory = new ConnectionFactory();
    connectionFactory.setHost("127.0.0.1");
    connectionFactory.setPort(5672);
    connectionFactory.setVirtualHost("/");
    connectionFactory.setUsername("guest");
    connectionFactory.setPassword("guest");
    connectionFactory.setAutomaticRecoveryEnabled(true);
    connectionFactory.setNetworkRecoveryInterval(3000);
    Connection connection = connectionFactory.newConnection();
    Channel channel = connection.createChannel();
    // 创建队列
    channel.queueDeclare("fanout_queue1_name", false, false, false, null);
    // 给队列绑定交换机
    channel.queueBind("fanout_queue1_name", "fanout_exchange_name", "");
    // 监听队列中的消息
    channel.basicConsume("fanout_queue1_name", true, new DefaultConsumer(channel) {
        @Override
        public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
            System.out.println("消费者1获得消息为：" + new String(body, "utf-8"));
        }
    });
    // 消费方不需要关闭连接，保持一直监听队列状态。
    //connection.close();
}

消费者2

public static void main(String[] args) throws Exception {
    ConnectionFactory connectionFactory = new ConnectionFactory();
    connectionFactory.setHost("127.0.0.1");
    connectionFactory.setPort(5672);
    connectionFactory.setVirtualHost("/");
    connectionFactory.setUsername("guest");
    connectionFactory.setPassword("guest");
    connectionFactory.setAutomaticRecoveryEnabled(true);
    connectionFactory.setNetworkRecoveryInterval(3000);
    Connection connection = connectionFactory.newConnection();
    Channel channel = connection.createChannel();
    // 创建队列
    channel.queueDeclare("fanout_queue2_name", false, false, false, null);
    // 给队列绑定交换机
    channel.queueBind("fanout_queue2_name", "fanout_exchange_name", "");
    // 监听队列中的消息
    channel.basicConsume("fanout_queue2_name", true, new DefaultConsumer(channel) {
        @Override
        public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
            System.out.println("消费者2获得消息为：" + new String(body, "utf-8"));
        }
    });
    // 消费方不需要关闭连接，保持一直监听队列状态。
    //connection.close();
}

四、Route：路由模式

4.1 基础

介绍

在发布订阅模式的基础上，根据routing key有选择地转发消息到匹配的queue。（用的是Direct Exchange交换机）

图示

4.2 代码 

生产者

public static void main(String[] args) throws Exception {
    // 创建ConnectionFactory
    ConnectionFactory connectionFactory = new ConnectionFactory();
    connectionFactory.setHost("127.0.0.1");
    connectionFactory.setPort(5672);
    connectionFactory.setUsername("guest");
    connectionFactory.setPassword("guest");
    // 设置虚拟主机
    connectionFactory.setVirtualHost("/");
    // 创建Connection
    Connection connection = connectionFactory.newConnection();
    // 创建Channel
    Channel channel = connection.createChannel();
    // 创建交换机（交换机没有存储数据的能力，数据存储在队列上。如果有交换机没队列的情况下，数据会丢失）  
    // 参数一：交换机名称；参数二：交换机类型。
    channel.exchangeDeclare("direct_exchange_name", "direct");
    // 向队列中发送消息
    for (int i = 1; i <= 10; i++) {
        // 设置路由键为"insert"
        channel.basicPublish("direct_exchange_name", "insert", null, ("Hello RabbitMQ!!!" + i).getBytes());
    }
    channel.close();
    connection.close();
}

 消费者1

public static void main(String[] args) throws Exception {
    ConnectionFactory connectionFactory = new ConnectionFactory();
    connectionFactory.setHost("127.0.0.1");
    connectionFactory.setPort(5672);
    connectionFactory.setVirtualHost("/");
    connectionFactory.setUsername("guest");
    connectionFactory.setPassword("guest");
    connectionFactory.setAutomaticRecoveryEnabled(true);
    connectionFactory.setNetworkRecoveryInterval(3000);
    Connection connection = connectionFactory.newConnection();
    Channel channel = connection.createChannel();
    // 创建队列
    channel.queueDeclare("direct_queue1_name", false, false, false, null);
    // 给队列绑定交换机，并设置路由键（binding key）。
    channel.queueBind("direct_queue1_name", "direct_exchange_name", "select");
    channel.queueBind("direct_queue1_name", "direct_exchange_name", "insert");
    // 监听队列中的消息
    channel.basicConsume("direct_queue1_name", true, new DefaultConsumer(channel) {
        @Override
        public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
            System.out.println("消费者1获得消息为：" + new String(body, "utf-8"));
        }
    });
    // 消费方不需要关闭连接，保持一直监听队列状态。
    //connection.close();
}

消费者2

public static void main(String[] args) throws Exception {
    ConnectionFactory connectionFactory = new ConnectionFactory();
    connectionFactory.setHost("127.0.0.1");
    connectionFactory.setPort(5672);
    connectionFactory.setVirtualHost("/");
    connectionFactory.setUsername("guest");
    connectionFactory.setPassword("guest");
    connectionFactory.setAutomaticRecoveryEnabled(true);
    connectionFactory.setNetworkRecoveryInterval(3000);
    Connection connection = connectionFactory.newConnection();
    Channel channel = connection.createChannel();
    // 创建队列
    channel.queueDeclare("direct_queue2_name", false, false, false, null);
    // 给队列绑定交换机，并设置路由键（binding key）。
    channel.queueBind("direct_queue2_name", "direct_exchange_name", "select");
    channel.queueBind("direct_queue2_name", "direct_exchange_name", "delete");
    // 监听队列中的消息
    channel.basicConsume("direct_queue2_name", true, new DefaultConsumer(channel) {
        @Override
        public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
            System.out.println("消费者2获得消息为：" + new String(body, "utf-8"));
        }
    });
    // 消费方不需要关闭连接，保持一直监听队列状态。
    //connection.close();
}

五、Topic：主题模式

5.1 基础

介绍

主题模式可以指定queue的binding key规则，消息携带的routing key与binding key进行模式匹配，消息将会转发到匹配的queue。（用的是Topic Exchange交换机）

图示

5.2 代码 

生产者

public static void main(String[] args) throws Exception {
    // 创建ConnectionFactory
    ConnectionFactory connectionFactory = new ConnectionFactory();
    connectionFactory.setHost("127.0.0.1");
    connectionFactory.setPort(5672);
    connectionFactory.setUsername("guest");
    connectionFactory.setPassword("guest");
    // 设置虚拟主机
    connectionFactory.setVirtualHost("/");
    // 创建Connection
    Connection connection = connectionFactory.newConnection();
    // 创建Channel
    Channel channel = connection.createChannel();
    // 创建交换机（交换机没有存储数据的能力，数据存储在队列上。如果有交换机没队列的情况下，数据会丢失。）  
    // 参数一：交换机名称；参数二：交换机类型。
    channel.exchangeDeclare("topic_exchange_name", "topic");
    // 向队列中发送消息
    for (int i = 1; i <= 10; i++) {
        // 设置路由键为"emp.hello world"  
        // #：匹配0-n个单词（之间以.区分，两点之间算一个单词，可以匹配hello world空格的情况。）
        // *：匹配一个单词
        channel.basicPublish("topic_exchange_name", "emp.hello world", null, ("Hello RabbitMQ!!!" + i).getBytes());
    }
    channel.close();
    connection.close();
}

消费者1 

public static void main(String[] args) throws Exception {
    ConnectionFactory connectionFactory = new ConnectionFactory();
    connectionFactory.setHost("127.0.0.1");
    connectionFactory.setPort(5672);
    connectionFactory.setVirtualHost("/");
    connectionFactory.setUsername("guest");
    connectionFactory.setPassword("guest");
    connectionFactory.setAutomaticRecoveryEnabled(true);
    connectionFactory.setNetworkRecoveryInterval(3000);
    Connection connection = connectionFactory.newConnection();
    Channel channel = connection.createChannel();
    // 创建队列
    channel.queueDeclare("topic_queue1_name", false, false, false, null);
    // 绑定交换机（routing key：路由键） 
    // #：匹配0-n个单词（之间以.区分，两点之间算一个单词。）
    channel.queueBind("topic_queue1_name", "topic_exchange_name", "emp.#");
    // 监听队列中的消息
    channel.basicConsume("topic_queue1_name", true, new DefaultConsumer(channel) {
        @Override
        public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
            System.out.println("消费者1获得消息为：" + new String(body, "utf-8"));
        }
    });
    // 消费方不需要关闭连接，保持一直监听队列状态。
    //connection.close();
}

消费者2

public static void main(String[] args) throws Exception {
    ConnectionFactory connectionFactory = new ConnectionFactory();
    connectionFactory.setHost("127.0.0.1");
    connectionFactory.setPort(5672);
    connectionFactory.setVirtualHost("/");
    connectionFactory.setUsername("guest");
    connectionFactory.setPassword("guest");
    connectionFactory.setAutomaticRecoveryEnabled(true);
    connectionFactory.setNetworkRecoveryInterval(3000);
    Connection connection = connectionFactory.newConnection();
    Channel channel = connection.createChannel();
    // 创建队列
    channel.queueDeclare("topic_queue2_name", false, false, false, null);
    // 绑定交换机（routing key：路由键）   
    // *：匹配1个单词（之间以.区分，两点之间算一个单词。）
    channel.queueBind("topic_queue2_name", "topic_exchange_name", "emp.*");
    // 监听队列中的消息
    channel.basicConsume("topic_queue2_name", true, new DefaultConsumer(channel) {
        @Override
        public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
            System.out.println("消费者2获得消息为：" + new String(body, "utf-8"));
        }
    });
    // 消费方不需要关闭连接，保持一直监听队列状态。
    //connection.close();
}

六、RPC：远程调用模式

6.1 基础

介绍

RPC即客户端远程调用服务端的方法 ，使用MQ可以实现RPC的异步调用。（用的是Direct Exchange交换机）

  • 客户端即是生产者也是消费者，向RPC请求队列发送RPC调用消息，同时监听RPC响应队列。

  • 服务端监听RPC请求队列的消息，收到消息后执行服务端的方法，得到方法返回的结果。

  • 服务端将RPC方法的结果发送到RPC响应队列

  • 客户端（RPC调用方）监听RPC响应队列，接收到RPC调用结果。

6.2 代码

七、Header模式

在此编码着未来
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
rabbitmq-server3.10.5
01-10
5. **工作模式** - **Direct模式**: 交换器根据精确匹配的路由键将消息发送到指定的队列。 - **Fanout模式**: 交换器将消息广播到所有绑定的队列。 - **Topic模式**: 交换器根据通配符匹配路由键将消息分发到多个...
rabbitmq-java (2).zip
01-11
为了确保消息的可靠传输，RabbitMQ支持事务和确认模式。在事务模式下，消息会被批量提交，只有在所有消息都成功送达队列后才会确认；而在确认模式中，RabbitMQ会在消息被正确处理后等待消费者的确认，如果未收到确认...
RabbitMQ工作模式
10-24 506
1.RabbitMQ常见的工作模式 RabbitMQ有以下几种工作模式 ： 1、Work queues 2、Publish/Subscribe 3、Routing 4、Topics 5、Header 6、RPC 2.Work queues 2.1.工作模式 work queues与入门程序相比，多了一个消费端，两个消费端共同消费同一个队列中的消息。 应用场景： 对于任务过重或任务较多...
rabbitmq 恢复连接问题
热门推荐
zhong1129116952的博客
06-12 1万+
rabbitmq 自带恢复连接机制，只要设置factory.setAutomaticRecoveryEnabled(true);，它自动使用AutorecoveringConnection去连接，如果连接超时，会自动去恢复。来自amqp-client-4.2.0.jar的恢复连接原码：private synchronized void beginAutomaticRecovery() throws...
rabbitmq4.0以下版本遇到断网重连异常
liuxinzhi1982的专栏
04-04 4182
现象描述：一个客户端反应经常性不更新显示信息，分析是rabbitmq的消息没有及时consumer。登陆服务器控制台查看消息状态是ready。终端连接状态running。但就是不消费信息了。 分析： 怀疑网络中途有中断波动 1.代码里已经设置setAutomaticRecoveryEnabled，所以Connection连接状态自动恢复了 2.但是consumer却没有设置自动恢复。 通过查看资料： 在客户端开启Connection和Topology（Queue、Exchange、Binding
springboot RabbitMQ客户端连接故障恢复
OceanSky的专栏
08-26 3144
最近做RabbitMQ故障演练发现RabbitMQ服务器停止后，基于springboot的消费端不可以自动的恢复，队列的消费者消失，消息一直积压到队列中，这种情况肯定是不可接收的；通过研究源代码找到了解决方案。
RabbitMQ生产故障问题分析
最新发布
Lamb的博客
09-18 680
生产环境不建议使用自动ack模式，这样会使QOS无法生效。在使用手动ack的时候，需要非常注意消息签收，业务代码使用try-catch-finally处理结构，防止业务代码异常时无法签收。规范约束mq客户端代码，正确的使用Rabbitmq配置。不同业务项目设置不同的vhost可以隔离一些影响，提升rabbitmq资源使用。考虑设置，当设置了时，可以放入，可以快速排查定位问题。
rabbitmq-server-3.6.15-1.el7.noarch.zip
05-27
- **Fanout Exchange**：广播模式，将所有消息复制到所有绑定的队列。 - **Topic Exchange**：允许模糊匹配路由键，更灵活的路由策略。 - **Header Exchange**：基于消息头中的特定键值进行路由，较少使用。 5. ...
rabbitmq-server-generic-unix-3.6.1.tar
08-16
了解RabbitMQ的基本概念，如Exchange（交换机）、Queue（队列）、Binding（绑定）以及不同工作模式（如Direct、Fanout、Topic、Header）是非常重要的。此外，熟悉RabbitMQ的管理和监控工具，如`rabbitmqctl`和Web...
rabbitmq-server-3.6.5-1.noarch.rar
05-22
同时，熟悉AMQP协议的基本概念和使用模式也有助于更好地利用RabbitMQ。 通过以上步骤，你可以在Linux系统中成功安装并运行RabbitMQ 3.6.5版本。记得根据实际情况调整Erlang版本以避免兼容性问题，并根据需求配置...
RabbitMQ镜像队列初始化连接时的“优化”
weixin_30549657的博客
03-30 209
之前发过一篇帖子应用.Net+Consul维护RabbitMq的高可用性，然后最近老大问我当初我这么搞是抽的什么想法- -然后顺便贴了两行C#代码： 　　　　　　　　　var factory = new ConnectionFactory() { UserName = "username", ...
RabbitMQ断链重连的配置
zy332719794的专栏
09-09 5630
问题描述： 自动删除的队列在网络断开恢复后不能自动创建并绑定关系。 解决办法： 在RabbitMQConfig中分别声明两个连接工厂类，其中一个用于RabbitAdmin声明的连接，另一个用于生产者和消费者的连接。其中用于RabbitAdmin声明的连接不设置连接、通道、恢复的事件监听，用于生产者和消费者的连接需要设置连接、通道、恢复的事件监听，并且在通道监听事件“onCreate(Channel channel, boolean b)”方法中调用声明队列和绑定关系。 参考示例： ..
【RabbitMQ-交换机】
吴小成的博客
09-17 441
一、简介 交换机的作用 接收生产者发送的消息并将这些消息路由给服务器中的队列 交换机的一些属性 Name：交换机名称 Durability：是否持久化。如果持久性，则RabbitMQ重启后，交换机还存在。 Auto-delete：当所有与之绑定的消息队列都完成了对此交换机的使用后，删掉它。 Arguments：扩展参数 二、Direct Exchange：直连交换机 2.1 基础 使用前提 消息中的路由键（routing key）如果和Bind
Rabbitmq客户端和spring AMQP失败修复实现对比
二当家的
03-19 1004
Rabbitmq客户端：1、通过参数automaticRecoveryEnabled设置是否开启自动修复连接的功能，如下图：2、通过增加ShutdownListener，并注册到勾子上，监听连接关闭异常ShutdownSignalException，如下图：3、只处理非应用初始化的异常或心跳断开的异常，如下图：4、新建一个连接，并替换原连接即可，如下图：spring AMQP：1、RabbitAd...
RabbitMQ Java开发教程（三）—官方原版
深圳市多克创新科技有限公司
03-18 566
RabbitMQ Java开发教程（三）—官方原版
[RabbitMQ] AutorecoveringConnection在连接恢复后才调用ShutdownListener 此博文包含图片
skiof007的专栏
06-04 2669
想玩一玩RabbitMQ中的ShutdownListener和RecoveryListener，又不想写自己的重连接逻辑，所以使用了ConnectionFactory类的setAutomaticRecoveryEnabled方法让其自动恢复连接。代码如下： package com.yqu.rabbitmq; import com.rabbitmq.client.*; import java...
RabbitMQ持久化编码注意事项
weixin_30537451的博客
06-17 108
以Java语言，MQ客户端为amqp-client作为示例 1、基本原则 direct模式，由生产者声明队列名，消费者也声明队列名 topic模式，由生产者声明交换器名，由消费者声明队列名+交换器名+绑定关系 即生产者只负责生产消息，至于消息要投递到哪里由消费者指定 2、队列、交换器、消息的持久化配置 队列声明持久化 public void queueDe...
RabbitMQ三种Exchange模式详解
TeamoPlum的博客
12-08 616
文章目录前言一、Direct示例示例代码二、Topic示例代码示例三、Fanout示例总结 前言 本文主要介绍RabbitMQ的三种Exchange模式，分别为Direct ，Topic ，Fanout 。 一、Direct 发送到该Exchange上的消息，会按照routing key路由到指定的Queue。该routing key必须和binding key完全匹配。 示例 可以看到，direct exchange X绑定了两个Queue，其中，Q1由binding key ‘orange’绑定，
官网指南-RabbitMQ-Java Client API Guide
lihaizhou1234的博客
07-18 629
官网指南-RabbitMQ-Java Client API Guide 概述 RabbitMQ Java client 将com.rabbitmq.client作为其顶层包. 关键类和接口有: Channel Connection ConnectionFactory Consumer 协议操作可通过Channel接口来进行.Connection用于开启channels,注册connec...
rabbitmq-server
09-14
RabbitMQ是一个开源的消息代理和队列服务器，它实现了高级消息队列协议（AMQP）。它可以用于构建可扩展的分布式系统，用于处理大量的消息和事件。RabbitMQ提供了可靠的消息传递机制，支持消息持久化、事务、发布/订阅等模式。它还可以与多种编程语言和框架集成，使开发者能够轻松地构建基于消息传递的应用程序。RabbitMQ的服务器端称为rabbitmq-server，它是RabbitMQ的核心组件之一。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值