RabbitMQ学习笔记五：Exchange的学习（3）

最新推荐文章于 2024-07-11 20:43:10 发布
最新推荐文章于 2024-07-11 20:43:10 发布
阅读量247 收藏
点赞数
分类专栏： RabbitMQ
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/chenxyt/article/details/79178603
版权

一、概述

    前两篇文章中讲述了全部匹配和直接匹配两种交换机Exchange的类型，这篇文章讲述第三种模糊匹配Topic类型的交换机。

Topic类型的交换机，支持路由规则routingKey模糊匹配，匹配符号有‘#’全部一个或多个单词，‘*’一个单词。

    示例：假设我们有两条队列，队列的绑定规则不确定，只有部分是确定的，也就是我们会接收包含这确定路由规则的信息。

    实现方式：使用Topic类型的交换机，定义路由规则带有匹配符号‘#’或者‘*’,如图，为了更好的说明‘*’和‘#’之间的关系，我们定义如下四个队列分别绑定四种绑定规则com.chen.#  #.com.chen  com.chen.*和*.com.chen 。预期功能，当传入消息绑定com.chen.me时，能被13消费者收到，当传入消息绑定me.com.chen时，能被24消费者收到，当传入消息绑定com.chen.its.me时，能被消费者1收到，当传入消息绑定its.me.com.chen时，能被2消费者收到。


    

二、源代码

    与前面两篇相同，先写生产者，创建Topic类型的交换机，发送四条消息，带有上述四个routingKey

package com.cn.chenxyt.mq;

import java.io.IOException;

import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import com.rabbitmq.client.Channel;


public class MqProducer {
	 public final static String EXCHANGE_NAME="HelloMq";
	 public static void main(String[] args) throws IOException, InterruptedException {
		 //创建连接工厂
		 ConnectionFactory factory = new ConnectionFactory();
		 //设置主机、用户名、密码和客户端端口号
		 factory.setHost("localhost");
		 factory.setUsername("guest");
		 factory.setPassword("guest");
		 factory.setPort(5672);
		 //创建一个新的连接 即TCP连接
		 Connection connection = factory.newConnection();
		 //创建一个通道
		 Channel channel = connection.createChannel();
		 //创建一个交换机
		 channel.exchangeDeclare(EXCHANGE_NAME,"topic");
		 String message1 = "我是com.chen.its.me";
		 String message2 = "我是its.me.com.chen";
		 String message3 = "我是com.chen.me";
		 String message4 = "我是me.com.chen";
		 channel.basicPublish(EXCHANGE_NAME,"com.chen.its.me",null,message1.getBytes("UTF-8"));
		 channel.basicPublish(EXCHANGE_NAME,"its.me.com.chen",null,message2.getBytes("UTF-8"));
		 channel.basicPublish(EXCHANGE_NAME,"com.chen.me",null,message3.getBytes("UTF-8"));
		 channel.basicPublish(EXCHANGE_NAME,"me.com.chen",null,message4.getBytes("UTF-8"));
	}
}

    编写消费者1代码，由于我们要先启动消费者，所以消费者里也创建一个交换机，（生产者即可不用创建），新建一个随机队列，绑定com.chen.#路由规则。 

package com.cn.chenxyt.mq;

import java.io.IOException;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import com.rabbitmq.client.Consumer;
import com.rabbitmq.client.DefaultConsumer;
import com.rabbitmq.client.Envelope;
import com.rabbitmq.client.AMQP.BasicProperties;
public class MqConsumer1 {
	 public final static String EXCHANGE_NAME="HelloMq";
	 public static void main(String[] args) throws IOException {
		 //创建连接工厂
		 ConnectionFactory factory = new ConnectionFactory();
		 //设置主机
		 factory.setHost("localhost");
		 //创建一个新的连接 即TCP连接
		 Connection connection = factory.newConnection();
		 //创建一个通道
		 Channel channel = connection.createChannel();
		 //创建随机队列
		 String queueName = channel.queueDeclare().getQueue();
		 //创建一个交换机
		 channel.exchangeDeclare(EXCHANGE_NAME,"topic");
		 //绑定队列到交换机
		 channel.queueBind(queueName, EXCHANGE_NAME, "com.chen.#");
	     System.out.println("Consumer1 Waiting Received messages");
	     //DefaultConsumer类实现了Consumer接口，通过传入一个channel，
	     //告诉服务器我们需要哪个channel的消息并监听channel，如果channel中有消息，就会执行回调函数handleDelivery
	     Consumer consumer = new DefaultConsumer(channel) {
	            @Override
	            public void handleDelivery(String consumerTag, Envelope envelope,
	                                       BasicProperties properties, byte[] body)
	                    throws IOException {
	                String message = new String(body, "UTF-8");
	                System.out.println("Consumer1 Received '" + message + "'");
	            }
	        };
	        //自动回复队列应答 -- RabbitMQ中的消息确认机制
	        channel.basicConsume(queueName, true, consumer);
	}
}

    新建消费者2，与消费者1类似，交换机只要创建一次即可，这里不保证哪个先启动，所以都声明了交换机。新建随机队列，绑定路由规则#.com.chen 

package com.cn.chenxyt.mq;

import java.io.IOException;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import com.rabbitmq.client.Consumer;
import com.rabbitmq.client.DefaultConsumer;
import com.rabbitmq.client.Envelope;
import com.rabbitmq.client.AMQP.BasicProperties;
public class MqConsumer2 {
	 public final static String EXCHANGE_NAME="HelloMq";
	 public static void main(String[] args) throws IOException {
		 //创建连接工厂
		 ConnectionFactory factory = new ConnectionFactory();
		 //设置主机
		 factory.setHost("localhost");
		 //创建一个新的连接 即TCP连接
		 Connection connection = factory.newConnection();
		 //创建一个通道
		 Channel channel = connection.createChannel();
		 //创建随机队列
		 String queueName = channel.queueDeclare().getQueue();
		 //创建一个交换机
		 channel.exchangeDeclare(EXCHANGE_NAME,"topic");
		 //绑定队列到交换机
		 channel.queueBind(queueName, EXCHANGE_NAME, "#.com.chen");
	     System.out.println("Consumer2 Waiting Received messages");
	     //DefaultConsumer类实现了Consumer接口，通过传入一个channel，
	     //告诉服务器我们需要哪个channel的消息并监听channel，如果channel中有消息，就会执行回调函数handleDelivery
	     Consumer consumer = new DefaultConsumer(channel) {
	            @Override
	            public void handleDelivery(String consumerTag, Envelope envelope,
	                                       BasicProperties properties, byte[] body)
	                    throws IOException {
	                String message = new String(body, "UTF-8");
	                System.out.println("Consumer2 Received '" + message + "'");
	            }
	        };
	        //自动回复队列应答 -- RabbitMQ中的消息确认机制
	        channel.basicConsume(queueName, true, consumer);
	}
}

    新建消费者3，绑定路由规则com.chen.*

package com.cn.chenxyt.mq;

import java.io.IOException;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import com.rabbitmq.client.Consumer;
import com.rabbitmq.client.DefaultConsumer;
import com.rabbitmq.client.Envelope;
import com.rabbitmq.client.AMQP.BasicProperties;
public class MqConsumer3 {
	 public final static String EXCHANGE_NAME="HelloMq";
	 public static void main(String[] args) throws IOException {
		 //创建连接工厂
		 ConnectionFactory factory = new ConnectionFactory();
		 //设置主机
		 factory.setHost("localhost");
		 //创建一个新的连接 即TCP连接
		 Connection connection = factory.newConnection();
		 //创建一个通道
		 Channel channel = connection.createChannel();
		 //创建随机队列
		 String queueName = channel.queueDeclare().getQueue();
		 //创建一个交换机
		 channel.exchangeDeclare(EXCHANGE_NAME,"topic");
		 //绑定队列到交换机
		 channel.queueBind(queueName, EXCHANGE_NAME, "com.chen.*");
	     System.out.println("Consumer3 Waiting Received messages");
	     //DefaultConsumer类实现了Consumer接口，通过传入一个channel，
	     //告诉服务器我们需要哪个channel的消息并监听channel，如果channel中有消息，就会执行回调函数handleDelivery
	     Consumer consumer = new DefaultConsumer(channel) {
	            @Override
	            public void handleDelivery(String consumerTag, Envelope envelope,
	                                       BasicProperties properties, byte[] body)
	                    throws IOException {
	                String message = new String(body, "UTF-8");
	                System.out.println("Consumer3 Received '" + message + "'");
	            }
	        };
	        //自动回复队列应答 -- RabbitMQ中的消息确认机制
	        channel.basicConsume(queueName, true, consumer);
	}
}

    新建消费者4，绑定路由规则*.com.chen

package com.cn.chenxyt.mq;

import java.io.IOException;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import com.rabbitmq.client.Consumer;
import com.rabbitmq.client.DefaultConsumer;
import com.rabbitmq.client.Envelope;
import com.rabbitmq.client.AMQP.BasicProperties;
public class MqConsumer4 {
	 public final static String EXCHANGE_NAME="HelloMq";
	 public static void main(String[] args) throws IOException {
		 //创建连接工厂
		 ConnectionFactory factory = new ConnectionFactory();
		 //设置主机
		 factory.setHost("localhost");
		 //创建一个新的连接 即TCP连接
		 Connection connection = factory.newConnection();
		 //创建一个通道
		 Channel channel = connection.createChannel();
		 //创建随机队列
		 String queueName = channel.queueDeclare().getQueue();
		 //创建一个交换机
		 channel.exchangeDeclare(EXCHANGE_NAME,"topic");
		 //绑定队列到交换机
		 channel.queueBind(queueName, EXCHANGE_NAME, "*.com.chen");
	     System.out.println("Consumer4 Waiting Received messages");
	     //DefaultConsumer类实现了Consumer接口，通过传入一个channel，
	     //告诉服务器我们需要哪个channel的消息并监听channel，如果channel中有消息，就会执行回调函数handleDelivery
	     Consumer consumer = new DefaultConsumer(channel) {
	            @Override
	            public void handleDelivery(String consumerTag, Envelope envelope,
	                                       BasicProperties properties, byte[] body)
	                    throws IOException {
	                String message = new String(body, "UTF-8");
	                System.out.println("Consumer4 Received '" + message + "'");
	            }
	        };
	        //自动回复队列应答 -- RabbitMQ中的消息确认机制
	        channel.basicConsume(queueName, true, consumer);
	}
}

    分别启动消费者1234，使其处于监听状态，可以在RabbitMQ控制台看见声明了一个名为'HelloMq'类型为topic的交换机和四个随机队列

  

    

    

    


    

    

    

        启动生产者，可以看见消费者12收到了两条消息，消费者34收到了一条消息，实际结果与开篇的预期结果吻合。

    

    

    

    

    至此，topic类型的交换机功能就实现了。

三、代码下载

    代码下载地址：https://pan.baidu.com/s/1mj2nEly

Crayoncxy
关注
专栏目录
RabbitMQ学习笔记九：SpringBoot集成RabbitMQ
weixin_45020617的博客
07-23 396
一 创建springboot项目 不选择依赖的话，也可以直接创建好项目后 再在pom.xml文件中导入依赖 <!-- rabbitmq集成依赖--> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-amqp</artifactId> </dependency> 二.
RabbitMQ学习笔记六：Fanout模型
weixin_45020617的博客
07-12 441
Fanout广播模型： 可以有多个消费者 每个消费者都有自己的队列（queue） 每个队列都要绑定到交换机（exchange） 生产者发送的消息，只能发送到交换机，交换机决定要发给哪个队列，生产者无法决定 交换机把消息发送给绑定过的所有队列 队列的消费者都能拿到消息，实现一条消息被多个消费者消费 代码实现： 1.创建生产者 import com.rabbitmq.client.Channel; import com.rabbitmq.client.Connection; impo...
Spring Boot RabbitMQ - 交换器
spring_root的博客
02-25 431
1fanout exchange 发送到该交换器的所有消息，会被路由到其绑定的所有队列。不处理路由键。你只需要简单的将队列绑定到交换机上。一个发送到交换机的消息都会被转发到与该交换机绑定的所有队列上。很像子网广播，每台子网内的主机都获得了一份复制的消息。Fanout交换机转发消息是最快的。 如图所示，所有发送到fanout exchange的消息都会路由到QUEUE-1和Q...
RabbitMQ学习笔记（二）-Exchange相关
sinb妃的博客
04-19 100
1、概念 交换机是用来发送消息的 AMQP 实体，交换机拿到一个消息之后将它路由给一个或零个队列。它使用哪种路由算法是由交换机类型和绑定（Bindings）规则所决定的。 注意： 交换机可以有两个状态：持久（durable）、暂存（transient）。 持久化的交换机会在消息代理（broker）重启后依旧存在，而暂存的交换机则不会（它们需要在代理再次上线后重新被声明）。 2、direct直连交换机（默认交换机） （1）概念：根据消息携带的路由键（routing key）将消息投递给对应绑定键的队列。
RabbitMQ学习笔记四：Exchange的学习（2）
CHENXY
01-25 435
一、概述     前一篇文章中，我们了解了交换机的四种类型，并使用了一个广播式发送消息的示例学习了fanout类型的交换机，这篇文章继续学习direct类型的交换机。direct类型的交换机可以实现不同的消息发送到不同的队列中去。     示例场景：在绑定同一个交换机的两个队列中，一个队列负责接收生产者发送的奇数消息，一个队列负责接收生产者发送的偶数消息，当发送的消息为10的整数倍时，两个队列
RabbitMQ学习笔记三：Exchange的学习（1）
CHENXY
01-23 321
一、概述     上一篇文章中讲述了一个简单的消息传递模型，消息从生产者发送到消费者再发送到队列，实际的工作中生产者不知道要把消息发送给哪个队列，可能有多个消费者要生产者的消息，也可能有的消费者不需要生产者的全部消息，比如日志系统，一个消费者需要info级别的信息，另一个消费者需要error和info级别的信息，这时候我们就用到了交换机，生产者把消息发送到交换机，交换机像是一个消息中转站，一边接
RabbitMQ学习笔记六：Exchange的学习（4）
CHENXY
02-01 271
一、概述     前面三篇文章讲述了RabbitMQ 常用的三种Exchange类型，这篇文章学习一下第四种不常用的Exchange类型：Headers这种类型与topic类型类似，只不过不是匹配routingKeys，是匹配AMQP协议中的Header，Header是一个HashTable类型的键值对，而routingKey是String类型的字符串。功能与Topic相同，消息发送者绑定消息的
RabbitMQ学习笔记：Event Exchange Plugin（事件交换器插件）rabbitmq-event-exchange
最新发布
smart_an的专栏
07-11 548
作者简介：大家好，我是哥，前中兴通讯、美团架构师，现某互联网公司联系qq：184480602，加我进群，大家一起学习，一起进步，一起对抗互联网寒冬学习必须往深处挖，挖的越深，基础越扎实！客户端connection、channels、queues、consumers和系统其它部分自动生成的事件。
RabbitMQ学习笔记：使用Docker部署RabbitMQ集群
smart_an的专栏
07-07 1300
RabbitMQ本身是基于Erlang编写，Erlang语言天生具备分布式、高并发的特性（通过同步Erlang集群各节点的magic cookie来实现）。因此，RabbitMQ天生支持Clustering。这使得RabbitMQ本身不需要像ActiveMQ、Kafka那样通过Zookeeper分别来实现HA方案和保存集群的元数据。集群是保证可靠性的一种方式，同时可以通过水平扩展以达到增加消息吞吐量的能力。
rabbitmq学习笔记和软件和插件
05-05
**RabbitMQ学习笔记与软件插件详解** RabbitMQ是一种广泛应用的消息中间件，它基于AMQP（Advanced Message Queuing Protocol）协议，提供可靠的消息传递服务。在分布式系统中，RabbitMQ扮演着数据交换中心的角色，...
rabbitMQ 学习笔记
12-27
**正文** ...通过以上的学习，你应该对RabbitMQ有了基本的理解，并掌握了在Java中使用RabbitMQ的基本方法。然而，实际应用中，还需要根据具体业务场景灵活运用和调整策略，以充分发挥RabbitMQ的优势。
RabbitMQ学习笔记
06-22
**RabbitMQ学习笔记** RabbitMQ是一款广泛应用的消息中间件，它基于AMQP（Advanced Message Queuing Protocol）协议，能够实现在分布式系统中可靠的消息传递。RabbitMQ的核心功能是作为一个消息代理，允许应用程序...
RabbitMQ学习笔记九：RabbitMQ实现RPC（远程过程调用）
CHENXY
02-07 3615
一、概述     前面几篇文章讲述的内容都是单向的消息传递，生产者将消息发送给消费者之后就不再管后续的业务处理了。实际业务中，有的时候我们还需要等待消费者返回结果给我们，或者是说我们需要消费者上的一个功能、一个方法或是一个接口返回给我们相应的值，而往往大型的系统软件，生产者跟消费者之间都是相互独立的两个系统，部署在两个不同的电脑上，不能通过直接对象.方法的形式获取想要的结果，这时候我们就需要用到
RabbitMQ学习笔记七：交换机、队列、消息的持久化
CHENXY
02-06 2975
一、概述     在生产过程中，难免会发生服务器宕机的事情，RabbitMQ也不例外，可能由于某种特殊情况下的异常而导致RabbitMQ宕机从而重启，那么这个时候对于消息队列里的数据，包括交换机、队列以及队列中存在消息恢复就显得尤为重要了。RabbitMQ本身带有持久化机制，包括交换机、队列以及消息的持久化。持久化的主要机制就是将信息写入磁盘，当RabbtiMQ服务宕机重启后，从磁盘中读取存入的
RabbitMQ学习笔记八：RabbitMQ的消息确认
CHENXY
02-07 2013
一、概述     前文说到RabbitMQ的交换机、队列、消息的持久化并不能100%的保证消息不会丢失。首先从生产者端，持久化的消息在RabbitMQ同步到磁盘之前，还需要一段时间，这个时间很短，但是不容忽视。假如此时服务器宕机了，那么消息就丢失了。这种发生在生产者上的消息丢失我们可以使用镜像队列和事务机制来保证数据的完整性。其次是消费者端，假如消费者拿到消息还未处理，发生异常而崩溃，此时这条消
RabbitMQ学习笔记二：Hello World
CHENXY
01-22 1023
一、流程概述     本文主要实现RabbitMQ在JAVA项目中的入门级别应用，即实现消息生成者发送一条‘’Hello World“ 消息，消费者收到这条信息并打印出来。消息的传递流程是“生产者-队列-消费者”，没有经过交换机，如图： P：消息生产者 QUEUE：队列 X：消息接收者 二、源代码     我这里用的是一个maven项目，首先要在pom.xml中引入RabbitMq
RabbitMQ学习笔记一：基本概念与环境搭建
CHENXY
01-20 478
一、定义     MQ（Message Queue，消息队列）是基于应用程序之间的一种通信方式，应用程序通过读写出入队列的消息进行通信，而不需要用专用的连接来连接它们。消息通信指的是程序之间在消息中传递信息进行通信，而不是传统的通过直接调用（如RPC）的方式进行通信。MQ的使用除去了消息接收和发送的应用程序同时执行的要求。RabbitMQ是实现了AMQP协议MQ的一个中间件，它由ERLANG语言
RabbitMQ学习笔记十：RabbitMQ与Spring 的整合
CHENXY
02-24 368
一、概述    前面的文章中整理了常规项目下RabbitMQ实现各种通用消息队列的方式，一般的企业级项目，通常使用Spring框架来实现项目，本文主要讲述RabbitMQ与Spring的集成，通过一个简单的示例演示集成。   示例：通过Spring管理项目，实现RabbitMQ的fanout类型交换机的消息队列，一个生产者Producer，一个fanout类型的交换机exchangeTest，两个...
RabbitMQ学习笔记：Java操作与Spring整合
"这是一份关于RabbitMQ的学习资料，涵盖了从基础的Java操作到Spring的整合使用，同时还包括了一些有价值的博客链接。" RabbitMQ是企业级的消息中间件，常用于实现分布式系统中的异步处理、应用解耦、流量削锋以及...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值