五、 RabbitMQ模式

最新推荐文章于 2024-05-22 16:27:08 发布
最新推荐文章于 2024-05-22 16:27:08 发布
阅读量91 收藏
点赞数
分类专栏： Rabbitmq 文章标签： rabbitmq ruby 分布式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/stert/article/details/132081809
版权

5.1. Work queues工作队列模式

5.1.1. 模式说明

 

Work Queues与入门程序的简单模式相比，多了一个或一些消费端，多个消费端共同消费同一个队列中的消息。

应用场景：对于 任务过重或任务较多情况使用工作队列可以提高任务处理的速度。

5.1.2. 代码

Work Queues与入门程序的简单模式的代码是几乎一样的；可以完全复制，并复制多一个消费者进行多个消费者同时消费消息的测试。

1）抽取工具类

package com.atguigu.rabbitmq.util;

import com.rabbitmq.client.Connection;

import com.rabbitmq.client.ConnectionFactory;

public class ConnectionUtil {

public static Connection getConnection() throws Exception {

    //定义连接工厂

    ConnectionFactory factory = new ConnectionFactory();

    //设置服务地址

    factory.setHost("192.168.137.118");

    //端口

    factory.setPort(5672);

    //设置账号信息，用户名、密码、vhost

    factory.setVirtualHost("/");

    factory.setUsername("admin");

    factory.setPassword("123456");

    // 通过工程获取连接

    Connection connection = factory.newConnection();

    return connection;

}



public static void **main**(String[] args) throws Exception {

    Connection con = ConnectionUtil.getConnection();

    System.out.println(con);

    //         amqp://admin@192.168.137.118:5672/

    con.close();

}

}

2）生产者

package com.atguigu.rabbitmq.work;

import com.rabbitmq.client.Channel;

import com.rabbitmq.client.Connection;

import com.rabbitmq.client.ConnectionFactory;

public class Producer {

**static** **final** String QUEUE_NAME = "work_queue";

**public** **static** **void** **main**(String[] args) **throws** Exception {

    Connection connection = ConnectionUtil.getConnection();

    Channel channel = connection.createChannel();

    channel.queueDeclare(QUEUE_NAME,**true**,**false**,**false**,**null**);

    **for** (**int** i = 1; i <= 10; i++) {

        String body = i+"hello rabbitmq~~~";

        channel.basicPublish("",QUEUE_NAME,**null**,body.getBytes());

    }

    channel.close();

    connection.close();

}

}

3）消费者1

package com.atguigu.rabbitmq.work;

import com.rabbitmq.client.*;

import java.io.IOException;

public class Consumer1 {

**static** **final** String QUEUE_NAME = "work_queue";

**public** **static** **void** **main**(String[] args) **throws** Exception {

    Connection connection = ConnectionUtil.getConnection();

    Channel channel = connection.createChannel();

    channel.queueDeclare(QUEUE_NAME,**true**,**false**,**false**,**null**);

    Consumer consumer = **new** DefaultConsumer(channel){

        @Override

        **public** **void** **handleDelivery**(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, **byte**[] body) **throws** IOException {

            System.out.println("body："+**new** String(body));

        }

    };

    channel.basicConsume(QUEUE_NAME,**true**,consumer);

}

}

4）消费者2

Consumer2与Consumer1类一样。省略。

运行两个消费者

5.1.3. 测试

启动两个消费者，然后再启动生产者发送消息；到IDEA的两个消费者对应的控制台查看是否竞争性的接收到消息。

5.1.4. 小结

  1. 在一个队列中如果有多个消费者，那么消费者之间对于同一个消息的关系是竞争的关系。
  2. Work Queues 对于任务过重或任务较多情况使用工作队列可以提高任务处理的速度。

5.2. 订阅模式类型

订阅模式示例图：

前面2个案例中，只有3个角色：

  • P：生产者，也就是要发送消息的程序
  • C：消费者：消息的接受者，会一直等待消息到来。
  • queue：消息队列，图中红色部分

而在订阅模型中，多了一个exchange角色，而且过程略有变化：

  • P：生产者，也就是要发送消息的程序，但是不再发送到队列中，而是发给X（交换机）
  • C：消费者，消息的接受者，会一直等待消息到来。
  • Queue：消息队列，接收消息、缓存消息。
  • Exchange：交换机，图中的X。一方面，接收生产者发送的消息。另一方面，知道如何处理消息，例如递交给某个特别队列、递交给所有队列、或是将消息丢弃。到底如何操作，取决于Exchange的类型。Exchange有常见以下3种类型：
    • Fanout：广播，将消息交给所有绑定到交换机的队列
    • Direct：定向，把消息交给符合指定routing key 的队列
    • Topic：通配符，把消息交给符合routing pattern（路由模式） 的队列

Exchange（交换机）只负责转发消息，不具备存储消息的能力，因此如果没有任何队列与Exchange绑定，或者没有符合路由规则的队列，那么消息会丢失！

5.3. Publish/Subscribe发布与订阅模式

5.3.1. 模式说明

发布订阅模式： 1、每个消费者监听自己的队列。 2、生产者将消息发给broker，由交换机将消息转发到绑定此交换机的每个队列，每个绑定交换机的队列都将接收 到消息

5.3.2. 代码

1）生产者

package com.atguigu.rabbitmq.fanout;

import com.rabbitmq.client.BuiltinExchangeType;

import com.rabbitmq.client.Channel;

import com.rabbitmq.client.Connection;

import com.rabbitmq.client.ConnectionFactory;

public class Producer {

**public** **static** **void** **main**(String[] args) **throws** Exception {



    Connection connection = ConnectionUtil.getConnection();

    Channel channel = connection.createChannel();

    /*

   exchangeDeclare(String exchange, BuiltinExchangeType type, boolean durable, boolean autoDelete, boolean internal, Map<String, Object> arguments)

   参数：

    1. exchange：交换机名称

    2. type：交换机类型

        DIRECT("direct"),：定向

        FANOUT("fanout"),：扇形（广播）,发送消息到每一个与之绑定队列。

        TOPIC("topic"),通配符的方式

        HEADERS("headers");参数匹配

    3. durable：是否持久化

    4. autoDelete：自动删除

    5. internal：内部使用。 一般false

    6. arguments：参数

    */

    String exchangeName = "test_fanout";

    //5. 创建交换机

    channel.exchangeDeclare(exchangeName, BuiltinExchangeType.FANOUT,**true**,**false**,**false**,**null**);

    //6. 创建队列

    String queue1Name = "test_fanout_queue1";

    String queue2Name = "test_fanout_queue2";

    channel.queueDeclare(queue1Name,**true**,**false**,**false**,**null**);

    channel.queueDeclare(queue2Name,**true**,**false**,**false**,**null**);

    //7. 绑定队列和交换机

    /*

    queueBind(String queue, String exchange, String routingKey)

    参数：

        1. queue：队列名称

        2. exchange：交换机名称

        3. routingKey：路由键,绑定规则

            如果交换机的类型为fanout ,routingKey设置为""

     */

    channel.queueBind(queue1Name,exchangeName,"");

    channel.queueBind(queue2Name,exchangeName,"");



    String body = "日志信息：张三调用了findAll方法...日志级别：info...";

    //8. 发送消息

    channel.basicPublish(exchangeName,"",**null**,body.getBytes());



    //9. 释放资源

    channel.close();

    connection.close();

}

}

运行

 

 

 

 2）消费者1

package com.atguigu.rabbitmq.fanout;

import com.rabbitmq.client.*;

import java.io.IOException;

public class Consumer1 {

**public** **static** **void** **main**(String[] args) **throws** Exception {

    Connection connection = ConnectionUtil.getConnection();

    Channel channel = connection.createChannel();

    String queue1Name = "test_fanout_queue1";

    Consumer consumer = **new** DefaultConsumer(channel){

        @Override

        **public** **void** **handleDelivery**(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, **byte**[] body) **throws** IOException {

            System.out.println("body："+**new** String(body));

            System.out.println("将日志信息打印到控制台.....");

        }

    };

    channel.basicConsume(queue1Name,**true**,consumer);

}

}

3）消费者2

package com.atguigu.rabbitmq.fanout;

import com.rabbitmq.client.*;

import java.io.IOException;

public class Consumer2 {

*public** **static** **void** **main**(String[] args) **throws** Exception {

    Connection connection = ConnectionUtil.getConnection();

    Channel channel = connection.createChannel();

    String queue2Name = "test_fanout_queue2";

    Consumer consumer = **new** DefaultConsumer(channel){

        @Override

        **public** **void** **handleDelivery**(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, **byte**[] body) **throws** IOException {

            System.out.println("body："+**new** String(body));

            System.out.println("将日志信息打印到控制台.....");

        }

    };

    channel.basicConsume(queue2Name,**true**,consumer);

}

}

5.3.3. 测试

启动所有消费者，然后使用生产者发送消息；在每个消费者对应的控制台可以查看到生产者发送的所有消息；到达广播的效果。

在执行完测试代码后，其实到RabbitMQ的管理后台找到Exchanges选项卡，点击 fanout_exchange 的交换机，可以查看到如下的绑定：

5.3.4. 小结

交换机需要与队列进行绑定，绑定之后；一个消息可以被多个消费者都收到。

发布订阅模式与工作队列模式的区别

1、工作队列模式不用定义交换机，而发布/订阅模式需要定义交换机。

2、发布/订阅模式的生产方是面向交换机发送消息，工作队列模式的生产方是面向队列发送消息(底层使用默认交换机)。

3、发布/订阅模式需要设置队列和交换机的绑定，工作队列模式不需要设置，实际上工作队列模式会将队列绑 定到默认的交换机 。

5.4. Routing路由模式

5.4.1. 模式说明

路由模式特点：

  • 队列与交换机的绑定，不能是任意绑定了，而是要指定一个RoutingKey（路由key）
  • 消息的发送方在 向 Exchange发送消息时，也必须指定消息的 RoutingKey。
  • Exchange不再把消息交给每一个绑定的队列，而是根据消息的Routing Key进行判断，只有队列的Routingkey与消息的 Routing key完全一致，才会接收到消息

 

 

图解：

  • P：生产者，向Exchange发送消息，发送消息时，会指定一个routing key。
  • X：Exchange（交换机），接收生产者的消息，然后把消息递交给 与routing key完全匹配的队列
  • C1：消费者，其所在队列指定了需要routing key 为 error 的消息
  • C2：消费者，其所在队列指定了需要routing key 为 info、error、warning 的消息

5.4.2. 代码

在编码上与 Publish/Subscribe发布与订阅模式 的区别是交换机的类型为：Direct，还有队列绑定交换机的时候需要指定routing key。

1）生产者

package com.atguigu.rabbitmq.routing;

import com.rabbitmq.client.BuiltinExchangeType;

import com.rabbitmq.client.Channel;

import com.rabbitmq.client.Connection;

import com.rabbitmq.client.ConnectionFactory;

public class Producer {

**public** **static** **void** **main**(String[] args) **throws** Exception {

   Connection connection = ConnectionUtil.getConnection();

   Channel channel = connection.createChannel();

   String exchangeName = "test_direct";

   // 创建交换机

   channel.exchangeDeclare(exchangeName,BuiltinExchangeType.DIRECT,**true**,**false**,**false**,**null**);

   // 创建队列

   String queue1Name = "test_direct_queue1";

   String queue2Name = "test_direct_queue2";

    // 声明（创建）队列

   channel.queueDeclare(queue1Name,**true**,**false**,**false**,**null**);

   channel.queueDeclare(queue2Name,**true**,**false**,**false**,**null**);

   // 队列绑定交换机

    // 队列1绑定error

    channel.queueBind(queue1Name,exchangeName,"error");

    // 队列2绑定info error warning

    channel.queueBind(queue2Name,exchangeName,"info");

    channel.queueBind(queue2Name,exchangeName,"error");

    channel.queueBind(queue2Name,exchangeName,"warning");



    String message = "日志信息：张三调用了delete方法.错误了,日志级别warning";

    // 发送消息

    channel.basicPublish(exchangeName,"warning",**null**,message.getBytes());

    System.out.println(message);



    channel.close();

    connection.close();

}

}

运行

 

 

2）消费者1

package com.atguigu.rabbitmq.routing;

import com.rabbitmq.client.*;

import java.io.IOException;

public class Consumer1 {

**public** **static** **void** **main**(String[] args) **throws** Exception {

    Connection connection = ConnectionUtil.getConnection();

    Channel channel = connection.createChannel();

    String queue1Name = "test_direct_queue1";

    Consumer consumer = **new** DefaultConsumer(channel){

        @Override

        **public** **void** **handleDelivery**(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, **byte**[] body) **throws** IOException {

            System.out.println("body："+**new** String(body));

            System.out.println("将日志信息打印到控制台.....");

        }

    };

    channel.basicConsume(queue1Name,**true**,consumer);

}

}

3）消费者2

package com.atguigu.rabbitmq.routing;

import com.rabbitmq.client.*;

import java.io.IOException;

public class Consumer2 {

**public** **static** **void** **main**(String[] args) **throws** Exception {

    Connection connection = ConnectionUtil.getConnection();

    Channel channel = connection.createChannel();

    String queue2Name = "test_direct_queue2";

    Consumer consumer = **new** DefaultConsumer(channel){

        @Override

        **public** **void** **handleDelivery**(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, **byte**[] body) **throws** IOException {

            System.out.println("body："+**new** String(body));

            System.out.println("将日志信息存储到数据库.....");

        }

    };

    channel.basicConsume(queue2Name,**true**,consumer);

}

}

5.4.3. 测试

启动所有消费者，然后使用生产者发送消息；在消费者对应的控制台可以查看到生产者发送对应routing key对应队列的消息；到达按照需要接收的效果。

5.4.4. 小结

Routing模式要求队列在绑定交换机时要指定routing key，消息会转发到符合routing key的队列。

5.5. Topics通配符模式

5.5.1. 模式说明

Topic类型与Direct相比，都是可以根据RoutingKey把消息路由到不同的队列。只不过Topic类型Exchange可以让队列在绑定Routing key 的时候使用通配符！

Routingkey 一般都是有一个或多个单词组成，多个单词之间以”.”分割，例如： item.insert

通配符规则：

#：匹配零个或多个词

*：匹配不多不少恰好1个词

举例：

item.#：能够匹配item.insert.abc 或者 item.insert

item.*：只能匹配item.insert

 

图解：

  • 红色Queue：绑定的是usa.# ，因此凡是以 usa.开头的routing key 都会被匹配到
  • 黄色Queue：绑定的是#.news ，因此凡是以 .news结尾的 routing key 都会被匹配

5.5.2. 代码

1）生产者

使用topic类型的Exchange，发送消息的routing key有3种： order.info

package com.atguigu.rabbitmq.topic;

import com.rabbitmq.client.BuiltinExchangeType;

import com.rabbitmq.client.Channel;

import com.rabbitmq.client.Connection;

import com.rabbitmq.client.ConnectionFactory;

public class Producer {

**public** **static** **void** **main**(String[] args) **throws** Exception {

    Connection connection = ConnectionUtil.getConnection();

    Channel channel = connection.createChannel();

    String exchangeName = "test_topic";

    channel.exchangeDeclare(exchangeName, BuiltinExchangeType.TOPIC,**true**,**false**,**false**,**null**);

    String queue1Name = "test_topic_queue1";

    String queue2Name = "test_topic_queue2";

    channel.queueDeclare(queue1Name,**true**,**false**,**false**,**null**);

    channel.queueDeclare(queue2Name,**true**,**false**,**false**,**null**);

    // 绑定队列和交换机

    /**

     *  参数：

         1. queue：队列名称

         2. exchange：交换机名称

         3. routingKey：路由键,绑定规则

             如果交换机的类型为fanout ,routingKey设置为""

     */

    // routing key  系统的名称.日志的级别。

    //需求： 所有error级别的日志存入数据库,所有order系统的日志存入数据库

    channel.queueBind(queue1Name,exchangeName,"#.error");

    channel.queueBind(queue1Name,exchangeName,"order.*");

    channel.queueBind(queue2Name,exchangeName,"*.*");

    String body = "日志信息：张三调用了findAll方法...日志级别：info...";

    //发送消息goods.info,goods.error

    channel.basicPublish(exchangeName,"order.info",**null**,body.getBytes());

    channel.close();

    connection.close();

}

}

运行程序

 

2）消费者1

接收两种类型的消息：更新商品和删除商品

package com.atguigu.rabbitmq.topic;

import com.rabbitmq.client.*;

import java.io.IOException;

public class Consumer1 {

**public** **static** **void** **main**(String[] args) **throws** Exception {

    Connection connection = ConnectionUtil.getConnection();

    Channel channel = connection.createChannel();

    String queue1Name = "test_topic_queue1";

    Consumer consumer = **new** DefaultConsumer(channel){

        @Override

        **public** **void** **handleDelivery**(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, **byte**[] body) **throws** IOException {

            System.out.println("body："+**new** String(body));

        }

    };

    channel.basicConsume(queue1Name,**true**,consumer);

}

}

3）消费者2

接收所有类型的消息：新增商品,更新商品和删除商品。

package com.atguigu.rabbitmq.topic;

import com.rabbitmq.client.*;

import java.io.IOException;

public class Consumer2 {

**public** **static** **void** **main**(String[] args) **throws** Exception {

    Connection connection = ConnectionUtil.getConnection();

    Channel channel = connection.createChannel();

    String queue2Name = "test_topic_queue2";

    Consumer consumer = **new** DefaultConsumer(channel){

        @Override

        **public** **void** **handleDelivery**(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, **byte**[] body) **throws** IOException {

            System.out.println("body："+**new** String(body));

        }

    };

    channel.basicConsume(queue2Name,**true**,consumer);

}

}

5.5.3. 测试

启动所有消费者，然后使用生产者发送消息；在消费者对应的控制台可以查看到生产者发送对应routing key对应队列的消息；到达按照需要接收的效果；并且这些routing key可以使用通配符。

 

 

 

5.5.4. 小结

Topic主题模式可以实现 Publish/Subscribe发布与订阅模式 和 Routing路由模式 的功能；只是Topic在配置routing key 的时候可以使用通配符，显得更加灵活。

5.6. 模式总结

RabbitMQ工作模式： 1、简单模式 HelloWorld 一个生产者、一个消费者，不需要设置交换机（使用默认的交换机）

 

 

 

牵兔散步的萝卜
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
RabbitMQ五种模式
07-01
没有1个积分的私聊我哈，我给你免费 消息队列中间件（简称消息中间件）是指利用高效可靠的消息传递机制进行与平台无关的数据交流，并基于数据通信来进行分布式系统的集成。通过提供消息传递和消息排队模型，它可以在...
rabbitmq 五种模式
Jornici的博客
02-05 2005
1、简单模式 2、工作队列模式 3、发布订阅模式 4、路由模式 5、topic通配符模式
RabbitMQ五大模式轻松理解
风影浪子
06-13 7259
简要概括RabbitMQ工作模式：1、简单模式 HelloWorld 2、工作队列模式 Work Queue 3、发布订阅模式 Publish/subscribe 4、路由模式 Routing 5、通配符模式 Topic
rabbitmq五种模式
weixin_49307896的博客
12-21 7341
rabbitmq五种模式 1.简单模式 2.争抢模式（工作模式，工作争抢模式） 3.路由模式 route 4.发布订阅模式 fanout 5.主题模式 topic 6. RPC异步调用模式（不常用） 1.简单模式 当生产端发送消息到交换机,交换机根据消息属性发送到队列,消费者监听绑定队列实现消息的接收和消费逻辑编写.简单模式下,强调的一个队列queue只被一个消费者监听消费. 1.1 结构 生产者：生成消息,发送到交换机 交换机：根据消息属性,将消息发送给队列 消费者：监听这个队列,发现消息后,
RabbitMQ五种工作模式
热门推荐
weixin_41882200的博客
05-21 1万+
RabbitMQ五种工作模式 1、简单队列 一个生产者对应一个消费者！！ 2、work 模式 一个生产者对应多个消费者，但是一条消息只能有一个消费者获得消息！！！ 轮询分发就是将消息队列中的消息，依次发送给所有消费者。一个消息只能被一个消费者获取。 3、发布/订阅模式 一个消费者将消息首先发送到交换器，交换器绑定到多个队列，然后被监听该队列的消费者所接收并消费。 ps:X表示交换器，在RabbitMQ中，交换器主要有四种类型:direct、fanout、topic、headers，这里的交换器是 fa
RabbitMQ五种消息模式
qq_43390704的博客
12-21 3433
1，简单模式 工作的流程: 当生产者生产消息后,将消息发往队列. 当队列中有消息时,消费者会实时的监听队列中的消息.如果有消息则会执行消息 2，工作模式 默认的传统队列是为均摊消费，存在不公平性；如果每个消费者速度不一样的情况下，均摊消费是不公平的，应该是能者多劳。 采用工作队列 在通道中只需要设置basicQos为1即可，表示MQ服务器每次只会给消费者推送1条消息必须手动ack确认之后才会继续发送。channel.basicQos(1); public class ...
基于RabbitMQ几种Exchange 模式详解
08-28
下面小编就为大家带来一篇基于RabbitMQ几种Exchange 模式详解。小编觉得挺不错的，现在就分享给大家，也给大家做个参考。一起跟随小编过来看看吧
rabbitmq常用三种模式的配置
03-16
rabbitmq包含多种模式，主要是fanout，direct，topic，本代码主要针对这三种模式进行相关的配置，配置文件单独放置在不同的文件夹里，以便学习。
spring boot整合RabbitMQ（Direct模式）
08-30
springboot集成RabbitMQ非常简单，如果只是简单的使用配置非常少，springboot提供了spring-boot-starter-amqp项目对消息各种...下面通过本文给大家介绍下spring boot整合RabbitMQ（Direct模式）,需要的朋友可以参考下
RabbitMQ 五种工作模式C#项目代码
02-08
测试普通队列模式--点对点--消费者 #region 测试工作队列模式-- 一个生产者多个消费者 --生产端 #region 发布/订阅模式 #region 路由模式 #region 主题模式
消息队列之Pulsar、kafaka、rabbitmq、mqtt、RocketMQ
CherryXieのblog
05-19 349
Pulsar 具有高度可扩展的架构，可以处理大规模的实时数据流，并提供低延迟的消息传递。
RabbitMQ .NET
ooo
05-18 282
.NET RabbitMQQ Send Receive
详解最新版RabbitMQ 基于RPM 方式的安装
持 开源思想，撰 必胜所学，望 勤学者，无难处
05-18 1169
各个包的对应关系也是有一定要求的，像笔者这一套就都是el8的，下载的时候也一定要下载一样的，每个包后面也都有标示，而且和linux版本显示的4.18.0-80.el8.x86_64也是一致的（查看linux版本：uname -r）这里的意思是开放使用，rabbitmq默认创建的用户guest，密码也是guest，这个用户默认只能是本机访问，localhost或者127.0.0.1，从外部访问需要添加上面的配置。输入默认的管理员账号密码：guest,guest。如果只显示：已经安装，没有报错那就安装成功了。
RabbitMQ统一消息处理
weixin_71020872的博客
05-18 359
实际使用中，没有必要每次都创建一个Message类，然后手动添加。使用RabbitMQ进行异步通信时，可能不仅仅需要传递消息本身，有时需要包含一些额外的信息，比如登录状态。可以参考前端发送请求时的做法，把登录状态保存在请求头中。一般情况下，消费更倾向于使用监听机制，也就是使用@RabbitListener注解，这种方式也可以自动的声明交换机、队列以及建立绑定，因此使用更加广泛。然而这种方式无法执行前面设置的后置处理器逻辑，也就是拿不到消息头中的信息。在异步场景下显然这两种方法都不满足要求。
Docker常用的部署（Mysql | Nginx | RabbitMQ | Seata | ES）
程序员碎像的博客
05-18 286
常用的Docker部署
RabbitMQ 消息队列安装及入门
2302_79789602的博客
05-18 1037
RabbitMQ 安装及入门消费者，生产者
python操作rabbitmq的consumer,并强制关闭特定consumer的连接
最新发布
Jesse_Kyrie的博客
05-22 351
python可以使用rabbitmq_management的api获取所有consumer的信息。【队列需要安装rabbitmq_management，在大部分情况下，我们安装队列的同时，都会安装管理界面，以方便一些简单的手动操作与简单监控】**暂时只能使用管理页面的close关闭或consumer内channel.close方法关闭**
RabbitMQ02-RebbitMQ简介及交换器
qq_43676797的博客
05-22 600
RabbitMQ是通过Erlang语言基于AMQP协议编写的消息中间件，它在分布式系统中可以解应用耦合、流量削峰、异步消息等问题。它有两个特性队列排队和异步应用解耦：多个个应用程序之间可通过RabbitMQ作为媒介，两个应用不再粘连，实现解耦；异步消息：多个应用可通过RabbitMQ进行消息传递；流量削峰：在高并发情况下，可以通过RabbitMQ的队列特性实现流量削峰；应用场景：应用到队列特性的应用场景： 排序算法、秒杀活动。
RabbitMQ
lercent的博客
05-21 1000
RabbitMQ是一个开源的消息队列中间件，它实现了高度可靠、灵活和可扩展的消息传递模型。RabbitMQ是由支持高并发的erlang语言开发，它实现了 AMQP（高级消息队列协议）。
rabbitmq模式
09-15
RabbitMQ是一个用于消息队列的开源软件。它实现了高度可靠的消息传递模式，可以在应用程序之间进行可靠的异步通信。 在RabbitMQ中，有几种常见的消息传递模式： 1. 简单模式（Simple mode）：一个生产者发送消息到一个队列，一个消费者接收并处理该消息。 2. 工作队列模式（Work queue mode）：一个生产者发送消息到一个队列，在多个消费者之间进行竞争，每个消费者获取并处理一个消息。 3. 发布/订阅模式（Publish-subscribe mode）：一个生产者发送消息到一个交换机（exchange），交换机将消息广播到绑定到它上面的所有队列中，每个队列都有自己的消费者来处理消息。 4. 路由模式（Routing mode）：一个生产者发送消息到一个交换机，并指定一个路由键（routing key），交换机根据路由键将消息转发到与之匹配的队列，并由消费者来处理。 5. 主题模式（Topic mode）：类似于路由模式，但是路由键可以使用通配符匹配，可以更灵活地进行消息的路由。 这些模式可以根据具体的需求和场景选择使用，以实现不同的消息传递方式和行为。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值