RabbitMQ使用

已于 2022-06-18 16:37:02 修改
阅读量1.3k 收藏
点赞数 1
分类专栏： 消息队列 后端 反射 文章标签： rabbitmq
于 2021-12-24 11:28:53 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43535970/article/details/122124086
版权
后端 同时被 3 个专栏收录
8 篇文章 0 订阅
订阅专栏
消息队列
4 篇文章 0 订阅
订阅专栏
反射
3 篇文章 0 订阅
订阅专栏

**

摘要

**
为帮助大家更为详细的了解RabbitMQ，本文会将配置以及消息发送接收的代码一并写出如下：

消息发送：

using GD.HTSupervisionModel.ApiModel;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using OracleToMySQL.Common;
using RabbitMQ.Client;
using RabbitMQ.Client.Events;
using System;
using System.Collections.Generic;
using System.Data;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading;
using System.Threading.Tasks;

namespace OracleToMySQL.OracleToMySqlBLL
{
    public class GetOracleTableServices
    {
        IModel channel;
        IConnection Connection;
        string DirectoryPath = "../PageParams";
        MsgCenter msgCenter = new MsgCenter();
        public List<string> TableList = new List<string>();
        public IFreeSql dbContextO = StaticVariable.DBContext[StaticVariable.Oracle];
        public IFreeSql dbContextM = StaticVariable.DBContext[StaticVariable.MySql];
        ConnectionFactory Factory = new ConnectionFactory()
        {
            HostName = "localhost",//主机名，Rabbit会拿这个IP生成一个endpoint，这个很熟悉吧，就是socket绑定的那个终结点。
            UserName = "guest",//默认用户名,用户可以在服务端自定义创建，有相关命令行
            Password = "guest"//默认密码
        };
        
        /// <summary>
        /// 入口
        /// </summary>
        public GetOracleTableServices()
        {
            ServiceInit();
            Console.ReadKey();
        }

        /// <summary>
        /// 初始化
        /// </summary>
        private void ServiceInit()
        {
            var fileNames = GetFilesName(new DirectoryInfo(Readjson("filePath"))).Select(x => x.TrimEnd(".cs".ToCharArray())).ToList();

            IEnumerable<string> queueList = GetTableName().Intersect(fileNames);

            Connection = Factory.CreateConnection();    //连接服务器，即正在创建终结点。

            channel = Connection.CreateModel();

            channel.ExchangeDeclare(msgCenter.ExchangeName, "topic", true, false, null);

            foreach (var queue in queueList)
            {
                channel.QueueDeclare(queue, true, false, false, null);//创建一个名称为kibaqueue的消息队列
                channel.QueueBind(queue, msgCenter.ExchangeName, queue);    //  绑定队列至交换机
                //chanel.QueueDelete(tableName, false, false);    //清空全部队列

                Task.Factory.StartNew(() =>
                {
                    var page = GetPageParams(queue);
                    GetDataTable(queue, page);
                });

            }
        }

        /// <summary>
        /// 获取oracle数据库所有用户表
        /// </summary>
        /// <returns></returns>
        public IEnumerable<string> GetTableName()
        {
            return dbContextO.Ado.Query<string>("select table_name from user_tables").AsEnumerable();
        }

        /// <summary>
        /// 递归获取文件夹目录下所有文件名
        /// </summary>
        /// <param name="dir">遍历文件夹</param>
        /// <param name="res">返回结果</param>
        /// <returns></returns>
        public List<string> GetFilesName(DirectoryInfo dir, List<string> res = null)
        {
            if (res == null)
            {
                res = new List<string>();
            }
            // 添加当前目录文件
            FileInfo[] finfo = dir.GetFiles();
            for (int i = 0; i < finfo.Length; i++)
            {
                res.Add(finfo[i].Name);
            }
            // 查找是否有下一级目录
            var deepDir = dir.GetDirectories();
            // 有，递归调用
            if (deepDir.Length > 0)
            {
                foreach (var item in deepDir)
                {
                    res = GetFilesName(item, res);
                }
            }
            // 无，返回
            return res;
        }

        /// <summary>
        /// 格式化新旧表属性
        /// </summary>
        /// <param name="dir">遍历文件夹</param>
        /// <param name="res">返回结果</param>
        /// <returns></returns>
        public DataTable FormatObject(DataTable table, List<string> res = null)
        {
            List<string> list = new List<string>();
            for (int i = 0; i < table.Columns.Count; i++)
            {
                list.Add(table.Columns[i].ColumnName);
            }
            Type type = Assembly.Load("Models").GetTypes().FirstOrDefault(t => t.Name == table.TableName);
            if(type != null)
            {
                PropertyInfo[] properinfos = type.GetProperties();
                foreach (var item in properinfos)
                {
                    if (item.Name != "IsChecked" && item.Name != "UpdateColumns")
                    {
                        if (!list.Contains(item.Name))
                        {
                            try
                            {
                                table.Columns.Add(item.Name, item.PropertyType);
                            }
                            catch (Exception)
                            {
                                table.Columns.Add(item.Name, item.PropertyType.GenericTypeArguments[0]);
                            }
                        }
                    }
                }
            }
            return table;
        }

        /// <summary>
        /// 获取文件索引
        /// </summary>
        /// <param name="tableName"></param>
        /// <returns></returns>
        public PageParams GetPageParams(string tableName)
        {
            string filePath = $"{DirectoryPath}/{tableName}.txt";
            if (!Directory.Exists(DirectoryPath))
            {
                Directory.CreateDirectory(DirectoryPath);
            }
            if (!File.Exists(filePath))
            {
                File.CreateText(filePath).Dispose();
                File.WriteAllText(filePath, "PageIndex:1, PageSize:100");
            }
            string pageString = File.ReadAllText(filePath);
            return new PageParams()
            {
                PageIndex = Convert.ToInt32(Regex.Match(pageString, "PageIndex:\\d+").Value.Split(":").Last()),
                PageSize = Convert.ToInt32(Regex.Match(pageString, "PageSize:\\d+").Value.Split(":").Last())
            };
        }

        /// <summary>
        /// 读取表数据
        /// </summary>
        /// <param name="tableName">表名</param>
        /// <returns></returns>
        public async void GetDataTable(string tableName, PageParams pageParams)
        {
            var table=  await getTable(tableName, pageParams);
            int rowsCount = table.Rows.Count;
          
            int count = rowsCount;
            // 数量与分页大小相同，证明表还有数据没有读完
            while (count != 0)
            {
                string filePath = $"{DirectoryPath}/{tableName}.txt";
                if (File.Exists(filePath))
                {
                    string pageString = "";
                    using (StreamReader sr = new StreamReader(filePath))
                    {
                         pageString = sr.ReadToEnd();
                    }
                    using (StreamWriter sw = new StreamWriter(filePath)) {
                        pageParams.PageIndex = Convert.ToInt32(Regex.Match(pageString, "PageIndex:\\d+").Value.Split(":").Last()) + 1;
                        pageParams.PageSize = Convert.ToInt32(Regex.Match(pageString, "PageSize:\\d+").Value.Split(":").Last());
                        sw.Write($"PageIndex:{pageParams.PageIndex}, PageSize:{pageParams.PageSize}");
                        sw.Flush();
                    }
                }
                count = table.Rows.Count;
                if (count > 0)
                {
                    string json = JsonConvert.SerializeObject(table);
                    //var insertSql = GenerateSql(json, tableName);
                    //int result = dbContextM.Ado.ExecuteNonQuery(insertSql);
                    // 发送
                    msgCenter.Content = json;
                    msgCenter.Property = channel.CreateBasicProperties();
                    msgCenter.Property.DeliveryMode = 2;
                    msgCenter.MsgTypeName = tableName;
                    await MsgSender(msgCenter);
                    
                    var methods = msgCenter.Property.GetType().GetMethods();
                    foreach (var method in methods)
                    {
                        try
                        {
                            method.Invoke(null, null);
                        }
                        catch (Exception)
                        {

                            Console.WriteLine("报错啦！");
                        }
                        
                    }

                }
                table = null;
                System.GC.Collect();
                table = await getTable(tableName, pageParams);
                Thread.Sleep(1000);
            }
        }

        /// <summary>
        /// 获取表格数据
        /// </summary>
        /// <param name="tableName"></param>
        /// <param name="pageParams"></param>
        /// <returns></returns>
        async Task<DataTable> getTable(string tableName,PageParams pageParams)
        {
            int startIndex = (pageParams.PageIndex - 1) * pageParams.PageSize;
            int endIndex = pageParams.PageIndex * pageParams.PageSize;
            string pageSql = $"select * from {tableName} where rowid in (select rid from (select rownum rn,rowid rid from {tableName}) where rn > {startIndex} and rn <= {endIndex})";
            var table = await dbContextO.Ado.ExecuteDataTableAsync(pageSql);
            if (tableName == "JGZHXY")
            {
                table.TableName = "JGZHXX";
            }
            else
            {
                table.TableName = tableName;
            }
            table = FormatObject(table);
            for (int i = 0; i < table.Rows.Count; i++)
            {
                for (int j = 0; j < table.Columns.Count; j++)
                {

                    if (string.IsNullOrWhiteSpace(table.Rows[i][table.Columns[j]].ToString()))
                    {
                        if (table.Columns[j].DataType == typeof(DateTime?) || table.Columns[j].DataType == typeof(DateTime))
                        {
                            table.Rows[i][table.Columns[j].ColumnName] = new DateTime(2000, 1, 1);
                        }
                        else if (table.Columns[j].DataType == typeof(char))
                        {
                            table.Rows[i][table.Columns[j].ColumnName] = '0';
                        }
                        else if (table.Columns[j].DataType == typeof(byte[]))
                        {
                            table.Rows[i][table.Columns[j].ColumnName] = Encoding.UTF8.GetBytes("54088");
                        }
                        else if (table.Columns[j].DataType == typeof(Decimal))
                        {
                            table.Rows[i][table.Columns[j].ColumnName] = 123.45;
                        }
                        else
                        {
                            table.Rows[i][table.Columns[j].ColumnName] = "0";
                            if (table.Columns[j].ColumnName.ToUpper() == "tenant_id".ToUpper())
                            {
                                table.Rows[i][table.Columns[j].ColumnName] = "0";
                            }
                            if (table.Columns[j].ColumnName.ToUpper() == "xzqh_id".ToUpper())
                            {
                                table.Rows[i][table.Columns[j].ColumnName] = "0";
                            }
                            //  XMTDSYZ表 ZZSJ字段用的string  但是新数据库用的mysql  有则取最后一条
                            if (tableName == "XMTDSYZ" && table.Columns[j].ColumnName == "ZZSJ" && !string.IsNullOrWhiteSpace(table.Rows[i][table.Columns[j]].ToString()))
                            {
                                table.Rows[i][table.Columns[j].ColumnName] = table.Rows[i][table.Columns[j].ColumnName].ToString().Split(',').Last();
                            }
                        }
                    }
                }
            }
            return table;
        }

        /// <summary>
        /// 读取JSON文件
        /// </summary>
        /// <param name="key">JSON文件中的key值</param>
        /// <returns>JSON文件中的value值</returns>
        public static string Readjson(string key)
        {
            string jsonfile = "../../../appsetting.json";//JSON文件路径

            using (System.IO.StreamReader file = System.IO.File.OpenText(jsonfile))
            {
                using (JsonTextReader reader = new JsonTextReader(file))
                {
                    JObject o = (JObject)JToken.ReadFrom(reader);
                    var value = o[key].ToString();
                    return value;
                }
            }
        }
        
        #region 消息队列
        /// <summary>
        /// 消息队列发送服务
        /// </summary>
        public Task MsgSender(MsgCenter msgCenter)
        {
            channel.BasicPublish(msgCenter.ExchangeName, msgCenter.MsgTypeName, msgCenter.Property, Encoding.UTF8.GetBytes(msgCenter.Content)); //生产消息
            return Task.CompletedTask;
        }
        #endregion

    }
}

消息接收：

using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using OracleToMySQL.Common;
using RabbitMQ.Client;
using RabbitMQ.Client.Events;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

namespace CustomsMQ
{
    public class Custom
    {
        public IModel channel { get; set; }
        public EventingBasicConsumer customer { get; set; }
    }

    public class RabbitMQCutsom
    {
        //定义一个私有成员变量，用于Lock  
        IEnumerable<string> names;
        private static object lockobj = new object();
        private IFreeSql dbContextM = StaticVariable.DBContext[StaticVariable.MySql];
        private Dictionary<string, Custom> Channel = new Dictionary<string, Custom>();
        IConnection Connection = new ConnectionFactory()
        {
            HostName = "localhost",
            UserName = "guest",
            Password = "guest"
        }.CreateConnection();
        string Exchange = "myExchange";

        public void Run()
        {
            RabbitMQCutsom services = new RabbitMQCutsom();
            names = services.getNameList().Select(x => x.ToUpper());
            IModel channel = Connection.CreateModel();  //  创建连接

            foreach (var tableName in names)
            {
                #region 初始化消费者
                channel.ExchangeDeclare(Exchange, "topic", true, false, null);
                channel.QueueBind(tableName, Exchange, tableName);
                #endregion
            }
            var consumer = new EventingBasicConsumer(channel);  //  消费者


            consumer.Received += (ch, ea) =>
            {
                lock (lockobj)
                {
                    string errMsg = string.Empty;
                    string message = Encoding.Default.GetString(ea.Body.ToArray());
                    if (!string.IsNullOrWhiteSpace(message))
                    {
                        //InsertData(message, msgCenter.MsgTypeName, ref errMsg);

                        //  消费完成
                        //if (string.IsNullOrWhiteSpace(errMsg))
                        //{
                        //    Console.WriteLine($"写入成功：{msgCenter.MsgTypeName}");
                        //}
                        if (!string.IsNullOrWhiteSpace(message))
                        {

                            //通过反射跨类库拿实体
                            Assembly assembly = Assembly.LoadFrom("Models");

                            Type instanceType = assembly.GetType($"GD.NP.FDCSCJG.Models.{ea.RoutingKey}");
                            var instanceTypes = Type.GetType($"System.Collections.Generic.List`1[[{instanceType.AssemblyQualifiedName}]]");

                            var instanceDatas = Newtonsoft.Json.JsonConvert.DeserializeObject(message, instanceTypes);
                            List<object> objList = ((IEnumerable<object>)instanceDatas).ToList();
                            var properties = objList[0].GetType().GetProperties();
                            foreach (var obj in objList)
                            {
                                foreach (var property in properties)
                                {
                                    if (property.Name == "SFYC" || property.Name == "SFDT" || property.Name == "SFTY" || property.Name == "SFZX")
                                    {
                                        property.SetValue(obj, property.GetValue(obj).ToString().ElementAt(0).ToString());
                                    }
                                    else if (property.Name == "ZZSJ")
                                    {
                                        property.SetValue(obj, property.GetValue(obj).ToString().Split(',').ElementAt(0));
                                    }
                                    else
                                    {
                                        property.SetValue(obj, property.GetValue(obj));
                                    }
                                }
                            }

                            //通过反射拿方法
                            var insertMethod = dbContextM.GetType().GetMethods()
                                        .Where(o => o.Name == "Insert"
                                            && o.GetParameters().Where(p => p.ParameterType.Name == "List`1").ToList().Count == 1
                                            && o.GetGenericArguments().Length == 1
                                        ).FirstOrDefault();

                            var insertGenericMethod = insertMethod.MakeGenericMethod(instanceType);
                            var iInsert = insertGenericMethod.Invoke(dbContextM, new object[] { instanceDatas });

                            var iInsertType = iInsert.GetType();
                            var executeAffrowsMethod = iInsertType.GetMethods()
                                                                  .Where(o => o.Name == "ExecuteAffrows" && o.GetGenericArguments().Length == 0)
                                                                  .FirstOrDefault();
                            try
                            {
                                var resultInsert = executeAffrowsMethod.Invoke(iInsert, null);
                                Console.WriteLine($"{ea.RoutingKey}成功！");
                            }
                            catch (Exception ex)
                            {
                                Console.WriteLine($"{ea.RoutingKey}插入失败了：{ex.Message}");
                            }


                            //channel.BasicAck(ea.DeliveryTag, false);
                        }
                    }
                    // 有的数据之前已经插入过表 不需要确认 以免造成消息积压
                    //Channel[msgCenter.MsgTypeName].channel.BasicAck(ea.DeliveryTag, false);
                    message = null;
                    errMsg = null;
                    Thread.Sleep(1000);
                    System.GC.Collect();
                }
            };

            //启动消费者 设置为手动应答消息
            foreach (var tableName in names)
            {
                channel.BasicConsume(tableName, true, consumer);
            }

            Console.ReadKey();
        }

        /// <summary>
        /// 获取数据库所有表名
        /// </summary>
        /// <returns></returns>
        public List<string> getNameList()
        {
            return dbContextM.Ado.Query<string>("SELECT TABLE_NAME FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_SCHEMA='gd_bdcfc_fcscjg'");
        }
    }

}
孟章豪
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
RabbitMQ的使用
qq_36602118的博客
03-19 2046
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录前言一、RabbitMQ是什么？二、项目中使用步骤1.在项目中引入RabbitMQ的依赖2.写配置文件1.生产者2.消费者3.写配置类对RabbitMQ的工作模式进行配置1.生产者2.消费者总结 前言 记录一次使用RabbitMQ的使用过程。 提示：以下是本篇文章正文内容，下面案例可供参考 一、RabbitMQ是什么？ 在使用RabbitMQ之前，需要对它有一个基本了解，更方便我们对它理解。 1.官网解释：RabbitMQ i.
.NET中RabbitMQ的使用
weixin_34010566的博客
04-10 317
概述 　　MQ全称为Message Queue, 消息队列（MQ）是一种应用程序对应用程序的通信方法。RabbitMQ是一个在AMQP基础上完整的，可复用的企业消息系统。他遵循Mozilla Public License开源协议。AMQP(高级消息队列协议) 是一个异步消息传递所使用的应用层协议规范，作为线路层协议，而不是API（例如JMS），AMQP 客户端能够无视消息的来源任意发送和接受信息...
高并发场景之RabbitMQ篇
angqishe7119的博客
04-02 182
上次我们介绍了在单机、集群下高并发场景可以选择的一些方案，传送门：高并发场景之一般解决方案 但是也发现了一些问题，比如集群下使用ConcurrentQueue或加锁都不能解决问题，后来采用Redis队列也不能完全解决问题， 因为使用Redis要自己实现分布式锁 这次我们来了解一下一个专门处理队列的组件：RabbitMQ，这个东西天生支持分布式队列。 下面我们来用Rabbit...
消息队列8：RabbitMq的QOS实验
火焰
04-27 2241
环境： win10 rabbitmq-3.8.8 .net core 3.1 RabbitMQ.Client 6.2.1 vs2019 实验目的： 探索RabbitMq消费者的处理模式 验证RabbitMq的队列在自动应答和手动应答中的表现 探索Qos的作用 一、说明 工作队列模式， 二、RabbitMq的消费者处理模式 结论： 给消费者绑定的事件是单线程顺序执行的，并不会并发执行，也就是说接收到的消息会在单线程模式下按照分发的顺序一个一个区去处理。 三、RabbitMq的自动应答 ...
消息队列5：rabbitmq的WorkQueue模式
火焰
04-18 298
环境： win10 rabbitmq-3.8.8 .net core 3.1 RabbitMQ.Client 6.2.1 说明： 这一部分的代码与上一篇：《消息队列3：rabbitmq入门实例》基本上没有出入。 这一片注重rabbitmq的模式和参数的说明。 一、rabbitmq模式概念 rabbitmq有5中模式，分别是： 工作者模式； 发布/订阅模式； 路由模式； 主题模式； rpc模式； 其他地方也有说是6种模式的，所谓的6种模式是将工作者模式拆分成两个模式： 简单模式： 一个生产者对应一个
RabbitMQ 消费者断线重连
lee576的专栏
05-27 6660
虽然RabbitMQ.Client 库有心跳机制，有断线重连机制，但是在网络断掉的时候并不能重连，下面的代码就是解决这个问题，经本人测试有效，适合作为挂机程序
RabbitMQ使用规范
08-04
RabbitMQ使用规范 概述 RabbitMQ是基于AMQP高性能的开源消息队列服务器，可以用来实现消息的发布、订阅和routing。该规范旨在为RabbitMQ的使用提供一个统一的标准，确保RabbitMQ的使用符合公司的技术架构和安全要求...
RabbitMq使用手册
12-07
RabbitMq 使用手册 本文档为 RabbitMq 使用手册，介绍了 RabbitMq 的应用场景和开发指导。RabbitMq 是一个由 Erlang 开发的 AMQP（Advanced Message Queue）流行的开源消息队列系统。RabbitMq 的结构图如下： ...
RabbitMQ使用总结
03-13
内容为自己总结的RabbitMQ的经验，内容大致有：安装顺序、关键文件路径、常用命令、集群注意事项等，有用的请收入
RabbitMQ使用文档.PDF
12-20
MQ全称为Message Queue，即消息队列， RabbitMQ是由erlang语言开发，基于AMQP（Advanced Message Queue 高级消息队列协议）协议实现的消息队列，它是一种应用程序之间的通信方法，消息队列在分布式系统开 发中应用...
rabbitMQ使用手册
06-03
RabbitMQ 使用手册 RabbitMQ 是一个流行的消息队列系统，它提供了多种交换机类型，每种交换机类型都有其特点和用途。下面我们将详细介绍 RabbitMQ 中的 Fanout Exchange、Direct Exchange 和 Topic Exchange。 ...
在CentOS 7.5系统上安装RabbitMQ
weixin_34417200的博客
08-11 351
http://www.rabbitmq.com/download.html http://www.rabbitmq.com/install-rpm.html [root@contoso ~]# wget http://packages.erlang-solutions.com/erlang-solutions-1.0-1.noarch.rpm [root@contoso ~]# rpm ...
分布式消息通信之RabbitMQ_01
adamli6668的博客
05-27 845
目录 官网 1. RabbitMQ安装 1.1 Window版安装 1.2 Linux版安装 2. 典型应用场景 3. 基本介绍 3.1 AMQP协议 3.2 RabbitMQ的特性 3.3...
消息队列3：rabbitmq入门实例
火焰
04-16 256
环境： window10 .net core 3.1 RabbitMQ.Client 6.2.1 RabbitMQ 3.8.8 Erlang 23.0 安装RabbitMq环境参照： window下安装rabbitmq linux下安装rabbitmq 一、准备代码 新建空白解决方案RabbitMQTrial 准备两个项目工程，发送端: Send，接收端：Receive，整体如下： 这两个工程都引入rabbitmq的客户端包<ItemGroup> <PackageRefe
.NET Core 中使用 RabbitMQ
一直在水些技术小文
03-25 1764
目录 一、RabbitMQ 队列模型 1. 简单队列 2.Work模式 3.订阅模式 4.路由模式 5.主题模式（通配符模式） 二、RabbitMQ 相关知识 1. 消息分发机制 2. 消息的确认模式 3. Ack，Nack，Reject的关系 三、RabbitMQ简单封装 一、RabbitMQ 队列模型 1. 简单队列 说明： P：消息的生产者 C：消息的消费者 红色：队列 生产者将消息发送到队列，消费者从队列中获取消息。 2.Work模式 说明： 一个生产者、2个消费者。 一个消息只能被一个消费
RabbitMQ具体使用
LongtengGensSupreme博客
04-14 167
上篇简述了RabbitMQ环境准备/环境搭建，本片在上篇的基础上讲述RabbitMQ具体使用 1、新建.NET Framwork console控制台项目ConsoleRabbitMQ项目(生产者，即产生消息的) 2、对控制台项目ConsoleRabbitMQ项目使用NuGet程序管理包添加RabbitMQ.Client 3、控制台项目ConsoleRabbitMQ项目的Program代码...
RabbitMQ初试（01）
weixin_30813225的博客
09-26 117
1、RabbitMQ简解 RabbitMQ是消息代理：它接受并转发消息。 您可以将其视为邮局：将要发布的邮件放在邮箱中时，可以确保Mailperson先生或女士最终将邮件传递给收件人。以此类推，RabbitMQ是一个邮箱，一个邮局和一个邮递员。 RabbitMQ与邮局之间的主要区别在于，它不处理纸张，而是接收，存储和转发数据消息的二进制斑点。 RabbitMQ主要知识框架 ...
RabbitMQ中常用的三种交换机【Fanout、Direct、Topic】
最新发布
LYJbao的博客
07-07 917
此时支付服务会把支付结果发送到交换机中，而短信服务就会去监听这个交换机，但是交换机不会把所有的消息都路由给短信服务，而只把支付成功的消息路由给这个短信服务。这种情况下，就需要使用到这个Direct交换机，短信服务下的队列和这个交换机设置一个key（例如：success），支付服务发消息时，支付成功RoutingKey设为success，失败为fail，交换机就会只把key为success的消息路由给短信服务了~上图中，就是，key为blue，消费者1去消费；一个只能接到新闻，一个只能接到和中国相关的消息~

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值