Quick.RabbitMQPlus.Furion 1.0.10

1、🍹更新日志

• 1.0.10

  • 注册方法AddRabbitMQPlus增加了单例、作用域和暂时的服务注册方式，只需要在方法中传入枚举参数QuickRabbitMQPlusAddType.Singleton、QuickRabbitMQPlusAddType.Scoped或QuickRabbitMQPlusAddType.Transient即可；

  • 增加了方法CheckConn，用于检查连接是否成功。该方法返回元组对象，第一个值为是否连接成功，第二个值为连接失败的说明。

• 1.0.9

  • 在路由模式消费的时候，去掉了调用实例化方法**Instance()**必须传入参数true的参数；

  • 提供了两种使用方式，第一种就是v1.0.8之前的通过实例化的方式进行初始化使用，第二种就是v1.0.9之后增加了可以通过依赖注入的方式进行初始化使用_（推荐使用依赖注入的方式）_;

  • 新增加了AddRabbitMQPlus和GetInstance方法，这两个方法分别有2个重载，具体说明参见Quick.RabbitMQPlus方法；

  • 增加了IQuickRabbitMQPlus接口，如果使用依赖注入的方式，就可以实现该接口并使用其中的各个方法。

• 1.0.8

  • 去掉了通过实体特性去配置各个属性，目的在于简化各个配置，都通过配置文件进行设置；

  • 在接收数据的时候，可以通过实体特性QuickRabbitMQPlusReceive去设置接收的消息队列（如**[QuickRabbitMQPlusReceive("TestRabbitMQName1")]），如果不要实体特性，那么就会通过配置中的QueueNames**属性去控制；

  • 对接收数据的方法进行了重载；

  • 配置中增加了Default属性，用于设置默认连接配置（如果配置中有多个连接配置，并且没有一个配置中设置Default为true，那么默认会使用第一个配置）；

  • 配置中增加了PrefetchCount属性，用于全局设置RabbitMQ一次最多推送多少条消息给消费者，默认为10；

  • 配置中去掉了~~RouteKey~~配置，如果使用的是路由模式，请使用RouteKeys属性进行配置，前提是RouteKeys和QueueNames集合的数量需要保持一致；

  • 实例化组件对象的时候，去掉了泛型的定义，如var sendInstance = QuickRabbitMQPlusInstance.Instance();；

  • 发送和接收的方法，增加了泛型的定义，这样做的目的是不受限于在组件实例化的时候指定只能是某个泛型，将泛型的定义设置到方法上更灵活，如同一个组件实例化对象可发送不同的泛型实体数据。

• 1.0.7

  • 去掉了必须要设置实体特性的控制（如果没有实体特性，那么就需要在配置文件中将相关属性配置齐全），默认使用的是配置中的第一个配置；

  • 在路由模式下，可指定将消息发送到对应的队列中，需要配置QueueNames和RouteKeys的集合数量保持一一对应的关系；

  • Send方法增加了第二个参数，路由Key名称；

  • 实例化对象的方法Instance增加了参数Instance(bool isReceive = false)，当前实例化对象是否为接收消息。

• 1.0.6

  • 新增加了可动态切换连接的方法ChangeConn；

  • 去掉了Furion的依赖；

  • 去掉了Newtonsoft.Json的依赖；

  • 同时将原来的Quick.RabbitMQPlus分为了Quick.RabbitMQPlus和Quick.RabbitMQPlus.Furion这两个版本。

2、🍟Quick.RabbitMQPlus.Furion使用说明

该组件是基于RabbitMQ.Client和Furion组件进行封装使用的，目的在于结合.Net Core更快、更简单和更灵活的使用RabbitMQ！！！

功能说明：

• 支持发布订阅模式、路由模式,通配符模式和Headers属性模式；

• 可根据配置文件读取RabbitMQ连接的各个配置（如：RabbitMQ服务地址、账号、密码和交换机名称等）；

• 支持配置多个RabbitMQ的连接配置；

• 支持动态切换RabbitMQ的连接配置；

• 可根据实体定义的特性发布和订阅消息（已废弃），目前只针对接收消息定义了实体特性，并且只能指定接收消息的队列_（v1.0.8调整）_；

• 支持配置将多个队列绑定到交换机；

• 一个消费端支持可以同时消费多个多列的消息等；

• 支持使用同一个实体，将不同的消息发送到不同的队列中（使用路由模式，同时在发送的时候将路由Key传入）；

• 支持全局设置接收消息一次性接收多少条的配置_（v1.0.8新增）_；

• 支持两种使用方式，第一种就是v1.0.8之前的通过实例化的方式进行初始化使用，第二种就是v1.0.9之后增加了可以通过依赖注入的方式进行初始化使用***（推荐使用依赖注入的方式）***。

3、🍖安装

安装命令如下所示：

Install-Package Quick.RabbitMQPlus.Furion

该组件的命名空间为：Quick.RabbitMQPlus，包括Quick.RabbitMQPlus原生组件。

4、🧀生产端

4.1、🥞配置appsettings.json

在appsettings.json配置文件中创建节点QuickRabbitMQPlus>PrefetchCount和QuickRabbitMQPlusConfigs，PrefetchCount为设置RabbitMQ一次最多推送多少条消息给消费者（默认为10），QuickRabbitMQPlusConfigs 为数组类型（即可配置多个 RabbitMQ 服务地址），具体配置如下所示：

{
    "QuickRabbitMQPlus": {
        "PrefetchCount": 1,
        "QuickRabbitMQPlusConfigs": [
            {
                "Default": false,
                "ConnId": 1,
                "UserName": "quber",
                "Password": "0807_quberONE",
                "HostName": "127.0.0.1",
                "Port": 5672,
                "ExchangeType": "direct",
                "ExchangeName": "TestExchangeName",
                "QueueNames": [ "TestRabbitMQName1", "TestRabbitMQName2" ],
                "RouteKeys": [ "TestRouteKey1", "TestRouteKey2" ], //ExchangeType=direct才起作用，并且和QueueNames一一对应
                //"ExchangeDurable": true,
                //"QueueDurable": true,
                //"MessageDurable": true
            },
            //fanout模式
            {
                "Default": true,
                "ConnId": 2,
                "UserName": "quber",
                "Password": "0807_quberONE",
                "HostName": "127.0.0.1",
                "Port": 5672,
                "ExchangeType": "fanout",
                "ExchangeName": "TestExchangeName",
                "QueueNames": [ "TestRabbitMQName1", "TestRabbitMQName2" ],
                "RouteKeys": [ "TestRouteKey1", "TestRouteKey2" ], //ExchangeType=direct才起作用，并且和QueueNames一一对应
                //"ExchangeDurable": true,
                //"QueueDurable": true,
                //"MessageDurable": true
            }
        ]
    }
}

配置说明（消费端通用）：

4.2、🍞配置Program.cs

由于我们使用的是Furion，因此，我们可在程序启动文件中配置如下代码（具体可参考Furion入门指南），目的是注册RabbitMQ服务和配置选项QuickRabbitMQPlusOptions。

1. 依赖注入方式-WinForm中使用：

   Program.cs的Main方法：

    [STAThread]
    static void Main()
    {
    	ApplicationConfiguration.Initialize();
   
    	//初始化Furion
    	Serve.Run(GenericRunOptions.DefaultSilence);
    }
   

   Furion提供的AppStartup启动配置文件：

    public void ConfigureServices(IServiceCollection services)
    {
    	//注册FrmMain窗体类
    	services.AddScoped<FrmMain>();
   
    	//注入IQuickRabbitMQPlus的方式
    	//通过AddRabbitMQPlus添加依赖注入
    	services.AddRabbitMQPlus();
   
    	////使用构造函数获取实例的方式：
    	////通过AddRabbitMQPlus添加依赖注入，并注册TestConsumerClassForDI类
    	//services.AddRabbitMQPlus<TestConsumerClassForDI>()
   
    	//DI容器生成serviceProvider
    	var serviceProvider = services.BuildServiceProvider();
   
    	//通过serviceProvider获取MainForm的注册实例
    	var frmMain = serviceProvider.GetRequiredService<FrmMain>();
    	//var frmMain = (FrmMain)serviceProvider.GetService(typeof(FrmMain));
   
    	Application.Run(frmMain);
    }
   

   **说明：上述的关键点就在于调用.AddRabbitMQPlus()或者.AddRabbitMQPlus<T>()**方法对服务进行注册。

2. 实例化方式-WinForm中使用：

   Program.cs的Main方法：

    [STAThread]
    static void Main()
    {
    	//初始化Furion
    	Serve.Run(GenericRunOptions.DefaultSilence);
   
    	//或者
    	//Serve.Run(RunOptions.DefaultSilence.ConfigureBuilder(builder =>
    	//{
    		//注册RabbitMQ连接配置对象
    		//builder.Services.AddConfigurableOptions<QuickRabbitMQPlusOptions>();
    	//}).Configure(app =>
    	//{
    	//}));
   
    	ApplicationConfiguration.Initialize();
    	Application.Run(new FrmMain());
    }
   

   Furion提供的AppStartup启动配置文件：

    public void ConfigureServices(IServiceCollection services)
    {
    	//注册RabbitMQ连接配置对象
    	services.AddConfigurableOptions<QuickRabbitMQPlusOptions>();
    }
   

3. Quick.RabbitMQPlus组件，依赖注入方式-WinForm中使用：

   Program.cs的Main方法：

    ApplicationConfiguration.Initialize();
   
    using IHost host = Host.CreateDefaultBuilder()
    	.ConfigureServices((_, services) =>
    		{
    			//注册FrmMain窗体类
    			services.AddScoped<FrmMain>();
   
    			//注入IQuickRabbitMQPlus的方式
    			//通过AddRabbitMQPlus添加依赖注入
    			services.AddRabbitMQPlus();
   
    			////使用构造函数获取实例的方式：
    			////通过AddRabbitMQPlus添加依赖注入，并注册TestConsumerClassForDI类
    			//services.AddRabbitMQPlus<TestConsumerClassForDI>()
   
    			//DI容器生成serviceProvider
    			var serviceProvider = services.BuildServiceProvider();
   
    			//通过serviceProvider获取MainForm的注册实例
    			var frmMain = serviceProvider.GetRequiredService<FrmMain>();
    			//var frmMain = (FrmMain)serviceProvider.GetService(typeof(FrmMain));
   
    			Application.Run(frmMain);
    		}
    	)
    	.Build();
   
    host.RunAsync();
   

4. Quick.RabbitMQPlus组件，实例化方式-WinForm中使用：

   Program.cs的Main方法：

    [STAThread]
    static void Main()
    {
    	ApplicationConfiguration.Initialize();
    	Application.Run(new FrmMain());
    }
   

其他库的使用方式也基本类似，就不一一介绍了。

4.3、🧀定义发送消息实体

如下所示我们可以定义一个消息实体：

namespace Quick.RabbitMQPlus.Publisher
{
    public class TestRabbitMQModel
    {
        public int UserId { get; set; }

        public string UserName { get; set; }

        public int UserAge { get; set; }

        public DateTime CreateTime { get; set; }
    }
}

4.4、🥐发送消息Demo

定义发送对象（依赖注入方式）：

public partial class FrmMain : Form
{
	private readonly IQuickRabbitMQPlus _quickRabbitMqPlus;

	public FrmMain(IQuickRabbitMQPlus quickRabbitMqPlus)
	{
		InitializeComponent();

		//定义发送对象
		_quickRabbitMqPlus = quickRabbitMqPlus;
	}
}

定义发送对象（实例化方式）：

//定义发送对象
var sendInstance = QuickRabbitMQPlusInstance.Instance();

发送单条消息（fanout模式）：

//发送10条数据
for (int i = 0; i < 10; i++)
{
	var msgModel = new TestRabbitMQModel
	{
		UserId = rand.Next(1, 9999),
		UserName = "Quick" + (i + 1),
		UserAge = rand.Next(20, 80),
		CreateTime = DateTime.Now
	};

	var sendRet = await _quickRabbitMqPlus.Send(msgModel);

	if (sendRet.Item1)
	{
		//发送成功
	}
	else
	{
		//发送失败
		var errMsg = $"失败原因：{sendRet.Item2}";
	}

	//间隔2秒发送一次
	await Task.Delay(2000);
}

//消息发送完成后，关闭通道
_quickRabbitMqPlus.Close();

发送单条消息（direct模式）：

//当i % 2为0时，发送给路由TestRouteKey1对应的队列TestRabbitMQName1，否则发送给路由TestRouteKey2对应的队列TestRabbitMQName2
//此处就实现了在路由模式下，将不同的消息发送给不同的队列
//需要注意的时候，此方式需要将交换机类型配置为direct路由模式，同时需要设置配置的QueueNames和RouteKeys属性（这两属性的集合数量需要保持一致，一一对应的关系）
var sendRet = await _quickRabbitMqPlus.Send(msgModel, i % 2 == 0 ? "TestRouteKey1" : "TestRouteKey2");

发送多条消息：

var sendList = new List<TestRabbitMQModel>{
	new TestRabbitMQModel(),
	new TestRabbitMQModel()
};

var sendRet = await _quickRabbitMqPlus.Send(sendList);

切换连接：

//切换到connId=2的配置
_quickRabbitMqPlus.ChangeConn(2);

var sendRetConn2 = await _quickRabbitMqPlus.Send(msgModel);

//切换到connId=3的配置
_quickRabbitMqPlus.ChangeConn(3);

var sendRetConn3 = await _quickRabbitMqPlus.Send(msgModel);

5、🥪消费端

5.1、🍝配置appsettings.json与实体特性QuickRabbitMQPlusReceive

• 配置说明：

  具体配置请参见生产端（和生产端完全一致）。

  需要注意的是，消费端中，增加了PrefetchCount配置，目的用于全局设置 RabbitMQ 一次最多推送多少条消息给消费者，默认为 10。

  需要注意的是，如果消费端中的QueueNames属性设置了多个队列，就代表该消费端同时接收多个队列的消息

• 实体特性配置说明（消费端使用）：

  属性名称	属性说明	是否必填	备注
  queueName	队列名称（多个队列名称请使用英文逗号,分隔）		如果同时设置了实体特性的队列名称和配置中的_QueueNames_属性，那么会优先采用实体的队列名称

  如下所示：

  namespace Quick.RabbitMQPlus.Publisher
  {
      [QuickRabbitMQPlusReceive("TestRabbitMQName1")]
      //[QuickRabbitMQPlusReceive("TestRabbitMQName1,TestRabbitMQName2")]
      public class TestRabbitMQModel
      {
          public int UserId { get; set; }
  
          public string UserName { get; set; }
  
          public int UserAge { get; set; }
  
          public DateTime CreateTime { get; set; }
      }
  }
  

5.2、🌮配置Program.cs

由于我们使用的是Furion，因此，我们可在程序启动文件中配置如下代码（具体可参考Furion入门指南），目的是注册RabbitMQ服务和配置选项QuickRabbitMQPlusOptions。

1. 依赖注入方式-Worker Service中使用：

   Program.cs中：

    //初始化Furion
    Serve.Run(GenericRunOptions.Default);
   

   Furion提供的AppStartup启动配置文件：

    public void ConfigureServices(IServiceCollection services)
    {
    	//通过AddRabbitMQPlus添加依赖注入
    	services.AddRabbitMQPlus();
    }
   

   **说明：上述的关键点就在于调用.AddRabbitMQPlus()或者.AddRabbitMQPlus<T>()**方法对服务进行注册。

2. 依赖注入方式-控制台中使用：

   Program.cs中：

    //初始化Furion
    Serve.Run(GenericRunOptions.DefaultSilence);
   

   Furion提供的AppStartup启动配置文件：

    public void ConfigureServices(IServiceCollection services)
    {
    	////通过AddRabbitMQPlus添加依赖注入
    	//services.AddRabbitMQPlus();
   
    	//使用构造函数获取实例的方式：
    	//通过AddRabbitMQPlus添加依赖注入，并注册TestConsumerClassForDI类
    	services.AddRabbitMQPlus<TestConsumerClassForDI>();
    }
   

3. Quick.RabbitMQPlus组件，依赖注入方式-Worker Service中使用：

   Program.cs的Main方法：

    IHost host = Host.CreateDefaultBuilder(args)
    	.ConfigureServices(services =>
    	{
    		services.AddHostedService<Worker>();
   
    		//通过AddRabbitMQPlus添加依赖注入
    		services.AddRabbitMQPlus();
    	})
   	.Build();
   
    await host.RunAsync();
   

4. Quick.RabbitMQPlus组件，依赖注入方式-控制台中使用：

   Program.cs的Main方法：

    using IHost host = Host.CreateDefaultBuilder(args)
    	.ConfigureServices((_, services) =>
    	//注入IQuickRabbitMQPlus的方式
    	//通过AddRabbitMQPlus添加依赖注入
    	services.AddRabbitMQPlus()
   
    	////使用构造函数获取实例的方式：
    	////通过AddRabbitMQPlus添加依赖注入，并注册TestConsumerClassForDI类
    	//services.AddRabbitMQPlus<TestConsumerClassForDI>()
    )
    .Build();
   

5.3、🧆定义接收消息实体

如下所示我们可以定义3个消息实体（第一个用于接收队列TestRabbitMQName1的消息，第二个用于接收队列TestRabbitMQName2的消息，第三个用于接收队列TestRabbitMQName1和TestRabbitMQName2）：

namespace Quick.RabbitMQPlus.Consumer
{
    [QuickRabbitMQPlusReceive("TestRabbitMQName1")]
    public class TestRabbitMQModel1
    {
        public int UserId { get; set; }

        public string UserName { get; set; }

        public int UserAge { get; set; }

        public DateTime CreateTime { get; set; }
    }
}

namespace Quick.RabbitMQPlus.Consumer
{
    [QuickRabbitMQPlusReceive("TestRabbitMQName2")]
    public class TestRabbitMQModel2
    {
        public int UserId { get; set; }

        public string UserName { get; set; }

        public int UserAge { get; set; }

        public DateTime CreateTime { get; set; }
    }
}

namespace Quick.RabbitMQPlus.Consumer
{
    [QuickRabbitMQPlusReceive("TestRabbitMQName1,TestRabbitMQName2")]
    public class TestRabbitMQModel3
    {
        public int UserId { get; set; }

        public string UserName { get; set; }

        public int UserAge { get; set; }

        public DateTime CreateTime { get; set; }
    }
}

5.4、🍨接收消息Demo

定义接收对象（依赖注入方式-Worker Service中）：

public class Worker : BackgroundService
{
	private readonly ILogger<Worker> _logger;
	private readonly IQuickRabbitMQPlus _quickRabbitMqPlus;

	public Worker(ILogger<Worker> logger, IQuickRabbitMQPlus quickRabbitMqPlus)
	{
		_logger = logger;
		_quickRabbitMqPlus = quickRabbitMqPlus;
	}
}

定义接收对象（依赖注入方式-控制台中）：

//获取IQuickRabbitMQPlus的实例（App是Furion中的静态类）
var _quickRabbitMqPlus = App.GetService<IQuickRabbitMQPlus>();

定义接收对象（依赖注入方式-控制台中【Quick.RabbitMQPlus组件】）：

//获取IQuickRabbitMQPlus的实例（其中的host为IHost对象，GetInstance方法为封装的扩展方法）
//var _quickRabbitMqPlus = host.Services.GetInstance<IQuickRabbitMQPlus>();

//获取IQuickRabbitMQPlus的实例（其中的host为IHost对象，GetInstance方法为封装的扩展方法）
var _quickRabbitMqPlus = host.GetInstance<IQuickRabbitMQPlus>();

定义接收对象（实例化方式）：

//定义接收对象
var recInstance = QuickRabbitMQPlusInstance.Instance();

定义两个消费端，一个消费端消费一个队列，具体的接收消息代码如下所示（接收单条消息）：

Worker Service中：

namespace Quick.RabbitMQPlus.ConsumerServiceFurion
{
    public class Worker : BackgroundService
    {
        private readonly ILogger<Worker> _logger;
        private readonly IQuickRabbitMQPlus _quickRabbitMqPlus;

        public Worker(ILogger<Worker> logger, IQuickRabbitMQPlus quickRabbitMqPlus)
        {
            _logger = logger;
            _quickRabbitMqPlus = quickRabbitMqPlus;
        }

        protected override async Task ExecuteAsync(CancellationToken stoppingToken)
        {
            while (!stoppingToken.IsCancellationRequested)
            {
                //接收队列1的消息
                var retRec1 = await _quickRabbitMqPlus.Receive<TestRabbitMQModel1>(async (data, msg) =>
                {
                    await Task.Delay(1000);

                    Console.ForegroundColor = ConsoleColor.Green;
                    Console.WriteLine($"\r\n队列1消息：{msg}");

                    //返回true代表业务逻辑处理成功，会告知MQ这条消息已经接收成功，会从MQ队列中删除
                    //返回false代表业务逻辑处理失败，会告知MQ这条消息没有处理成功，则MQ会继续推送这条消息
                    return true;
                }, async (errMsg, msg) =>
                {
                    await Task.Delay(3000);

                    Console.ForegroundColor = ConsoleColor.Red;
                    Console.WriteLine($"\r\n队列1接收错误：{errMsg}\r\n原始数据：{msg}");
                }, 1);
                if (!retRec1.Item1)
                {
                    Console.ForegroundColor = ConsoleColor.Red;
                    Console.WriteLine($"\r\n队列1接收失败：{retRec1.Item2}");
                }

                //接收队列2的消息
                var retRec2 = await _quickRabbitMqPlus.Receive<TestRabbitMQModel2>(async (data, msg) =>
                {
                    await Task.Delay(2500);

                    Console.ForegroundColor = ConsoleColor.Magenta;
                    Console.WriteLine($"\r\n队列2消息：{msg}");

                    //返回true代表业务逻辑处理成功，会告知MQ这条消息已经接收成功，会从MQ队列中删除
                    //返回false代表业务逻辑处理失败，会告知MQ这条消息没有处理成功，则MQ会继续推送这条消息
                    return true;
                }, async (errMsg, msg) =>
                {
                    await Task.Delay(3000);

                    Console.ForegroundColor = ConsoleColor.Red;
                    Console.WriteLine($"\r\n队列1接收错误：{errMsg}\r\n原始数据：{msg}");
                }, 10);
                if (!retRec2.Item1)
                {
                    Console.ForegroundColor = ConsoleColor.Red;
                    Console.WriteLine($"\r\n队列2接收失败：{retRec2.Item2}");
                }
            }
        }
    }
}

控制台中：

//接收队列1的消息
var retRec1 = await _quickRabbitMqPlus.Receive<TestRabbitMQModel1>(async (data, msg) =>
{
    await Task.Delay(1000);

    Console.ForegroundColor = ConsoleColor.Green;
    Console.WriteLine($"\r\n队列1消息：{msg}");

    //返回true代表业务逻辑处理成功，会告知MQ这条消息已经接收成功，会从MQ队列中删除
    //返回false代表业务逻辑处理失败，会告知MQ这条消息没有处理成功，则MQ会继续推送这条消息
    return true;
});
if (!retRec1.Item1)
{
    Console.ForegroundColor = ConsoleColor.Red;
    Console.WriteLine($"\r\n队列1接收失败：{retRec1.Item2}");
}

//接收队列2的消息
var retRec2 = await _quickRabbitMqPlus.Receive<TestRabbitMQModel2>(async (data, msg) =>
{
    await Task.Delay(2500);

    Console.ForegroundColor = ConsoleColor.Magenta;
    Console.WriteLine($"\r\n队列2消息：{msg}");

    //返回true代表业务逻辑处理成功，会告知MQ这条消息已经接收成功，会从MQ队列中删除
    //返回false代表业务逻辑处理失败，会告知MQ这条消息没有处理成功，则MQ会继续推送这条消息
    return true;
});
if (!retRec2.Item1)
{
    Console.ForegroundColor = ConsoleColor.Red;
    Console.WriteLine($"\r\n队列2接收失败：{retRec2.Item2}");
}

定义一个消费端，同时消费两个队列，具体的接收消息代码如下所示（接收单条消息）：

//接收队列1的消息
var retRec = await _quickRabbitMqPlus.Receive<TestRabbitMQModel3>(async (data, msg) =>
{
    await Task.Delay(1000);

    Console.ForegroundColor = ConsoleColor.Green;
    Console.WriteLine($"\r\n队列1、2消息：{msg}");

    //返回true代表业务逻辑处理成功，会告知MQ这条消息已经接收成功，会从MQ队列中删除
    //返回false代表业务逻辑处理失败，会告知MQ这条消息没有处理成功，则MQ会继续推送这条消息
    return true;
});
if (!retRec.Item1)
{
    Console.ForegroundColor = ConsoleColor.Red;
    Console.WriteLine($"\r\n队列1、2接收失败：{retRec.Item2}");
}

如果需要接收多条消息，请使用Receives方法：

//接收队列1的消息
var retRec = await _quickRabbitMqPlus.Receives<TestRabbitMQModel3>(async (dataList, msg) =>
{
	//此处的dataList为List<TestRabbitMQModel3>
	
    return true;
});

5.5、🍱预览效果

<div style="background:#000;padding:10px;"> <div><font color="DarkCyan">####消费端已启动####</div></br> <div><font color="Green">队列1消息：{"UserId":8739,"UserName":"CCCC1","UserAge":40,"CreateTime":"2022-09-06 10:44:37"}</div></br> <div><font color="Magenta">队列2消息：{"UserId":8739,"UserName":"CCCC1","UserAge":40,"CreateTime":"2022-09-06 10:44:37"}</div></br> <div><font color="Green">队列1消息：{"UserId":8646,"UserName":"CCCC2","UserAge":54,"CreateTime":"2022-09-06 10:44:39"}</div></br> <div><font color="Magenta">队列2消息：{"UserId":8646,"UserName":"CCCC2","UserAge":54,"CreateTime":"2022-09-06 10:44:39"}</div></br> <div><font color="Magenta">队列2消息：{"UserId":1966,"UserName":"CCCC3","UserAge":21,"CreateTime":"2022-09-06 10:44:41"}</div></br> <div><font color="Green">队列1消息：{"UserId":1966,"UserName":"CCCC3","UserAge":21,"CreateTime":"2022-09-06 10:44:41"}</div></br> <div><font color="Magenta">队列2消息：{"UserId":8349,"UserName":"CCCC4","UserAge":25,"CreateTime":"2022-09-06 10:44:43"}</div></br> <div><font color="Green">队列1消息：{"UserId":8349,"UserName":"CCCC4","UserAge":25,"CreateTime":"2022-09-06 10:44:43"}</div></br> <div><font color="Magenta">队列2消息：{"UserId":3770,"UserName":"CCCC5","UserAge":31,"CreateTime":"2022-09-06 10:44:45"}</div></br> <div><font color="Green">队列1消息：{"UserId":3770,"UserName":"CCCC5","UserAge":31,"CreateTime":"2022-09-06 10:44:45"}</div></br> </div>

6、🥙Quick.RabbitMQPlus方法

• 首先声明Quick.RabbitMQPlus的实例化对象，有两种方式可以得到Quick.RabbitMQPlus的实例化对象，一种是通过依赖注入在构造函数中得到，另一种是直接通过实例化对象的方式，具体可参照上述文档中的相关示例。

• 依赖注入方法：

  方法名称	方法说明	方法参数	备注
  AddRabbitMQPlus	添加依赖注入服务	重载1：(QuickRabbitMQPlusAddType addType = QuickRabbitMQPlusAddType.Singleton)<br />重载2：<T>(QuickRabbitMQPlusAddType addType = QuickRabbitMQPlusAddType.Singleton)	该方法为IServiceCollection的扩展方法，目的是实现IQuickRabbitMQPlus接口的注册。<br />重载1代表注册的是IQuickRabbitMQPlus服务；<br />重载2传入了泛型T，代表的是注册了IQuickRabbitMQPlus服务的同时，也注册了T这个服务（T这个泛型类中，在构造函数中实现了IQuickRabbitMQPlus接口服务，该方法可能在控制台程序使用的情况较多）。<br /><br />其中的addType参数为服务注册类型，可以为单例、作用域或暂时。
  GetInstance	获取某接口服务的实例	重载1：()<br />重载2：()	该方法为IServiceProvider或IHost的扩展方法，目的是获取某接口或类的实例。<br />重载1是基于IServiceProvider的扩展；<br />重载2是基于IHost的扩展。

• 其次就可以使用使用该实例化对象中的发送和接收方法了，具体说明如下所示：

  方法名称	方法说明	方法参数	备注
  CheckConn	检查连接是否成功	()	该方法返回元组对象，第一个值为是否连接成功，第二个值为连接失败的说明
  Send	发送消息方法，支持单条消息和多条消息的发送	(data,routeKey)	方法的第一个参数data可以为T或List<T><br />方法的第二个参数为路由名称（当交换机类型为路由模式的时候，该参数起作用，如可以实现使用同一个实体将不同的消息发送到不同的队列中）
  Receive	接收消息（单条消息），该方法有3个重载	重载1：(received)<br />重载2：(received, receivedError)<br />重载3：(received, receivedError, prefetchCount)	方法的第一个参数为回调函数，该回调函数包含2个返回数据（第一个为T，第二个为T对应的字符串），并且该回调函数需要返回bool类型（以便告诉RabbitMQ服务该消息是否处理成功）；<br /><br />方法的第二个参数为消费出错的回调函数，该回调函数包括2个返回数据（第一个为错误提示信息，第二个为T对应的字符串）<br />方法的第三个参数为设置RabbitMQ一次最多推送多少条消息给消费者，默认为10
  Receives	接收消息（多条消息），该方法有3个重载	重载1：(received)<br />重载2：(received, receivedError)<br />重载3：(received, receivedError, prefetchCount)	方法的第一个参数为回调函数，该回调函数包含2个返回数据（第一个为List<T>，第二个为List<T>对应的字符串），并且该回调函数需要返回bool类型（以便告诉RabbitMQ服务该消息是否处理成功）；<br />方法的第二个参数为消费出错的回调函数，该回调函数包括2个返回数据（第一个为错误提示信息，第二个为List<T>对应的字符串）<br />方法的第三个参数为设置RabbitMQ一次最多推送多少条消息给消费者，默认为10
  ChangeConn	切换连接（切换配置文件中某个连接配置）	(connId)	方法参数connId为int类型，即与配置中的ConnId保持一致
  Close	关闭连接	()	注意，如果调用了该方法，又想重新使用实例化对象mqInstance发送或接收消息，需要重新实例化该对象。

  如下所示为接收消息的使用方式：

  //接收队列1的消息
  var retRec1 = await _quickRabbitMqPlus.Receive<TestRabbitMQModel1>(async (data, msg) =>
  {
    await Task.Delay(1000);
  
    Console.ForegroundColor = ConsoleColor.Green;
    Console.WriteLine($"\r\n队列1消息：{msg}");
  
    //返回true代表业务逻辑处理成功，会告知MQ这条消息已经接收成功，会从MQ队列中删除
    //返回false代表业务逻辑处理失败，会告知MQ这条消息没有处理成功，则MQ会继续推送这条消息
    return true;
  }, async (errMsg, msg) =>
  {
    await Task.Delay(3000);
  
    Console.ForegroundColor = ConsoleColor.Red;
    Console.WriteLine($"\r\n队列1接收错误：{errMsg}\r\n原始数据：{msg}");
  }, 1);
  if (!retRec1.Item1)
  {
    Console.ForegroundColor = ConsoleColor.Red;
    Console.WriteLine($"\r\n队列1接收失败：{retRec1.Item2}");
  }
  

7、🍟Quick.RabbitMQPlus使用说明

Quick.RabbitMQPlus组件的使用方式和Quick.RabbitMQPlus.Furion组件完全一致（包括配置、实体特性和方法等），唯一不同的就是Quick.RabbitMQPlus.Furion需要在启动程序中通过依赖注入注册服务（services.AddRabbitMQPlus()、services.AddRabbitMQPlus<T>()）或注册RabbitMQ连接配置对象（builder.Services.AddConfigurableOptions<QuickRabbitMQPlusOptions>();）。