RabbitMq的安装和三种常用方式（direct,fanout,topic）

最新推荐文章于 2024-08-06 08:00:00 发布
最新推荐文章于 2024-08-06 08:00:00 发布
阅读量1.4k 收藏 1
点赞数
分类专栏： 消息中间件 架构师学习 RabbitMq 文章标签： RabbitMq安装 Rabbitmq常用方式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_39380737/article/details/105960845
版权

RabbitMq原理 请参考这篇文档和Springboot整合RabbitMq

1.Rabbit安装

1.安装Erlang
由于RabbitMQ依赖Erlang， 所以需要先安装Erlang。
        从EPEL源安装(这种方式安装的Erlang版本可能不是最新的，有时候不能满足RabbitMQ需要的最低版本)

 # 启动EPEL源
 $ sudo yum install epel-release 
 # 安装erlang
 $ sudo yum install erlang

2.完成后安装RabbitMQ

先下载rpm：

wget http://www.rabbitmq.com/releases/rabbitmq-server/v3.6.6/rabbitmq-server-3.6.6-1.el7.noarch.rpm

下载完成后安装：

yum install rabbitmq-server-3.6.6-1.el7.noarch.rpm

3.关于RabbitMQ的一些基本操作
sudo chkconfig rabbitmq-server on # 添加开机启动RabbitMQ服务
sudo /sbin/service rabbitmq-server start # 启动服务
sudo /sbin/service rabbitmq-server status # 查看服务状态
sudo /sbin/service rabbitmq-server stop # 停止服务
sudo /sbin/service rabbitmq-server restart # 重启服务

# 查看当前所有用户
 sudo rabbitmqctl list_users

# 查看默认guest用户的权限
sudo rabbitmqctl list_user_permissions guest

# 由于RabbitMQ默认的账号用户名和密码都是guest。
 sudo rabbitmqctl delete_user guest

# 添加新用户
 sudo rabbitmqctl add_user username password

# 设置用户tag
 sudo rabbitmqctl set_user_tags username administrator

# 赋予用户默认vhost的全部操作权限
 sudo rabbitmqctl set_permissions -p / username ".*" ".*" ".*"

# 查看用户的权限
sudo rabbitmqctl list_user_permissions username

4.开启web管理接口
如果只从命令行操作RabbitMQ，多少有点不方便。幸好RabbitMQ自带了web管理界面，只需要启动插件便可以使用。

 sudo rabbitmq-plugins enable rabbitmq_management

然后通过浏览器访问

http://localhost:15672

输入用户名和密码访问web管理界面了。
4. 开启用户远程访问
默认情况下，RabbitMQ的默认的guest用户只允许本机访问， 如果想让guest用户能够远程访问的话，只需要将配置文件中的loopback_users列表置为空即可，/etc/rabbitmq/rabbitmq.config默认是没有，只需要创建即可，然后加入配置，.一定不要忽略，然后执行重启命令

[
  {rabbit, [
      {loopback_users, []}
    ]
  }
].

sudo /sbin/service rabbitmq-server restart

然后就可以远程连接上rabbitmq了

2. 常用模式

通用RabbitMq连接代码

   <dependencies>
        <dependency>
            <groupId>com.rabbitmq</groupId>
            <artifactId>amqp-client</artifactId>
            <version>3.6.5</version>
        </dependency>
    </dependencies>

public class ConnectionUtils {
    private static String virtualHost = "/";

    public static Connection newConnection() throws IOException, TimeoutException {
        // 1.创建连接工厂
        ConnectionFactory connectionFactory = new ConnectionFactory();
        // 2.虚拟服务器
        connectionFactory.setVirtualHost(virtualHost);
        // 3.连接用户名
        connectionFactory.setUsername("guest");
        // 4.连接密码
        connectionFactory.setPassword("guest");
        // 5.连接地址
        connectionFactory.setHost("127.0.0.1");
        // 6.连接端口
        connectionFactory.setPort(5672);
        Connection connection = connectionFactory.newConnection();

        return connection;
    }
}
1.Direct模式

生产者

public class DirectProducer {

    private static String EXCHANGE = "direct";

    public static void main(String[] args) throws IOException, TimeoutException {
        //1.创建连接
        Connection connection = ConnectionUtils.newConnection();
        // 2.创建通道
        Channel channel = connection.createChannel();
        //3.绑定的交换机 参数1交互机名称 参数2 exchange类型
        channel.exchangeDeclare(EXCHANGE, "direct");
        String msg = "Direct模式生产消息";
        System.out.println("生产者生产消息：" + msg);
        String routingKey = "info";
        // 4.生产消息
        channel.basicPublish(EXCHANGE,routingKey ,null, msg.getBytes());
    }
}

消费者

public class DirectConsumer {
    private static String QUEUE_DIRECT = "direct";

    private static String EXCHANGE = "direct";

    public static void main(String[] args) throws IOException, TimeoutException, InterruptedException {
        System.out.println("Direct消费者");
        //1.创建连接
        Connection connection = ConnectionUtils.newConnection();
        // 2.创建通道
        final Channel channel = connection.createChannel();
        // 3.声明队列
        /**
         * String queue, boolean durable, boolean exclusive, boolean autoDelete, Map<String, Object> arguments
         * queue：这没什么好说的，队列名
         *
         * durable：是否持久化，那么问题来了，这是什么意思？持久化，指的是队列持久化到数据库中。在之前的博文中也说过，如果RabbitMQ服务挂了怎么办，队列丢失了自然是不希望发生的。持久化设置为true的话，即使服务崩溃也不会丢失队列
         * exclusive：是否排外，what？ 这又是什么呢。设置了排外为true的队列只可以在本次的连接中被访问，也就是说在当前连接创建多少个channel访问都没有关系，但是如果是一个新的连接来访问，对不起，不可以，下面是我尝试访问了一个排外的queue报的错。还有一个需要说一下的是，排外的queue在当前连接被断开的时候会自动消失（清除）无论是否设置了持久化
         * autoDelete：这个就很简单了，是否自动删除。也就是说queue会清理自己。但是是在最后一个connection断开的时候
         * 设置队列的其他一些参数
         */
        channel.queueDeclare(QUEUE_DIRECT, false, false, false, null);
        /**
         * String queue, String exchange, String routingKey
         */
        channel.queueBind(QUEUE_DIRECT, EXCHANGE, "info");
        DefaultConsumer defaultConsumer = new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                String msgString = new String(body, "UTF-8");
                System.out.println("短信消费者获取消息:" + msgString);
            }
        };
        // 4.设置应答模式，true的时候为自动应答，false为手动应答，需要处理
        channel.basicConsume(QUEUE_DIRECT, true, defaultConsumer);
    }
}

在这里插入图片描述

2.Fanout模式

生产者

public class Producer {

    private static String EXCHANGE = "sms_email";

    public static void main(String[] args) throws IOException, TimeoutException {
        //1.创建连接
        Connection connection = ConnectionUtils.newConnection();
        // 2.创建通道
        Channel channel = connection.createChannel();
        //3.绑定的交换机 参数1交互机名称 参数2 exchange类型
        channel.exchangeDeclare(EXCHANGE, "fanout");
        String msg = "测试生产消息";
        try {
//            channel.txSelect();
            // 4.生产消息
            channel.basicPublish(EXCHANGE, "", null, msg.getBytes());
//            int i = 1 / 0;
            System.out.println("生产品生产消息：" + msg);
//            channel.txCommit();
        } catch (IOException e) {
            e.printStackTrace();
//            channel.txRollback();
        } finally {
            channel.close();
            connection.close();
        }
    }
}

短信消费者

/**
 * @author Administrator
 */
public class SmsConsumer {
    private static String QUEUE_SMS = "sms";

    private static String EXCHANGE = "sms_email";
    public static void main(String[] args) throws IOException, TimeoutException, InterruptedException {
        System.out.println("短信消费者");
        //1.创建连接
        Connection connection = ConnectionUtils.newConnection();
        // 2.创建通道
        final Channel channel = connection.createChannel();
        // 3.声明队列
        /**
         * String queue, boolean durable, boolean exclusive, boolean autoDelete, Map<String, Object> arguments
         * queue：这没什么好说的，队列名
         *
         * durable：是否持久化，那么问题来了，这是什么意思？持久化，指的是队列持久化到数据库中。在之前的博文中也说过，如果RabbitMQ服务挂了怎么办，队列丢失了自然是不希望发生的。持久化设置为true的话，即使服务崩溃也不会丢失队列
         * exclusive：是否排外，what？ 这又是什么呢。设置了排外为true的队列只可以在本次的连接中被访问，也就是说在当前连接创建多少个channel访问都没有关系，但是如果是一个新的连接来访问，对不起，不可以，下面是我尝试访问了一个排外的queue报的错。还有一个需要说一下的是，排外的queue在当前连接被断开的时候会自动消失（清除）无论是否设置了持久化
         * autoDelete：这个就很简单了，是否自动删除。也就是说queue会清理自己。但是是在最后一个connection断开的时候
         * 设置队列的其他一些参数
         */
        channel.queueDeclare(QUEUE_SMS, false, false, false, null);
        /**
         * String queue, String exchange, String routingKey
         */
        channel.queueBind(QUEUE_SMS, EXCHANGE, "message");
        DefaultConsumer defaultConsumer = new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                String msgString = new String(body, "UTF-8");
                System.out.println("短信消费者获取消息:" + msgString);
            }
        };
        // 4.设置应答模式，true的时候为自动应答，false为手动应答，需要处理
        channel.basicConsume(QUEUE_SMS, true, defaultConsumer);
    }
}

在这里插入图片描述

邮件消费者

public class EmailConsumer {
    private static String QUEUE_EMAIL = "eamil";
    private static String EXCHANGE = "sms_email";

    public static void main(String[] args) throws IOException, TimeoutException, InterruptedException {
        System.out.println("邮件消费者");
        //1.创建连接
        Connection connection = ConnectionUtils.newConnection();
        // 2.创建通道
        final Channel channel = connection.createChannel();
        // 3.声明队列
        /**
         * String queue, boolean durable, boolean exclusive, boolean autoDelete, Map<String, Object> arguments
         * queue：这没什么好说的，队列名
         *
         * durable：是否持久化，那么问题来了，这是什么意思？持久化，指的是队列持久化到数据库中。在之前的博文中也说过，如果RabbitMQ服务挂了怎么办，队列丢失了自然是不希望发生的。持久化设置为true的话，即使服务崩溃也不会丢失队列
         * exclusive：是否排外，what？ 这又是什么呢。设置了排外为true的队列只可以在本次的连接中被访问，也就是说在当前连接创建多少个channel访问都没有关系，但是如果是一个新的连接来访问，对不起，不可以，下面是我尝试访问了一个排外的queue报的错。还有一个需要说一下的是，排外的queue在当前连接被断开的时候会自动消失（清除）无论是否设置了持久化
         * autoDelete：这个就很简单了，是否自动删除。也就是说queue会清理自己。但是是在最后一个connection断开的时候
         * 设置队列的其他一些参数
         */
        channel.queueDeclare(QUEUE_EMAIL, false, false, false, null);
        channel.queueBind(QUEUE_EMAIL, EXCHANGE, "message");
//        channel.txSelect();
        try {
//            int i = 1/0;
            DefaultConsumer defaultConsumer = new DefaultConsumer(channel) {
                @Override
                public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                    String msgString = new String(body, "UTF-8");
                    System.out.println("邮件消费者获取消息:" + msgString);
                }
            };
            // 4.设置应答模式，true的时候为自动应答，false为手动应答，需要处理
            channel.basicConsume(QUEUE_EMAIL, true, defaultConsumer);
//            channel.txCommit();
        } catch (Exception e) {
//            channel.txRollback();
        }

    }
}

在这里插入图片描述

3.Topic模式

生产者

public class Producer {

    private static String TOPIC_EXCHANGE = "topic";

    public static void main(String[] args) throws IOException, TimeoutException {
        //1.创建连接
        Connection connection = ConnectionUtils.newConnection();
        // 2.创建通道
        Channel channel = connection.createChannel();
        //3.绑定的交换机 参数1交互机名称 参数2 exchange类型
        channel.exchangeDeclare(TOPIC_EXCHANGE, "topic");
        String msg = "Topic生产消息";
        String msg1 = "Topic1生产消息";
        String msg2 = "Topic2生产消息";
        // 4.生产消息
        channel.basicPublish(TOPIC_EXCHANGE, "topic.test", null, msg.getBytes());
        System.out.println("Topic生产消息：" + msg1);
        channel.basicPublish(TOPIC_EXCHANGE, "topic.test.test", null, msg1.getBytes());
        System.out.println("Topic生产消息：" + msg1);
        channel.basicPublish(TOPIC_EXCHANGE, "topic.test1", null, msg2.getBytes());
        System.out.println("Topic生产消息：" + msg2);
    }

在这里插入图片描述
短信消费者：topic.*，*代表匹配0个或多个单词

public class TopicSmsConsumer {
    private static String QUEUE_SMS = "sms";

    private static String EXCHANGE = "topic";
    public static void main(String[] args) throws IOException, TimeoutException, InterruptedException {
        System.out.println("短信消费者");
        //1.创建连接
        Connection connection = ConnectionUtils.newConnection();
        // 2.创建通道
        final Channel channel = connection.createChannel();
        // 3.声明队列
        /**
         * String queue, boolean durable, boolean exclusive, boolean autoDelete, Map<String, Object> arguments
         * queue：这没什么好说的，队列名
         *
         * durable：是否持久化，那么问题来了，这是什么意思？持久化，指的是队列持久化到数据库中。在之前的博文中也说过，如果RabbitMQ服务挂了怎么办，队列丢失了自然是不希望发生的。持久化设置为true的话，即使服务崩溃也不会丢失队列
         * exclusive：是否排外，what？ 这又是什么呢。设置了排外为true的队列只可以在本次的连接中被访问，也就是说在当前连接创建多少个channel访问都没有关系，但是如果是一个新的连接来访问，对不起，不可以，下面是我尝试访问了一个排外的queue报的错。还有一个需要说一下的是，排外的queue在当前连接被断开的时候会自动消失（清除）无论是否设置了持久化
         * autoDelete：这个就很简单了，是否自动删除。也就是说queue会清理自己。但是是在最后一个connection断开的时候
         * 设置队列的其他一些参数
         */
        channel.queueDeclare(QUEUE_SMS, false, false, false, null);
        /**
         * String queue, String exchange, String routingKey
         */
        channel.queueBind(QUEUE_SMS, EXCHANGE, "topic.*");
        DefaultConsumer defaultConsumer = new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                String msgString = new String(body, "UTF-8");
                System.out.println("短信消费者获取消息:" + msgString);
            }
        };
        // 4.设置应答模式，true的时候为自动应答，false为手动应答，需要处理
        channel.basicConsume(QUEUE_SMS, true, defaultConsumer);
    }
}

在这里插入图片描述

邮件消费者，topic.#,#代表匹配一个

public class TopicEamilConsumer {
    private static String QUEUE_EMAIL = "eamil";
    private static String EXCHANGE = "topic";

    public static void main(String[] args) throws IOException, TimeoutException, InterruptedException {
        System.out.println("邮件消费者");
        //1.创建连接
        Connection connection = ConnectionUtils.newConnection();
        // 2.创建通道
        final Channel channel = connection.createChannel();
        // 3.声明队列
        /**
         * String queue, boolean durable, boolean exclusive, boolean autoDelete, Map<String, Object> arguments
         * queue：这没什么好说的，队列名
         *
         * durable：是否持久化，那么问题来了，这是什么意思？持久化，指的是队列持久化到数据库中。在之前的博文中也说过，如果RabbitMQ服务挂了怎么办，队列丢失了自然是不希望发生的。持久化设置为true的话，即使服务崩溃也不会丢失队列
         * exclusive：是否排外，what？ 这又是什么呢。设置了排外为true的队列只可以在本次的连接中被访问，也就是说在当前连接创建多少个channel访问都没有关系，但是如果是一个新的连接来访问，对不起，不可以，下面是我尝试访问了一个排外的queue报的错。还有一个需要说一下的是，排外的queue在当前连接被断开的时候会自动消失（清除）无论是否设置了持久化
         * autoDelete：这个就很简单了，是否自动删除。也就是说queue会清理自己。但是是在最后一个connection断开的时候
         * 设置队列的其他一些参数
         */
        channel.queueDeclare(QUEUE_EMAIL, false, false, false, null);
        channel.queueBind(QUEUE_EMAIL, EXCHANGE, "topic.#");

        DefaultConsumer defaultConsumer = new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                String msgString = new String(body, "UTF-8");
                System.out.println("邮件消费者获取消息:" + msgString);
            }
        };
        // 4.设置应答模式，true的时候为自动应答，false为手动应答，需要处理
        channel.basicConsume(QUEUE_EMAIL, true, defaultConsumer);
    }
}

在这里插入图片描述

机智的豆子
关注
专栏目录
消息队列篇-RabbitMQ四种交换器模式（Direct、Fanout、Topic、Header）
Simon的博客
06-21 2403
文章目录一、Direct模式1、创建四个不同名称的Queue2、创建direct类型的交换器exchange.direct3、将exchange.direct与四个Queue绑定4、给exchange.direct交换机发送消息5、接收到消息的队列simon.emps消费消息6、总结二、Fanout模式1.创建fanout类型的交换机exchange.fanout2.将exchange.fanout与四个Queue绑定3.给exchange.fanout发送消息4.队列列表查看消息5.总结三、Topic模式
RabbitMQ核心API-Exchange之Direct、Topic、Fanout、其他关键概念
a898712940的博客
04-26 300
一：RabbitMQ核心API-Exchange之Direct【直连模式】 二：RabbitMQ核心API-Exchange之Topic【正则匹配模式】 三：RabbitMQ核心API-Exchange之Fanout【类似广播】 四：RabbitMQ核心API-其他关键概念讲解 一：RabbitMQ核心API-Exchange之Direct【直连模式】 1、Exchange 接收消息，并根据路由键(Routing key)转发消息所绑定的队列 2、Exchange 交换机的属性 Na.
spring集成rabbitMq(基于direct、topic和fanout模式)
11-15
spring集成rabbitMq(基于direct、topic和fanout模式)，包括main方法，5种情景，一天总结运行
【整理】各种 RabbitMQ 安装方式汇总
weixin_33777877的博客
01-11 62
2019独角兽企业重金招聘Python工程师标准>>> ...
【RabbitMQ】fanout概述_direct概述_topic概述
最新发布
wosixiaokeai的博客
08-06 429
定义与特点Direct交换机是RabbitMQ中另一种常见的交换机类型，它根据消息的路由键将消息路由到指定的队列。在Direct模式中，每个消息都会被发送到具有相同路由键的队列中。工作原理消息发送：生产者发送消息到Direct交换机时，需要指定一个路由键。路由匹配：Direct交换机会将消息的路由键与队列的绑定键进行匹配。消息路由：如果找到匹配的绑定键，Direct交换机会将消息路由到对应的队列中。如果没有找到匹配的绑定键，消息可能会被丢弃或返回给生产者（取决于交换机的配置）。应用场景。
RabbitMQ交换器Exchange介绍与实践
绝圣弃智-零的博客
04-17 292
交换器分类 RabbitMQ的Exchange（交换器）分为四类： direct（默认） headers fanout topic 其中headers交换器允许你匹配AMQP消息的header而非路由键，除此之外headers交换器和direct交换器完全一致，但性能却很差，几乎用不到，所以我们本文也不做讲解。 注意：fanout、topic交换器是没有历史数据的，也就是说对于中途创建的队列，获取不到之前的消息。 1、direct交换器 direct为默认的交换器类型，也非常的简单，如果路由
RabbitMQ安装使用,六种工作模式,详解
ywdevil1314的博客
12-07 414
文章目录RabbitMQ 使用场景服务解耦流量削峰异步调用rabbitmq 基本概念ExchangeMessage QueueBinding KeyRouting Keyrabbitmq安装安装erlang语言库rabbitmq官方精简的Erlang语言包下载和安装安装socat依赖socat依赖包下载和安装安装rabbitmqrabbitmq安装包下载和安装rabbitmq启动和停止命令rabbitmq管理界面启用管理界面访问添加用户添加用户设置访问权限开放客户端连接端口rabbitmq六种工作模式简单模
rabbitmq 设计的概念介绍
每天积累一点，一年后你会发现，自己变化很大
08-18 1499
RabbitMQ是流行的开源消息队列系统，用erlang语言开发。我曾经对这门语言挺有兴趣，学过一段时间，后来没坚持。RabbitMQ是 AMQP（高级消息队列协议）的标准实现。如果不熟悉AMQP，直接看RabbitMQ的文档会比较困难。不过它也只有几个关键概念，这里简单介绍。 RabbitMQ的结构图如下： 概念说明： Broker：简单来说就是消息队列服务器实体。
springboot2.1.4集成rabbitmq，三种模式：fanout direct topic的实现
05-16
本篇文章将深入探讨如何在Spring Boot 2.1.4版本中集成RabbitMQ，并实现三种主要的交换机类型：Fanout、Direct和Topic模式。 首先，我们需要在Spring Boot项目中添加RabbitMQ的相关依赖。在`pom.xml`文件中，引入`...
基于spring集成rabbitMq(基于direct、topic和fanout模式)源码.rar
11-07
在这个基于Spring集成RabbitMQ的源码示例中，我们主要会关注三种不同的交换机类型：direct、topic和fanout。 1. **Direct Exchange（直连交换机）**： 直连交换机是最简单的模型，它将消息路由到绑定键与发布时...
RabbitMq的原理及四种常用方式（direct,fanout,topic）
qq_39380737的博客
02-26 1849
1.RabbitMQ简介 在介绍RabbitMQ之前实现要介绍一下MQ，MQ是什么？         MQ全称是Message Queue，可以理解为消息队列的意思，简单来说就是消息以管道的方式进行传递。         RabbitMQ是...
rabbitmq-3 交换模式 fanout、direct、topic
qq_38475911的博客
01-25 314
四种交换模式：fanout、direct、topic、handers 1 fanout交换机： 转发消息到所有绑定队列（最快，广播），不处理路由键。你只需要简单的将队列绑定到交换机上。一个发送到交换机的消息都会被转发到与该交换机绑定的所有队列上。很像子网广播，每台子网内的主机都获得了一份复制的消息。Fanout交换机转发消息是最快的。 2 Direct交换机： 转发消息到routingKey指定队列（完全匹配，单播）,处理路由键。需要将一个队列绑定到交换机上，要求该消息与一个特定的路由键完全匹
RabbitMQ交换机（Fanout、Direct、Topic）三种模式详解
热门推荐
m0_46084075的博客
07-09 1万+
一. 交换机 1.1 Exchanges 1.1.1 Exchanges概念 ​ RabbitMQ 消息传递模型的核心思想是: 生产者生产的消息从不会直接发送到队列。实际上，通常生产 者甚至都不知道这些消息传递传递到了哪些队列中。 ​ 相反，生产者只能将消息发送到交换机(exchange)，交换机工作的内容非常简单，一方面它接收来自生产者的消息，另一方面将它们推入队列。交换机必须确切知道如何处理收到的消息。是应该把这些消息放到特定队列还是说把他们到许多队列中还是说应该丢弃它们。这就的由交换机的类型来决定
【RabbitMQ】Fanout、Direct、Topic、消息转换器
专注于Java领域开发 关注我 带你玩转Java
02-07 934
生产者将消息发给broker，由交换机将消息转发到绑定此交换机的每个队列，每个绑定交换机的队列都将接收到消息
RabbitMQ交换器类型（Direct、Topic、Fanout、Headers）与消息的发送/接收模式
pan_junbiao的博客
01-19 6876
1、RabbitMQ 交换器类型 RabbitMQ 常用的交换器类型有Direct、Topic、Fanout、Headers 这四种。AMQP 协议里还提到另外两种类型：System 和自定义，这里不予描述。对于这四种类型下面一一阐述。 1.1Direct类型 Direct类型的交换器由路由规则很简单，它会把消息路由到那些 BindingKey 和 RoutingKey 完全匹配的队列中。 Direct Exchange 是 RabbitMQ 默认的交换器模式，也是最简单的模式。它根据Ro...
Rabbitmq交换机三种模式介绍
weixin_30920513的博客
09-05 493
1、topic 将路由键和某模式进行匹配。此时队列需要绑定要一个模式上。符号“#”匹配一个或多个词，符号“*”匹配不多不少一个词。因此“abc.#”能够匹配到“abc.def.ghi”，但是“abc.*” 只会匹配到“abc.def”。 任何发送到Topic Exchange的消息都会被转发到所有关心RouteKey中指定话题的Queue上 1.这种模式较为复杂，简单来说，就是每个队列...
rabbitMQ 中三种常用交换机：direct、topic、fanout的使用以及区别和queue消息的Ack,Nack ,Reject 消息类型
码农崛起
08-10 4167
当消息发送到Exchange时，RabbitMQ会取到该消息的headers（也是一个键值对的形式），对比其中的键值对是否完全匹配Queue与Exchange绑定时指定的键值对；生产者将消息不是直接发送到队列，而是发送到X交换机，然后由交换机发送给两个队列，两个消费者各自监听一个队列，来消费消息。生产者，一个队列一个或多个消费者，当多个消费者同时监听一个队列时，他们并不能同时消费一条消息，而是随机消费消息，即一个队列中一条消息，只能被一个消费者消费。如果匹配请求中的值，则向程序返回该响应数据。.......
rabbitmq 交换模式-Direct
IT民工的博客
05-15 3079
direct 模式中 路由键 是必须的。import org.springframework.amqp.core.BindingBuilder; import org.springframework.amqp.core.DirectExchange; import org.springframework.amqp.core.Queue; import org.springframework.amqp
Linux--安装rabbitMQ（比较简单快捷的一种安装方式）
伊莱文
12-07 439
rabbitMQ的配置文件 链接：https://pan.baidu.com/s/1HjkJCipgOiDf5uIchsHpjg 提取码：igl3 1.将以上配置文件导入到linux的任意目录下 2.命令：赋予权限 chmod 777 ./installRabbitmq.sh 3.命令：联网操作 ./installRabbitmq.sh 4.遇到的问题： 1.rabbitMQ可以在linux上访问...
RabbitMQ Exchange深度解析：fanout、direct与topic模式
"这篇文章主要介绍了RabbitMQ的Exchange模式，包括Fanout、Direct和Topic三种模式，以及如何在代码中实现生产者和消费者的示例。" 在AMQP（Advanced Message Queuing Protocol）协议中，RabbitMQ作为消息队列服务器...
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值