消息队列之—RabbitMQ

最新推荐文章于 2024-04-06 19:26:11 发布
最新推荐文章于 2024-04-06 19:26:11 发布
阅读量473 收藏 1
点赞数
分类专栏： 工具 消息队列 文章标签： rabbitmq 中间件
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_39559282/article/details/114801761
版权

目前项目中需要使用消息队列，同时行内开始搞国产化，综合几种消息队列的产品决定引入RabbitMQ，一起来学习下这款消息队列中间件吧。

RabbitMQ

AMQP协议模型

  • AMQP协议（Advanced Message Queuing Protocol，高级消息队列协议）是一个进程间传递异步消息的网络协议.

AMQP协议模型
在这里插入图片描述

  • 流程：（一般流程）
    • 生产者生产消息–》与Server建立连接–》找到对应的Virtual Host–》到对应的交换机–》然后将消息放入到对应 的queue
    • 消费者–》连接Server–》找到对应的Virtual Host–》到对应的queue中取到消息
  • 官方提供7种消息的发布的模式

几种消息队列产品的对比：

在这里插入图片描述

  • Activemq： 性能受到诟病。成熟，完善的手册。
  • kafka: 基于大数据的消息中间件，追求高的吞吐量，开始的目的是用于日志收集与传输。0.8版本开始支持复制，不支持事务，对消息的重复、丢失、错误没有严格的要求。适合产生大数据的互联网服务数据收集业务。
  • RocketMQ: 官方版本支持事务，开源的版本不支持事务
  • Rabbitmq：erlang语开发的开源消息队列系统，基于AMQP协议来实现。AMQP主要特征面向消息、队列、路由（包括点对点和发布订阅）、可靠性、安全。AMQP协议更多用于企业系统对数据一致性、稳定性和可靠性要求很高的场景，对性能和吞吐量的要求还在其次。
    在这里插入图片描述
  • 虚拟主机（类比数据库中的表的概念）与用户进行绑定（首先创建用户，然后创建虚拟主机，再将虚拟主机和用户进行绑定）。

rabbitmq官方提供其中消息的方式

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

源码可以到：源码GitHub地址

方式一：直连：简单方式

在这里插入图片描述

  • 生产者代码
public class Provider {
    // 直连方式：生产消息
    @Test
    public void sendMesssge() throws IOException, TimeoutException {
        /*//创建连接mq的工厂
        ConnectionFactory connectionFactory = new ConnectionFactory();
        //设置连接mq的主机
        connectionFactory.setHost("localhost");
        // 设置端口 5672
        connectionFactory.setPort(5672);
        //设置连接的虚拟主机
        connectionFactory.setVirtualHost("/rabbitmqtest1");
        //设置用户名和密码
        connectionFactory.setUsername("rabbitmqtest1user");
        connectionFactory.setPassword("rabbitmqtest1user");

        //获取连接对象
        Connection connection = connectionFactory.newConnection();*/
        Connection connection = RabbitMQConnectUtils.getRabbitMQConnection();
        //获取通道对象
        Channel channel = connection.createChannel();
        //通道绑定对应的消息队列
        // 参数1:队列名称(如果首次会自动新建名称)
        // 参数2:durable是否持久化 false 不持久话. true 持久化
        // 参数3: exclusive 是否独占队列 false不独占 ,true 独占队列
        // 参数4: autoDelete 消息消费完后是否删除 true 删除 ,false 不删除
        // 参数5: 其他参数
        channel.queueDeclare("rabbitmqtestqueue1", false, false, false, null);
        //发布消息
        // 参数1:交换机(简单模式没有交换机) 参数2: 队列名称 参数3:传递消息额外设置 参数4:消息的具体内容
        channel.basicPublish("", "rabbitmqtestqueue1", null, "你好".getBytes());

        /*channel.close();
        connection.close();*/
        RabbitMQConnectUtils.closeChannelAndConnection(channel,connection);
    }
}
  • 消费者代码
public class Consumer {

    public static void main(String[] args) throws IOException, TimeoutException {
        // 获取连接工厂对象
       /* ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("localhost");
        factory.setPort(5672);
        factory.setVirtualHost("/rabbitmqtest1");
        factory.setUsername("rabbitmqtest1user");
        factory.setPassword("rabbitmqtest1u);

        Connection connection = factory.newConnection();*/
        Connection connection = RabbitMQConnectUtils.getRabbitMQConnection();
        Channel channel = connection.createChannel();
        channel.queueDeclare("rabbitmqtestqueue1", false, false, false, null);

        //消费消息
        // 参数1:消费哪个队列的消息(队列名称)
        // 参数2:开启消息的自动确认机制
        // 参数3:消费时的回调
        channel.basicConsume("rabbitmqtestqueue1", true, new DefaultConsumer(channel) {
            @Override //最后一个参数 :消息队列中取出的消息
            public void handleDelivery(String consumerTag,
                                       Envelope envelope,
                                       AMQP.BasicProperties properties,
                                       byte[] body) throws IOException {
                System.out.println("接收到消息:--> "+new String(body));

            }
        });
        // consumer端不建议关闭连接和通道(否则可能会接受不到回调,就结束了.)
//        channel.close();
//        connection.close();

    }
}

总结：

消费者和生产者的参数配置必须严格一致，否则可能出现异常问题。
通讯都是基于通道（Channel）的，生产者通过通道往队列里放消息；消费者通过通道从队列里取消息。

方式二：工作队列模型

在这里插入图片描述

在这里插入图片描述

  • 生产者代码
public class Provider {
    @Test
    public void sendMessage() throws IOException {
        //获取连接对象
        Connection connection = RabbitMQConnectUtils.getRabbitMQConnection();
        //获取通道
        Channel channel = connection.createChannel();
        //通过通道声明队列
        channel.queueDeclare("workqueue", true, false, false, null);
        for (int i = 0; i < 20; i++) {
            //生产消息
            channel.basicPublish("", "workqueue", MessageProperties.PERSISTENT_TEXT_PLAIN, (i + "< > 你好工作队列").getBytes());
        }
        RabbitMQConnectUtils.closeChannelAndConnection(channel, connection);
    }
}
  • 消费者1代码
public class Consumer1 {
    public static void main(String[] args) throws IOException {
        Connection connection = RabbitMQConnectUtils.getRabbitMQConnection();
        Channel channel = connection.createChannel();
        channel.queueDeclare("workqueue", true, false, false, null);
        channel.basicConsume("workqueue", true, new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag,
                                       Envelope envelope,
                                       AMQP.BasicProperties properties,
                                       byte[] body) throws IOException {
                try {
                    Thread.sleep(1000); //由于工作队列默认的是对每个消费则平均分配任务,模拟其中一个处理较慢,是否还是平均分配
                } catch (Exception e) {
                    e.printStackTrace();
                }
                System.out.println("Consumer1 获取到工作消息--> " + new String(body));
            }
        });

    }
}
  • 消费者2代码

public class Consumer2 {
    public static void main(String[] args) throws IOException {
        Connection connection = RabbitMQConnectUtils.getRabbitMQConnection();
        Channel channel = connection.createChannel();
        channel.queueDeclare("workqueue", true, false, false, null);
        channel.basicConsume("workqueue", true, new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag,
                                       Envelope envelope,
                                       AMQP.BasicProperties properties,
                                       byte[] body) throws IOException {
                System.out.println("Consumer1 获取到工作消息--> "+new String(body));
            }
        });

    }
}

总结：平均分配是会产生处理慢的依旧会积累。

By default, RabbitMQ will send each message to the next consumer, in sequence. On average every consumer will get the same number of messages. This way of distributing messages is called round-robin. Try this out with three or more workers.
默认情况下，RabbitMQ会将每条消息依次发送给下一个消费者。平均而言，每个消费者将获得相同数量的消息。这种分发消息的方式称为循环。让三个或更多的工人试试这个方法。

弊端：

1.当一个消费者的处理能力很差，则会导致消息不能被及时的处理掉，造成消息的堆积
2.（自动确认机制中）如果其中一个消费者宕机，则会导致分配给它的任务丢失。

消息确认机制：

在这里插入图片描述

 // 参数:参数2:自动确认 true时, 消费者自动向rabbitmq确认消息消费. false 不会自动确认
channel.basicConsume("workqueue", true, new DefaultConsumer(channel) {}
// 此时消息队列会将消息一次性平均分给不同的消费者（弊端1）；自动确认（弊端2）
  • 处理办法
// 1.首先通道告诉队列一次只消费一个消息
channel.basicQos(1);//每次只能消费一个消息
 // 参数:参数2:自动确认 true时, 消费者自动向rabbitmq确认消息消费. false 不会自动确认
// 2.关闭自动确认机制
channel.basicConsume("workqueue", false, new DefaultConsumer(channel) {}
// 业务逻辑处理
// XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
//3.手动确认 参数1:手动确认消息标识 ,参数2:false,每次确认一个
channel.basicAck(envelope.getDeliveryTag(),false);
  • 处理问题的代码：
public class Consumer1 {
    public static void main(String[] args) throws IOException {
        Connection connection = RabbitMQConnectUtils.getRabbitMQConnection();
        Channel channel = connection.createChannel();
        channel.basicQos(1);//每次只能消费一个消息
        //通道与队列建立连接
        channel.queueDeclare("workqueue", true, false, false, null);

        // 参数:参数2:自动确认 true时, 消费者自动向rabbitmq确认消息消费. false 不会自动确认
        channel.basicConsume("workqueue", false, new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag,
                                       Envelope envelope,
                                       AMQP.BasicProperties properties,
                                       byte[] body) throws IOException {
                try {
                    Thread.sleep(1000); //由于工作队列默认的是对每个消费则平均分配任务,模拟其中一个处理较慢,是否还是平均分配
                } catch (Exception e) {
                    e.printStackTrace();
                }
                System.out.println("Consumer1 获取到工作消息--> " + new String(body));
                //手动确认 参数1:手动确认消息标识(确认队列中哪个具体的消息) ,参数2:false,每次确认一个
                channel.basicAck(envelope.getDeliveryTag(),false);

            }
        });
    }
}

总结：

上述代码的优点
1：避免一次平均分配导致处理慢的消费者卡住，实现能者多劳。提高系统吞吐量
2：如果未确认，则在会一直在队列里。

方式三：（fanout）扇出、广播

应用场景：发一条消息被不同的业务系统同时去执行。（购物车结算时：同时调用订单系统、库存系统。）
在这里插入图片描述

  • 消费者1和消费者2，两个拿到的消息是同一个消息只是做不同的处理。

  • 生产者代码

public class Provider {
    public static void main(String[] args) throws IOException {
        //获取连接对象
        Connection connection = RabbitMQConnectUtils.getRabbitMQConnection();
        //获取通道
        Channel channel = connection.createChannel();

        // 参数: 参数1: 交换机的名称, 参数2 : 交换机的类型: fanout: 广播类型
        channel.exchangeDeclare("logs", "fanout");

        //发送消息
        channel.basicPublish("logs","", MessageProperties.PERSISTENT_TEXT_PLAIN,"fanout Message".getBytes());

        RabbitMQConnectUtils.closeChannelAndConnection(channel,connection);
    }
}
  • 消费者代码(消费者代码相同，只是最后的业务处理逻辑不同)
  • 特点：所有的消费者拿到的消息都是相同的，处理逻辑不同。（发一条消息被不同的业务系统同时去执行）
public class Consumer1 {
    public static void main(String[] args) throws IOException {
        // 创建连接
        Connection connection = RabbitMQConnectUtils.getRabbitMQConnection();
        //创建通道
        Channel channel = connection.createChannel();
        //通道绑定交换机
        channel.exchangeDeclare("logs", "fanout");

        //创建临时队列
        String queueName = channel.queueDeclare().getQueue();
        //将临时队列和交换机建立连接
        channel.queueBind(queueName, "logs", "");

        //消费消息
        channel.basicConsume(queueName, true, new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag,
                                       Envelope envelope,
                                       AMQP.BasicProperties properties,
                                       byte[] body) throws IOException {
                System.out.println("consumer1获取到了消息: " + new String(body));
            }
        });

    }
}

应用场景：

银行核心发送消息到每一个业务系统，不同的业务系统拿到相同的信息做不同的处理。
购物车模块结算时，需要同时掉订单、库存、支付等模块

方式四：路由模型

在这里插入图片描述

  • 生产者代码：
public class Provider {

    public static void main(String[] args) throws IOException {
        // 获取连接对象
        Connection connection = RabbitMQConnectUtils.getRabbitMQConnection();
        //获取通道
        Channel channel = connection.createChannel();
        String exchangeName = "logs_direct";
        //绑定交换机
        channel.exchangeDeclare(exchangeName, "direct");
        //路由模式:需要routingKey
        String routingKey = "error";
        // 参数1:交换机名 参数2:路由key 参数3:持久化消息. 参数4:真正要发送的消息
        channel.basicPublish(exchangeName, routingKey, MessageProperties.PERSISTENT_TEXT_PLAIN, ("这是路由模式下的rabbitmq消息[" + routingKey + "]请接收").getBytes());
        //关闭资源
        RabbitMQConnectUtils.closeChannelAndConnection(channel, connection);
    }
}
  • 消费者1代码：
public class Consumer1 {
    public static void main(String[] args) throws IOException {
        //创建连接
        Connection connection = RabbitMQConnectUtils.getRabbitMQConnection();
        //获取通道
        Channel channel = connection.createChannel();
        //通道绑定队列
        channel.exchangeDeclare("logs_direct", "direct");
        // 获取临时queue
        String queue = channel.queueDeclare().getQueue();
        //将队列和交换机绑定,同时声明接受那些routing key
        channel.queueBind(queue, "logs_direct", "info");
        channel.queueBind(queue, "logs_direct", "error");
        channel.queueBind(queue, "logs_direct", "warning");
        channel.basicConsume(queue, true, new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag,
                                       Envelope envelope,
                                       AMQP.BasicProperties properties,
                                       byte[] body) throws IOException {
                System.out.println("Consumer1 获取消息--> " + new String(body));
            }
        });
    }
}

总结：

模式4：基于不同的应用场景对消息进行不同的执行路线，指定特定的程序去处理不同的业务。获取有选择的接收可能。
弊端：但是还不够灵活，不能基于多个标准进行路由。

方式五：Topics

topics类型的Exchange与Direct相比，都是可以根据RoutingKey把消息路由到不同的队列。只不过Topics类型Exchange可以让队列绑定Routing key 的时候使用通配符。这种模式的routingkey 一般是由一个或多个单词组成，多个单词之间以”.“ 分割。如：account.name
在这里插入图片描述

通配符：

*(star) can substitute for exactly one word. 仅匹配一个词
#(hash) can substitute for zero or more words. 匹配0个或多个

例如：

account.# 可以匹配： account 或account.name.value或account.name 等
account.* 可以匹配： account.name 或account.value

  • 消费者代码：
public class Provider {

    public static void main(String[] args) throws IOException {
        //获取连接
        Connection connection = RabbitMQConnectUtils.getRabbitMQConnection();
        //获取通道Channel
        Channel channel = connection.createChannel();
        //交换机和通道绑定
        String exchangeName="logs_topic";
        channel.exchangeDeclare(exchangeName, "topic");
        //发布消息
        String routingKey = "user.save.aaa";//路由key
        channel.basicPublish(exchangeName, routingKey, MessageProperties.PERSISTENT_TEXT_PLAIN, ("模型5基于动态路由的方式发布消息RoutingKey-> " + routingKey + "<").getBytes());
        RabbitMQConnectUtils.closeChannelAndConnection(channel, connection);
    }
}
  • 消费者1代码：仅支持"user.*" user后面跟一个词的情况
public class Consumer1 {
    public static void main(String[] args) throws IOException {

        //获取连接
        Connection connection = RabbitMQConnectUtils.getRabbitMQConnection();
        //获取通道
        Channel channel = connection.createChannel();
        //通道绑定交换机
        String exchangeName = "logs_topic";
        channel.exchangeDeclare(exchangeName, "topic");
        //获取临时队列
        String queue = channel.queueDeclare().getQueue();
        //队列绑定交换机
        String routingKey = "user.*";
        channel.queueBind(queue, exchangeName, routingKey);
        //消费消息
        channel.basicConsume(queue, true, new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("Consumer1 接收到了消息--> " + new String(body));
            }
        });

    }
}
  • 消费者2代码：支持"user.#" user后面跟0个或多个词的情况
public class Consumer2 {
    public static void main(String[] args) throws IOException {

        //获取连接
        Connection connection = RabbitMQConnectUtils.getRabbitMQConnection();
        //获取通道
        Channel channel = connection.createChannel();
        //通道绑定交换机
        String exchangeName = "logs_topic";
        channel.exchangeDeclare(exchangeName, "topic");
        //获取临时队列
        String queue = channel.queueDeclare().getQueue();
        //队列绑定交换机
        String routingKey = "user.#";
        channel.queueBind(queue, exchangeName, routingKey);
        //消费消息
        channel.basicConsume(queue, true, new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("Consumer2 接收到了消息--> " + new String(body));
            }
        });
    }
}

总结：

topics 模式和模式4 路由模式的区别在于topic支持动态路由，即：路由key可以使用通配符。

方式六：RPC

方式七： Publisher Confirms

总结

区别：

  • 1.是否使用到交换机。
    • a：如果不使用交换机，生产者和消费者直接通过队列进行数据发布与获取（当然需要在Channel的帮助下）。
    • b：如果使用交换机：则生产者和消费者则是通过Exchange交换机进行数据的交换。
  • 2：不使用交换机的情况：
    • a：模式1：一对一，生产者和消费者一一对应。
    • b：模式2：一对多，一个生产者对应多个消费者，消息被平均分给每一个消费者。（需要关闭自动消息确认机制，提高服务器的吞吐量）
  • 3：使用交换机的情况 ：
    • a： 模式3：扇出模型：一个消息可以被多个消费者消费。
    • b： 模式4：路由模型：一个消息可以指定被某一个消费者消费
    • c： 模式5：topics动态路由模型：在模式4的基础上可以使用动态路由key
生产者代码编写：
//获取连接
//获取通道Channel
//交换机和通道绑定
//发布消息
消费者代码编写：
//获取连接
//获取通道
 //通道绑定交换机
 //获取临时队列
 //队列绑定交换机
 //消费消息
benboerdong
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
erlang-18.1-1.el6.x86_64.rpm
06-09
erlang安装包
超云信创服务器与openEuler开源操作系统完成互认证
KJSOO的博客
03-12 417
本次参与适配的超云国产化产品 R3215 和 R3216 均为 2U 高性能通用计算机型，具有低能耗、高扩展、高可靠及易管理等特点，广泛适用于 IT 核心业务、云计算虚拟化、高性能计算、分布式存储、大数据处理等领域，以及金融、运营商、央企、党政、能源等行业的关键任务场景。openEuler 是一个面向数字基础设施的操作系统，支持服务器、云计算、边缘计算、嵌入式等应用场景，支持多样性计算， 致力于提供安全、稳定、易用的操作系统。智能管理：带外管理，支持远程控制与管理，精细化的故障分析报警。
信创国产中间件概览
ITSM/ITIL/网络安全/IT运维
05-04 9085
中间件国内中间件市场份额第一梯队仍然是IBM> 和Oracle，市场份额合计51%。第二梯队为五大国产厂商，包括东方通、普元信息、宝兰德、中创中间件、金蝶天燕，市场份额合计15%。东方通应用服务器TongWeb对标 开源：Apache-Tomcat消息中间件TongLINK/Q对标 IBM-MQSeries Microsoft Message-Queue（MSMQ） 开源：RabbitMQK
FluxMQ：新一代国产高性能 MQTT 云原生的 IoT 物联网网关
最新发布
04-06 1178
为你打造专属的云原生企业级物联网平台01FluxMQ物联网平台FluxMQ 是一款基于Java开发，支持百万级设备连接的高性能、云原生的物联网云网关，专为 IoT 物联网、工业互联网、IT 运维监控等场景设计并优化，具有极强的弹性伸缩能力，高并发，低延迟。FluxMQ能大幅度的减小物联网系统搭建过程中的复杂度，降低研发和运维成本，是一个物联网平台的基础且重要的组件。多协议连接多协议支持：支持M...
国产化服务器内网安装onlyoffice
仅此而已
08-07 6122
国产化服务器安装onlyoffice
消息队列产品RabbitMQ、RocketMQ、Kafka的比较
万里归来少年心
11-21 1417
1.RabbitMQ RabbitMQ用Erlang语言编写，最早是为电信系统间的可靠通信设计的。 优点： （1）轻量级，迅捷，容易部署和使用，是应用最广泛的消息中间件之一。 （2）灵活的路由配置。它在生产者和队列之间增加了一个Exchange模块，根据配置的路由规则将生产者发出的消息分发到不同的队列中。 （3）每秒可以处理几万到几十万条消息，可以支撑绝大多...
RabbitMQ的替代方案
qq_31195821的博客
04-29 1472
业务背景：数据库分库分表，涉及多个子系统以及分片区的数据更新，往往不能直接操作数据库，http请求也会造成单点故障，通过网关又会拉长整体业务链路。 技术背景：springboot体系 问题描述：各业务子系统可以通过微服务请求到pub子系统，但是由于内部系统架构，禁止pub依赖子系统，所以往往一些多子系统消息通讯采取的是主流的RabbitMq或者kafka等。由于公司的产品面对的是不同的银行，考虑到后续银行会存在使用不同的中间件的情况，这样系统兼容不同中间件成本会加大，所以本文章介绍此种情况如果替代Rabbi
中间件到底是什么？
AChaiYA的博客
09-12 343
看狂神说笔记 1. ActiveMq 2. rabbitmq 开源的，spring一个厂商.（滴滴美团），持久化 机制完善! 应用领域广泛。 3. kafaka 接近底层 ，不支持事务。 4. rocketmq 国产化的mq 中间件 实现mysql 集群高可用 必须用第三方的中间件来实现 数据库中间件 Mycat sharding.jdbc go语言开发 ：在并发场景很高 ...
【大厂消息队列】面试解析(2)-MQ选型
JavaEdge全是干货的技术号
07-29 2021
02 | 该如何选择消息队列？ 2019-07-25 李玥 你好，我是李玥。这节课我们来聊一下几个比较常见的开源的消息队列中间件。如果你正在做消息队列技术选型，不知道该选择哪款消息队列，你一定要先听一下这节课的内容。 1 MQ选型的标准 开源 如果你使用的消息队列遇到影响业务的Bug，可以修改源代码，而非一味地等待软件提供商猴年马月发布的下个版本解决。 生态好 只要你的使用场景不冷门，你遇到Bug的概率非常低，因为大部分你可能遇到的，其他人早就遇到并且修复。使用过程中遇到的一些问题，也容易在网上搜索到类似的
基于rabbitMQ实现的消息队列（MQ）
10-09
基于rabbitmq实现的消息队列组件，附所有源代码，大家可以放心的使用，可用于商业程序，欢迎大家交流。
Spring学习笔记3之消息队列(rabbitmq)发送邮件功能
09-01
主要介绍了Spring学习笔记3之消息队列(rabbitmq)发送邮件功能的相关资料,非常不错，具有参考借鉴价值，需要的朋友可以参考下
消息队列+RabbitMQ3.12.10和Erlang安装包
01-02
包含了rabbitMQ3.12.10安装包和Erlang26.0.2安装包（Windows版）。
消息队列RabbitMQ示例6种模式
01-22
简单模式：生产者与消费者 Work模式：发布者与3个订阅者 Topic交换机：生产者与3个消费者 Fanout交换机：生产者与2个消费者 Direct交换机：产生者与两个消费者 RPC远程回调：客户端与服务端
MQ消息队列之——RabbitMQ
06-01
学习RabbitMQ的学习笔记
NanoMQ 国产开源工业物联网 IIoT 边缘场景中轻量级、高性能 MQTT 网关
07-23 2291
NanoMQ 是于 2021 年初发布的边缘计算开源项目，是面向物联网边缘计算场景的下一代轻量级高性能 MQTT 消息服务器。IoT 时代数据是第一生产力，而边缘则是数据诞生的地方。在边缘复杂的网络环境中对数据进行快速汇聚分发，一个高实时、高吞吐的边缘消息总线至关重要。然而由于产业链条长和各垂直行业的历史原因，使得边缘存在协议碎片化和多种消息模式，而且嵌入式环境的算力和功耗也有严格限制。这些问题都...
深入了解 RabbitMQ：高性能消息中间件
热门推荐
唯有努力，方可自信！
10-05 1万+
RabbitMQ 是一个开源的高性能、可扩展、消息中间件（Message Broker），实现了 Advanced Message Queuing Protocol（AMQP）协议，可以帮助不同应用程序之间进行通信和数据交换。RabbitMQ 是由 Erlang 开发的，支持多种编程语言，包括 Java、Python、Ruby、PHP、C# 等。它的核心思想是将发送者（producer）与接收者（consumer）完全解耦，实现异步处理和低耦合度的系统架构。
rabbitmq 和 erlang 的 .rpm文件下载并安装
zhangxinliang0513的博客
09-26 910
6.浏览器登录，账号密码默认都是guest，出现下图，表明无法远程登录，需要修改配置，cd /etc/rabbitmq，这个目录是安装rabbitmq后自动生成的目录，在里面添加一个配置文件，命令：vim rabbitmq.config，进去后按i进行编辑，添加[{rabbit,[{loopback_users,[]}]}]. ，2.安装rabbitmq命令：yum -y install rabbitmq-server-3.11.23-1.suse.noarch.rpm。注意最后的.一定不要漏掉，
RabbitMQ基础知识
qq_29212701的博客
03-28 392
原文链接地址：http://www.cnblogs.com/dwlsxj/p/RabbitMQ.html 一、背景 RabbitMQ是一个由erlang开发的AMQP（Advanced Message Queue ）的开源实现。AMQP 的出现其实也是应了广大人民群众的需求，虽然在同步消息通讯的世界里有很多公开标准（如 COBAR的 IIOP ，或者是 SOAP 等），但是在异步消息处理中却...
消息队列笔记
你知道的越多，你不知道的越多
12-07 715
消息队列笔记 ​ 本文部分图片摘自极客课程：消息队列高手课；部分概念摘自维基百科。 消息队列的概念 ​ 任何技术的出现都是为了解决某个问题，消息队列是为了解决应用之间通信的需求，但是又不仅仅是这个需求。 ​ 那么消息队列是什么，有什么作用呢？ ​ 举个例子来说，就比如现在网购这么发达，最开始的快递行业是送货上门，你有个快递，快递小哥就会送到你家门口。但是问题来了，家里不一定有人啊。快递小哥就会直接把快递放在家门口，然后给你发个短信——xxx单号的快递放你家门口了，记得签收一下。如果没什么意外你下班回到家拿
消息队列-RabbitMQ
09-14
RabbitMQ是一个开源的消息队列系统，它实现了高效的消息传递机制。它使用AMQP（Advanced Message Queuing Protocol）作为通信协议，并提供了可靠的消息传递、灵活的路由方式和强大的消息模式支持。 通过RabbitMQ，应用程序可以在不同的组件之间异步地发送和接收消息。它可以处理大量的消息，并确保它们按照指定的规则进行路由、持久化和传递。 RabbitMQ的核心概念是生产者、消费者和队列。生产者负责发送消息到队列，消费者从队列中接收消息并进行处理。队列是消息的缓冲区，它存储了等待被消费的消息。 RabbitMQ还支持各种高级特性，如消息确认、持久化、事务、优先级队列等。它可以与各种编程语言和平台进行集成，并广泛应用于分布式系统、微服务架构、异步任务处理等场景中。 总之，RabbitMQ是一个功能强大、可靠性高的消息队列系统，可以帮助应用程序实现解耦、提高性能和可扩展性。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

benboerdong

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值