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

最新推荐文章于 2023-07-12 16:11:18 发布
最新推荐文章于 2023-07-12 16:11:18 发布
阅读量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 1633
一.Direct Exchange 任何发送到Direct Exchange的消息都会被转发到RouteKey中指定的Queue。 1.一般情况可以使用rabbitMQ自带的Exchange：”"(该Exchange的名字为空字符串，下文称其为default Exchange)。 2.这种模式下不需要将Exchange进行任何绑定(binding)操作 3.消息传递时需要一个“RouteKey”，可以简单的理解为要发送到的队列名字。 4.如果vhost中不存在RouteKey中指定的队列名，.
RabbitMQ
chenguoao1999的博客
12-27 932
学习目标 了解RabbitMQ的作用及架构 掌握RabbitMQ安装及基本使用 掌握Springboot整合RabbitMQ 一.RabbitMQ安装 1.1 为什么使用RabbitMQ 1.降低耦合度 2.RabbitMQ速度快，微秒级别 3.学习成本低 4.支持多种语言 1.2 什么是RabbitMQ RabbitMQ是一个由erlang开发的AMQP（Advanced Message Queue 高级消息队列协议）的开源实现 能够实现异步消息处理 1.3 安装RabbitMQ #在线安
RabbitMq中交换器（Exchange）类型详解
技术人集结地
04-04 6943
RabbitMQ是工作中经常使用的一个开源消息队列，它是通过Erlang语言来开发的，RabbitMQ中有一个非常常见且重要的概念叫交换器（Exchange），所有生产者提交的消息都是通过Exchange进行接收，然后通过特定的路由策略转发对特定的队列（Queue）中，然后消费者通过绑定特定的队列，将队列中的信息进行消费处理。我们如果是通过RabbitMQ的客户端来进行创建Exchange的话，一定需要你选择一个特定的Exchange类型的，这个时候如果不了解每一种类型的特性，就很容易选择错误，造成整
RabbitMQ的三种exchange类型
qq_43750656的博客
06-12 485
一、Direct类型 1.图解概述 如图所示，该模式下生产者发送消息给broker中的交换机（一个broker中可以有多个exchange交换机，一个exchange可以绑定多个queue队列），交换机根据这条消息携带的routing-key（123）来分发到这个routing-key对应的队列（queue1），因为queue1这个队列绑定的routing-key也是123，那这时，监听queue1的consumer1这个消费者就拿到了‘“张三”’这条消息，也就是说消费者和routing-key是没有直接
rabbitmq的延迟队列spring配置（单exchange，多queue）
踏雪听雨
03-30 6432
rabbit mq 延迟队列spring配置
RabbitMQ-Learn:RabbitMQ学习实践项目
05-15
通过这个项目，你可以深入理解RabbitMQ的工作原理，熟悉其在Java中的使用，并通过实践提升对消息队列的掌握。同时，该项目也可以作为一个基础模板，帮助你在实际项目中快速接入RabbitMQ。记得在实践中不断探索和学习...
java使用rabbitMq服务
04-24
【Java使用RabbitMQ服务】 RabbitMQ是一款开源的消息队列系统，广泛应用于分布式系统中的消息传递。本文将简要介绍如何在Java环境中使用RabbitMQ，包括安装、基本结构、消息发送模式以及高级特性。 ### 1. 安装 在...
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: Publisher(消息生产者)提前创建Exchange、Queue
Xin Adn Meng
12-24 335
RabbitMQ: Publisher(消息生产者)提前创建Exchange、Queue
Rabbit MQ
weixin_46685542的博客
09-04 1063
Rabbit MQ 笔记
java实现rabbitmq消息队列
最新发布
weixin_44905972的博客
07-12 1508
生产者向交换机发送消息—交换机根据路由key发送给队列-队列的消费者接收消息。多个消费者，每一个消费这都有自己的队列，每个队列都绑定到交换机。在某种场景下，我们希望不同的消息被不同的队列消费。一个生产者丶默认交换机丶一个队列丶一个消费者。一个生产者丶默认交换机丶一个队列丶多个消费者。生产者发送消息到交换机-交换机发送到哪个队列。区别在于Topic类型的交换机可以匹配通配符。符号(通配符)：#表示匹配一个或者多个词。创建controller。创建rabbit工具类。
java exchange()_rabbitmq+java入门（三）exchange的使用
weixin_42648844的博客
02-28 484
参考：http://www.rabbitmq.com/tutorials/tutorial-three-java.html源码：https://github.com/zuzhaoyue/JavaDemo先决条件本教程假定RabbitMQ在标准端口(5672)上的本地主机上安装并运行。如果您使用不同的主机，端口或证书，则连接设置需要进行调整。在之前的教程中，我们创建了一个工作队列。工作队列背后的假设...
rabbitMQ消息服务器学习笔记（java）3 交换器exchange
两碗面的博客
11-13 301
既是自己的学习笔记又转自我老师的博客：http://blog.csdn.net/chwshuang/article/details/50512057 交换器 在之前的教程中，我们都是直接在消息队列中进行发送和接收消息，现在开始要介绍RabbitMQ完整的消息模型了。  首先，我们先来回顾一下之前学到关于RabbitMQ的内容： 生产者是发送消息的应用程序队列是存
RabbitMQ系列教程（六）RabbitMQ Exchange类型之headers Exchange
warybee
11-18 2690
headers Exchange介绍 headers Exchange与Direct、topic、fanout不同，它时通过匹配AMQP消息的header而非路由键。 headers Exchange与Direct Exchange类似，性能方面比后者查很多，所以在实际项目中用的很少，通过一张图来直观感受一下其工作流程 Java代码实现 生产者 public static void main...
java修改mq报文头,如何使用Java在RabbitMQ中实现Headers Exchange？
weixin_30465747的博客
02-27 182
i am a newbie trying to implement Headers exchange in java client . im aware that This is what the "x-match" binding argument is for. When the "x-match" argument is set to "any", just one matching he...
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（虚拟消息服务器）...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值