devbox
bf789
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

5. RabbitMQ工作模式——RabbitMQ

作者：bf789 | 2024-02-01 09:05:46

赞

踩

5. RabbitMQ工作模式——RabbitMQ

5. RabbitMQ工作模式——RabbitMQ

5.1. Work queues工作队列模式

5.1.1. 模式说明

Work Queues与入门程序的简单模式相比，多了一个或一些消费端，多个消费端共同消费同一个队列中的消息。

应用场景：对于 任务过重或任务较多情况使用工作队列可以提高任务处理的速度。

5.1.2. 代码

Work Queues与入门程序的简单模式的代码是几乎一样的；可以完全复制，并复制多一个消费者进行多个消费者同时消费消息的测试。

1）抽取工具类
  1. package com.atguigu.rabbitmq.util;
  2.  
  3. import com.rabbitmq.client.Connection;
  4. import com.rabbitmq.client.ConnectionFactory;
  5.  
  6. public class ConnectionUtil {
  7.     public static Connection getConnection() throws Exception {
  8.         //定义连接工厂
  9.         ConnectionFactory factory = new ConnectionFactory();
  10.         //设置服务地址
  11.         factory.setHost("192.168.6.100");
  12.         //端口
  13.         factory.setPort(5672);
  14.         //设置账号信息，用户名、密码、vhost
  15.         factory.setVirtualHost("/");
  16.         factory.setUsername("admin");
  17.         factory.setPassword("123456");
  18.         // 通过工程获取连接
  19.         Connection connection = factory.newConnection();
  20.         return connection;
  21.     }
  22.  
  23.     public static void main(String[] args) throws Exception {
  24.         Connection con = ConnectionUtil.getConnection();
  25.         System.out.println(con);
  26.         //         amqp://admin@192.168.6.100:5672/
  27.         con.close();
  28.     }
  29. }
2）生产者
  1. package com.atguigu.rabbitmq.work;
  2.  
  3. import com.rabbitmq.client.Channel;
  4. import com.rabbitmq.client.Connection;
  5. import com.rabbitmq.client.ConnectionFactory;
  6.  
  7. public class Producer {
  8.     static final String QUEUE_NAME = "work_queue";
  9.     public static void main(String[] args) throws Exception {
  10.         Connection connection = ConnectionUtil.getConnection();
  11.         Channel channel = connection.createChannel();
  12.         channel.queueDeclare(QUEUE_NAME,true,false,false,null);
  13.         for (int i = 1; i <= 10; i++) {
  14.             String body = i+"hello rabbitmq~~~";
  15.             channel.basicPublish("",QUEUE_NAME,null,body.getBytes());
  16.         }
  17.         channel.close();
  18.         connection.close();
  19.     }
  20. }

3）消费者1
  1. package com.atguigu.rabbitmq.work;
  2.  
  3. import com.rabbitmq.client.*;
  4. import java.io.IOException;
  5.  
  6. public class Consumer1 {
  7.     static final String QUEUE_NAME = "work_queue";
  8.     public static void main(String[] args) throws Exception {
  9.         Connection connection = ConnectionUtil.getConnection();
  10.         Channel channel = connection.createChannel();
  11.         channel.queueDeclare(QUEUE_NAME,true,false,false,null);
  12.         Consumer consumer = new DefaultConsumer(channel){
  13.             @Override
  14.             public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
  15.                 System.out.println("body："+new String(body));
  16.             }
  17.         };
  18.         channel.basicConsume(QUEUE_NAME,true,consumer);
  19.     }
  20. }
4）消费者2

Consumer2与Consumer1类一样。省略。

运行两个消费者

5.1.3. 测试

启动两个消费者，然后再启动生产者发送消息；到IDEA的两个消费者对应的控制台查看是否竞争性的接收到消息。

5.1.4. 小结

  1. 在一个队列中如果有多个消费者，那么消费者之间对于同一个消息的关系是**竞争**的关系。
  2. Work Queues 对于任务过重或任务较多情况使用工作队列可以提高任务处理的速度。

5.2. 订阅模式类型

订阅模式示例图：

前面2个案例中，只有3个角色：

  • P：生产者，也就是要发送消息的程序
  • C：消费者：消息的接受者，会一直等待消息到来。
  • queue：消息队列，图中红色部分

而在订阅模型中，多了一个exchange角色，而且过程略有变化：

  • P：生产者，也就是要发送消息的程序，但是不再发送到队列中，而是发给X（交换机）
  • C：消费者，消息的接受者，会一直等待消息到来。
  • Queue：消息队列，接收消息、缓存消息。
  • Exchange：交换机，图中的X。一方面，接收生产者发送的消息。另一方面，知道如何处理消息，例如递交给某个特别队列、递交给所有队列、或是将消息丢弃。到底如何操作，取决于Exchange的类型。Exchange有常见以下3种类型：
    • Fanout：广播，将消息交给所有绑定到交换机的队列
    • Direct：定向，把消息交给符合指定routing key 的队列
    • Topic：通配符，把消息交给符合routing pattern（路由模式） 的队列

Exchange（交换机）只负责转发消息，不具备存储消息的能力，因此如果没有任何队列与Exchange绑定，或者没有符合路由规则的队列，那么消息会丢失！

5.3. Publish/Subscribe发布与订阅模式

5.3.1. 模式说明

发布订阅模式：
1、每个消费者监听自己的队列。
2、生产者将消息发给broker，由交换机将消息转发到绑定此交换机的每个队列，每个绑定交换机的队列都将接收
到消息

5.3.2. 代码

1）生产者
  1. package com.atguigu.rabbitmq.fanout;
  2.  
  3. import com.rabbitmq.client.BuiltinExchangeType;
  4. import com.rabbitmq.client.Channel;
  5. import com.rabbitmq.client.Connection;
  6. import com.rabbitmq.client.ConnectionFactory;
  7.  
  8. public class Producer {
  9.     public static void main(String[] args) throws Exception {
  10.  
  11.         Connection connection = ConnectionUtil.getConnection();
  12.         Channel channel = connection.createChannel();
  13.         /*
  14.        exchangeDeclare(String exchange, BuiltinExchangeType type, boolean durable, boolean autoDelete, boolean internal, Map<String, Object> arguments)
  15.        参数：
  16.         1. exchange：交换机名称
  17.         2. type：交换机类型
  18.             DIRECT("direct"),：定向
  19.             FANOUT("fanout"),：扇形（广播）,发送消息到每一个与之绑定队列。
  20.             TOPIC("topic"),通配符的方式
  21.             HEADERS("headers");参数匹配
  22.         3. durable：是否持久化
  23.         4. autoDelete：自动删除
  24.         5. internal：内部使用。 一般false
  25.         6. arguments：参数
  26.         */
  27.         String exchangeName = "test_fanout";
  28.         //5. 创建交换机
  29.         channel.exchangeDeclare(exchangeName, BuiltinExchangeType.FANOUT,true,false,false,null);
  30.         //6. 创建队列
  31.         String queue1Name = "test_fanout_queue1";
  32.         String queue2Name = "test_fanout_queue2";
  33.         channel.queueDeclare(queue1Name,true,false,false,null);
  34.         channel.queueDeclare(queue2Name,true,false,false,null);
  35.         //7. 绑定队列和交换机
  36.         /*
  37.         queueBind(String queue, String exchange, String routingKey)
  38.         参数：
  39.             1. queue：队列名称
  40.             2. exchange：交换机名称
  41.             3. routingKey：路由键,绑定规则
  42.                 如果交换机的类型为fanout ,routingKey设置为""
  43.          */
  44.         channel.queueBind(queue1Name,exchangeName,"");
  45.         channel.queueBind(queue2Name,exchangeName,"");
  46.  
  47.         String body = "日志信息：张三调用了findAll方法...日志级别：info...";
  48.         //8. 发送消息
  49.         channel.basicPublish(exchangeName,"",null,body.getBytes());
  50.  
  51.         //9. 释放资源
  52.         channel.close();
  53.         connection.close();
  54.     }
  55. }

运行

2）消费者1
  1. package com.atguigu.rabbitmq.fanout;
  2.  
  3. import com.rabbitmq.client.*;
  4. import java.io.IOException;
  5.  
  6. public class Consumer1 {
  7.     public static void main(String[] args) throws Exception {
  8.         Connection connection = ConnectionUtil.getConnection();
  9.         Channel channel = connection.createChannel();
  10.         String queue1Name = "test_fanout_queue1";
  11.         Consumer consumer = new DefaultConsumer(channel){
  12.             @Override
  13.             public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
  14.                 System.out.println("body："+new String(body));
  15.                 System.out.println("将日志信息打印到控制台.....");
  16.             }
  17.         };
  18.         channel.basicConsume(queue1Name,true,consumer);
  19.     }
  20. }
3）消费者2
  1. package com.atguigu.rabbitmq.fanout;
  2.  
  3. import com.rabbitmq.client.*;
  4. import java.io.IOException;
  5.  
  6. public class Consumer2 {
  7.     public static void main(String[] args) throws Exception {
  8.         Connection connection = ConnectionUtil.getConnection();
  9.         Channel channel = connection.createChannel();
  10.         String queue2Name = "test_fanout_queue2";
  11.         Consumer consumer = new DefaultConsumer(channel){
  12.             @Override
  13.             public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
  14.                 System.out.println("body："+new String(body));
  15.                 System.out.println("将日志信息打印到控制台.....");
  16.             }
  17.         };
  18.         channel.basicConsume(queue2Name,true,consumer);
  19.     }
  20. }

5.3.3. 测试

启动所有消费者，然后使用生产者发送消息；在每个消费者对应的控制台可以查看到生产者发送的所有消息；到达**广播**的效果。

在执行完测试代码后，其实到RabbitMQ的管理后台找到Exchanges选项卡，点击 fanout_exchange 的交换机，可以查看到如下的绑定：

5.3.4. 小结

交换机需要与队列进行绑定，绑定之后；一个消息可以被多个消费者都收到。

发布订阅模式与工作队列模式的区别

1、工作队列模式不用定义交换机，而发布/订阅模式需要定义交换机。

2、发布/订阅模式的生产方是面向交换机发送消息，工作队列模式的生产方是面向队列发送消息(底层使用默认交换机)。

3、发布/订阅模式需要设置队列和交换机的绑定，工作队列模式不需要设置，实际上工作队列模式会将队列绑 定到默认的交换机 。

5.4. Routing路由模式

5.4.1. 模式说明

路由模式特点：

  • 队列与交换机的绑定，不能是任意绑定了，而是要指定一个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 的消息

5.4.2. 代码

在编码上与 Publish/Subscribe发布与订阅模式 的区别是交换机的类型为：Direct，还有队列绑定交换机的时候需要指定routing key。

1）生产者

 

  1. package com.atguigu.rabbitmq.routing;
  2.  
  3. import com.rabbitmq.client.BuiltinExchangeType;
  4. import com.rabbitmq.client.Channel;
  5. import com.rabbitmq.client.Connection;
  6. import com.rabbitmq.client.ConnectionFactory;
  7.  
  8. public class Producer {
  9.     public static void main(String[] args) throws Exception {
  10.        Connection connection = ConnectionUtil.getConnection();
  11.        Channel channel = connection.createChannel();
  12.        String exchangeName = "test_direct";
  13.        // 创建交换机
  14.        channel.exchangeDeclare(exchangeName,BuiltinExchangeType.DIRECT,true,false,false,null);
  15.        // 创建队列
  16.        String queue1Name = "test_direct_queue1";
  17.        String queue2Name = "test_direct_queue2";
  18.         // 声明（创建）队列
  19.        channel.queueDeclare(queue1Name,true,false,false,null);
  20.        channel.queueDeclare(queue2Name,true,false,false,null);
  21.        // 队列绑定交换机
  22.         // 队列1绑定error
  23.         channel.queueBind(queue1Name,exchangeName,"error");
  24.         // 队列2绑定info error warning
  25.         channel.queueBind(queue2Name,exchangeName,"info");
  26.         channel.queueBind(queue2Name,exchangeName,"error");
  27.         channel.queueBind(queue2Name,exchangeName,"warning");
  28.  
  29.         String message = "日志信息：张三调用了delete方法.错误了,日志级别warning";
  30.         // 发送消息
  31.         channel.basicPublish(exchangeName,"warning",null,message.getBytes());
  32.         System.out.println(message);
  33.  
  34.         channel.close();
  35.         connection.close();
  36.     }
  37. }

运行

2）消费者1
  1. package com.atguigu.rabbitmq.routing;
  2.  
  3. import com.rabbitmq.client.*;
  4. import java.io.IOException;
  5.  
  6. public class Consumer1 {
  7.     public static void main(String[] args) throws Exception {
  8.         Connection connection = ConnectionUtil.getConnection();
  9.         Channel channel = connection.createChannel();
  10.         String queue1Name = "test_direct_queue1";
  11.         Consumer consumer = new DefaultConsumer(channel){
  12.             @Override
  13.             public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
  14.                 System.out.println("body："+new String(body));
  15.                 System.out.println("将日志信息打印到控制台.....");
  16.             }
  17.         };
  18.         channel.basicConsume(queue1Name,true,consumer);
  19.     }
  20. }

 

3）消费者2
  1. package com.atguigu.rabbitmq.routing;
  2.  
  3. import com.rabbitmq.client.*;
  4. import java.io.IOException;
  5.  
  6. public class Consumer2 {
  7.     public static void main(String[] args) throws Exception {
  8.         Connection connection = ConnectionUtil.getConnection();
  9.         Channel channel = connection.createChannel();
  10.         String queue2Name = "test_direct_queue2";
  11.         Consumer consumer = new DefaultConsumer(channel){
  12.             @Override
  13.             public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
  14.                 System.out.println("body："+new String(body));
  15.                 System.out.println("将日志信息存储到数据库.....");
  16.             }
  17.         };
  18.         channel.basicConsume(queue2Name,true,consumer);
  19.     }
  20. }

5.4.3. 测试

启动所有消费者，然后使用生产者发送消息；在消费者对应的控制台可以查看到生产者发送对应routing key对应队列的消息；到达**按照需要接收**的效果。

5.4.4. 小结

Routing模式要求队列在绑定交换机时要指定routing key，消息会转发到符合routing key的队列。

5.5. Topics通配符模式

5.5.1. 模式说明

Topic类型与Direct相比，都是可以根据RoutingKey把消息路由到不同的队列。只不过Topic类型Exchange可以让队列在绑定Routing key 的时候**使用通配符**！

Routingkey 一般都是有一个或多个单词组成，多个单词之间以”.”分割，例如： item.insert

通配符规则：

#：匹配零个或多个词

*：匹配不多不少恰好1个词

举例：

item.#：能够匹配item.insert.abc 或者 item.insert

item.*：只能匹配item.insert

 

图解：

  • 红色Queue：绑定的是usa.# ，因此凡是以 usa.开头的routing key 都会被匹配到
  • 黄色Queue：绑定的是#.news ，因此凡是以 .news结尾的 routing key 都会被匹配

5.5.2. 代码

1）生产者

使用topic类型的Exchange，发送消息的routing key有3种： order.info

  1. package com.atguigu.rabbitmq.topic;
  2.  
  3. import com.rabbitmq.client.BuiltinExchangeType;
  4. import com.rabbitmq.client.Channel;
  5. import com.rabbitmq.client.Connection;
  6. import com.rabbitmq.client.ConnectionFactory;
  7.  
  8. public class Producer {
  9.     public static void main(String[] args) throws Exception {
  10.         Connection connection = ConnectionUtil.getConnection();
  11.         Channel channel = connection.createChannel();
  12.         String exchangeName = "test_topic";
  13.         channel.exchangeDeclare(exchangeName, BuiltinExchangeType.TOPIC,true,false,false,null);
  14.         String queue1Name = "test_topic_queue1";
  15.         String queue2Name = "test_topic_queue2";
  16.         channel.queueDeclare(queue1Name,true,false,false,null);
  17.         channel.queueDeclare(queue2Name,true,false,false,null);
  18.         // 绑定队列和交换机
  19.         /**
  20.          *  参数：
  21.              1. queue：队列名称
  22.              2. exchange：交换机名称
  23.              3. routingKey：路由键,绑定规则
  24.                  如果交换机的类型为fanout ,routingKey设置为""
  25.          */
  26.         // routing key  系统的名称.日志的级别。
  27.         //需求： 所有error级别的日志存入数据库,所有order系统的日志存入数据库
  28.         channel.queueBind(queue1Name,exchangeName,"#.error");
  29.         channel.queueBind(queue1Name,exchangeName,"order.*");
  30.         channel.queueBind(queue2Name,exchangeName,"*.*");
  31.         String body = "日志信息：张三调用了findAll方法...日志级别：info...";
  32.         //发送消息goods.info,goods.error
  33.         channel.basicPublish(exchangeName,"order.info",null,body.getBytes());
  34.         channel.close();
  35.         connection.close();
  36.     }
  37. }

 运行程序

2）消费者1

接收两种类型的消息：更新商品和删除商品

  1. package com.atguigu.rabbitmq.topic;
  2.  
  3. import com.rabbitmq.client.*;
  4. import java.io.IOException;
  5.  
  6. public class Consumer1 {
  7.     public static void main(String[] args) throws Exception {
  8.         Connection connection = ConnectionUtil.getConnection();
  9.         Channel channel = connection.createChannel();
  10.         String queue1Name = "test_topic_queue1";
  11.         Consumer consumer = new DefaultConsumer(channel){
  12.             @Override
  13.             public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
  14.                 System.out.println("body："+new String(body));
  15.             }
  16.         };
  17.         channel.basicConsume(queue1Name,true,consumer);
  18.     }
  19. }

 

3）消费者2

接收所有类型的消息：新增商品,更新商品和删除商品。

  1. package com.atguigu.rabbitmq.topic;
  2.  
  3. import com.rabbitmq.client.*;
  4. import java.io.IOException;
  5.  
  6. public class Consumer2 {
  7.     public static void main(String[] args) throws Exception {
  8.         Connection connection = ConnectionUtil.getConnection();
  9.         Channel channel = connection.createChannel();
  10.         String queue2Name = "test_topic_queue2";
  11.         Consumer consumer = new DefaultConsumer(channel){
  12.             @Override
  13.             public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
  14.                 System.out.println("body："+new String(body));
  15.             }
  16.         };
  17.         channel.basicConsume(queue2Name,true,consumer);
  18.     }
  19. }

 

5.5.3. 测试

启动所有消费者，然后使用生产者发送消息；在消费者对应的控制台可以查看到生产者发送对应routing key对应队列的消息；到达**按照需要接收**的效果；并且这些routing key可以使用通配符。

5.5.4. 小结

Topic主题模式可以实现 Publish/Subscribe发布与订阅模式 和 Routing路由模式 的功能；只是Topic在配置routing key 的时候可以使用通配符，显得更加灵活。

5.6. 模式总结

RabbitMQ工作模式：
1、简单模式 HelloWorld
一个生产者、一个消费者，不需要设置交换机（使用默认的交换机）

2、工作队列模式 Work Queue
一个生产者、多个消费者（竞争关系），不需要设置交换机（使用默认的交换机）

3、发布订阅模式 Publish/subscribe
需要设置类型为fanout的交换机，并且交换机和队列进行绑定，当发送消息到交换机后，交换机会将消息发送到绑定的队列

4、路由模式 Routing
需要设置类型为direct的交换机，交换机和队列进行绑定，并且指定routing key，当发送消息到交换机后，交换机会根据routing key将消息发送到对应的队列

5、通配符模式 Topic
需要设置类型为topic的交换机，交换机和队列进行绑定，并且指定通配符方式的routing key，当发送消息到交换机后，交换机会根据routing key将消息发送到对应的队列

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/article/detail/52800
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号