RabbitMq的学习（三）：Java使用Exchange（路由）

最新推荐文章于 2022-12-24 04:03:29 发布
最新推荐文章于 2022-12-24 04:03:29 发布
阅读量1.9k 收藏 5
点赞数 1
分类专栏： RabbitMq
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/h996666/article/details/83587657
版权

RabbitMq的Exchange（路由）官方文档：http://www.rabbitmq.com/getstarted.html（语言记得选Java）

路由概要说明：一个Exchange（路由）可以绑定多个Queue（队列），

根据不同的Exchange类型可以实现不同Exchange策略。

 

一、fanout

说明：把所有发送到该Exchange的消息路由到所有与它绑定的Queue中

代码如下：

package com.mq;

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.net.URISyntaxException;
import java.security.KeyManagementException;
import java.security.NoSuchAlgorithmException;
import java.util.concurrent.TimeoutException;

public class ProducerExchangeTest {

    public static void main(String[] args) {
        // 创建连接工厂
        ConnectionFactory factory = new ConnectionFactory();
        // 连接
        Connection connection = null;
        // 通道
        Channel channel = null;
        try {
            // amqp://用户名:密码@IP:端口号/虚拟服务器名称
            factory.setUri("amqp://testuser:testuser@192.168.162.130:5672/my_test");
            // 获取连接
            connection = factory.newConnection();
            System.out.println(connection);

            // 创建通道
            channel = connection.createChannel();
            System.out.println(channel);

            /**
             * 创建一个队列
             *
             * queue 队列名称
             * durable 是否申明持久队列，true：rabbitmq重启后继续存在
             * exclusive 是否独占，ture：只有该连接能访问
             * autoDelete 是否自动删除，true：服务器不再使用时，将自动删除该队列
             * arguments 队列其它参数
             */
            channel.queueDeclare("testQueue", true, false, false, null);


            /**
             * 创建路由
             *
             * exchange 路由名称
             * type 路由类型，这里可以用string类型，我直接用了架包里自带的枚举类
             * durable true：持久化操作，rabbitmq重启后，依然存在
             * autoDelete true：自动删除，当没被使用时，自动删除该路由
             * internal
             * arguments 创建路由时的构造参数
             */
            channel.exchangeDeclare("testExchange",BuiltinExchangeType.FANOUT,
                    true, false, false, null);


            /**
             * 队列绑定路由
             *
             * queue 队列名称
             * exchange 路由名称
             * routingKey 路由密钥
             */
            channel.queueBind("testQueue","testExchange","");

            String msg = "今天天气不错";

            /**
             * 推送消息
             *
             * exchange 路由
             * routingKey 路由密钥
             * props 消息的头信息
             * body 消息主体
             */
            channel.basicPublish("testExchange", "", null, msg.getBytes("UTF-8"));

        } catch (URISyntaxException e) {
            e.printStackTrace();
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        } catch (KeyManagementException e) {
            e.printStackTrace();
        } catch (TimeoutException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

与之前的代码相比较，就加了两行代码，1创建Exchange，2将Exchange和Queue绑定。

运行以上代码之后，RabbitMq管理后台如下图所示：

testExchange内容如下：

testExchange已经成功绑定到testQueue。

一个Exchange可以绑定多个Queue，我这里只绑定了一个Queue。

二、direct

说明：把消息路由到bindingKey与routingKey完全匹配的Queue中

代码如下：

package com.mq;

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.net.URISyntaxException;
import java.security.KeyManagementException;
import java.security.NoSuchAlgorithmException;
import java.util.concurrent.TimeoutException;

public class ProducerExchangeTest {

    public static void main(String[] args) {
        // 创建连接工厂
        ConnectionFactory factory = new ConnectionFactory();
        // 连接
        Connection connection = null;
        // 通道
        Channel channel = null;
        try {
            // amqp://用户名:密码@IP:端口号/虚拟服务器名称
            factory.setUri("amqp://testuser:testuser@192.168.162.130:5672/my_test");
            // 获取连接
            connection = factory.newConnection();
            System.out.println(connection);

            // 创建通道
            channel = connection.createChannel();
            System.out.println(channel);

            /**
             * 创建一个队列
             *
             * queue 队列名称
             * durable 是否申明持久队列，true：rabbitmq重启后继续存在
             * exclusive 是否独占，ture：只有该连接能访问
             * autoDelete 是否自动删除，true：服务器不再使用时，将自动删除该队列
             * arguments 队列其它参数
             */
            channel.queueDeclare("queueDirect", true, false, false, null);

            /**
             * 创建路由
             *
             * exchange 路由名称
             * type 路由类型，这里可以用string类型，我直接用了架包里自带的枚举类
             * durable true：持久化操作，rabbitmq重启后，依然存在
             * autoDelete true：自动删除，当没被使用时，自动删除该路由
             * internal
             * arguments 创建路由时的构造参数
             */
            channel.exchangeDeclare("exchangeDirect",BuiltinExchangeType.DIRECT,
                    true, false, false, null);
            
            /**
             * 队列绑定路由
             *
             * queue 队列名称
             * exchange 路由名称
             * routingKey 路由密钥
             */
            channel.queueBind("queueDirect","exchangeDirect","test.direct.my");

            String msg = "今天天气不错";

            /**
             * 推送消息
             *
             * exchange 路由
             * routingKey 路由密钥
             * props 消息的头信息
             * body 消息主体
             */
            channel.basicPublish("exchangeDirect", "test.direct.my",
                    null, msg.getBytes("UTF-8"));

        } catch (URISyntaxException e) {
            e.printStackTrace();
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        } catch (KeyManagementException e) {
            e.printStackTrace();
        } catch (TimeoutException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

创建Queue的方式不变，创建Channel时，将类型修改成direct，绑定和推送时，加上routingKey即可。

在推送消息的时候，把routingKey修改掉，比如：test.direct.*。

看看还能不能推送成功，显然queueDirect里并没有消息。

RabbitMq后台查看routingKey：

三、topic

说明：把消息路由到bindingKey与routingKey模糊匹配的Queue中

【*】表示匹配1个单词

【#】表示匹配0个或多个单词

 

(1)给张官方图例，方便理解

a.orange.rabbit能分发到Q1，Q2

a.orange.b只能分发到Q1

a.b.rabbit只能分发到Q2

lazy.a.b或者lazy.a只能分发到Q2

(2)下面是我自己写的，代码如下：

package com.mq;

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.net.URISyntaxException;
import java.security.KeyManagementException;
import java.security.NoSuchAlgorithmException;
import java.util.concurrent.TimeoutException;

public class ProducerExchangeTest {

    public static void main(String[] args) {
        // 创建连接工厂
        ConnectionFactory factory = new ConnectionFactory();
        // 连接
        Connection connection = null;
        // 通道
        Channel channel = null;
        try {
            // amqp://用户名:密码@IP:端口号/虚拟服务器名称
            factory.setUri("amqp://testuser:testuser@192.168.162.130:5672/my_test");
            // 获取连接
            connection = factory.newConnection();
            System.out.println(connection);

            // 创建通道
            channel = connection.createChannel();
            System.out.println(channel);

            /**
             * 创建一个队列
             *
             * queue 队列名称
             * durable 是否申明持久队列，true：rabbitmq重启后继续存在
             * exclusive 是否独占，ture：只有该连接能访问
             * autoDelete 是否自动删除，true：服务器不再使用时，将自动删除该队列
             * arguments 队列其它参数
             */
            channel.queueDeclare("queueTopic1", true, false, false, null);

            /**
             * 创建一个队列
             *
             * queue 队列名称
             * durable 是否申明持久队列，true：rabbitmq重启后继续存在
             * exclusive 是否独占，ture：只有该连接能访问
             * autoDelete 是否自动删除，true：服务器不再使用时，将自动删除该队列
             * arguments 队列其它参数
             */
            channel.queueDeclare("queueTopic2", true, false, false, null);

            /**
             * 创建一个队列
             *
             * queue 队列名称
             * durable 是否申明持久队列，true：rabbitmq重启后继续存在
             * exclusive 是否独占，ture：只有该连接能访问
             * autoDelete 是否自动删除，true：服务器不再使用时，将自动删除该队列
             * arguments 队列其它参数
             */
            channel.queueDeclare("queueTopic3", true, false, false, null);

            /**
             * 创建路由
             *
             * exchange 路由名称
             * type 路由类型，这里可以用string类型，我直接用了架包里自带的枚举类
             * durable true：持久化操作，rabbitmq重启后，依然存在
             * autoDelete true：自动删除，当没被使用时，自动删除该路由
             * internal
             * arguments 创建路由时的构造参数
             */
            channel.exchangeDeclare("exchangeTopic",BuiltinExchangeType.TOPIC,
                    true, false, false, null);

            /**
             * 队列绑定路由
             *
             * queue 队列名称
             * exchange 路由名称
             * routingKey 路由密钥
             */
            channel.queueBind("queueTopic1","exchangeTopic","*.topic.*");

            /**
             * 队列绑定路由
             *
             * queue 队列名称
             * exchange 路由名称
             * routingKey 路由密钥
             */
            channel.queueBind("queueTopic2","exchangeTopic","test.topic.*");

            /**
             * 队列绑定路由
             *
             * queue 队列名称
             * exchange 路由名称
             * routingKey 路由密钥
             */
            channel.queueBind("queueTopic3","exchangeTopic","test.#");

            String msg = "今天天气不错";

            /**
             * 推送消息
             *
             * queueTopic1，queueTopic2，queueTopic3队列能分发到
             */
            channel.basicPublish("exchangeTopic", "test.topic.a",
                    null, msg.getBytes("UTF-8"));

            /**
             * 推送消息
             *
             * 只有queueTopic3队列能分发到
             */
//            channel.basicPublish("exchangeTopic", "test.t.a",
//                    null, msg.getBytes("UTF-8"));

            /**
             * 推送消息
             *
             * 只有queueTopic1队列能分发到
             */
//            channel.basicPublish("exchangeTopic", "a.topic.a",
//                    null, msg.getBytes("UTF-8"));

        } catch (URISyntaxException e) {
            e.printStackTrace();
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        } catch (KeyManagementException e) {
            e.printStackTrace();
        } catch (TimeoutException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

我创建了3个队列，并分别绑定了不同的routingKey。通配符的使用，慢慢尝试吧，我代码里只列举了一部分。

四、headers

说明：headers类型的Exchange不依赖于routingKey与bindingKey的匹配规则来路由消息，

而是根据发送的消息内容中的headers属性进行匹配

注意：关于headers的官方说明，我找了几次都没找到，下面是我自己测试以及结合网络资料得出来的。

所以谨慎参考。

headers里有个key“x-match”，有两个取值：all(默认)，any。

(1).all，匹配所有headers里的键值对，只有全部全部匹配才能成功推送消息。

匹配基准是Exchange绑定Queue时，写入的headers，我这里称之为bindHeaders。

推送消息时的headers，我这里称之为pushHeaders。

pushHeaders键值对要大于等于bindHeaders，才能成功推送。

如下图：

(2).any，就比较简单了，bindHeaders和pushHeaders只要有一个键值对匹配即可成功推送。

下面直接上代码：

package com.mq;

import com.rabbitmq.client.*;

import java.io.IOException;
import java.net.URISyntaxException;
import java.security.KeyManagementException;
import java.security.NoSuchAlgorithmException;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.TimeoutException;

public class ProducerExchangeTest {

    public static void main(String[] args) {
        // 创建连接工厂
        ConnectionFactory factory = new ConnectionFactory();
        // 连接
        Connection connection = null;
        // 通道
        Channel channel = null;
        try {
            // amqp://用户名:密码@IP:端口号/虚拟服务器名称
            factory.setUri("amqp://testuser:testuser@192.168.162.130:5672/my_test");
            // 获取连接
            connection = factory.newConnection();
            System.out.println(connection);

            // 创建通道
            channel = connection.createChannel();
            System.out.println(channel);

            /**
             * 创建一个队列
             *
             * queue 队列名称
             * durable 是否申明持久队列，true：rabbitmq重启后继续存在
             * exclusive 是否独占，ture：只有该连接能访问
             * autoDelete 是否自动删除，true：服务器不再使用时，将自动删除该队列
             * arguments 队列其它参数
             */
            channel.queueDeclare("queueHeaders", true, false, false, null);

            /**
             * 创建路由
             *
             * exchange 路由名称
             * type 路由类型，这里可以用string类型，我直接用了架包里自带的枚举类
             * durable true：持久化操作，rabbitmq重启后，依然存在
             * autoDelete true：自动删除，当没被使用时，自动删除该路由
             * internal
             * arguments 创建路由时的构造参数
             */
            channel.exchangeDeclare("exchangeHeaders",BuiltinExchangeType.HEADERS,
                    true, false, false, null);

            // Exchange绑定Queue的头部
            Map<String, Object> headers = new HashMap<>();
            headers.put("x-match", "all"); // x-match:all(默认),any
            headers.put("sign", "123456");
            headers.put("a", "000");

            /**
             * 队列绑定路由
             *
             * queue 队列名称
             * exchange 路由名称
             * routingKey 路由密钥
             */
            channel.queueBind("queueHeaders","exchangeHeaders","", headers);

            String msg = "今天天气不错";

            // 推送时的头部
            Map<String, Object> pushHeaders = new HashMap<>();
            pushHeaders.put("sign", "123456");
            pushHeaders.put("a", "000");
            AMQP.BasicProperties properties = new AMQP.BasicProperties().builder().headers(pushHeaders).build();

            // 下面写法是错误的，不要踩坑
//            AMQP.BasicProperties properties = new AMQP.BasicProperties();
//            properties.builder().headers(pushHeaders).build();

            /**
             * 推送消息
             *
             * exchange 路由
             * routingKey 路由密钥
             * props 消息的头信息
             * body 消息主体
             */
            channel.basicPublish("exchangeHeaders", "",
                    properties, msg.getBytes("UTF-8"));


        } catch (URISyntaxException e) {
            e.printStackTrace();
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        } catch (KeyManagementException e) {
            e.printStackTrace();
        } catch (TimeoutException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

我代码里只列举了all的用法，其它自行测试吧。运行之后，RabbitMq后台部分信息如下：

 

五、Exchange绑定Exchange

哈哈，没想到吧，路由还可以绑定路由，用法和绑定队列的用法类似。

下面我就贴一下简单的代码：

package com.mq;

import com.rabbitmq.client.*;

import java.io.IOException;
import java.net.URISyntaxException;
import java.security.KeyManagementException;
import java.security.NoSuchAlgorithmException;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.TimeoutException;

public class ProducerExchangeTest {

    public static void main(String[] args) {
        // 创建连接工厂
        ConnectionFactory factory = new ConnectionFactory();
        // 连接
        Connection connection = null;
        // 通道
        Channel channel = null;
        try {
            // amqp://用户名:密码@IP:端口号/虚拟服务器名称
            factory.setUri("amqp://testuser:testuser@192.168.162.130:5672/my_test");
            // 获取连接
            connection = factory.newConnection();
            System.out.println(connection);

            // 创建通道
            channel = connection.createChannel();
            System.out.println(channel);

            /**
             * 创建路由
             *
             * exchange 路由名称
             * type 路由类型，这里可以用string类型，我直接用了架包里自带的枚举类
             * durable true：持久化操作，rabbitmq重启后，依然存在
             * autoDelete true：自动删除，当没被使用时，自动删除该路由
             * internal
             * arguments 创建路由时的构造参数
             */
            channel.exchangeDeclare("exchange1",BuiltinExchangeType.FANOUT,
                    true, false, false, null);

            /**
             * 创建路由
             *
             * exchange 路由名称
             * type 路由类型，这里可以用string类型，我直接用了架包里自带的枚举类
             * durable true：持久化操作，rabbitmq重启后，依然存在
             * autoDelete true：自动删除，当没被使用时，自动删除该路由
             * internal
             * arguments 创建路由时的构造参数
             */
            channel.exchangeDeclare("exchange2",BuiltinExchangeType.FANOUT,
                    true, false, false, null);

            /**
             * destination 目标路由
             * source 来源路由
             * routingKey 密钥
             * argument 自定义参数
             *
             * 绑定方向：source->destination，即exchange2->exchange1
             */
            channel.exchangeBind("exchange1", "exchange2", "", null);

        } catch (URISyntaxException e) {
            e.printStackTrace();
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        } catch (KeyManagementException e) {
            e.printStackTrace();
        } catch (TimeoutException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

顺便也贴一下，运行成功之后的RabbitMq后台部分信息：

exchange2信息：

exchange1信息：

 

ok，结束。

lemon_cake
关注
  • 1
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
（七） RabbitMQ的消息路由机制四种Exchange模式(fanout,direct,topic,header)
mtsbv110的专栏
05-11 1624
一.Direct Exchange 任何发送到Direct Exchange的消息都会被转发到RouteKey中指定的Queue。 1.一般情况可以使用rabbitMQ自带的Exchange：”"(该Exchange的名字为空字符串，下文称其为default Exchange)。 2.这种模式下不需要将Exchange进行任何绑定(binding)操作 3.消息传递时需要一个“RouteKey”，可以简单的理解为要发送到的队列名字。 4.如果vhost中不存在RouteKey中指定的队列名，.
RabbitMq中交换器（Exchange）类型详解
技术人集结地
04-04 6642
RabbitMQ是工作中经常使用的一个开源消息队列，它是通过Erlang语言来开发的，RabbitMQ中有一个非常常见且重要的概念叫交换器（Exchange），所有生产者提交的消息都是通过Exchange进行接收，然后通过特定的路由策略转发对特定的队列（Queue）中，然后消费者通过绑定特定的队列，将队列中的信息进行消费处理。我们如果是通过RabbitMQ的客户端来进行创建Exchange的话，一定需要你选择一个特定的Exchange类型的，这个时候如果不了解每一种类型的特性，就很容易选择错误，造成整
RabbitMQ的三种exchange类型
qq_43750656的博客
06-12 480
一、Direct类型 1.图解概述 如图所示，该模式下生产者发送消息给broker中的交换机（一个broker中可以有多个exchange交换机，一个exchange可以绑定多个queue队列），交换机根据这条消息携带的routing-key（123）来分发到这个routing-key对应的队列（queue1），因为queue1这个队列绑定的routing-key也是123，那这时，监听queue1的consumer1这个消费者就拿到了‘“张三”’这条消息，也就是说消费者和routing-key是没有直接
RabbitMQ: Publisher(消息生产者)提前创建Exchange、Queue
Xin Adn Meng
12-24 330
RabbitMQ: Publisher(消息生产者)提前创建Exchange、Queue
RabbitMQ-Learn:RabbitMQ学习实践项目
05-15
通过这个项目，你可以深入理解RabbitMQ的工作原理，熟悉其在Java中的使用，并通过实践提升对消息队列的掌握。同时，该项目也可以作为一个基础模板，帮助你在实际项目中快速接入RabbitMQ。记得在实践中不断探索和学习...
java队列源码-rabbitmq-repository:RabbitMQ消息队列学习的源码记录
05-24
rabbitmq路由示例 rabbitmq-spring-topic-exchange rabbitmq主题示例 rabbitmq-java-rpc rabbitmq PRC通信示例 rabbitmq-spring-helloworld spring boot 使用rabbitmq的第一个demo rabbitmq-spring-work-queue ...
Java使用RabbitMq的一个简单demo
最新发布
06-21
RabbitMQ是当前广泛使用的开源消息队列系统，它基于AMQP（Advanced Message Queuing Protocol）协议，适用于多种编程语言，包括Java。本篇文章将深入探讨如何在Java环境下使用RabbitMQ实现一个简单的示例。 首先，...
java使用rabbitmq demo
05-26
在IT行业中，消息队列...通过这个RmqDemo项目，你可以更深入地学习和实践Java与RabbitMQ的集成，进一步提升你的分布式系统设计和实现能力。记得始终关注RabbitMQ的新版本和最佳实践，以便保持代码的最新和最优化。
rabbitmq-component:rabbitmq组件
04-20
Java中可以使用`rabbitmq-client`库来与RabbitMQ交互。主要类包括`ConnectionFactory`（连接工厂）、`Connection`（网络连接）、`Channel`（通道，实际操作的接口）等。 4. **创建连接和通道**： 首先，通过`...
Rabbit MQ
weixin_46685542的博客
09-04 1048
Rabbit MQ 笔记
rabbitMQ消息服务器学习笔记（java）3 交换器exchange
两碗面的博客
11-13 295
既是自己的学习笔记又转自我老师的博客：http://blog.csdn.net/chwshuang/article/details/50512057 交换器 在之前的教程中，我们都是直接在消息队列中进行发送和接收消息，现在开始要介绍RabbitMQ完整的消息模型了。  首先，我们先来回顾一下之前学到关于RabbitMQ的内容： 生产者是发送消息的应用程序队列是存
headers java_RabbitMQ四种Exchange类型之Headers(Java)
weixin_39932611的博客
02-23 279
版权声明：本文为博主原创文章，如果转载请给出原文链接：http://doofuu.com/article/4156157.htmlHeaders 类型的Exchanges是不处理路由键的，而是根据发送的消息内容中的headers属性进行匹配。在绑定Queue与Exchange时指定一组键值对；当消息发送到RabbitMQ时会取到该消息的headers与Exchange绑定时指定的键值对进行匹配；如...
（转）RabbitMQ学习之Headers交换类型（java）
07-06 134
http://blog.csdn.net/zhu_tianwei/article/details/40923131 Headers类型的exchange使用的比较少，它也是忽略routingKey的一种路由方式。是使用Headers来匹配的。Headers是一个键值对，可以定义成Hashtable。发送者在发送的时候定义一些键值对，接收者也可以再绑定时候传入一些键值对，两者匹配的话，则...
RabbitMQ使用总结及实例
weixin_41037842的博客
03-25 3752
RabbitMQ学习总结 一、基本原理 订阅发布机制,生产者发布消息到队列，消费者订阅该队列，内部的监听机制监听到订阅的队列有消息，就会调用相关的方法进行处理; 二、组件： 生产者、消费者、服务器Server（vhost虚拟主机）、exchange交换机、queue队列、routing key路由键、banding key绑定键 三、各个组件之间关系 生产者发送消息带有routing key的消息头，交换机和队列通过bandging key进行绑定，消息的消息头和banding key相匹配决定消息路由到
大忙人系列_RabbitMQ通过java HttpClient代码获取服务器上的所有交换机、队列
ultingCSDN的博客
12-17 3621
如图所示,我们可以找到HttpClient的API地址，通过账号密码我们可以在浏览器中获得相关的RabbitMQ的数据。 当我们获得所有的API以后，我们可以通过HttpClient远程调用API获得RabbitMQ的队列、交换机等信息。 但是我们是使用HttpClient会获得如下异常： 错误一：报405异常 18:18:05.793 [main] DEBUG org.ap...
rabbitmq手动确认消费_Java操作RabbitMQ添加队列、消费队列和三个交换机
weixin_39595430的博客
11-22 637
一、发送消息到队列(生产者)新建一个maven项目，在pom.xml文件加入以下依赖 com.rabbitmq amqp-client 3.6.5 新建一个P1类package com.rabbitMQ.test; import com.rabbitmq.client.Channel;import com.rabbitmq.client.Connection;import com.rabbitm...
RabbitMQ常用Exchange详解
weixin_58670730的博客
02-25 7701
目录 1.Exchange 介绍 1.2 路由键(RoutingKey) 1.3 绑定键(BindingKey) 2.直连交换机：Direct exchange 3.主题交换机：Topic 4. 扇形交换机：Fanout exchange 1.Exchange 介绍 在RabbitMQ中，生产者发送消息不会直接将消息投递到队列中，而是先将消息投递到交换机中，在由交换机转发到具体的队列，队列再将消息以推送或者拉取方式给消费者进行消费 1.2 路由键(RoutingKey)...
RabbitMq的学习（一）：VirtualHost
热门推荐
LemonCake的博客
10-23 2万+
参考博客：https://blog.csdn.net/super_rd/article/details/71191851?utm_source=itdadao&amp;utm_medium=referral 服务器官方使用文档：https://www.rabbitmq.com/admin-guide.html VirtualHost RabbitMq的VirtualHost（虚拟消息服务器）...
introduction-to-messaging-slides
03-10
3. **Direct Messages**：讲解了如何使用直接模式（direct exchange）发送和接收具有特定路由键的消息。 4. **Remote Procedure Call (RPC) vs. Local Procedure Call (LPC)**：区分远程过程调用（RPC）和本地过程...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值