大数据最新RabbitMQ实战学习

于 2024-05-04 08:54:37 发布
阅读量772 收藏 11
点赞数 18
分类专栏： 程序员 文章标签： 大数据 rabbitmq 学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_82243558/article/details/138434563
版权

RabbitMQ常用资料

1、安装教程

https://blog.csdn.net/l1090739767/article/details/116302051

2、使用安装包

rabbitmq-server

https://repo.huaweicloud.com/rabbitmq-server/v3.12.1/

erlang

https://erlang.org/download/

3、常用命令
rabbitmq-service.bat start # 启动服务
service rabbitmq-server start 
service rabbitmq-server stop # 停止服务
service rabbitmq-server restart # 重启服务

如果环境变量不生效，可以进行强制设置

#设置ERLANG\_HOME的路径地址
set ERLANG\_HOME=E:\app\MQ\Erlang OTP
4、验证访问

http://localhost:15672/

5、代码示例

码云仓库

https://gitee.com/zhang_w_b/rabbit-mq

（1）RabbitMQ五种工作模式

rabbitmq-producer

rabbitmq-consumer

（2）SpringBoot 整合RabbitMQ

rabbitmq-producer

rabbitmq-consumer

一、RabbitMQ基本概念

1.1. MQ概述
  • MQ全称 Message Queue（消息队列），是在消息的传输过程中保存消息的容器。多用于分布式系统之间进行通信。

在这里插入图片描述

小结

  1. MQ，消息队列，存储消息的中间件
  2. 分布式系统通信两种方式：直接远程调用 和 借助第三方 完成间接通信
  3. 发送方称为生产者，接收方称为消费者
1.2 MQ 的优势和劣势

优势：

  • 应用解耦
  • 异步提速
  • 削峰填古

劣势：

  • 系统可用性降低
  • 系统复杂性提高
  • 一致性问题
1.3 MQ 的优势
1. 应用解耦

没有使用MQ：
在这里插入图片描述- 系统的耦合性越高，容错性就越低，可维护性就越低。

使用MQ：
在这里插入图片描述

  • 使用 MQ 使得应用间解耦，提升容错性和可维护性。
2. 异步提速

没有使用MQ：
在这里插入图片描述

  • 一个下单操作耗时：20 + 300 + 300 + 300 = 920ms
  • 用户点击完下单按钮后，需要等待920ms才能得到下单响应，太慢！

使用MQ：
在这里插入图片描述

  • 用户点击完下单按钮后，只需等待25ms就能得到下单响应 (20 + 5 = 25ms)。
  • 提升用户体验和系统吞吐量（单位时间内处理请求的数目）。
3. 削峰填谷

没有使用MQ：
在这里插入图片描述使用MQ：

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

  • 使用了 MQ 之后，限制消费消息的速度为1000，这样一来，高峰期产生的数据势必会被积压在 MQ
    中    ，高峰就被“削”掉了，但是因为消息积压，在高峰期过后的一段时间内，消费消息的速度还是会维持在1000，直到消费完积压的消息，这就叫做填谷。
  • 使用MQ后，可以提高系统稳定性。

小结：

  • 应用解耦：提高系统容错性和可维护性
  • 异步提速：提升用户体验和系统吞吐量
  • 削峰填谷：提高系统稳定性
1.4 MQ 的劣势

在这里插入图片描述

  • 系统可用性降低

系统引入的外部依赖越多，系统稳定性越差。一旦 MQ 宕机，就会对业务造成影响。如何保证MQ的高可用？

  • 系统复杂度提高

MQ 的加入大大增加了系统的复杂度，以前系统间是同步的远程调用，现在是通过 MQ 进行异步调用。如何保证消息没有被重复消费？怎么处理消息丢失情况？那么保证消息传递的顺序性？

  • 一致性问题

A 系统处理完业务，通过 MQ 给B、C、D三个系统发消息数据，如果 B 系统、C 系统处理成功，D 系统处理失败。如何保证消息数据处理的一致性？

小结

既然 MQ 有优势也有劣势，那么使用 MQ 需要满足什么条件呢？

  • 生产者不需要从消费者处获得反馈。引入消息队列之前的直接调用，其接口的返回值应该为空，这才让明明下层的动作还没做，上层却当成动作做完了继续往后走，即所谓异步成为了可能。
  • 容许短暂的不一致性。
  • 确实是用了有效果。即解耦、提速、削峰这些方面的收益，超过加入MQ，管理MQ这些成本。
1.5 RabbitMQ 基础架构

在这里插入图片描述

RabbitMQ 中的相关概念：

  • Broker：接收和分发消息的应用，RabbitMQ Server就是 Message Broker
  • Virtual host：出于多租户和安全因素设计的，把 AMQP 的基本组件划分到一个虚拟的分组中，类似于网络中的 namespace概念。当多个不同的用户使用同一个 RabbitMQ server 提供的服务时，可以划分出多个vhost，每个用户在自己的 vhost创建 exchange／queue 等
  • 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)
  • Queue：消息最终被送到这里等待 consumer 取走
  • Binding：exchange 和 queue 之间的虚拟连接，binding 中可以包含 routing key。Binding
    信息被保存到 exchange 中的查询表中，用于 message 的分发依据

RabbitMQ 提供了 6 种工作模式：简单模式、work queues、Publish/Subscribe 发布与订阅模式、Routing 路由模式、Topics 主题模式、RPC 远程调用模式（远程调用，不太算 MQ；暂不作介绍）。

1.6 JMS
  • JMS 即 Java 消息服务（JavaMessage Service）应用程序接口，是一个 Java 平台中关于面向消息中间件的API
  • JMS 是 JavaEE 规范中的一种，类比JDBC
  • 很多消息中间件都实现了JMS规范，例如：ActiveMQ。RabbitMQ 官方没有提供 JMS 的实现包，但是开源社区有

小结

  • RabbitMQ 是基于 AMQP 协议使用 Erlang 语言开发的一款消息队列产品。
  • RabbitMQ提供了6种工作模式，我们学习5种。这是今天的重点。
  • AMQP 是协议，类比HTTP。
  • JMS 是 API 规范接口，类比 JDBC。

二、RabbitMQ学习

1、五种工作模式

简单模式、work queues、Publish/Subscribe 发布与订阅模式、Routing 路由模式、Topics 主题模式、RPC 远程调用模式

1.1 简单模式

上述的入门案例中其实使用的是如下的简单模式：

在这里插入图片描述

在上图的模型中，有以下概念：

  • P：生产者，也就是要发送消息的程序
  • C：消费者：消息的接收者，会一直等待消息到来
  • queue：消息队列，图中红色部分。类似一个邮箱，可以缓存消息；生产者向其中投递消息，消费者从其中取出消息

代码示例：

依赖

    <dependency>
      <groupId>com.rabbitmq</groupId>
      <artifactId>amqp-client</artifactId>
      <version>5.6.0</version>
    </dependency>

生产者：

package com.zwb.producer;

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\_HelloWorld {

    public static void main(String[] args) throws IOException, TimeoutException {
        //1、创建连接工厂
        ConnectionFactory factory = new ConnectionFactory();
        //2、设置参数
        //factory.setHost("192.168.1.100"); //默认localhost
        factory.setPort(5672);     //默认5672
        factory.setVirtualHost("/itcast"); //设置RabbitMQ服务器中的虚拟机，类似mysql数据库中的某一个库
        factory.setUsername("heima");
        factory.setPassword("heima");
        //3、创建连接Connection
        Connection connection = factory.newConnection();
        //4、创建Channel
        Channel channel = connection.createChannel();
        //5.创建队列Queue 暂时不用交换机
            /\*
 String queue, boolean durable, boolean exclusive, boolean autoDelete,
 Map<String, Object> arguments)
 1.queue 队列名称
 2.durable 是否持久化，当mq重启之后，还在
 3.exclusive：
 \*是否独占：只能有一个消费者监听队列
 \*当connection关闭时，是否删除队列
 4.autoDelete: 是否自动删除，当没有consumer时，自动删除掉
 5.arguments: 参数
 \*/
        //如果没有一个名字为hello\_world的队列，则会创建队列，如果有则不会创建
        channel.queueDeclare("hello\_world",true,false,false,null);
        //6.发送消息
            /\*
 String exchange, String routingKey, boolean mandatory, byte[] body
 参数：
 1. exchange：交换机名称，简单模式下交换机会使用默认的 ""
 2. routingKey: 路由名称
 3. props: 配置信息
 4. body: 发送消息数据
 \*/
        String body="hello rabbitmq----测试内容222";
        channel.basicPublish("","hello\_world",null,body.getBytes());
        //7、释放资源
        /\*
 channel.close();
 connection.close();
 \*/
    }
}

消费者：

package com.zwb.consumer;

import com.rabbitmq.client.\*;

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

public class Consumer\_HelloWorld {

    public static void main(String[] args) throws IOException, TimeoutException {
        //1、创建工厂
        ConnectionFactory factory = new ConnectionFactory();
        //2、设置参数
        //factory.setHost("192.168.1.100"); //默认localhost
        factory.setPort(5672);//默认5672
        factory.setVirtualHost("/itcast");// 默认/
        factory.setUsername("heima");// heima
        factory.setPassword("heima");// heima
        //3、创建连接Connection
        Connection connection = factory.newConnection();
        //4、创建Channel
        Channel channel = connection.createChannel();
        //5、创建队列Queue 暂时不用交换机
            /\*
 String queue, boolean durable, boolean exclusive, boolean autoDelete,
 Map<String, Object> arguments)
 1.queue 队列名称
 2.durable 是否持久化，当mq重启之后，还在
 3.exclusive：
 \*是否独占：只能有一个消费者监听队列
 \*当connection关闭时，是否删除队列
 4.autoDelete: 是否自动删除，当没有consumer时，自动删除掉
 5.arguments: 参数
 \*/
        //如果没有一个名字为hello\_world的队列，则会创建队列，如果有则不会创建
        channel.queueDeclare("hello\_world",true,false,false,null);
        //6、接收消息
        /\*
 basicConsume(String queue, boolean autoAck, Consumer callback)
 参数：
 1. queue：队列名称
 2. autoAck: 是否自动确认
 3. callback: 回调对象
 \*/
        Consumer consumer = new DefaultConsumer(channel) {
            /\*
 回调方法，当收到消息后，会自动执行该方法
 1.consumerTag：标识
 2.envelope：获取一些信息。交换机，路由key...
 3.properties: 配置信息
 4.body: 数据
 \*/
            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));//byte数组转string字符串
            }
        };
        channel.basicConsume("hello\_world",true,consumer);
        //关闭资源？不要，因为消费者要监听
    }
}
1.2 work queues模式

（1）模式说明

在这里插入图片描述

  • Work Queues：与入门程序的简单模式相比，多了一个或一些消费端，多个消费端共同消费同一个队列中的消息。（队列存在竞争关系，可以理解为抢红包）
  • 应用场景：对于任务过重或任务较多情况使用工作队列可以提高任务处理的速度。

（2）代码编写

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

Producer_WorkQueues

package com.itheima.producer;
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\_WorkQueues {
    public static void main(String[] args) throws IOException, TimeoutException {
      //1.创建连接工厂
      ConnectionFactory factory=new ConnectionFactory();
      //2.设置参数
        factory.setHost("192.168.101.22");//ip地址 默认localhost
        factory.setPort(5672);//端口 默认值5672
        factory.setVirtualHost("/itcast");//虚拟机默认值 /虚拟机
        factory.setUsername("heima");//用户名 默认guest
        factory.setPassword("heima");//密码 默认guest
       //3.创建连接 connection
        Connection connection = factory.newConnection();
        //4.创建channel
        Channel channel = connection.createChannel();
        //5.创建队列Queue 暂时不用交换机
        /\*
 String queue, boolean durable, boolean exclusive, boolean autoDelete,
 Map<String, Object> arguments)
 1.queue 队列名称
 2.durable 是否持久化，当mq重启之后，还在
 3.exclusive：
 \*是否独占：只能有一个消费者监听队列
 \*当connection关闭时，是否删除队列
 4.autoDelete: 是否自动删除，当没有consumer时，自动删除掉
 5.arguments: 参数
 \*/
        //如果没有一个名字为hello\_world的队列，则会创建队列，如果有则不会创建
        channel.queueDeclare("work\_queues",true,false,false,null);
      //6.发送消息
        /\*
 String exchange, String routingKey, boolean mandatory, byte[] body
 参数：
 1. exchange：交换机名称，简单模式下交换机会使用默认的 ""
 2. routingKey: 路由名称
 3. props: 配置信息
 4. body: 发送消息数据
 \*/
        for (int i = 1; i <=10; i++) {
            String body=i+"hello rabbitmq----";
            channel.basicPublish("","work\_queues",null,body.getBytes());
        }

        //7.释放资源
        /\*channel.close();
 connection.close();\*/

    }
}

Consumer_WorkQueues1

package com.itheima.consumer;

import com.rabbitmq.client.\*;

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

public class Consumer\_WorkQueues1 {
    public static void main(String[] args) throws IOException, TimeoutException {
        //1.创建连接工厂
        ConnectionFactory factory=new ConnectionFactory();
        //2.设置参数
        factory.setHost("192.168.101.22");//ip地址 默认localhost
        factory.setPort(5672);//端口 默认值5672
        factory.setVirtualHost("/itcast");//虚拟机默认值 /虚拟机
        factory.setUsername("heima");//用户名 默认guest
        factory.setPassword("heima");//密码 默认guest
        //3.创建连接 connection
        Connection connection = factory.newConnection();
        //4.创建channel
        Channel channel = connection.createChannel();
        //5.创建队列Queue 暂时不用交换机
        /\*
 String queue, boolean durable, boolean exclusive, boolean autoDelete,
 Map<String, Object> arguments)
 1.queue 队列名称
 2.durable 是否持久化，当mq重启之后，还在
 3.exclusive：
 \*是否独占：只能有一个消费者监听队列
 \*当connection关闭时，是否删除队列
 4.autoDelete: 是否自动删除，当没有consumer时，自动删除掉
 5.arguments: 参数
 \*/
        //如果没有一个名字为hello\_world的队列，则会创建队列，如果有则不会创建
        channel.queueDeclare("work\_queues",true,false,false,null);
        //6.接收消息
        /\*
 basicConsume(String queue, boolean autoAck, Consumer callback)
 参数：
 1. queue：队列名称
 2. autoAck: 是否自动确认
 3. callback: 回调对象
 \*/
       Consumer consumer=new DefaultConsumer(channel){
           /\*
 回调方法，当收到消息后，会自动执行该方法
 1.consumerTag：标识
 2.envelope：获取一些信息。交换机，路由key...
 3.properties: 配置信息
 4.body: 数据
 \*/
           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));//byte数组转string字符串
           }
       };
        channel.basicConsume("work\_queues",true,consumer);
        //关闭资源？不要，因为消费者要监听
    }
}

Consumer_WorkQueues2

package com.itheima.consumer;

import com.rabbitmq.client.\*;

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

public class Consumer\_WorkQueues2 {
    public static void main(String[] args) throws IOException, TimeoutException {
        //1.创建连接工厂
        ConnectionFactory factory=new ConnectionFactory();
        //2.设置参数
        factory.setHost("192.168.101.22");//ip地址 默认localhost
        factory.setPort(5672);//端口 默认值5672
        factory.setVirtualHost("/itcast");//虚拟机默认值 /虚拟机
        factory.setUsername("heima");//用户名 默认guest
        factory.setPassword("heima");//密码 默认guest
        //3.创建连接 connection
        Connection connection = factory.newConnection();
        //4.创建channel
        Channel channel = connection.createChannel();
        //5.创建队列Queue 暂时不用交换机
        /\*
 String queue, boolean durable, boolean exclusive, boolean autoDelete,
 Map<String, Object> arguments)
 1.queue 队列名称
 2.durable 是否持久化，当mq重启之后，还在
 3.exclusive：
 \*是否独占：只能有一个消费者监听队列
 \*当connection关闭时，是否删除队列
 4.autoDelete: 是否自动删除，当没有consumer时，自动删除掉
 5.arguments: 参数
 \*/
        //如果没有一个名字为hello\_world的队列，则会创建队列，如果有则不会创建
        channel.queueDeclare("work\_queues",true,false,false,null);
        //6.接收消息
        /\*
 basicConsume(String queue, boolean autoAck, Consumer callback)
 参数：
 1. queue：队列名称
 2. autoAck: 是否自动确认
 3. callback: 回调对象
 \*/
       Consumer consumer=new DefaultConsumer(channel){
           /\*
 回调方法，当收到消息后，会自动执行该方法
 1.consumerTag：标识
 2.envelope：获取一些信息。交换机，路由key...
 3.properties: 配置信息
 4.body: 数据
 \*/
           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));//byte数组转string字符串
           }
       };
        channel.basicConsume("work\_queues",true,consumer);
        //关闭资源？不要，因为消费者要监听
    }
}

（3）测试

注意：先运行消费者1和消费者2，再运行生产者

结果如下：消费者1消费消息序号 1,3,5,7,9
消费者2消费消息序号 2,4,6,8,10

在这里插入图片描述

在这里插入图片描述

（4） 小结

  1. 在一个队列中如果有多个消费者，那么消费者之间对于同一个消息的关系是竞争的关系。
  2. Work Queues 对于任务过重或任务较多情况使用工作队列可以提高任务处理的速度。例如：短信服务部署多个，只需要有一个节点成功发送即可。
1.3 Pub/Sub 订阅模式

（1）模式说明

在这里插入图片描述

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

  • P：生产者，也就是要发送消息的程序，但是不再发送到队列中，而是发给X（交换机）
  • C：消费者，消息的接收者，会一直等待消息到来
  • Queue：消息队列，接收消息、缓存消息
  • Exchange：交换机（X）。一方面，

接收生产者发送的消息

。另一方面，

知道如何处理消息

，例如递交给某个特别队列、递交给所有队列、或是将消息丢弃。到底如何操作，取决于Exchange的类型。Exchange有常见以下3种类型：

1. Fanout：**广播**，将消息交给**所有绑定到交换机的队列**
2. Direct：**定向**，把消息交给**符合指定routing key 的队列**
3. Topic：**通配符**，把消息交给**符合routing pattern（路由模式） 的队列**

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

（2）代码编写

生产者Producer_PubSub

package com.itheima.producer;
import com.rabbitmq.client.BuiltinExchangeType;
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\_PubSub {
    public static void main(String[] args) throws IOException, TimeoutException {
      //1.创建连接工厂
      ConnectionFactory factory=new ConnectionFactory();
      //2.设置参数
        factory.setHost("192.168.101.22");//ip地址 默认localhost
        factory.setPort(5672);//端口 默认值5672
        factory.setVirtualHost("/itcast");//虚拟机默认值 /虚拟机
        factory.setUsername("heima");//用户名 默认guest
        factory.setPassword("heima");//密码 默认guest
       //3.创建连接 connection
        Connection connection = factory.newConnection();
        //4.创建channel
        Channel channel = connection.createChannel();
        //5.创建交换机
        /\*
 exchangeDeclare
 (String exchange, 交换机名称
 BuiltinExchangeType type, 交换机类型 枚举类型
 DIRECT("direct"), ：定向
 FANOUT("fanout"), ：扇形（广播），发送消息到每一个与之绑定的队列
 TOPIC("topic"),：通配符方式
 HEADERS("headers");参数匹配
 boolean durable, 是否持久化
 boolean autoDelete, 是否自动删除
 boolean internal, 内部使用一般false
 Map<String, Object> arguments) 参数列表
 \*/
        String exchangeName="test\_fanout";
        channel.exchangeDeclare(exchangeName, BuiltinExchangeType.FANOUT,true,false,false,null);
        //6.创建两个队列
        String queue1Name="test\_fanout\_queue1";
        String queue2Name="test\_fanout\_queue2";
        /\*
 String queue, boolean durable, boolean exclusive, boolean autoDelete,
 Map<String, Object> arguments)
 1.queue 队列名称
 2.durable 是否持久化，当mq重启之后，还在
 3.exclusive：
 \*是否独占：只能有一个消费者监听队列
 \*当connection关闭时，是否删除队列
 4.autoDelete: 是否自动删除，当没有consumer时，自动删除掉
 5.arguments: 参数
 \*/
        channel.queueDeclare(queue1Name,true,false,false,null);
        channel.queueDeclare(queue2Name,true,false,false,null);
        //7，绑定队列和交换机
        /\*
 queueBind(String queue, String exchange, String routingKey)
 参数：
 1.queue: 队列名称
 2.exchange：交换机
 3.routingKey：路由键：绑定规则
 如果交换机的类型为fanout，routingKey设置为""
 \*/
        channel.queueBind(queue1Name,exchangeName,"");
        channel.queueBind(queue2Name,exchangeName,"");
        //8.发送消息
        String body="日志信息：张三调用了findAll方法...日志级别：info";
        channel.basicPublish(exchangeName,"",null,body.getBytes());
        //9.释放资源
        channel.close();
        connection.close();
    }
}

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576

Consumer_PubSub1

package com.itheima.consumer;
import com.rabbitmq.client.\*;
import java.io.IOException;
import java.util.concurrent.TimeoutException;

public class Consumer\_PubSub1 {
    public static void main(String[] args) throws IOException, TimeoutException {
        //1.创建连接工厂
        ConnectionFactory factory=new ConnectionFactory();
        //2.设置参数
        factory.setHost("192.168.101.22");//ip地址 默认localhost
        factory.setPort(5672);//端口 默认值5672
        factory.setVirtualHost("/itcast");//虚拟机默认值 /虚拟机
        factory.setUsername("heima");//用户名 默认guest
        factory.setPassword("heima");//密码 默认guest
        //3.创建连接 connection
        Connection connection = factory.newConnection();
        //4.创建channel
        Channel channel = connection.createChannel();
        //5.队列已经声明一次了，这里不用再声明队列
        String queue1Name="test\_fanout\_queue1";
        String queue2Name="test\_fanout\_queue2";
        //6.接收消息
        /\*
 basicConsume(String queue, boolean autoAck, Consumer callback)
 参数：
 1. queue：队列名称
 2. autoAck: 是否自动确认
 3. callback: 回调对象
 \*/
       Consumer consumer=new DefaultConsumer(channel){
           /\*
 回调方法，当收到消息后，会自动执行该方法
 1.consumerTag：标识
 2.envelope：获取一些信息。交换机，路由key...
 3.properties: 配置信息
 4.body: 数据
 \*/
           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));//byte数组转string字符串
               System.out.println("将日志信息打印到控制台");
           }
       };
        channel.basicConsume(queue1Name,true,consumer);
        //关闭资源？不要，因为消费者要监听
    }
}

Consumer_PubSub2

package com.itheima.consumer;
import com.rabbitmq.client.\*;
import java.io.IOException;
import java.util.concurrent.TimeoutException;

public class Consumer\_PubSub2 {
    public static void main(String[] args) throws IOException, TimeoutException {
        //1.创建连接工厂
        ConnectionFactory factory=new ConnectionFactory();
        //2.设置参数
        factory.setHost("192.168.101.22");//ip地址 默认localhost
        factory.setPort(5672);//端口 默认值5672
        factory.setVirtualHost("/itcast");//虚拟机默认值 /虚拟机
        factory.setUsername("heima");//用户名 默认guest
        factory.setPassword("heima");//密码 默认guest
        //3.创建连接 connection
        Connection connection = factory.newConnection();
        //4.创建channel
        Channel channel = connection.createChannel();
        //5.队列已经声明一次了，这里不用再声明队列
        String queue1Name="test\_fanout\_queue1";
        String queue2Name="test\_fanout\_queue2";
        //6.接收消息
        /\*
 basicConsume(String queue, boolean autoAck, Consumer callback)
 参数：
 1. queue：队列名称
 2. autoAck: 是否自动确认
 3. callback: 回调对象
 \*/
       Consumer consumer=new DefaultConsumer(channel){
           /\*
 回调方法，当收到消息后，会自动执行该方法
 1.consumerTag：标识
 2.envelope：获取一些信息。交换机，路由key...
 3.properties: 配置信息
 4.body: 数据
 \*/
           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));//byte数组转string字符串
               System.out.println("将日志信息保存数据库");
           }
       };
        channel.basicConsume(queue2Name,true,consumer);
        //关闭资源？不要，因为消费者要监听
    }
}

运行结果：

在这里插入图片描述

在这里插入图片描述

（3）小结

  1. 交换机需要与队列进行绑定，绑定之后；一个消息可以被多个消费者都收到。
  2. 发布订阅模式与工作队列模式的区别：

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

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

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

1.4 Routing 路由模式

（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 的消息

（2）代码编写

Producer_Routing

package com.zwb.producer.routing;

import com.rabbitmq.client.BuiltinExchangeType;
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\_Routing {

    public static void main(String[] args) throws IOException, TimeoutException {
        //1、创建连接工厂
        ConnectionFactory factory = new ConnectionFactory();
        //2、设置参数
        //factory.setHost("192.168.1.100"); //默认localhost
        factory.setPort(5672);     //默认5672
        factory.setVirtualHost("/itcast"); //设置RabbitMQ服务器中的虚拟机，类似mysql数据库中的某一个库
        factory.setUsername("heima");
        factory.setPassword("heima");
        //3、创建连接Connection
        Connection connection = factory.newConnection();
        //4、创建Channel
        Channel channel = connection.createChannel();
        //5、创建交换机
           /\*
 exchangeDeclare
 (String exchange, 交换机名称
 BuiltinExchangeType type, 交换机类型 枚举类型
 DIRECT("direct"), ：定向
 FANOUT("fanout"), ：扇形（广播），发送消息到每一个与之绑定的队列
 TOPIC("topic"),：通配符方式
 HEADERS("headers");参数匹配
 boolean durable, 是否持久化
 boolean autoDelete, 是否自动删除
 boolean internal, 内部使用一般false
 Map<String, Object> arguments) 参数列表
 \*/
        String exchangeName = "test\_direct";
        channel.exchangeDeclare(exchangeName, BuiltinExchangeType.DIRECT,true,false,null);
        //6、创建两个队列
        String queue1Name="test\_direct\_queue1";
        String queue2Name="test\_direct\_queue2";
           /\*
 String queue, boolean durable, boolean exclusive, boolean autoDelete,
 Map<String, Object> arguments)
 1.queue 队列名称
 2.durable 是否持久化，当mq重启之后，还在
 3.exclusive：
 \*是否独占：只能有一个消费者监听队列
 \*当connection关闭时，是否删除队列
 4.autoDelete: 是否自动删除，当没有consumer时，自动删除掉
 5.arguments: 参数
 \*/
        channel.queueDeclare(queue1Name,true,false,false,null);
        channel.queueDeclare(queue2Name,true,false,false,null);
        //7、绑定队列和交换机
        /\*
 queueBind(String queue, String exchange, String routingKey)
 参数：
 1.queue: 队列名称
 2.exchange：交换机
 3.routingKey：路由键：绑定规则
 如果交换机的类型为fanout，routingKey设置为""
 \*/
        //队列1
        channel.queueBind(queue1Name,exchangeName,"error");
        //队列2
        channel.queueBind(queue2Name,exchangeName,"info");
        channel.queueBind(queue2Name,exchangeName,"warning");
        channel.queueBind(queue2Name,exchangeName,"error");
        //8.发送消息
        String body="日志信息：张三调用了delete方法出错误了...日志级别：error";
        channel.basicPublish(exchangeName,"error",null,body.getBytes());
        //9.释放资源
        channel.close();
        connection.close();
    }
}

Consumer_Routing1

package com.zwb.consumer.routing;

import com.rabbitmq.client.\*;

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

public class Consumer\_Routing1 {

    public static void main(String[] args) throws IOException, TimeoutException {
        //1、创建工厂
        ConnectionFactory factory = new ConnectionFactory();
        //2、设置参数
        //factory.setHost("192.168.1.100"); //默认localhost
        factory.setPort(5672);//默认5672
        factory.setVirtualHost("/itcast");// 默认/
        factory.setUsername("heima");// heima
        factory.setPassword("heima");// heima
        //3、创建连接Connection
        Connection connection = factory.newConnection();
        //4、创建Channel
        Channel channel = connection.createChannel();
        //5.队列已经声明一次了，这里不用再声明队列
        String queue1Name="test\_direct\_queue1";
        String queue2Name="test\_direct\_queue2";
        //6.接收消息
        /\*
 basicConsume(String queue, boolean autoAck, Consumer callback)
 参数：
 1. queue：队列名称
 2. autoAck: 是否自动确认
 3. callback: 回调对象
 \*/
        Consumer consumer=new DefaultConsumer(channel){
            /\*
 回调方法，当收到消息后，会自动执行该方法
 1.consumerTag：标识
 2.envelope：获取一些信息。交换机，路由key...
 3.properties: 配置信息
 4.body: 数据
 \*/
            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);\*/


![img](https://img-blog.csdnimg.cn/img_convert/2a0d3a54a48725eb3420ea179036f7d1.png)
![img](https://img-blog.csdnimg.cn/img_convert/65eb2a4166bf6c3dd90b60d3471f7e2c.png)
![img](https://img-blog.csdnimg.cn/img_convert/eec24cf71938be86adc2688715626cdb.png)

**既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上大数据知识点，真正体系化！**

**由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新**

**[需要这份系统化资料的朋友，可以戳这里获取](https://bbs.csdn.net/topics/618545628)**

queue1Name="test\_direct\_queue1";
        String queue2Name="test\_direct\_queue2";
        //6.接收消息
        /\*
 basicConsume(String queue, boolean autoAck, Consumer callback)
 参数：
 1. queue：队列名称
 2. autoAck: 是否自动确认
 3. callback: 回调对象
 \*/
        Consumer consumer=new DefaultConsumer(channel){
            /\*
 回调方法，当收到消息后，会自动执行该方法
 1.consumerTag：标识
 2.envelope：获取一些信息。交换机，路由key...
 3.properties: 配置信息
 4.body: 数据
 \*/
            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);\*/


[外链图片转存中...(img-GZvX3NXO-1714784032870)]
[外链图片转存中...(img-UOKB0uI4-1714784032871)]
[外链图片转存中...(img-23QoCQTv-1714784032871)]

**既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上大数据知识点，真正体系化！**

**由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新**

**[需要这份系统化资料的朋友，可以戳这里获取](https://bbs.csdn.net/topics/618545628)**
2301_82243558
关注
  • 18
    点赞
  • 踩
  • 11
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
RabbitMQ实战 高效部署分布式消息队列.part1 高清
10-21
RabbitMQ实战 高效部署分布式消息队列.part1.rar 高清 80M 2部分
RabbitMQ快速实战以及核心概念详解
Zhuxiaoyu_91的博客
06-08 993
​ 如果你之前已经使用过RabbitMQ，那么前面的操作你都可以忘记，但是最后这个大模型，你一定要先构建起来，并且可以尝试根据你的经验，看看可以往这个模型中添加一些什么内容。​ 另外，Exchange并不只是简单的将消息全部转发给Queue，在实际使用中，Exchange与Queue之间可以建立不同类型的绑定关系，然后通过一些不同的策略，选择将消息转发到哪些Queue上。从这里可以看到，RabbitMQ中的消息都是通过Queue队列传递的，这个Queue其实就是一个典型的FIFO的队列数据结构。
RabbitMQ详解与实战(绝对足够惊喜)
IT小辉同学
06-16 6570
感谢相遇，一起努力！！！
RabbitMQ基础概念及工作模式的简单介绍
下雨了亦留此地的博客
09-06 778
文章目录RabbitMQ中的MQ是什么?MQ的优势和劣势优势：1.应用解耦2.异步提速3.削峰填谷劣势：1.系统可用性降低2.系统复杂度提高3.一致性问题使用MQ的满足条件常见的MQRabbitMQ简介发展史JMS的概念RabbitMQ相关概念RabbitMQ的六种工作模式1.简单模式2.Work queues工作队列模式3.Pub/Sub发布订阅模式4.Routing路由模式5.Topics通配符模式总结 RabbitMQ中的MQ是什么? MQ全称Message Queue(消息队列），是在消息的传输过程
《我要进大厂》- MQ夺命连环11问
java_kider的博客
11-24 468
你们为什么使用mq？具体的使用场景是什么？ mq的作用很简单，削峰填谷。以电商交易下单的场景来说，正向交易的过程可能涉及到创建订单、扣减库存、扣减活动预算、扣减积分等等。每个接口的耗时如果是100ms，那么理论上整个下单的链路就需要耗费400ms，这个时间显然是太长了。 如果这些操作全部同步处理的话，首先调用链路太长影响接口性能，其次分布式事务的问题很难处理，这时候像扣减预算和积分这种对实时一致性要求没有那么高的请求，完全就可以通过mq异步的方式去处理了。同时，考虑到异步带来的不一致的问题，我们可以
2024年最新RabbitMQ实战学习(1)
最新发布
2401_84165953的博客
05-03 963
//*回调方法，当收到消息后，会自动执行该方法1.consumerTag：标识2.envelope：获取一些信息。交换机，路由key…3.properties: 配置信息4.body: 数据*/*///byte数组转string字符串//关闭资源？不要，因为消费者要监听//1.创建连接工厂//2.设置参数//ip地址 默认localhost//端口 默认值5672//虚拟机默认值 /虚拟机。
RabbitMQ实战 高效部署分布式消息队列.part2
10-21
RabbitMQ实战 高效部署分布式消息队列.part2.rar ) 高清 80M
大数据工程师 Flink技术与实战 源码笔记下载
10-15
标题和描述中提到的“大数据工程师 Flink技术与实战 源码笔记下载”表明这是一份关于大数据处理框架Apache Flink的实战教程，可能包含了源代码解析、实战案例以及学习笔记等内容。对于Flink技术的学习者而言，这样的...
大数据高并发架构实战案例分享-ppt资源
12-05
通过以上实战案例的分享，我们可以学习到如何将大数据和高并发技术应用于实际项目中，解决业务挑战，提升系统性能。这些案例不仅包含理论知识，还包含实施步骤和最佳实践，对于从事相关工作的IT从业者来说，是非常...
大数据高并发架构实战案例分享
10-21
通过一系列的PPT资源，我们将一起学习如何设计和优化大数据高并发架构，以确保系统的可扩展性和性能。 首先，大数据处理涉及到数据的收集、存储、分析和挖掘。Hadoop是大数据处理的基础框架，它通过HDFS（分布式...
RabbitMQ的高可用机制
qq_43012298的博客
02-14 1367
RabbitMQ通过多种机制提供高可用性(HA)支持，以确保消息系统的稳定性和可靠性。下面将详细介绍这些机制，并提供代码示例。
超详细的RabbitMQ入门与实战介绍，看这篇文章就够了！
石杉的架构笔记
08-24 2122
上一篇文章我们已经给出了一整套的数据一致性的保障方案。 本文我们将从三个角度，给出方案如何实现，并且通过数据平台和电商系统进行了举例分析。
rabbitmq实战使用
slava_chines的博客
11-20 294
队列绑定到交换机上，并指定路由键 routing key的名称，然后生产者安照rabbitmq的模糊匹配规则发送消息，满足模糊匹配规则的消费者就能消费到。队列绑定到交换机上，并指定路由键 routing key的名称，然后生产者指定发送哪个交换机上的哪个路由键上，消费者就精确查找到这个路由键进行消费消息。2是异步 ，对于一些比较耗时的操作，像发邮件或发短信之类的，可以让这些步骤脱离主程序，存到mq里，后续消费处理。1是削峰，对于突然涌进来的流量，可以先简单的记录参数值，后面消费消息慢慢处理这些数据。
activeMQ笔记之一
kongxiangqi的专栏
04-26 445
1.JMS介绍     JMS源于企业应用对于消息中间件的需求，使应用程序可以通过消息进行异步处理而互不影响。Sun公司和它的合作伙伴设计的JMS API定义了一组公共的应用程序接口和相应语法，使得Java程序能够和其他消息组件进行通信。JMS有四个组成部分：JMS服务提供者、消息管理对象、消息的生产者消费者和消息本身。 1)JMS服务提供者实现消息队列和通知，同时实现消息管理的API。JMS已经
史上最透彻的 RabbitMQ 可靠消息传输实战
程序员之家
09-27 1340
作者：极客慧链接：https://my.oschina.net/jikeh/blog/2207127可能是缓存架构之史上讲的最明白的 RabbitMQ 可靠消息传输实战演...
RibbitMQ 实战教程
Hbernet的博客
08-21 514
dfghjkl;'
SpringBoot整合RabbitMQ之 典型应用场景实战一
热门推荐
青松之竹_Java博客
10-09 9万+
实战前言 RabbitMQ 作为目前应用相当广泛的消息中间件，在企业级应用、微服务应用中充当着重要的角色。特别是在一些典型的应用场景以及业务模块中具有重要的作用，比如业务服务模块解耦、异步通信、高并发限流、超时业务、数据延迟处理等。 其中课程的学习链接地址：https://edu.csdn.net/course/detail/9314 RabbitMQ 官网拜读 首先，让我们先拜读 Ra...
RocketMQ特性、专业术语（Producer,Producer Group,Consumer Group,Topic,Message,Tag,Broker,Name Server）等
涂作权的博客
10-24 2万+
RocketMQ 是什么 Github 上关于 RocketMQ 的介绍： RcoketMQ 是一款低延迟、高可靠、可伸缩、易于使用的消息中间件。具有以下特性： 支持发布/订阅（Pub/Sub）和点对点（P2P）消息模型 在一个队列中可靠的先进先出（FIFO）和严格的顺序传递 支持拉（pull）和推（push）两种消息模式 单一队列百万消息的堆积能力 支持多种消息协议，如 JMS、MQTT 等
RibbitMQ入门实战详解
翰萨姆的博客
09-17 762
RabbitMQ 实战教程 MQ(Message Queue)=消息队列，消息中间件,是一种理念（规范）RabbitMQ其中的一个具体产品 1.MQ引言 1.1 什么是MQ MQ(Message Quene) : 翻译为 消息队列,通过典型的 生产者和消费者模型,生产者不断向消息队列中生产消息，消费者不断的从队列中获取消息。因为消息的生产和消费都是异步的，而且只关心消息的发送和接收，没有业务逻辑的侵入,轻松的实现系统间解耦。别名为 消息中间件 通过利用高效可靠的消息传递机制进行平台无关的数据交流，并基于数
大数据银行项目实战Java
05-10
大数据银行项目实战Java涉及的技术栈主要包括： 1. 数据库：MySQL、Oracle、Hbase等 2. 大数据处理框架：Hadoop、Spark等 3. 消息中间件：Kafka、RabbitMQ等 4. Web框架：Spring、Spring Boot等 5. 前端框架：Vue、React等 在实战过程中，需要对以上技术进行深入学习和理解，并且结合实际的业务需求进行开发。常见的开发步骤包括需求分析、数据建模、系统设计、编码实现、测试和部署等。 具体的实现过程中，可以根据具体的业务场景选择不同的技术方案，比如使用MapReduce进行数据批处理、使用Spark进行实时数据处理、使用Kafka进行消息传递等。 总之，大数据银行项目实战Java需要掌握多种技术和工具，需要不断学习和实践，才能够开发出高质量、高可用的系统。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值