RabbitMQ：交换机

最新推荐文章于 2024-09-16 18:14:56 发布
最新推荐文章于 2024-09-16 18:14:56 发布
阅读量167 收藏
点赞数
分类专栏： rabbitmq 文章标签： 交换机 队列 rabbitmq java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_49896962/article/details/118543043
版权

交换机在使用前都需要绑定(bindings)队列，什么是 binding 呢，binding 其实是 exchange 和 queue 之间的桥梁，它告诉我们 exchange 和哪个队列进行了绑定关系。

绑定关系介绍：

一、Fanout（扇出交换机）
Fanout 这种类型非常简单。它将接收到的所有消息广播到它知道的所有队列中（RoutingKey一致的情况下）。通俗点说，使用了扇出（Fanout）类型的交换机可以将消息转发到所有它绑定的队列中，每一个队列都可接收到消息。

代码：

生产者：

package com.run.rabbitmq.five;

import com.rabbitmq.client.Channel;
import com.run.rabbitmq.utils.RabbitMqUtils;

import java.util.Scanner;

/**
 * @Date: 2021/07/07/9:56
 *
 *
 *  发消息 交换机
 */
public class EmitLog {

    //交换机的名称
    public static final String EXCHANGER_NAME = "logs";

    public static void main(String[] args) throws Exception {
        Channel channel = RabbitMqUtils.getChannel();
        //声明交换机类型
        channel.exchangeDeclare(EXCHANGER_NAME,"fanout");

        Scanner scanner = new Scanner(System.in);

        while (scanner.hasNext()){
            String message = scanner.next();
            channel.basicPublish(EXCHANGER_NAME,"",null,message.getBytes());
            System.out.println("生产者发送消息："+message);
        }
    }
}

消费者 1：

package com.run.rabbitmq.five;

import com.rabbitmq.client.CancelCallback;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.DeliverCallback;
import com.run.rabbitmq.utils.RabbitMqUtils;

/**
 * @Date: 2021/07/07/9:45
 *
 * 消息接收
 */
public class ReceiveLogs01 {

    //交换机名称
    public static final String EXCHANGE_NAME = "logs";

    public static void main(String[] args) throws Exception {
        Channel channel = RabbitMqUtils.getChannel();
        //声明一个交换机
        channel.exchangeDeclare(EXCHANGE_NAME,"fanout");
        //声明一个临时队列
        /**
         * 生成一个临时队列、队列的名称是随机的
         * 当消费者断开与队列的连接的时候  队列就自动删除
         */
        String queueName = channel.queueDeclare().getQueue();
        /**
         * 绑定交换机与队列
         */
        channel.queueBind(queueName,EXCHANGE_NAME,"");
        System.out.println("等待接收消息....把接受到的消息打印在终端");

        //接收消息
        DeliverCallback deliverCallback = (consumerTag,message) -> {
            System.out.println("消费机01 接收消息:"+new String(message.getBody()));
        };
        //消费者取消消息回调接口
        channel.basicConsume(queueName,true,deliverCallback,consumerTge ->{});
    }
}

消费者 2：

package com.run.rabbitmq.five;

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.DeliverCallback;
import com.run.rabbitmq.utils.RabbitMqUtils;

/**
 * @Date: 2021/07/07/9:45
 *
 * 消息接收
 */
public class ReceiveLogs02 {

    //交换机名称
    public static final String EXCHANGE_NAME = "logs";

    public static void main(String[] args) throws Exception {
        Channel channel = RabbitMqUtils.getChannel();
        //声明一个交换机
        channel.exchangeDeclare(EXCHANGE_NAME,"fanout");
        //声明一个临时队列
        /**
         * 生成一个临时队列、队列的名称是随机的
         * 当消费者断开与队列的连接的时候  队列就自动删除
         */
        String queueName = channel.queueDeclare().getQueue();
        /**
         * 绑定交换机与队列
         */
        channel.queueBind(queueName,EXCHANGE_NAME,"");
        System.out.println("等待接收消息....把接受到的消息打印在终端");

        //接收消息
        DeliverCallback deliverCallback = (consumerTag,message) -> {
            System.out.println("消费机02 接收消息:"+new String(message.getBody()));
        };
        //消费者取消消息回调接口
        channel.basicConsume(queueName,true,deliverCallback,consumerTge ->{});
    }
}

二、Direct exchange（直接交换机）

direct 这种类型的工作方式是，消息只去到它绑定的routingKey 队列中去。

代码：
生产者：

package com.run.rabbitmq.six;

import com.rabbitmq.client.BuiltinExchangeType;
import com.rabbitmq.client.Channel;
import com.run.rabbitmq.utils.RabbitMqUtils;

import java.util.Scanner;

/**
 * @Date: 2021/07/07/10:29
 *
 * 直接交换机    生产者
 */
public class DirectLogs {
    //交换机的名称
    public static final String EXCHANGER_NAME = "direct_logs";

    public static void main(String[] args) throws Exception {
        Channel channel = RabbitMqUtils.getChannel();
        channel.exchangeDeclare(EXCHANGER_NAME, BuiltinExchangeType.DIRECT);

        Scanner scanner = new Scanner(System.in);

        System.out.println("error   info    warning");

        while (scanner.hasNext()){
            String message = scanner.next();
            channel.basicPublish(EXCHANGER_NAME,message,null,message.getBytes());
            System.out.println("生产者发送消息："+message);
        }
    }
}

消费者 1：

package com.run.rabbitmq.six;

import com.rabbitmq.client.BuiltinExchangeType;
import com.rabbitmq.client.CancelCallback;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.DeliverCallback;
import com.run.rabbitmq.utils.RabbitMqUtils;

/**
 * @Date: 2021/07/07/10:20
 *
 *  直接交换机   消费者
 */
public class ReceiveLogsDirect01 {

    public static final String EXCHANGE_NAME = "direct_logs";

    public static void main(String[] args) throws Exception {
        Channel channel = RabbitMqUtils.getChannel();
        //声明一个交换机
        channel.exchangeDeclare(EXCHANGE_NAME, BuiltinExchangeType.DIRECT);
        //声明一个队列
        channel.queueDeclare("console",false,false,false,null);
        //队列绑定交换机
        channel.queueBind("console",EXCHANGE_NAME,"info");
        channel.queueBind("console",EXCHANGE_NAME,"warning");
        //接收消息
        DeliverCallback deliverCallback = (consumerTag, message) -> {
            System.out.println("ReceiveLogsDirect01 接收消息:"+new String(message.getBody()));
        };
        channel.basicConsume("console",true,deliverCallback, consumerTag -> {});
        System.out.println("等待接收消息....把接受到的消息打印在终端");
    }

}

消费者 2 ：

package com.run.rabbitmq.six;

import com.rabbitmq.client.BuiltinExchangeType;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.DeliverCallback;
import com.run.rabbitmq.utils.RabbitMqUtils;

/**
 * @Date: 2021/07/07/10:20
 *
 *  直接交换机   生产者
 */
public class ReceiveLogsDirect02 {

    public static final String EXCHANGE_NAME = "direct_logs";

    public static void main(String[] args) throws Exception {
        Channel channel = RabbitMqUtils.getChannel();
        //声明一个交换机
        channel.exchangeDeclare(EXCHANGE_NAME, BuiltinExchangeType.DIRECT);
        //声明一个队列
        channel.queueDeclare("disk",false,false,false,null);
        //队列绑定交换机
        channel.queueBind("disk",EXCHANGE_NAME,"error");
        //接收消息
        DeliverCallback deliverCallback = (consumerTag, message) -> {
            System.out.println("ReceiveLogsDirect02 接收消息:"+new String(message.getBody()));
        };
        channel.basicConsume("disk",true,deliverCallback, consumerTag -> {});
        System.out.println("等待接收消息....把接受到的消息打印在终端");
    }

}

三、Topics交换机（主题交换机）

使用最广泛也是最强大的交换机。特点是可以发送到类型， topic 交换机的消息的 routing_key 不能随意写，必须满足一定的要求，它必须是一个单词列表，以点号分隔开。这些单词可以是任意单词，比如说：“stock.usd.nyse”, “nyse.vmw”, “quick.orange.rabbit”.这种类型的。当然这个单词列表最多不能超过 255 个字节。

在这个规则列表中，其中有两个替换符是大家需要注意的

*(星号)可以代替一个单词

#(井号)可以替代零个或多个单词

当队列绑定关系是下列这种情况时需要引起注意
当一个队列绑定键是#,那么这个队列将接收所有数据，就有点像 fanout 了
如果队列绑定键当中没有#和*出现，那么该队列绑定类型就是 direct 了

代码：
消费者 1 ：

package com.run.rabbitmq.seven;

import com.rabbitmq.client.BuiltinExchangeType;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.DeliverCallback;
import com.run.rabbitmq.utils.RabbitMqUtils;

/**
 * @Date: 2021/07/07/10:49
 *
 *
 * 主题交换机 消费者 1
 */
public class ReceiveLogsTopic01 {
    public static final String EXCHANGE_NAME = "topic_logs";

    public static void main(String[] args) throws Exception {
        Channel channel = RabbitMqUtils.getChannel();
        //声明一个交换机
        channel.exchangeDeclare(EXCHANGE_NAME, BuiltinExchangeType.TOPIC);
        //声明一个队列
        String queueName = "Q1";
        channel.queueDeclare(queueName,false,false,false,null);
        //队列绑定交换机
        channel.queueBind(queueName,EXCHANGE_NAME,"*.orange.*");
        //接收消息
        DeliverCallback deliverCallback = (consumerTag, message) -> {
            System.out.println("ReceiveLogsTopic01 接收消息:"+new String(message.getBody()));
        };
        channel.basicConsume(queueName,true,deliverCallback, consumerTag -> {});
        System.out.println("等待接收消息....把接受到的消息打印在终端");
    }
}

消费者 2 ：

package com.run.rabbitmq.seven;

import com.rabbitmq.client.BuiltinExchangeType;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.DeliverCallback;
import com.run.rabbitmq.utils.RabbitMqUtils;

/**
 * @Date: 2021/07/07/10:49
 *
 * 主题交换机 消费者 2
 */
public class ReceiveLogsTopic02 {
    public static final String EXCHANGE_NAME = "topic_logs";

    public static void main(String[] args) throws Exception {
        Channel channel = RabbitMqUtils.getChannel();
        //声明一个交换机
        channel.exchangeDeclare(EXCHANGE_NAME, BuiltinExchangeType.TOPIC);
        //声明一个队列
        String queueName = "Q2";
        channel.queueDeclare(queueName,false,false,false,null);
        //队列绑定交换机
        channel.queueBind(queueName,EXCHANGE_NAME,"*.*.rabbit");
        channel.queueBind(queueName,EXCHANGE_NAME,"lazy.#");
        //接收消息
        DeliverCallback deliverCallback = (consumerTag, message) -> {
            System.out.println("ReceiveLogsTopic02 接收消息:"+new String(message.getBody()));
        };
        channel.basicConsume(queueName,true,deliverCallback, consumerTag -> {});
        System.out.println("等待接收消息....把接受到的消息打印在终端");
    }
}

生产者 ：

package com.run.rabbitmq.seven;

import com.rabbitmq.client.BuiltinExchangeType;
import com.rabbitmq.client.Channel;
import com.run.rabbitmq.utils.RabbitMqUtils;

import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;

/**
 * @Date: 2021/07/07/10:49
 *
 * 主题交换机 生产者
 */
public class TopicLogs {
    //交换机的名称
    public static final String EXCHANGER_NAME = "topic_logs";

    public static void main(String[] args) throws Exception {
        Channel channel = RabbitMqUtils.getChannel();
        channel.exchangeDeclare(EXCHANGER_NAME, BuiltinExchangeType.TOPIC);

        Map<String,String> bindingKeyMap = new HashMap<>();
        bindingKeyMap.put("quick.orange.rabbit","被队列 Q1Q2 接收到");
        bindingKeyMap.put("lazy.orange.elephant","被队列 Q1Q2 接收到");
        bindingKeyMap.put("quick.orange.fox","被队列 Q1 接收到");
        bindingKeyMap.put("lazy.brown.fox","被队列 Q2 接收到");
        bindingKeyMap.put("lazy.pink.rabbit","虽然满足两个绑定但只被队列 Q2 接收一次");
        bindingKeyMap.put("quick.brown.fox","不匹配任何绑定不会被任何队列接收到会被丢弃");
        bindingKeyMap.put("quick.orange.male.rabbit","是四个单词不匹配任何绑定会被丢弃");
        bindingKeyMap.put("lazy.orange.male.rabbit","是四个单词但匹配 Q2");

        for (Map.Entry<String, String> stringStringEntry : bindingKeyMap.entrySet()) {
            String routingKey = stringStringEntry.getKey();
            String message = stringStringEntry.getValue();
            channel.basicPublish(EXCHANGER_NAME,routingKey,null,message.getBytes("UTF-8"));
            System.out.println("生产者发出消息:"+message);
        }

    }
}
微笑pro
关注
专栏目录
rabbitMQ 交换机绑定问题
feng_xinlei的博客
02-25 3024
  做项目的时候，发现绑定的ROUTING_KEY换成什么字符串都直接放入队列，根本不能匹配。查了半天，终于找到问题以及解决方法。 在命令行查看rabbitMQ的时候，发现交换机绑定队列里出现好多次重复绑定，并且都为失效，如下图所示：  topic.queue1被我绑定过很多次，是由于每次我都换一下 routing_key，然后继续运行程序造成的。 为了解决问题，首先停止运行rab...
RabbitMQ创建队列及交换机、重试、ACK机制的使用
莫失莫忘的博客
10-11 5772
一、 前言： 之前使用rabbitMQ时只是简单的应用，停留在demo的概念上，本片博客是结合实际使用时会遇到的问题，在之前那篇文章springboot整合RabbitMQ简单使用基础上，继续进行讨论，有兴趣的可以看看之前那篇文章，里面有一些基本的概念介绍。 二、摘要： 本篇文章将尝试回答这么几个问题： SpringBoot中创建RabbitMQ的队列、交换机、及绑定的几种方式? RabbitMQ中的ack机制是什么、如何使用? RabbitMQ中confirm-callback与return-cal
RabbitMQ：交换机（default exchange）
kaven
02-09 4888
Java初识RabbitMQ一 首先看看AMQP协议，对RabbitMQ的架构会更了解。 深入理解AMQP协议 创建一个Maven项目，根据自己服务器RabbitMQ的版本导入相应的包。 <dependency> <groupId>com.rabbitmq</groupId> <artifactId>amqp-client</...
RabbitMQ：交换机（direct exchange）
kaven
02-10 1838
Java初识RabbitMQ一交换机（direct exchange） 首先看看AMQP协议，对RabbitMQ的架构会更了解。 深入理解AMQP协议 创建一个Maven项目，根据自己服务器RabbitMQ的版本导入相应的包。 <dependency> <groupId>com.rabbitmq</groupId> <artifactId...
RabbitMQ：交换机（topic exchange）
kaven
02-11 2365
Java初识RabbitMQ一交换机（topic exchange） 首先看看AMQP协议，对RabbitMQ的架构会更了解。 深入理解AMQP协议 创建一个Maven项目，根据自己服务器RabbitMQ的版本导入相应的包。 <dependency> <groupId>com.rabbitmq</groupId> <artifactId&...
SpringBoot整合RabbitMQ：Direct类型交换机
何哥的博客
01-04 2859
前言：本篇博客主要介绍SpringBoot中如何根据直连型交换机去使用RabbitMQTemplate，Direct模式的Exchange根据消息携带的路由值将消息投递给对应队列。 一、RabbitMQ通信模型和Exchange类型 1.1、RabbitMQ通信模型 在代码中使用MQ发送消息的过程是异步执行的，消息到达RabbitMQ后，会在通信模型中找到适合的队列进行入队。 RabbitMQ通信模型下面来看看消息到达RabbitMQ会发生什么，Exchange会将消息通过RoutingKey将
RabbitMQ：第四种交换机类型
Leon_Jinhai_Sun的博客
08-06 247
RabbitMQ：第四种交换机类型
消息队列RabbitMQ核心：交换机（路由、主题、发布订阅）
我这么骄傲的一个人。
12-13 4051
RabbitMQ 消息传递模型的核心思想是:生产者生产的消息从不会直接发送到队列。实际上，通常生产者甚至都不知道这些消息传递传递到了哪些队列中。相反，生产者只能将消息发送到交换机(exchange)，交换机工作的内容非常简单，一方面它接收来自生产者的消息，另一方面将它们推入队列。交换机必须确切知道如何处理收到的消息。是应该把这些消息放到特定队列还是说把他们到许多队列中还是说应该丢弃它们。这就的由交换机的类型来决定。交换机的类型。
RabbitMQ之交换机
热门推荐
m0_53151031的博客
02-27 1万+
一、RabbitMQ交换机 二、RabbitMQ交换机实例讲解
RabbitMQ交换机详解
weixin_74268571的博客
01-25 2084
交换机（Exchange）是RabbitMQ中重要的概念之一，用于接收生产者发送的消息，并根据一定的规则将消息路由到相应的队列中。本文将详细介绍交换机的定义、作用、应用场景以及常见的交换机类型。交换机是计算机网络中的一种设备，用于连接多个计算机或其他网络设备，并根据目标设备的MAC地址将数据包从一个接口转发到另一个接口。它可以在局域网内部实现数据包的转发和通信功能，使得多台计算机能够快速、可靠地进行数据传输和交流。交换机是实现局域网的重要组成部分，被广泛应用于各种网络环境，包括家庭、办公室、数据中心等。
批量删除rabbitmq的队列或交换机
06-29
删除交换机: python3 rabbitmq_delete.py -k ‘udata.climb’ -d 2 命令说明： -k 指定队列前缀，如udata.climb，则类似udata.climb.user, udata.climb.menu这种的会被删除 -d 指定删除队列还是交换机，1表示队列，...
ituac-rabbitmq:RabbitMq 常规使用、进阶使用代码实战
05-26
消息中间件作用围绕着解耦、冗余(存储)、扩展性、削峰、可恢复性、顺序保证、异步通信等等，实例项目贯穿交换机的4中模式中进行代码展示。所有知识点全部在读者熟悉RabbitMq概念后可直接进行参考，比如Broker、...
simple-RabbitMq:RabbitMq.Client上的简单包装
04-04
1. **RabbitMQ基础**：RabbitMQ的核心概念包括交换机（Exchanges）、队列（Queues）、绑定（Bindings）和消息（Messages）。理解这些概念对于使用任何RabbitMQ客户端库都至关重要。 2. **RabbitMQ.Client库**：这是...
RabbitMQ:交换机
小小&大大
01-04 275
交换机分为6种，分别为直流交换机，主题交换机，扇形交换机，首部交换机，默认交换机，死信交换机 流程 综合交换机的使用 rabbitmq_01 主模块 rabbitmq-provider 子模块 rabbitmq-consumer 子模块 在子模块的pom文件中导入依赖 <dependency> <groupId>org.springfra...
使用 RabbitMQ 实现秒杀订单系统的异步消息处理
cxkjntm123的博客
09-10 1418
秒杀订单的主交换机和队列：用于处理异步下单请求。成功和失败的订单队列：分别处理订单处理成功和失败的消息。死信队列（Dead Letter Queue）：处理超时或者其他异常导致的消息失败。我们使用了来根据路由键将消息发送到不同的队列。每个订单请求在被处理时，首先会进入秒杀队列，然后根据处理结果被转发到成功或失败的队列。处理成功的订单如果超时未支付，会被转发到死信队列，进行进一步处理（例如取消订单、回滚库存等）。在 RabbitMQ 中，交换机是负责将消息路由到相应队列的组件。
RabbitMQ SDK 支持发布、消费，连接恢复，死信队列，多种使用场景
panshiqu的专栏
09-13 767
基于Example封装便于使用的SDK，支持发布、消费，连接恢复，死信队列，以及官方入门中的多种使用场景 使用手动消息确认，队列和消息标记为持久，并不使用临时独占队列 消费者可合理调大Qos.prefetchCount来提高吞吐率 业务逻辑如下返回错误，重新投递仍失败后将进入死信队列，保证消息不丢失，还可反复消费来排查问题 生产者正常退出若是等待发布接口返回消息将不丢失 消费者正常退出是会等待业务逻辑处理且发送确认完成的 建议业务逻辑对消息的消费支持幂等
SpringBoot 消息队列RabbitMQ 交换机模式 Fanout广播 Direct定向 Topic话题
最新发布
生产队的驴
09-16 435
作用是接收生产者发送的消息，并根据某种规则将这些消息路由到一个或多个队列。交换机根据绑定规则和路由键来决定如何将消息分发到队列。简而言之，交换机是消息路由的核心组件，它负责将消息从生产者引导到适当的队列，以便消费者能够处理这些消息。
RabbitMQ消费者确认和重复机制
sdg_advance的博客
09-13 517
极端情况就是消费者一直无法执行成功，那么消息requeue就会无限循环，导致mq的消息处理飙升，带来不必要的压力，为了应对上述情况Spring又提供了消费者失败重试机制：在消费者出现异常时利用本地重试，而不是无限制的requeue到mq队列。如果消费者再次执行依然出错，消息会再次requeue到队列，再次投递，直到消息处理成功为止。即：当消费者处理消息结束后，应该向RabbitMQ发送一个回执，告知RabbitMQ自己消息处理状态。测试可以发现：当消息处理发生异常时，消息依然被RabbitMQ删除了。
Canal+RabbitMQ数据同步环境配置
cyt涛的博客
09-13 1120
Canal 是阿里巴巴开发的开源工具，主要用于解析 MySQL 的 binlog 日志，从而实现数据同步。Canal 会模拟 MySQL 从库的协议，订阅主库的 binlog，从而获取数据库的变更信息。 将 Canal 解析到的 MySQL 数据库变更消息通过 RabbitMQ 分发给下游的消费服务。RabbitMQ 在这个场景中充当消息中间件，保证消息的可靠传递和队列管理。
RabbitMQ详解：交换机、消息队列与绑定
"RabbitMQ学习笔记，涵盖了RabbitMQ的基本理论知识，包括Exchange(交换机)、Queue(消息队列)以及如何在Springboot中整合RabbitMQ的配置信息。" RabbitMQ是一个开源的消息代理和队列服务器，广泛用于分布式系统中，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值