大数据最全RabbitMQ实战学习(3)，大数据开发开发面试准备

于 2024-05-11 18:20:49 发布
阅读量767 收藏 28
点赞数 30
分类专栏： 程序员 文章标签： 大数据 面试 学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/2401_84572976/article/details/138725792
版权

img
img

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化资料的朋友，可以戳这里获取

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

  • 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);\*/
                System.out.println("body:"+new String(body));//byte数组转string字符串
                System.out.println("将日志信息打印到控制台");
            }
        };
        channel.basicConsume(queue2Name,true,consumer);
        //关闭资源？不要，因为消费者要监听
    }
}

Consumer_Routing2

package com.zwb.consumer.routing;

import com.rabbitmq.client.\*;

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

public class Consumer\_Routing2 {

    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);\*/
                System.out.println("body:"+new String(body));//byte数组转string字符串
                System.out.println("将日志信息打印到控制台");
            }
        };
        channel.basicConsume(queue1Name,true,consumer);
        //关闭资源？不要，因为消费者要监听
    }


}

(3) 运行结果

在这里插入图片描述

小结

  • Routing 模式：要求队列在绑定交换机时要指定 routing key，消息会转发到符合 routing key 的队列
1.5 Topics 通配符模式

（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 都会被匹配
  • *代表一个单词，#代表0个或者多个单词

（2）代码实现

Producer_Topics

package com.zwb.producer.topics;

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

    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\_topic";
        channel.exchangeDeclare(exchangeName, BuiltinExchangeType.TOPIC,true,false,null);
        //6、创建两个队列
        String queue1Name="test\_topic\_queue1";
        String queue2Name="test\_topic\_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设置为""
 \*/
        //routing key：系统的名称，日志级别
        //--需求：所有error级别的日志存入数据库，所有order系统的日志存入数据库
        channel.queueBind(queue1Name,exchangeName,"#.error");
        channel.queueBind(queue1Name,exchangeName,"order.\*");
        channel.queueBind(queue2Name,exchangeName,"\*.\*");
        //8.发送消息
        String body="日志信息：张三调用了findAll方法...日志级别：info";
        channel.basicPublish(exchangeName,"order.info",null,body.getBytes());
        //9.释放资源
        channel.close();
        connection.close();
    }
}

Consumer_Topic1

package com.zwb.consumer.topics;

import com.rabbitmq.client.\*;

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

public class Consumer\_Topic1 {

    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\_topic\_queue1";
        String queue2Name="test\_topic\_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);
        //关闭资源？不要，因为消费者要监听
    }


}

Consumer_Topic2

package com.zwb.consumer.topics;

import com.rabbitmq.client.\*;

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

public class Consumer\_Topic2 {

    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


![img](https://img-blog.csdnimg.cn/img_convert/9a1f8c53de604e77026d074817d01f83.png)
![img](https://img-blog.csdnimg.cn/img_convert/89aa2c5687b1381f6abb9ce58912b5b0.png)
![img](https://img-blog.csdnimg.cn/img_convert/cef744f3dcea7921ad0c87a8716333d7.png)

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

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

**[需要这份系统化资料的朋友，可以戳这里获取](https://bbs.youkuaiyun.com/forums/4f45ff00ff254613a03fab5e56a57acb)**

,true,consumer);
        //关闭资源？不要，因为消费者要监听
    }


}

Consumer_Topic2

package com.zwb.consumer.topics;

import com.rabbitmq.client.\*;

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

public class Consumer\_Topic2 {

    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


[外链图片转存中...(img-6juRqvqU-1715422817163)]
[外链图片转存中...(img-tjy4rVdJ-1715422817164)]
[外链图片转存中...(img-FfflDSmW-1715422817164)]

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

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

**[需要这份系统化资料的朋友，可以戳这里获取](https://bbs.youkuaiyun.com/forums/4f45ff00ff254613a03fab5e56a57acb)**
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值