（七）.NET6.0部署RabbitMQ

合集 - RabbitMQ(2)

1.（七）.NET6.0部署RabbitMQ2024-12-27

2.基于.NET8.0实现RabbitMQ的Publish/Subscribe发布订阅以及死信队列01-09

1.下载erlang语言包OTP。官网地址：
https://www.erlang.org/downloads

2.Rabbitmq官网下载地址：
https://www.rabbitmq.com/download.html

需要先安装Erlang语言包，然后再安装RabbitMQ，安装RabbitMQ的服务器名称(电脑名称)，以及用户名称，不要带中文，有可能会导致服务无法识别服务器，导致一些bug。

3.安装成功以后Rabbitmq服务是启动状态，就代表成功
●Win+R打开运行
●输入services.msc点击确定
●查看服务是否正在运行

4.配置环境变量
●设置Erlang语言包的环境变量，新建系统变量ERLANG_HOME，变量值是对应的安装目录

●添加Path环境变量

●设置MQ的环境变量，新建系统变量RABBITMQ_SERVER值是MQ的安装目录

●添加Path环境变量

注：
这里还未确定是系统变量里的Path要设置还是用户变量要设置，我全部都设置了
Erlang 会生成两个 cookie 文件：C:\Windows\System32\config\systemprofile.erlang.cookie 及 C:\用户\你的用户名.erlang.cookie。

5.安装RabbitMQ-Plugins插件
打开cmd命令提示符，并且输入
rabbitmq-plugins enable rabbitmq_management
即可自动安装MQ插件。
6.在菜单（开始）里找到这个程序（没有的话，可以直接以管理员运行cmd然后打开到rabbitmq的sbin目录下），然后右键管理员运行

rabbitmq-server.bat ---启动rabbitmq服务（这个如果启动了，那么服务中的就没有启动）

rabbitmqctl status命令

7.出现上面的结果说明rabbitmq服务已经正常启动，建议访问http://localhost:15672/，默认用户名密码都是guest
8.设置自己的用户名密码

添加完成以后，页面如下：

页面提示没有权限访问虚拟主机，我们需要点击刚刚创建的名称，就可以进去设置虚拟主机的访问权限。我们使用默认的设置即可：

设置完成以后，刚才的页面就会提示一个默认的 / 了，代表默认虚拟主机权限设置完成：

注意：由此，MQ环境配置以及完成。如果安装以后，服务还没启动的，可以先看下服务里面的MQ配置是不是自动，如果不是自动，就先手动启动并且设置自动。如果手动起不来，就重启一下计算机。如果还是不行，可以考虑是否计算机的用户名、计算机名称有特殊符号或中文。

9.接下来开始.net core操作Rabbitmq有关的内容。我使用direct直连模式首先，我在我的package包项目上面，添加对RabbitMQ.Client的引用

10.在启动项目下的appsettings配置文件里面，新增访问RabbitMQ的配置连接字符串

11.然后，在实体类项目下，新建实体类MqConfigInfo，用于把读取的配置信息赋值到该实体类下

12.在刚刚新建的RabbitMQ类库项目下面，引用该实体类库项目，以及APppSettings项目。然后新建一个类，叫做ReadMqConfigHelper，以及它的interface接口，并且提供一个方法，叫ReadMqConfig，用来进行读取配置信息使用

13.新建类MqConnectionHelper以及接口IMqConnectionHelper，用于做MQ连接、创建生产者和消费者等有关操作

点击查看代码

public class MqConnectionHelper:IMqConnectionHelper
{
    private readonly ILogger<MqConnectionHelper> _logger;

    public MqConnectionHelper(ILogger<MqConnectionHelper> logger)
    {
        _logger = logger;
        _connectionReceiveFactory = new IConnectionFactory[_costomerCount];
        _connectionReceive = new IConnection[_costomerCount];
        _modelReceive = new IModel[_costomerCount];
        _basicConsumer = new EventingBasicConsumer[_costomerCount];
    }



    //使用数组的部分，是给消费端用的，目前生产者只设置了一个，消费者可能存在多个。

    /// <summary>
    /// RabbitMQ工厂发送端
    /// </summary>
    private static IConnectionFactory _connectionSendFactory;
    /// <summary>
    /// RabbitMQ工厂接收端
    /// </summary>
    private static IConnectionFactory[] _connectionReceiveFactory;

    /// <summary>
    /// 连接 发送端
    /// </summary>
    private static IConnection _connectionSend;
    /// <summary>
    /// 连接 消费端
    /// </summary>
    private static IConnection[] _connectionReceive;

    /// <summary>
    /// 配置信息
    /// </summary>
    public static List<MqConfigInfo> _mqConfigs;

    /// <summary>
    /// 通道 发送端
    /// </summary>
    private static IModel _modelSend;
    /// <summary>
    /// 通道 消费端
    /// </summary>
    private static IModel[] _modelReceive;

    private static EventingBasicConsumer[] _basicConsumer;//事件

    //设置两个routingKey和队列名称，用来做测试使用
    public static int _costomerCount = 2;
    public static string[] _routingKey = new string[] { "YsqNet001", "YsqNet002" };
    public static string[] _queueName = new string[] { "Queue001", "Queue002" };

    /// <summary>
    /// 生产者初始化连接配置
    /// </summary>
    public void SendFactoryConnectionInit()
    {
        _connectionSendFactory = new ConnectionFactory
        {
            HostName = _mqConfigs.FirstOrDefault().Host,
            Port = _mqConfigs.FirstOrDefault().Port,
            UserName = _mqConfigs.FirstOrDefault().User,
            Password = _mqConfigs.FirstOrDefault().Password
        };
    }

    /// <summary>
    /// 生产者连接
    /// </summary>
    public void SendFactoryConnection()
    {
        if (_connectionSend != null && _connectionSend.IsOpen)
        {
            return;//已有连接
        }

        _connectionSend = _connectionSendFactory.CreateConnection();//创建生产者连接

        if (_modelSend != null && _modelSend.IsOpen)
        {
            return;//已有通道
        }

        _modelSend = _connectionSend.CreateModel();//创建生产者通道

        _modelSend.ExchangeDeclare(_mqConfigs.FirstOrDefault().ExchangeName, ExchangeType.Direct);
    }

    /// <summary>
    /// 消费者初始化连接配置
    /// </summary>
    public void ReceiveFactoryConnectionInit()
    {
        var factories = new ConnectionFactory
        {
            HostName = _mqConfigs.FirstOrDefault().Host,
            Port = _mqConfigs.FirstOrDefault().Port,
            UserName = _mqConfigs.FirstOrDefault().User,
            Password = _mqConfigs.FirstOrDefault().Password
        };

        for (int i = 0; i < _costomerCount; i++)
        {
            _connectionReceiveFactory[i] = factories;//给每个消费者绑定一个连接工厂
        }
    }

    /// <summary>
    /// 消费者连接
    /// </summary>
    /// <param name="consumeId"></param>
    /// <param name="exchangeName"></param>
    /// <param name="routeKey"></param>
    /// <param name="queueName"></param>
    public void ConncetionReceive(int consumeId, string exchangeName, string routeKey, string queueName)
    {
        _logger.LogInformation($"开始连接RabbitMQ消费者：{routeKey}");

        if (_connectionReceive[consumeId] != null && _connectionReceive[consumeId].IsOpen)
        {
            return;
        }

        _connectionReceive[consumeId] = _connectionReceiveFactory[consumeId].CreateConnection();//创建消费者连接

        _modelReceive[consumeId] = _connectionReceive[consumeId].CreateModel();//创建消费者通道

        _basicConsumer[consumeId] = new EventingBasicConsumer(_modelReceive[consumeId]);

        _modelReceive[consumeId].ExchangeDeclare(exchangeName, ExchangeType.Direct);//定义交换机名称和类型 与生产者保持一致

        _modelReceive[consumeId].QueueDeclare(
            queue:queueName,//消息队列名称
            durable:_mqConfigs.FirstOrDefault().Durable,//是否可持久化，此处配置在文件中，默认全局持久化（true）
            exclusive:false,
            autoDelete:false,
            arguments:null
            );//定义消费者队列

        _modelReceive[consumeId].QueueBind(queueName,exchangeName,routeKey);//队列绑定给指定的交换机

        _modelReceive[consumeId].BasicQos(0, 1, false);//设置消费者每次只接收一条消息

        StartListener((model, ea) =>
        {
            byte[] message = ea.Body.ToArray();//接收到的消息
            string msg = Encoding.UTF8.GetString(message);

            _logger.LogInformation($"队列{queueName}接收到消息：{msg}");
            Thread.Sleep(2000);
            _modelReceive[consumeId].BasicAck(ea.DeliveryTag, true);
        }, queueName, consumeId);
    }

    /// <summary>
    /// 消费者接收消息的确认机制
    /// </summary>
    /// <param name="basicDeliverEventArgs"></param>
    /// <param name="queueName"></param>
    /// <param name="consumeId"></param>
    private static void StartListener(EventHandler<BasicDeliverEventArgs> basicDeliverEventArgs,string queueName,int consumeId)
    {
        _basicConsumer[consumeId].Received += basicDeliverEventArgs;
        _modelReceive[consumeId].BasicConsume(queue: queueName, autoAck: false, consumer: _basicConsumer[consumeId]);//设置手动确认
    }

    /// <summary>
    /// 消息发布
    /// </summary>
    /// <param name="message"></param>
    /// <param name="exchangeName"></param>
    /// <param name="routeKey"></param>
    public static void PublishExchange(string message,string exchangeName,string routeKey="")
    {
        byte[] body = Encoding.UTF8.GetBytes(message);
        _modelSend.BasicPublish(exchangeName,routeKey,null,body);
    }
}