RabbitMQ系列之工作模式

于 2021-09-19 18:38:43 发布
阅读量144 收藏
点赞数
分类专栏： RabbitMQ 文章标签： rabbitmq java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_38668544/article/details/120383220
版权

RabbitMQ的工作模式

代码地址：https://gitee.com/webprogram/spring_rabbit

RabbitMQ有一下四种工作模式：

  • DIRECT(“direct”),定向
  • FANOUT(“fanout”),发送到所有绑定的队列
  • TOPIC(“topic”),通配符的方式
  • HEADERS(“headers”);参数匹配

下面将逐个讲解各个模式的用法

Work queues 工作队列模式

模式说明

在这里插入图片描述

如图所示，一个队列对应多个消费者，C1和C2属于竞争关系，同一条消息要么被C1消费，要么被C2消费

总结：Work queues多个消费端共同消费同一队列中的消息

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

生产者

public class MessageProducer {

    public static void sendMessage() throws IOException, TimeoutException {
        // 1.创建连接工厂
        ConnectionFactory connectionFactory = new ConnectionFactory();
        // 2.设置参数
        // ip，默认为本地localhost
        connectionFactory.setHost("127.0.0.1");
        // 端口，默认值5672
        connectionFactory.setPort(5672);
        // 虚拟机,默认值/
        connectionFactory.setVirtualHost("my_vhost");
        // 账号,默认值guest
        connectionFactory.setUsername("admin");
        // 密码,默认值guest
        connectionFactory.setPassword("admin");
        // 3.创建连接 Connection
        Connection connection = connectionFactory.newConnection();
        // 4.创建Channel
        Channel channel = connection.createChannel();
        // 5.创建队列
        /**
         * 参数说明：
         * 1.queue：队列名称
         * 2.durable：是否持久化，当mq重启之后，数据依旧存在
         * 3.exclusive：
         *            - 是否独占，只能有一个监听者该队列
         *            - 当connection关闭时，是否删除队列
         * 4.autoDelete：是否 自动删除，当没有Consumer是，自动删除
         * 5.arguments：参数

         */
        // 如果没有名为“first_queue”的队列，则会创建，否则不会创建
        channel.queueDeclare("work_queue",true,false,false,null);
        // 6.发送消息
        /**
         * 参数：
         * 1.exchange:交换机名称，简单模式下交换机默认为""
         * 2.routing key:路由mingc
         * 3.props:配置信息
         * 4.body:发送的消息数据
         */
        for (int i = 1; i < 21; i++) {
            String message = "work queues 第" + i + "条消息";
            channel.basicPublish("","work_queue",null,message.getBytes());
        }

        // 7.释放资源
        channel.close();
        connection.close();
    }
}

为了测试出效果，循环发送20条消息

消费者

public class MessageConsumer {
    public static void getMessage() throws IOException, TimeoutException {
        // 1.创建连接工厂
        ConnectionFactory connectionFactory = new ConnectionFactory();
        // 2.设置参数
        // ip，默认为本地localhost
        connectionFactory.setHost("127.0.0.1");
        // 端口，默认值5672
        connectionFactory.setPort(5672);
        // 虚拟机,默认值/
        connectionFactory.setVirtualHost("my_vhost");
        // 账号,默认值guest
        connectionFactory.setUsername("admin");
        // 密码,默认值guest
        connectionFactory.setPassword("admin");
        // 3.创建连接 Connection
        Connection connection = connectionFactory.newConnection();
        // 4.创建Channel
        Channel channel = connection.createChannel();
        // 5.创建队列
        /**
         * 参数说明：
         * 1.queue：队列名称
         * 2.durable：是否持久化，当mq重启之后，数据依旧存在
         * 3.exclusive：
         *            - 是否独占，只能有一个监听者该队列
         *            - 当connection关闭时，是否删除队列
         * 4.autoDelete：是否 自动删除，当没有Consumer是，自动删除
         * 5.arguments：参数

         */
        // 如果没有名为“first_queue”的队列，则会创建，否则不会创建
        channel.queueDeclare("work_queue",true,false,false,null);
        // 6.接收消息
        /**
         * handleDelivery()参数：
         * 1.consumerTag:标识
         * 2.envelope:获取一些信息，交换机，路由key
         * 3.properties:配置信息
         * 4.bady:数据
         */
        Consumer consumer = new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("客户端1消费：" + new String(body));
            }
        };
        channel.basicConsume("work_queue",true,consumer);
        // 7.释放资源？不需要  消费者相当于一个监听者 时刻监听队列
        // 此处只是不让程序结束，等待回调函数执行
        while (true){}
    }
}

同样的代码在复制一份，修改打印输出内容，作为客户端2，启动会看到work_queue有两个消费者

在这里插入图片描述

消费端启动后，然后运行生产客户端发送消息

消费客户端1控制台打印如下：

客户端1消费：work queues 第2条消息
客户端1消费：work queues 第4条消息
客户端1消费：work queues 第6条消息
客户端1消费：work queues 第8条消息
…

消费客户端2控制台打印如下：

客户端2消费：work queues 第1条消息
客户端2消费：work queues 第3条消息
客户端2消费：work queues 第5条消息
客户端2消费：work queues 第7条消息
客户端2消费：work queues 第9条消息

…

可以看出生产的20条消息，被两个消费端共同分担

Pub/Sub订阅模式

模式说明

在这里插入图片描述

该模式中多了Exchange，整个发送过程相较之前 有所变化，生产者生产的消息不再是发送到队列中去，而是发给交换机

Exchange：交换机(X),一方面接收生产者发送的消息，另一方面知道如何处理消息，例如递交给某个特别队列、递交给所有队列、或者丢弃消息。到底怎么操作，取决于Exchange的类型，常见以下三种：

  • Fanout:广播，将消息交给所有绑定的交换机队列
  • Direct:定向，把消息交给符合指定routing key的队列
  • Topic：通配符，把消息交给符合routing pattern（路由模式）的队列

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

生产者

public class MessageProducer_PubSub {

    public static void sendMessage() throws IOException, TimeoutException {
        // 1.创建连接工厂
        ConnectionFactory connectionFactory = new ConnectionFactory();
        // 2.设置参数
        // ip，默认为本地localhost
        connectionFactory.setHost("127.0.0.1");
        // 端口，默认值5672
        connectionFactory.setPort(5672);
        // 虚拟机,默认值/
        connectionFactory.setVirtualHost("my_vhost");
        // 账号,默认值guest
        connectionFactory.setUsername("admin");
        // 密码,默认值guest
        connectionFactory.setPassword("admin");
        // 3.创建连接 Connection
        Connection connection = connectionFactory.newConnection();
        // 4.创建Channel
        Channel channel = connection.createChannel();
        // 5.常见交换机
        /**
         * 参数说明：
         * 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";
        channel.exchangeDeclare(exchangeName,BuiltinExchangeType.FANOUT,true,false,false,null);
        // 6.创建队列
        String queue1 = "test_fanout_queue1";
        String queue2 = "test_fanout_queue2";
        channel.queueDeclare(queue1,true,false,false,null);
        channel.queueDeclare(queue2,true,false,false,null);
        // 7.绑定队列和交换机
        /**
         * 参数说明：
         * 1.queue:队列名称
         * 2.exchange：交换机名称
         * 3.routingKey:路由键，绑定规则
         * 如果交换机的类型为fanout，routingKey设置为""
         */
        channel.queueBind(queue1,exchangeName,"");
        channel.queueBind(queue2,exchangeName,"");
        // 8.发送消息到交换机
        String message = "pubsub模式的消息";
        channel.basicPublish(exchangeName,"", null,message.getBytes());
        // 9.释放资源
        channel.close();
        connection.close();
    }
}

运行代码后观察rabbit控制台

交换机新增了自定义的交换机名

在这里插入图片描述

点击交换机名，查看详情，能看到如下图的绑定关系

在这里插入图片描述

队列新增了和交换机绑定的两个队列，并且队列中各有一条消息待消费

在这里插入图片描述

消费者

public class MessageConsumer_PubSub1 {

    public static void getMessage() throws IOException, TimeoutException {
        // 1.创建连接工厂
        ConnectionFactory connectionFactory = new ConnectionFactory();
        // 2.设置参数
        // ip，默认为本地localhost
        connectionFactory.setHost("127.0.0.1");
        // 端口，默认值5672
        connectionFactory.setPort(5672);
        // 虚拟机,默认值/
        connectionFactory.setVirtualHost("my_vhost");
        // 账号,默认值guest
        connectionFactory.setUsername("admin");
        // 密码,默认值guest
        connectionFactory.setPassword("admin");
        // 3.创建连接 Connection
        Connection connection = connectionFactory.newConnection();
        // 4.创建Channel
        Channel channel = connection.createChannel();
        // 5.接收消息
        /**
         * handleDelivery()参数：
         * 1.consumerTag:标识
         * 2.envelope:获取一些信息，交换机，路由key
         * 3.properties:配置信息
         * 4.bady:数据
         */
        Consumer consumer = new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("客户端1消费：" + new String(body));
            }
        };
        channel.basicConsume("test_fanout_queue1",true,consumer);
        // 6.释放资源？不需要  消费者相当于一个监听者 时刻监听队列
        // 此处只是不让程序结束，等待回调函数执行
        while (true){}
    }
}

相同代码复制一份，修改监听队列为test_fanout_queue2，修改打印信息作为客户端2，分别启动消费客户端1和消费客户端2

控制台输出如下：

客户端1消费：pubsub模式的消息

客户端2消费：pubsub模式的消息

可以看出，同一条消息换发送到交换机，由交换机分发到两个队列中，两个客户端分别在对应的队列中进行消费

Routing 路由模式

模式说明：

在这里插入图片描述

图中表示不同的日志级别，由交换机分发到不同的队列中

  • 队列与交换机绑定，不能是任意绑定了，而是指定一个RoutingKey（路由key）
  • 消息发送到exchange时，必须指定消息的RoutingKey
  • Exchange不在把消息发送到每一个绑定的队列，而是根据消息的RoutingKey进行判断，只有队列的Routingkey与消息的RoutingKey一致时，才会收到消息
  • 交换机类型为Direct，绑定

生产者

public class MessageProducer_Routing {

    public static void sendMessage() throws IOException, TimeoutException {
        // 1.创建连接工厂
        ConnectionFactory connectionFactory = new ConnectionFactory();
        // 2.设置参数
        // ip，默认为本地localhost
        connectionFactory.setHost("127.0.0.1");
        // 端口，默认值5672
        connectionFactory.setPort(5672);
        // 虚拟机,默认值/
        connectionFactory.setVirtualHost("my_vhost");
        // 账号,默认值guest
        connectionFactory.setUsername("admin");
        // 密码,默认值guest
        connectionFactory.setPassword("admin");
        // 3.创建连接 Connection
        Connection connection = connectionFactory.newConnection();
        // 4.创建Channel
        Channel channel = connection.createChannel();
        // 5.常见交换机
        /**
         * 参数说明：
         * 1.exchange：交换机类型
         * 2.type：交换机类型
         *     DIRECT("direct"),定向
         *     FANOUT("fanout"),发送到所有绑定的队列
         *     TOPIC("topic"),通配符的方式
         *     HEADERS("headers");参数匹配
         * 3.durable：是否持久化
         * 4.autoDelete：是否自动删除
         * 5.internal：内部使用，一般为false
         * 6.arguments：参数
         */
        String exchangeName = "test_direct";
        channel.exchangeDeclare(exchangeName,BuiltinExchangeType.DIRECT,true,false,false,null);
        // 6.创建队列
        String queue1 = "test_direct_queue1";
        String queue2 = "test_direct_queue2";
        channel.queueDeclare(queue1,true,false,false,null);
        channel.queueDeclare(queue2,true,false,false,null);
        // 7.绑定队列和交换机
        /**
         * 参数说明：
         * 1.queue:队列名称
         * 2.exchange：交换机名称
         * 3.routingKey:路由键，绑定规则
         * 如果交换机的类型为fanout，routingKey设置为""
         */
        // error队列绑定
        channel.queueBind(queue1,exchangeName,"error");
        // info error warn队列绑定
        channel.queueBind(queue2,exchangeName,"info");
        channel.queueBind(queue2,exchangeName,"error");
       channel.queueBind(queue2,exchangeName,"warning");
        // 8.发送消息到交换机
        String messageInfo = "日志信息：info";
        String messageError = "日志信息：error";
        String messageWarn = "日志信息：warning";
        // 发送不同RoutingKey类型的消息，观察exchange会怎么处理
        channel.basicPublish(exchangeName,"info", null,messageInfo.getBytes());
        channel.basicPublish(exchangeName,"error", null,messageError.getBytes());
        channel.basicPublish(exchangeName,"warning", null,messageWarn.getBytes());
        // 9.释放资源
        channel.close();
        connection.close();
    }
}

运行生产者代码，观察rabbit控制台

Exchange交换机新增名称为test_direct的交换机

在这里插入图片描述

点击名称进入，可查看和队列绑定关系

在这里插入图片描述

在观察queues栏，可以看出消息根据不同的routingkey被分发到不同队列

在这里插入图片描述

队列1接收RoutingKey为error的消息，只有1条

队列2接收RoutingKey为info、error、warning的消息，有三天

因为两个队列都绑定了RoutingKey为error的消息，所以error消息会出现在两个队列中

消费者

public class MessageConsumer_Routing1 {

    public static void getMessage() throws IOException, TimeoutException {
        // 1.创建连接工厂
        ConnectionFactory connectionFactory = new ConnectionFactory();
        // 2.设置参数
        // ip，默认为本地localhost
        connectionFactory.setHost("127.0.0.1");
        // 端口，默认值5672
        connectionFactory.setPort(5672);
        // 虚拟机,默认值/
        connectionFactory.setVirtualHost("my_vhost");
        // 账号,默认值guest
        connectionFactory.setUsername("admin");
        // 密码,默认值guest
        connectionFactory.setPassword("admin");
        // 3.创建连接 Connection
        Connection connection = connectionFactory.newConnection();
        // 4.创建Channel
        Channel channel = connection.createChannel();
        // 5.接收消息
        /**
         * handleDelivery()参数：
         * 1.consumerTag:标识
         * 2.envelope:获取一些信息，交换机，路由key
         * 3.properties:配置信息
         * 4.bady:数据
         */
        Consumer consumer = new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("客户端1消费：" + new String(body));
            }
        };
        channel.basicConsume("test_direct_queue1",true,consumer);
        // 6.释放资源？不需要  消费者相当于一个监听者 时刻监听队列
        // 此处只是不让程序结束，等待回调函数执行
        while (true){}
    }
}

复制相同代码，修改监听队列名称，修改打印信息作为客户端2

启动消费者，控制台打印如下：

客户端1消费：日志信息：error

客户端2消费：日志信息：info
客户端2消费：日志信息：error
客户端2消费：日志信息：warning

总结：生产者发送的消息经过exchange处理，根据RoutingKey进行匹配，分发到不同的队列中，由该队列对应的消费者去消费

Topic通配符模式

模式说明：

在这里插入图片描述

在这里插入图片描述

  • 交换机类型为Topic，通配符模式
  • 例RoutingKey为Usa.news 可以匹配usa.#的队列，也可以匹配#.news的队列
  • 过程：生产者将消息发送给交换机，由交换机根据队列RoutingKey设定的匹配规则进行分发到不同队列

生产者：

public class MessageProducer_Topic {

    public static void sendMessage() throws IOException, TimeoutException {
        // 1.创建连接工厂
        ConnectionFactory connectionFactory = new ConnectionFactory();
        // 2.设置参数
        // ip，默认为本地localhost
        connectionFactory.setHost("127.0.0.1");
        // 端口，默认值5672
        connectionFactory.setPort(5672);
        // 虚拟机,默认值/
        connectionFactory.setVirtualHost("my_vhost");
        // 账号,默认值guest
        connectionFactory.setUsername("admin");
        // 密码,默认值guest
        connectionFactory.setPassword("admin");
        // 3.创建连接 Connection
        Connection connection = connectionFactory.newConnection();
        // 4.创建Channel
        Channel channel = connection.createChannel();
        // 5.常见交换机
        /**
         * 参数说明：
         * 1.exchange：交换机类型
         * 2.type：交换机类型
         *     DIRECT("direct"),定向
         *     FANOUT("fanout"),发送到所有绑定的队列
         *     TOPIC("topic"),通配符的方式
         *     HEADERS("headers");参数匹配
         * 3.durable：是否持久化
         * 4.autoDelete：是否自动删除
         * 5.internal：内部使用，一般为false
         * 6.arguments：参数
         */
        String exchangeName = "test_topic";
        channel.exchangeDeclare(exchangeName,BuiltinExchangeType.TOPIC,true,false,false,null);
        // 6.创建队列
        String queue1 = "test_topic_queue1";
        String queue2 = "test_topic_queue2";
        channel.queueDeclare(queue1,true,false,false,null);
        channel.queueDeclare(queue2,true,false,false,null);
        // 7.绑定队列和交换机
        /**
         * 参数说明：
         * 1.queue:队列名称
         * 2.exchange：交换机名称
         * 3.routingKey:路由键，绑定规则
         * 如果交换机的类型为fanout，routingKey设置为""
         */
        // 订单相关信息、info信息存入队列1
        channel.queueBind(queue1,exchangeName,"*.info.*");
        channel.queueBind(queue1,exchangeName,"order.#");
        // 订单错误信息、支付信息存入队列2
        channel.queueBind(queue2,exchangeName,"order.error.*");
        channel.queueBind(queue2,exchangeName,"pay.#");
        // 8.发送消息到交换机
        String message = "Topic模式消息";
        // 发送不同RoutingKey类型的消息，观察exchange会怎么处理
        channel.basicPublish(exchangeName,"test.info.test", null,message.getBytes());
        channel.basicPublish(exchangeName,"order.error.select", null,message.getBytes());
        channel.basicPublish(exchangeName,"order.error.select.success", null,message.getBytes());
        channel.basicPublish(exchangeName,"pay.test", null,message.getBytes());
        // 9.释放资源
        channel.close();
        connection.close();
    }
}

启动生产者，观察rabbit控制台

Exchange新增名称为test_topic的交换机

在这里插入图片描述

点击名称查看队列及相关绑定的通配符

在这里插入图片描述

队列情况

在这里插入图片描述

队列1绑定通配符*.info.*，order.#，和它匹配的RoutingKey有test.info.test，order.error.select，order.error.select.success，因此它有三条消息

队列2绑定通配符order.error.*，pay.#，和它匹配的RoutingKey有order.error.select，pay.test，因此只有两个

为什么order.error.*不能匹配order.error.select.success

因为*表示一个单词，#表示多个单词，而单词界定以.为界，所以不能匹配

消费者

public class MessageConsumer_Topic1 {

    public static void getMessage() throws IOException, TimeoutException {
        // 1.创建连接工厂
        ConnectionFactory connectionFactory = new ConnectionFactory();
        // 2.设置参数
        // ip，默认为本地localhost
        connectionFactory.setHost("127.0.0.1");
        // 端口，默认值5672
        connectionFactory.setPort(5672);
        // 虚拟机,默认值/
        connectionFactory.setVirtualHost("my_vhost");
        // 账号,默认值guest
        connectionFactory.setUsername("admin");
        // 密码,默认值guest
        connectionFactory.setPassword("admin");
        // 3.创建连接 Connection
        Connection connection = connectionFactory.newConnection();
        // 4.创建Channel
        Channel channel = connection.createChannel();
        // 5.接收消息
        /**
         * handleDelivery()参数：
         * 1.consumerTag:标识
         * 2.envelope:获取一些信息，交换机，路由key
         * 3.properties:配置信息
         * 4.bady:数据
         */
        Consumer consumer = new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("客户端1消费：" + new String(body));
            }
        };
        channel.basicConsume("test_topic_queue1",true,consumer);
        // 6.释放资源？不需要  消费者相当于一个监听者 时刻监听队列
        // 此处只是不让程序结束，等待回调函数执行
        while (true){}
    }
}

复制代码修改队列名，修改打印内容作为客户端2

运行两个消费者客户端，控制台分别打印

客户端1：

客户端1消费：Topic模式消息
客户端1消费：Topic模式消息
客户端1消费：Topic模式消息

客户端2：

客户端1消费：Topic模式消息
客户端1消费：Topic模式消息

总结：Topic模式和Routing模式很类似，不过Routing模式属于值绑定，topic属于通配符绑定，应用范围更广

喝一杯java
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
ansible-role-rabbitmq:提供和安装RabbitMQ节点和_或集群的角色
05-10
ansible-role-rabbitmq ... （不要忘记使用与将要安装的Rabbitmq版本兼容的erlang系列。请参阅） 袜子 对数旋转 python请求> = 1.0.0（如果使用此角色提供的绑定，交换，队列管理） 对于群集，群集中的
rabbitmq工作模式
lion的博客
12-30 217
1.简单模式 一个队列中只有一个生产者(producer)一个消费者(consumer) 2.工作模式 多个消费者(consumer)监听同一个队列，这个队列只有一个生产者(producer) A服务修改A库后加入队列，B/C服务只需要其中一个修改B库即可 3.订阅模式 有多个消息队列，每个消息队列有一个消费者(consumer)监听 4.路由模式 一个交换机绑定多个消息队列，每个消息队列都有自己唯一的key，每个消息队列有一个消费者(consumer)监听 ...
rabbitmq【工作模式】
FeeLing
02-25 175
work工作队列模式 多个消费者监听同一个队列 默认队列中的同一条消息会被多个消费者消费，可以设置一个开关syncronize保证一个消息只能被一个消费者消费 publish/subscribe发布订阅模式 交换机将消息发送到多个队列，各个队列中的消息是一样的 每种消费者监听各自的队列 也可以设置开关确保一个队列中的同一条消息只能被一个消费者消费到 发布的意思：交换机将消息发布到各个绑定了交换机的队列中 订阅的意思：绑定了交换机的队列都将收到交换机的消息 routing路由模式..
RabbitMQ-工作模式
BNMZY的博客
05-15 197
文章目录概述Work Queues 概述 RabbitMQ有以下几种工作模式 Work Queues 工作队列 Publish/Subscribe 发布订阅 Routing 路由 Topics 通配符 Header Header转发器 RPC 远程过程调用 Work Queues
RabbitMQ 工作模式
Janet的博客
04-15 389
新建项目的依赖： <dependencies> <dependency> <groupId>com.rabbitmq</groupId> <artifactId>amqp-client</artifactId> <vers...
RabbitMQ工作模式
Rewind的博客
11-21 202
模式简介 这里简单介绍下六种工作模式（最后一种省略）的主要特点： 简单模式：一个生产者，一个消费者 work模式：一个生产者，多个消费者，每个消费者获取到的消息唯一。 订阅模式：一个生产者发送的消息会被多个消费者获取。 路由模式：发送消息到交换机并且要指定路由key ，消费者将队列绑定到交换机时需要指定路由key topic模式：将路由键和某模式进行匹配，此时队列需要绑定在一个模式上，“#”匹配一个词或多个词，“*”只匹配一个词。 抽取创建connection的工具类 public class Connec
高性能架构面试题系列：Nginx+ActiveMQ+RabbitMQ+Kafka.zip
07-04
高性能架构面试题系列：Nginx+ActiveMQ+RabbitMQ+Kafka 请解释Nginx如何处理HTTP请求。 Nginx使用反应器模式。主事件循环等待操作系统发出准备事件的信号，这样数据就可以从套接字读取，在该实例中读取到缓冲区并...
gamekeeper:RabbitMQ 的 Nagios 监控和 GangliaGraphite HTTP 统计信息聚合
06-28
measure子命令将从指定的--uri为许多 RabbitMQ/AMQP 原语发出一系列指标。 所有指标都以标识符为前缀（Ganglia、Graphite 等）： <node>.rabbit. 常量目前是通过转义本地主机名来确定的，并且可以在未来的版本中...
JAVA后端详细面试资料
04-12
包括 Dubbo、Java基础、并发、集合、BIO，NIO，AIO，Netty、ElastSerarch、JVM、Linux、Mybatis、kafka、MySQL、Redis、RabbitMQ、Spring系列、设计模式、计算机网络等等详细面试题
超详细Java程序员的系列教程，从0学习Java
最新发布
05-08
设计模式 JVM 并发 Spring 框架系列 Spring SpringMVC SpringBoot SpringCloud SpringCloud-Alibaba 等 ORM 映射框架 MyBatis JPA Hibernate ZooKeeper Kafka Redis 数据库 MySQL Oracle MogonDB PostgreSQL ...
rabbitMQ的工作模式
tuzhu123的博客
04-10 95
1.RabbitMq 1.1介绍 RabbitMQ是一个消息代理：它接受并转发消息。你可以把它当成一个邮局：当你想邮寄信件的时候，你会把信件放在投递箱中，并确信邮递员最终会将信件送到收件人的手里。在这个例子中，RabbitMQ就相当与投递箱、邮局和邮递员。 AMQP协议中的核心思想就是生产者和消费者隔离，生产者从不直接将消息发送给队列。生产者通常不知道是否一个消息会被发送到队列中，只是将消息发送到...
RabbitMQ的工作模式
卑微的小白
10-27 119
1、简单模式 消息生产者将消息方式到队列中，消费者监听队列，如果队列中有消息，则取出消费，在消费者取出消息后队列将自动删除该消息。 2、工作模式 消息生产者将消息发送到队列中，一个队列有多个消费者监听，则多个消费者之间存在着竞争关系，消息会会被消费者谁先拿到谁先消费。高并发情况下，会产生某条消息会被多个消费者共同使用，这时可以添加一个开关（syncronize与同步锁）保证每个消息只被一个消费者消费。 3、发布/订阅模式 x表示rabbitmq的内部组件交换机，队列绑定到交换机上，消息发送到交换机中，
深入学习rabbitmq
07-28
1. 了解消息队列和 RabbitMQ 的基本概念：开始之前，确保你对消息队列的概念有一定的了解，比如发布/订阅模式、生产者/消费者模式等。然后，学习 RabbitMQ 的基本概念，如交换机、队列、绑定等。 2. 安装和配置 ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值