RabbitMQ学习总结

最新推荐文章于 2024-04-22 07:19:48 发布
最新推荐文章于 2024-04-22 07:19:48 发布
阅读量207 收藏
点赞数
原文链接：http://www.cnblogs.com/lonelyxmas/p/10336460.html
版权
RabbitMQ学习总结
原文: RabbitMQ学习总结

关于RabbitMQ是什么以及它的概念，不了解的可以先查看一下下面推荐的几篇博客

https://blog.csdn.net/whoamiyang/article/details/54954780

https://www.cnblogs.com/frankyou/p/5283539.html

https://blog.csdn.net/mx472756841/article/details/50815895

官网介绍：http://www.rabbitmq.com/getstarted.html

本文github源码：http://www.cnblogs.com/bluesummer/p/8992225.html

因为之前不了解交换机及AMQP协议，上来就研究RabbitMQ，很多概念都有点蒙圈，所以建议大家在学习RabbitMQ之前先对一些概念有基本的了解

安装与配置：

服务相关命令

  • rabbitmq-plugins enable rabbitmq_management //开启管理插件
  • rabbitmq-service.bat start //开启服务
  • rabbitmq-service.bat stop //关闭服务
  • rabbitmqctl list_queues //查看任务

注意在执行命令rabbitmqctl list_queues时若报错unable to perform an operation on node。。。。，可将C:\Users\用户名\.erlang.cookie.erlang.cookie文件拷贝到C:\Windows\System32\config\systemprofile\.erlang.cookie中替换，然后重启服务

至此RabbitMQ服务我们已经安装好了

后台管理

开启管理插件后我们重启rabbitmq服务，打开http://localhost:15672/后台管理界面，
用户名和密码均为guest

guest账户在最新版本只能通过localhost登陆了，如果想要通过ip来登陆需要设置一下配置文件：

找到/rabbitmq_server-x.x.x/ebin下面的rabbit.app文件文件： 找到：loopback_users将里面的<<”guest”>>删除。

删除后的内容为：{loopback_users, []}，然后重启服务

关于用户密码管理的操作我们都可以在管理页面中设置

默认端口：

  1. client端通信口5672
  2. 管理口15672
  3. server间内部通信口25672
  4. erlang发现口：4369

想要修改默认端口可修改 安装目录下 etc/rabbitmq.config文件，有个默认的example，改一改就可以了

发送消息

我们先构建一个应用程序，建议创建一个winform或wpf程序，控制台在这里并不太好用。
项目中引用nuget包：RabbitMQ.Client

接下来我们编写一个发送消息和接收消息的代码：

  public void SendMsg(string message)
    {
        //这里的端口及用户名都是默认的，可以直接设置一个hostname=“localhost”其他的不用配置
        var factory = new ConnectionFactory() { HostName = "192.168.1.15",Port=5672,UserName= "guest",Password= "guest" };
        //创建一个连接，连接到服务器：
        using (var connection = factory.CreateConnection())
        {
            using (var channel = connection.CreateModel())
            {
                //创建一个名称为hello的消息队列
                //durable:队列持久化，为了防止RabbitMQ在退出或者crash等异常情况下数据不会丢失，可以设置durable为true
                //exclusive：排他队列,只对首次声明它的连接（Connection）可见，不允许其他连接访问，在连接断开的时候自动删除，无论是否设置了持久化
                //autoDelete：自动删除，如果该队列已经没有消费者时，该队列会被自动删除。这种队列适用于临时队列。
                channel.QueueDeclare(queue: "hello", durable: false, exclusive: false, autoDelete: true, arguments: null);
                //channel.BasicConsume("hello", autoAck: true);
               
                var props = channel.CreateBasicProperties();
                //消息持久化，若启用durable则该属性启用
                props.Persistent = true;
                //封装消息主体
                var body = Encoding.UTF8.GetBytes(message);

                channel.BasicPublish(exchange: "", routingKey: "hello", basicProperties: props, body: body);
                Console.WriteLine(" 发送消息{0}", message);
            }
        }
    }
    
     public class Consumer : IDisposable
    {
        public static int _number;
        private static ConnectionFactory factory;
        private static IConnection connection;
        static Receive()
        {
            factory = new ConnectionFactory() { HostName = "localhost" };
        }
        public Receive()
        {
            _number++;
        }
        public void ReceiveMsg(Action<string> callback)
        {
            if(connection==null||!connection.IsOpen)
                connection = factory.CreateConnection();
            IModel _channel = connection.CreateModel();
            _channel.QueueDeclare(queue: "hello", durable: false, exclusive: false, autoDelete: true, arguments: null);
            _channel.BasicQos(prefetchSize: 0, prefetchCount: 1, global: false);
            // 创建事件驱动的消费者
            var consumer = new EventingBasicConsumer(_channel); 
            consumer.Received += (model, ea) =>
            {
                var body = ea.Body;
                var message = Encoding.UTF8.GetString(body);
                callback($"number:{_number}.message:{message}");
                //模拟消息处理需要两秒
                Thread.Sleep(2000);
                //显示发送ack确认接收并处理完成消息，只有在前面进行启用显示发送ack机制后才奏效。
                _channel.BasicAck(ea.DeliveryTag, false);
            };
            //指定消费队列,autoAct是否自动确认
            string result = _channel.BasicConsume(queue: "hello", autoAck: false, consumer: consumer);

            //设置后当所有的channel都关闭了连接会自动关闭
            //connection.AutoClose = true;
        }
        public void Dispose()
        {
            if (connection != null && connection.IsOpen)
                connection.Dispose();
        }
    }

上面一个很简单的消息队列的发送者和消费者，解释下基本的流程：

Publisher中调用send函数先创建一个连接到服务器，然后用该连接创建了一个channel，接着用该channel声明了一个hello的队列，最后向默认的交换机发送了一条消息。（exchange: ""） 空字符串即为默认的交换机 ，消息的路由为hello ，默认的交换机是direct类型，根据路由名称完全匹配队列的名称。所有的队列都会绑定到默认的交换机上,路由名称就是队列的名称。所以默认的交换机将消息发送到名声为hello 的队列。紧接着Consumer中调用ReceiveMsg 函数从hello 队列获取消息，获取到消息后调用act函数通知broker该消息已经被成功地消费，broker将这条消息删除，如下图
1017082-20180507104150158-341702593.png

网上有部分示例是使用QueueingBasicConsumer来创建消费者的，我发现在新版本中已经过时了，原因是它容易造成内存溢出性能降低等一系列的问题,简单说一下QueueingBasicConsumer的处理流程，它接收到消息之后会把消息塞到一个Queue队列中，然后用户来循环这个队列处理消息，但是如果你一个消息处理的很慢，而消息又发送过来的很快很大，就会造成队列里面存的消息越来越多，最终造成内存溢出。所以现在推荐使用EventingBasicConsumer或者继承DefaultBasicConsumer来创建消费者，事件驱动就不会有这个问题了

上面的代码需要注意以下几点：

  1. 想要通过guest账户指定ip连接需要修改loopback_users配置
  2. 我们调用QueueDeclare函数声明一个队列，如果设置了队列持久化，即使重启服务队列仍然在。如果不是持久化，即使消息全都被消费了，只要服务没有重启，队列仍然存在。RabbitMQ不允许你使用不同的参数重新定义一个已经存在的队列，所以要么删除队列要么重新命名一个队列，删除队列可以通过管理界面来删除或者调用QueueDelete函数。
  3. 队列如果存在声明一次就够了，如果多次声明了一样的队列将不会有任何异常，但是如果消费者绑定了一个不存在的队列是会发生异常的:**_channel.BasicConsume**，所以习惯是在Woker中将需要监听的队列先声明一遍
  4. 排他队列：大概意思就是通过连接connectionA声明一个排他队列之后，以后也只能通过连接connectionA来访问该队列，其他连接一旦访问就会报队列被锁定的错误，这个实在想不到应用场景
  5. 队列持久化代表的是重启服务后队列仍然在，想要队列里的消息仍然存在需要同时设置消息持久化，但是如果只设置消息持久化不设置队列持久话也没有意义。但这也并不一定能保证消息一定不会丢失。首先必须要有消息确认机制来保证消息一定被正确消费了。最主要的问题是消息写入到磁盘需要一定的时间，如果服务接收到消息没有来得及写入磁盘就挂掉了，那么这个消息就丢失了，对于这一点可以查询一下RabbitMQ集群相关的文章
  6. 默认发送的消息都需要消费者确认，可以通过设置autoAct为true来自动确认消息，也可以调用BasicAck函数确认，总之如果消息需要确认，一定要在消息处理完成之后进行确认。如果当前消费者未确认的消息达到了perfetchCount的数量时，该消费者便无法再接收新的消息。 当消费者连接关闭之后未被确认的消息很快就会被退回。
  7. 可以通过BasicNack()函数将消息重新塞回队列，如果消息未确认消费者断开链接，消息也会退回。需要注意的是：如果不是因为程序异常而仅仅是因为业务逻辑上的错误，则不应该手动退回消息，否则退回的消息永远也无法被消费掉
  8. 我上面定义的消费者原本是想要多次实例化Receive来模拟多个消费者的，然而事实证明并不好用，想要模拟多个消费者还是需要打开多个程序
  9. EventingBasicConsumer的监听会创建一个前台线程一直在运行，所以在winform中如果关闭程序需要dispose掉connection占用的线程

轮询调度

轮询调度就是同时运行多个消费者，当任务数量很多的时候RabbitMQ会将消息分发给不同的消费者（Worker）来减轻压力，想要让RabbitMQ公平的分发任务，需要在worker中用以下代码来设置一个worker的最大未确认消息数量

channel.BasicQos(0, 1, false);

BasicQos方法接收三个参数：

prefetchSize：消费者接收消息的长度，如果长度在小于等于设定值，则接收，如果设置0，则不限消息长度

prefetchCount：消费者可同时缓存的最大消息数量，假设数值设为2，那么队列会向该woker推送两条消息，直到该Woker处理了该消息（处理指的是Act或者nack），队列才会再次向该woker推送新的消息。

上面的势力中，参数prefetchCount=1就代表此Worker同时只会处理一条消息，如果当前的消息没有处理完毕（没有act），rabbitmq就会把剩下的任务发送给其他的worker，如果所有的worker都很忙，消息久会在队列中排队等待

绑定

上面的一个示例中我们用的是默认的交换机发送消息，我们可以通过给exchange赋值来使用指定的交换机，通过QueueBind将交换机与队列进行绑定

_channel.QueueBind("log1", "logs", "info");

声明一个交换机的代码如下

_channel.ExchangeDeclare("logs", ExchangeType.Direct, false, false);

我们将队列log1绑定到了交换机：logs上，路由为info，交换机的类型为Direct，Direct代表的是路由完全匹配，现在我们向logs交换机发送一条消息，路由为info，队列log1就会接收到消息了

channel.BasicPublish(exchange: "logs", routingKey: "info", basicProperties: props, body: body);

队列和交换机的关系是多对多的，交换机的类型常用的有三个：Direct，Fanout，Topic，Headers

Direct：要求路由键完全匹配

Fanout：忽略路由键，给所有绑定到交换机上的队列都发送消息

Topic：模糊匹配，通过字母配合符号“*”和“#”来设置路由键

Headers：Headers类型用的比较少，它也忽略路由键，而是匹配交换机的headers，headers为键值对的hashtable，对publisher和consumer两边设置的header进行匹配，需要指定匹配的方式是 all还是any，具体代码可看github

下面展示了一个使用direct类型交换机的相关代码

public class LogDirectPub
{
    public void SendMsg(string message)
    {
        var factory = new ConnectionFactory() { HostName = "192.168.1.15", Port = 5672, UserName = "guest", Password = "guest" };
        //创建一个连接，连接到服务器：
        using (var connection = factory.CreateConnection())
        {
            using (var channel = connection.CreateModel())
            {
                var props = channel.CreateBasicProperties();
                var body = Encoding.UTF8.GetBytes(message);
                channel.BasicPublish(exchange: "logs", routingKey: "info", basicProperties: props, body: body);
                channel.BasicPublish(exchange: "logs", routingKey: "error", basicProperties: props, body: body);
                Console.WriteLine("发送消息{0}", message);
            }
        }
    }
}


public class LogDirectConsumer : IDisposable
{
    private static ConnectionFactory factory;
    private static IConnection connection;
    static LogDirectConsumer()
    {
        factory = new ConnectionFactory() { HostName = "localhost" };
    }
    public void ReceiveMsg(Action<string> callback)
    {
        if (connection == null || !connection.IsOpen)
            connection = factory.CreateConnection();
        IModel _channel = connection.CreateModel();
        _channel.ExchangeDeclare("logs", ExchangeType.Direct, false, false);
        _channel.QueueDeclare(queue: "log1", durable: false, exclusive: false, autoDelete: false, arguments: null);
        _channel.QueueBind("log1", "logs", "info");
        _channel.QueueBind("log1", "logs", "error");
        _channel.BasicQos(prefetchSize: 0, prefetchCount: 1, global: false);
        var consumer = new EventingBasicConsumer(_channel);
        consumer.Received += (model, ea) =>
        {
            var body = ea.Body;
            var message = Encoding.UTF8.GetString(body);
            callback($"log1Write.message:{ea.RoutingKey}:{message}");
            //模拟消息处理需要两秒
            Thread.Sleep(2000);
            _channel.BasicAck(ea.DeliveryTag, false);
        };
        string result = _channel.BasicConsume(queue: "log1", autoAck: false, consumer: consumer);
    }
    public void Dispose()
    {
        if (connection != null && connection.IsOpen)
            connection.Dispose();
    }
}

RabbitMQ Management HTTP API

RabbitMQ有一套自己的http/api,地址为http://192.168.1.15:15672/api，可以查询你想查的所有信息配置，通过这些api，我们可以自己实现RabbitMQ的监控管理，英文看的头痛，这里有一篇中文的翻译文档：http://www.blogjava.net/qbna350816/archive/2016/08/13/431575.html

这是一个获取所有队列的简单示例：

    string username = "guest";
    string password = "guest";
    string queuesUrl = "http://localhost:15672/api/queues";
    /// <summary>
    /// 查询所有队列
    /// </summary>
    /// <returns></returns>
    public string GetAllQuenes()
    {
        string jsonContent = GetApiResult(queuesUrl).Result;
        List<QueueModel> queues = JsonConvert.DeserializeObject<List<QueueModel>>(jsonContent);
        return JsonConvert.SerializeObject(queues);
    }

    private async Task<string> GetApiResult(string Url)
    {
        var client = new HttpClient();
        var passByte = Encoding.UTF8.GetBytes(string.Format("{0}:{1}", username, password));
        client.DefaultRequestHeaders.Authorization = new System.Net.Http.Headers.AuthenticationHeaderValue("Basic", Convert.ToBase64String(passByte));
        using (HttpResponseMessage response = await client.GetAsync(Url).ConfigureAwait(false))
        {
            string result = await response.Content.ReadAsStringAsync().ConfigureAwait(false);
            return result;
        }
    }

自定义Consumer

之前说过用QueueingBasicConsumer会有性能问题，但是eventconsumer无法阻塞线程，对于某些需要阻塞线程的功能用起来不太方便，这时我们就可以自定义一个Consumer继承DefaultBasicConsumer，只需要实现其中的HandleBasicDeliver函数就可以了，下面是我定义的一个consumer，用来实现后面的Rpc客户端

public class QueueingConsumer : DefaultBasicConsumer
{
    private IModel _channel;
    private BasicDeliverEventArgs args = new BasicDeliverEventArgs();

    private AutoResetEvent argResetEvent = new AutoResetEvent(false);
    public QueueingConsumer(IModel channel)
    {
        _channel = channel;
    }
    public override void HandleBasicDeliver(string consumerTag,
       ulong deliveryTag,
       bool redelivered,
       string exchange,
       string routingKey,
       IBasicProperties properties,
       byte[] body)
    {
        args = new BasicDeliverEventArgs
        {
            ConsumerTag = consumerTag,
            DeliveryTag = deliveryTag,
            Redelivered = redelivered,
            Exchange = exchange,
            RoutingKey = routingKey,
            BasicProperties = properties,
            Body = body
        };
        argResetEvent.Set();
    }

    public void GetResult(Action<BasicDeliverEventArgs> callback)
    {
        argResetEvent.WaitOne();
        callback(args);
    }

}

RPC实现

Rpc是什么不用多说了,反正我也就知道他是远程过程调用嘛。用RabbitMQ来实现Rpc，官网有一篇简单的示例，但个人感觉RabbitMQ并不太适合做Rpc。不过用这个示例作为对RabbitMQ的一个学习成果实践还是蛮不错的，下面请看代码：

public class RpcPub
{
    public async Task<string> SendMsg(string message)
    {
        ConnectionFactory factory = RabbitMQHelper.ConFactory;
        //创建一个连接，连接到服务器：
        using (var connection = factory.CreateConnection())
        {
            using (var channel = connection.CreateModel())
            {
                //定义一个临时的队列，用来接收返回的消息
                string replyQueueName = channel.QueueDeclare().QueueName;
                var consumer = new QueueingConsumer(channel);
                //监听该临时队列，自动act消息
                channel.BasicConsume(queue: replyQueueName, autoAck: true, consumer: consumer);


                string corrId = Guid.NewGuid().ToString();
                var props = channel.CreateBasicProperties();
                //定义ReplyTo让服务端知道返回消息给哪个路由
                props.ReplyTo = replyQueueName;
                //定义CorrelationId作为消息的唯一关联ID
                props.CorrelationId = corrId;

                var messageBytes = Encoding.UTF8.GetBytes(message);
                channel.BasicPublish(exchange: "", routingKey: "rpc_queue", basicProperties: props, body: messageBytes);
                Task<string> result = new Task<string>(() =>
                {
                    while (true)
                    {
                        string replystr = string.Empty;
                        consumer.GetResult((args) =>
                        {
                            if (args.BasicProperties.CorrelationId == corrId)
                            {
                                replystr = Encoding.UTF8.GetString(args.Body);
                            }
                        });
                        if (replystr != string.Empty)
                            return replystr;
                    }
                });
                result.Start();
                return await result;
            }
        }
    }
}


public class RpcConsumer : IDisposable
{

    private ConnectionFactory factory = RabbitMQHelper.ConFactory;
    private IConnection connection;


    public void ReceiveMsg(Action<string> callback)
    {
        if (connection == null || !connection.IsOpen)
            connection = factory.CreateConnection();
        IModel channel = connection.CreateModel();

        channel.QueueDeclare(queue: "rpc_queue", durable: false, exclusive: false, autoDelete: false, arguments: null);
        //channel.BasicQos(0, 1, false);
        var consumer = new EventingBasicConsumer(channel);

        consumer.Received += (model, arg) =>
        {
            var props = arg.BasicProperties;
            var replyProps = channel.CreateBasicProperties();
            replyProps.CorrelationId = props.CorrelationId;
            callback($"接收到消息：{Encoding.UTF8.GetString(arg.Body)}");
            var responseBytes = Encoding.UTF8.GetBytes($"成功接收你的消息：{ Encoding.UTF8.GetString(arg.Body)}");
            channel.BasicPublish(exchange: "", routingKey: props.ReplyTo, basicProperties: replyProps, body: responseBytes);
            channel.BasicAck(deliveryTag: arg.DeliveryTag, multiple: false);
        };
        channel.BasicConsume(queue: "rpc_queue", autoAck: false, consumer: consumer);

    }
    public void Dispose()
    {
        if (connection != null && connection.IsOpen)
            connection.Dispose();
    }

}
基本流程：
  1. 当客户端发送消息之前，创建一个匿名的回调队列channel.QueueDeclare()，并监听该队列。
  2. 客户端获取匿名队列的名称，在请求中设置2个属性：replyTo=回调队列名称；CorrelationId=请求关联的唯一id
  3. 客户端发送请求到rpc_queue队列中。
  4. RPC服务器端监听rpc_queue队列中的请求，当请求到来时，服务器端会处理消息，返回结果发送到replyTo指定的队列，在请求中设置1个属性：CorrelationId=请求过来的CorrelationId
  5. 客户端监听的队列收到消息，检查correlationId是否与之前生成的匹配，匹配成功返回结果。
  6. 对于为什么要验证correlationId这一项，有两个原因，1.消息可能并不是rpc服务器发送的 2.rpc服务如果在某个阶段突然挂掉，可能会发送一个不包含correlationId的消息

1017082-20180508125549395-1904353458.png

publish confirm

在消费端可通过消息确认机制来保证队列的正常消费 ，在服务端可通过数据持久化到磁盘保证数据的不丢失 ，发送端同样可以使用publish confrim机制来保证数据的正确发送

confirm有普通模式WaitForConfirms和批量模式WaitForConfirmsOrDie

具体流程为：标记该消息需要confirm，发送消息，等待confirm结果。一个保证消息可靠性的相关代码体现为：

var props = channel.CreateBasicProperties();
props.Persistent = true;
var body = Encoding.UTF8.GetBytes("hi");
channel.ConfirmSelect();
channel.BasicPublish(exchange: "ali", routingKey: "ali.point", mandatory: true, basicProperties: props, body: body);
//获取rabbitmq服务返回的消息
channel.BasicReturn += Channel_BasicReturn;
try
{
    bool pubAct = channel.WaitForConfirms();
    if (!pubAct)
        Console.WriteLine("消息发送失败");
}
catch (Exception)
{
    Console.WriteLine("消息发送失败");
}

用了confirm机制之后，发送一条消息会遇到以下几种情况：

1.消息成功发送到交换机，成功匹配到队列，pubAct=true
2.消息成功发送到交换机，没有队列绑定该路由，pubAct=true。 此时如果设置mandatory=true，则会触发BasicReturn事件，通知路由未匹配到任何队列，如果mandatory=false，消息直接抛弃
3.交换机名称未定义，或消息发送失败，抛出异常
4.消息成功发送到交换机之后，尚未持久化到磁盘，pubAct=false （尚未验证，消息确认失败的情况不太容易模拟，所以这条结论不一定准确）

posted on 2019-01-30 00:12 NET未来之路 阅读( ...) 评论( ...) 编辑 收藏

转载于:https://www.cnblogs.com/lonelyxmas/p/10336460.html

weixin_30852419
关注
RabbitMQ学习总结（9）——RabbitMQ 核心知识点再总结
科技D人生
08-05 742
一、核心概念 server：又称broker，接受客户端连接，实现AMQP实体服务。 connection：连接和具体broker网络连接。 channel：网络信道，几乎所有操作都在channel中进行，channel是消息读写的通道。客户端可以建立多个channel，每个channel表示一个会话任务。 message：消息，服务器和应用程序之间传递的数据，由properties和body组成。properties可以对消息进行修饰，比如消息的优先级，延迟等高级特性；
RabbitMQ学习总结（8）——RabbitMQ后台管理控制台页面属性总结
科技D人生
07-29 2171
一、 RabbitMq Web rabbitmq-management是RabbitMq web管理端，用的是erlang的cowboy框架进行开发。web页面包括Overview(概述)、Connections(连接)、Channels(通道)、Exchanges(交换器)、Queues(队列)、Admin(用户管理)。 二、Overview(概述) 2.1、overview->...
WPF使用MassTransit组件正确消费RabbitMQ队列的正确姿势
dacong的专栏
07-10 921
WPF（winform）使用MassTransit组件正确消费RabbitMQ队列的正确姿势。 可更新UI页面，自动通知。 思路：传统实现消费IConsumer接口，采用new窗体来消费。 关键代码： var win2 = new Window1(); cfg.ReceiveEndpoint(host, "customer_update_queue", e =&gt...
C# WPF RabbitMq收发消息实例解析
zls365365的博客
03-09 408
概述 在项目开发中rabbitmq常用来进行消息收发，这节我通过一个简单的实例来演示在C#中如何进行应用rabbitmq.首先要在nuget上引用rabbitmq.client：如下图最终的效果图：源码讲解 前台XMAL:<UserControl x:Class="Caliburn.Micro.Hello.Views.RabbitMqView" xm...
[c#]RabbitMQ的简单使用
weixin_34244102的博客
09-11 316
摘要 Message Queue消息队列，简称MQ，是一种应用程序对应用程序的通信方法，应用程序通过读写出入队列的消息来通信，而无需专用连接来链接它们。消息传递指的是程序之间通过在消息中发送数据进行通信，而不是通过直接调用彼此通信。 MQ是消费-生产者模型的一个典型代表，一端往消息队列中不断写入消息，而另一端则可以读取或者订阅队列中的消息。 安装 官网地址：http://www.rabbi...
rabbitmq（二）简单测试
monkey131499的博客
02-23 732
1.下载rabbitmq的javaClient库 文件名：rabbitmq-client.jar 下载地址：http://download.csdn.net/detail/monkey131499/9440572 下载后将文件导入到项目中。 2.消息发送类 import java.io.IOException; import java.util.concurrent.T
C# RabbitMQ使用--动态更新
Blue
02-23 682
C# RabbitMQ使用--动态更新
RabbitMQ学习总结（1）——基础概念详细介绍
科技D人生
12-18 5153
1、Windows下RabbitMQ的安装 下载Erlang，地址：http://www.erlang.org/download/otp_win32_R15B.exe ，双击安装即可（首先装） 下载RabbitMQ，地址：http://www.rabbitmq.com/releases/rabbitmq-server/v3.3.4/rabbitmq-server-3.3.4.exe ，
RabbitMQ学习总结（7）——Spring整合RabbitMQ实例
科技D人生
12-21 4925
一、RabbitMQ简介 RabbitMQ是流行的开源消息队列系统，用erlang语言开发。RabbitMQ是AMQP（高级消息队列协议）的标准实现。 官网：http://www.rabbitmq.com/ 二、Spring集成RabbitMQ 2.1、maven配置 //pom.xml <dependency> <groupId>com.rabbi...
生产者消费者问题C#
12-25
生产消费者问题，用C#控制台编写，希望对大家有用吧~
WPF实现MSMQ的接收和发送
03-01
使用MSMQ开发分布式应用 　　首先，实现服务器端。创建一个控制台项目，添加System.Messaging引用，因为消息队列的类全部封装在System.Messaging.dll程序集里。 界面采用WPF开发
C#之RabbitMQ系列（三）--Work Queues
by_ron的专栏
01-08 1677
工作队列 使用场景：Work Queue被用以处理大量耗时任务，与其等待任务处理完毕耗费大量cpu资源，还不如立即返回并交由代理worker随后处理message。 消息持久化 生产者和消费者的代码和上一节Publish-Consumer基本相同，唯一不同的是配置项的参数调整。代码如下： using System; using System.Collections.Gene
RabbitMQ实现收发消息
weixin_44809056的博客
03-23 2369
RabbitMQ实现收发消息 1 环境准备 1.1 安装Erlang 官方下载地址：http://www.erlang.org/downloads 注意： 在搭建RabbitMQ环境过程中，由于版本问题导致环境一直搭建不起来，以下是RabbitMQ与Erlang的版本对应关系 RabbitMQ版本 Erlang最低要求 Erlang最高要求 3.7.7 - 3.7.12 20.3.x 21.x 3.7.0 - 3.7.6 19.3 20.3.x 1.2 配置环境变量 1.3
RabbitMQ入门（一）——RabbitMQ的安装以及使用(Windows环境下)
晓太白的博客
02-26 4万+
一、RabbitMQ介绍 1、RabbitMQ简介 RabbitMQ是一个消息代理：它接受和转发消息。你可以把它想象成一个邮局：当你把你想要发布的邮件放在邮箱中时，你可以确定邮差先生最终将邮件发送给你的收件人。在这个比喻中，RabbitMQ是邮政信箱，邮局和邮递员。 RabbitMQ和邮局的主要区别在于它不处理纸张，而是接受，存储和转发二进制数据块 - 消息。引自（https://www...
分布式异步队列学习总结4(生产者和消费者)
每天学习一点点
08-28 603
生产者向RabbitMQ服务发送消息，消费者从RabbitMQ服务中获取消息。 单生产者单消费者模式 使用程序演示单生产者和单消费者模型： 项目结构为两个.net Core 控制台程序应用程序 程序需要添加引用 RabbitMQ.Client AspNetCore.RabbitMQ.MessageConsumer_01.MessageConsumer： using RabbitMQ.Client; using RabbitMQ.Client.Events; using S.
activemq之MessageConsumer.receive方法
johnhuster的专栏
08-15 6714
activemq提供的客户端分离了消息的读取以及接收，以Queue模式为例，这其中的中介就是ActiveMQMessageConsumer的unconsumedMessages属性(MessageDispatchChannel unconsumedMessages，该属性存储了将要被发送的消息)，下面就以ActiveMQMessageConsumer：receive为例来说明读取消息：     ...
.NET 6 项目整合RabbitMQ实现-应用场景与模式结合实战
最新发布
m0_65664914的博客
04-22 2032
RabbitMQ是一个开源的消息中间件，用于在分布式系统中传递和存储消息。它实现了高级消息队列协议（AMQP），提供了可靠的消息传递机制。RabbitMQ基于生产者-消费者模型，其中生产者将消息发送到队列中，而消费者从队列中接收并处理消息。它支持多种消息传递模式，包括点对点、发布/订阅和请求/响应模式。一次向许多消费者发送消息，一个生产者发送的消息会被多个消费者获取，也就是将消息将广播到所有的消费者中。
RabbitMQ Consumer获取消息的两种方式(poll,subscribe)解析
热门推荐
云计算、分布式架构、K8S、大数据、机器学习、搜索、推荐、广告
09-01 5万+
Producer和Queue Consumer和Queue 长连接
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值