using System.Text;
using System.Text.Json;
using Dpz.Core.Entity.Base;
using Dpz.Core.MessageQueue.Abstractions;
using Dpz.Core.MessageQueue.Enums;
using Microsoft.Extensions.Logging;
using RabbitMQ.Client;
using ExchangeType = Dpz.Core.MessageQueue.Enums.ExchangeType;

namespace Dpz.Core.MessageQueue.RabbitMQ;

/// <summary>
/// RabbitMQ消息发布者实现
/// 队列发布频繁可以改为 Channel 池 或者 AsyncLocal&lt;IChannel&gt;线程本地化
/// 不必过早优化
/// </summary>
/// <typeparam name="TMessage">消息类型</typeparam>
public class RabbitMQPublisher<TMessage>(
    IRabbitMQConnectionFactory connectionFactory,
    IMessageRoutingConvention routingConvention,
    ILogger<RabbitMQPublisher<TMessage>> logger
) : IMessagePublisher<TMessage>, IAsyncDisposable
    where TMessage : MessageBase
{
    private readonly string _exchangeName = routingConvention.GetExchangeName<TMessage>();
    private readonly ExchangeType _exchangeType = routingConvention.GetExchangeType<TMessage>();
    private readonly string _defaultRoutingKey = routingConvention.GetRoutingKey<TMessage>();
    private readonly string _queueName = routingConvention.GetQueueName<TMessage>();

    // 并发控制:保护 Channel 的创建和基础设施初始化
    private readonly SemaphoreSlim _initLock = new(1, 1);

    // 0 = 未初始化,1 = 已初始化。Channel 断开(Broker 重启/网络中断)后需要重新声明,
    // 否则 Broker 侧队列/绑定丢失时将无法再次创建,消息会被静默丢弃。
    private int _infrastructureInitialized;

    // Channel 复用(单例模式下安全,通过 SemaphoreSlim 保护并发访问)
    private IChannel? _channel;
    private readonly SemaphoreSlim _channelLock = new(1, 1);

    public async Task PublishAsync(
        TMessage message,
        string? routingKey = null,
        CancellationToken cancellationToken = default
    )
    {
        // 获取复用的 Channel
        await _channelLock.WaitAsync(cancellationToken);
        try
        {
            if (_channel is not { IsOpen: true })
            {
                // 复用的 Channel 已失效,Broker 可能重启过,基础设施需要重新声明
                Volatile.Write(ref _infrastructureInitialized, 0);
            }

            await InitializeInfrastructureAsync();
            var channel = await GetOrCreateChannelAsync();

            // 序列化消息
            var json = JsonSerializer.Serialize(message);
            var body = Encoding.UTF8.GetBytes(json);

            // 设置消息属性
            var properties = new BasicProperties
            {
                Persistent = true,
                MessageId = message.MessageId,
                Timestamp = new AmqpTimestamp(
                    ((DateTimeOffset)message.Timestamp).ToUnixTimeSeconds()
                ),
                ContentType = "application/json",
                DeliveryMode = DeliveryModes.Persistent,
            };

            // 发布消息(mandatory=true 启用路由失败检测)
            var actualRoutingKey = routingKey ?? _defaultRoutingKey;
            await channel.BasicPublishAsync(
                exchange: _exchangeName,
                routingKey: actualRoutingKey,
                mandatory: true,
                basicProperties: properties,
                body: body,
                cancellationToken: cancellationToken
            );

            logger.LogInformation(
                "消息已发布: MessageId={MessageId}, Exchange={Exchange}, RoutingKey={RoutingKey}",
                message.MessageId,
                _exchangeName,
                actualRoutingKey
            );
        }
        catch (Exception ex)
        {
            logger.LogError(
                ex,
                "发布消息失败: MessageId={MessageId}, Exchange={Exchange}, RoutingKey={RoutingKey}",
                message.MessageId,
                _exchangeName,
                routingKey ?? _defaultRoutingKey
            );

            // 发生异常时清理 Channel,下次重新创建
            await CleanupChannelAsync();
            throw;
        }
        finally
        {
            _channelLock.Release();
        }
    }

    public async Task PublishBatchAsync(
        IEnumerable<TMessage> messages,
        string? routingKey = null,
        CancellationToken cancellationToken = default
    )
    {
        var messageList = messages.ToList();
        if (messageList.Count == 0)
        {
            return;
        }

        // 获取复用的 Channel
        await _channelLock.WaitAsync(cancellationToken);
        try
        {
            if (_channel is not { IsOpen: true })
            {
                // 复用的 Channel 已失效,Broker 可能重启过,基础设施需要重新声明
                Volatile.Write(ref _infrastructureInitialized, 0);
            }

            await InitializeInfrastructureAsync();
            var channel = await GetOrCreateChannelAsync();
            var actualRoutingKey = routingKey ?? _defaultRoutingKey;

            // 批量发布所有消息
            // 1. 复用 Channel,减少连接开销
            // 2. 在同一个锁内批量发送,保证顺序性和原子性
            // 3. 消息持久化(Persistent=true)保证可靠性
            foreach (var message in messageList)
            {
                var json = JsonSerializer.Serialize(message);
                var body = Encoding.UTF8.GetBytes(json);

                var properties = new BasicProperties
                {
                    Persistent = true,
                    MessageId = message.MessageId,
                    Timestamp = new AmqpTimestamp(
                        ((DateTimeOffset)message.Timestamp).ToUnixTimeSeconds()
                    ),
                    ContentType = "application/json",
                    DeliveryMode = DeliveryModes.Persistent,
                };

                await channel.BasicPublishAsync(
                    exchange: _exchangeName,
                    routingKey: actualRoutingKey,
                    mandatory: true,
                    basicProperties: properties,
                    body: body,
                    cancellationToken: cancellationToken
                );
            }

            logger.LogInformation(
                "批量发布 {Count} 条消息成功: Exchange={Exchange}, RoutingKey={RoutingKey}",
                messageList.Count,
                _exchangeName,
                actualRoutingKey
            );
        }
        catch (Exception ex)
        {
            logger.LogError(ex, "批量发布消息失败: 尝试发布 {Count} 条消息", messageList.Count);

            // 发生异常时清理 Channel,下次重新创建
            await CleanupChannelAsync();
            throw;
        }
        finally
        {
            _channelLock.Release();
        }
    }

    /// <summary>
    /// 初始化 Exchange、Queue 和 Binding(线程安全,双重检查锁定)
    /// 这样即使消费者未启动,消息也能正确路由到队列
    /// </summary>
    private async Task InitializeInfrastructureAsync()
    {
        // 第一次检查:避免不必要的锁竞争
        if (Volatile.Read(ref _infrastructureInitialized) == 1)
        {
            return;
        }

        await _initLock.WaitAsync();
        try
        {
            // 第二次检查:防止重复创建
            if (Volatile.Read(ref _infrastructureInitialized) == 1)
            {
                return;
            }

            var channel = await connectionFactory.CreateChannelAsync();
            await using var _ = channel.ConfigureAwait(false);

            // 1. 声明Exchange(幂等操作)
            await channel.ExchangeDeclareAsync(
                exchange: _exchangeName,
                type: _exchangeType.ToRabbitMQString(),
                durable: true,
                autoDelete: false,
                arguments: null
            );

            // 2. 声明Queue(幂等操作)
            await channel.QueueDeclareAsync(
                queue: _queueName,
                durable: true,
                exclusive: false,
                autoDelete: false,
                arguments: null
            );

            // 3. 绑定Queue到Exchange(幂等操作)
            await channel.QueueBindAsync(
                queue: _queueName,
                exchange: _exchangeName,
                routingKey: _defaultRoutingKey,
                arguments: null
            );

            Volatile.Write(ref _infrastructureInitialized, 1);

            logger.LogInformation(
                "RabbitMQ基础设施已就绪: Exchange={Exchange}, Queue={Queue}, RoutingKey={RoutingKey}, Type={Type}",
                _exchangeName,
                _queueName,
                _defaultRoutingKey,
                _exchangeType
            );
        }
        catch (Exception ex)
        {
            logger.LogError(
                ex,
                "创建RabbitMQ基础设施失败: Exchange={Exchange}, Queue={Queue}",
                _exchangeName,
                _queueName
            );
            throw;
        }
        finally
        {
            _initLock.Release();
        }
    }

    /// <summary>
    /// 获取或创建复用的 Channel
    /// 注意:调用此方法前必须已获取 _channelLock
    /// </summary>
    private async Task<IChannel> GetOrCreateChannelAsync()
    {
        // 如果 Channel 已存在且可用,直接返回
        if (_channel is { IsOpen: true })
        {
            return _channel;
        }

        // 清理旧的 Channel
        if (_channel != null)
        {
            try
            {
                await _channel.CloseAsync();
                await _channel.DisposeAsync();
            }
            catch
            {
                // 忽略清理异常
            }
        }

        // 创建新的 Channel
        var channel = await connectionFactory.CreateChannelAsync();
        channel.ChannelShutdownAsync += (_, args) =>
        {
            // Channel 断开说明 Broker 可能已经重启,队列/绑定不再可信,
            // 下一次发布时必须重新声明基础设施,避免消息被投递到不存在的队列。
            Volatile.Write(ref _infrastructureInitialized, 0);
            if (args.ReplyCode != 0)
            {
                logger.LogWarning(
                    "RabbitMQ发布Channel已关闭,将重新声明基础设施: Exchange={Exchange}, ReplyCode={ReplyCode}, Reason={Reason}",
                    _exchangeName,
                    args.ReplyCode,
                    args.ReplyText
                );
            }
            return Task.CompletedTask;
        };
        _channel = channel;

        logger.LogDebug("已创建新的 Channel: Exchange={Exchange}", _exchangeName);

        return _channel;
    }

    /// <summary>
    /// 清理 Channel(在发生异常时调用)
    /// 调用此方法时无需持有 _channelLock
    /// </summary>
    private async Task CleanupChannelAsync()
    {
        if (_channel == null)
        {
            return;
        }

        try
        {
            await _channel.CloseAsync();
            await _channel.DisposeAsync();
        }
        catch (Exception ex)
        {
            logger.LogWarning(ex, "清理 Channel 时发生异常");
        }
        finally
        {
            _channel = null;
            // 发布异常后 Channel 会被重建,基础设施需要重新声明
            Volatile.Write(ref _infrastructureInitialized, 0);
        }
    }

    /// <summary>
    /// 释放资源
    /// </summary>
    public async ValueTask DisposeAsync()
    {
        await CleanupChannelAsync();

        _initLock.Dispose();
        _channelLock.Dispose();

        GC.SuppressFinalize(this);
    }
}
⚠⚠    以下内容为AI分析的结果,请根据实际情况进行判断。

一句话定位

RabbitMQPublisher<TMessage> 是消息队列库中唯一真正向 RabbitMQ 投递消息的发布者:IMessagePublisher.cs 的实现,负责懒初始化 Exchange/Queue/Binding + 单 Channel 复用 + JSON 序列化投递,实际由 OutboxMessagePublisher.cs 或各 Controller(如 ArticleController.cs)通过 IMessagePublisher<T> 使用。

关键类型与方法

构造函数阶段一次性把路由约定结果固化为只读字段(_exchangeName / _exchangeType / _defaultRoutingKey / _queueName)。这意味着 DefaultMessageRoutingConvention.cs 里基于反射读取 [MessageRoute] 的开销只发生一次,但也意味着运行期无法切换路由。

PublishAsync(单条)与 PublishBatchAsync(批量)是两条几乎逐行重复的实现,差异只有循环和日志文案。二者都是:拿 _channelLock → 若 Channel 不可用则把初始化标志清零 → InitializeInfrastructureAsync → GetOrCreateChannelAsync → 逐条 BasicPublishAsync(mandatory: true) → 任何异常都 CleanupChannelAsync() 后 throw。

语义要点:

  • 使用 mandatory: true,加上 RabbitMQConnectionFactory.cs 里 CreateChannelOptions(publisherConfirmationsEnabled: true, publisherConfirmationTrackingEnabled: true),因此无法路由或 Broker 未确认时会抛异常,而不是静默成功。这是整个可靠性链的基础(Outbox 的 MarkPublishFailedAsync 依赖它)。
  • 消息属性固定为持久化(Persistent + DeliveryMode.Persistent)、ContentType=application/json、带 MessageId 与 Timestamp。
  • 失败语义是「一失败就丢 Channel」:不区分故障类型,序列化异常、OperationCanceledException、确认超时一律销毁复用的 Channel 并把 _infrastructureInitialized 归零,下次发布重建 Channel 并重新声明交换机/队列。
  • 批量的「原子性」注释与实现不符:代码用的是注释里的 Channel(单 Channel),没有事物(事务);每条消息各自等待 confirm,中途第 N 条失败时前 N-1 条已经真实入队,异常照旧抛给调用方。OutboxMessagePublisher.cs 的 PublishBatchAsync 在 catch 中把整批都标记为发布失败,重试时会重复发送前 N-1 条。批量方法相对「循环调用单条」的收益也很有限:同样 N 次网络往返,却把全局锁持有得更久。

InitializeInfrastructureAsync 用 SemaphoreSlim + Volatile.Read/Write 做双重检查,用一个临时 Channel 声明 durable 的 Exchange、durable 非独占的 Queue,并把 Queue 绑定到 _defaultRoutingKey。声明参数与消费者侧 RabbitMQConsumerBackgroundServiceBase.cs 的 ExchangeDeclareAsync/QueueDeclareAsync/QueueBindAsync 完全一致(同为 arguments: null),这点很关键——两侧参数不一致会让 Broker 返回 PRECONDITION_FAILED,此处是一致的。失败后不置标志位,下次发布重试声明。

GetOrCreateChannelAsync 只负责 Channel 生命周期,并挂载 ChannelShutdownAsync,在 Channel 断开时把初始化标志清零,保证 Broker 重启/队列被删后下次发布会重新声明基础设施。方法本身的注释要求调用方先持有 _channelLock,这是一个只靠注释维护的隐含前置条件。

CleanupChannelAsync 关闭并释放 Channel 后把 _channel 置 null、标志位清零,异常只记 warning。DisposeAsync 复用同一方法,然后释放两个信号量。

依赖与协作

  • 依赖注入的是 IRabbitMQConnectionFactory(RabbitMQConnectionFactory.cs 内部维护单条 IConnection 并开启自动恢复)、IMessageRoutingConvention、ILogger。本类不接触 ConnectionFactory、不读配置。
  • 注册在 MessageQueueServiceExtensions.cs:services.AddSingleton(typeof(IMessagePublisher<>), typeof(RabbitMQPublisher<>)),即每种消息类型一个单例。
  • 启用 Outbox 时 MessageOutboxExtensions.cs 又调用 services.AddSingleton(typeof(RabbitMQPublisher<>)) 注册了具体类型,供 OutboxMessagePublisher<TMessage> 按具体类型注入以绕开装饰器自引用。微软 DI 的容器缓存在 CallSite 粒度,这两次是不同注册,因此 IMessagePublisher<T> 与 RabbitMQPublisher<T> 是两个不同实例:一个消息类型会存在两份 Channel、两份 SemaphoreSlim、两个独立的初始化标志。总量约为 2 × 消息类型数。连接是共享的,Channel 不共享。
  • 发布的路由键与队列绑定必须与消费者侧共享同一套约定推出的名字,才能形成「发布 → 路由 → 入队 → 消费」闭环;两侧代码都调用同一 IMessageRoutingConvention。

流程/时序

flowchart TD
    A[PublishAsync / PublishBatchAsync] --> B[await _channelLock]
    B --> C{_channel.IsOpen?}
    C -- 否 --> D[_infrastructureInitialized = 0]
    C -- 是 --> E
    D --> E[InitializeInfrastructureAsync]
    E --> F{标志位 == 1?}
    F -- 是 --> G[GetOrCreateChannelAsync]
    F -- 否 --> H[await _initLock<br/>临时 Channel 声明 Exchange/Queue/Binding<br/>置标志位 1]
    H --> G
    G --> I{复用 Channel 可用?}
    I -- 否 --> J[关闭旧 Channel 并新建<br/>挂 ChannelShutdownAsync 回调]
    I -- 是 --> K
    J --> K[JSON 序列化 + BasicProperties]
    K --> L[BasicPublishAsync mandatory=true<br/>等待 publisher confirm]
    L -- 成功 --> M[记日志]
    L -- 异常 --> N[CleanupChannelAsync<br/>标志位清零 + 抛异常]
    M --> O[finally 释放 _channelLock]
    N --> O

需要注意的点

  • 锁粒度就是单消息类型的全局串行:整个发布过程(含等待 confirm 的网络往返、基础设施声明、连接建立)都在 _channelLock 内。同一 TMessage 的所有并发发布被完全串行化;PublishBatchAsync 持锁时间随条数线性增长。类头注释已承认这是「现阶段不优化」,但它的代价不只在吞吐,还在下面这条。
  • 锁内等待连接且不可取消:InitializeInfrastructureAsync 的 _initLock.WaitAsync() 及各 ExchangeDeclareAsync/QueueDeclareAsync/QueueBindAsync 都没有传 cancellationToken。Broker 不可达时,持锁线程会一直等到 RequestedConnectionTimeout 才失败,期间该消息类型的所有调用方(包括带超时的 HTTP 请求)全部阻塞。传入的 cancellationToken 只在 BasicPublishAsync 处生效。
  • 取消/普通异常会被误判为 Channel 损坏:catch (Exception) 一律 CleanupChannelAsync()。调用方取消一次发布,就会销毁一个健康 Channel 并触发下一条消息重新声明整套基础设施。这类「取消导致重建」的抖动在 Outbox 后台补发场景下会被放大。
  • DisposeAsync 与并发发布有竞态:它不置 _disposed 标记、不取 _channelLock 就清理 Channel 并 Dispose() 两个信号量;此时正在 WaitAsync 或已持有信号量的发布调用会得到 ObjectDisposedException 或 SemaphoreFullException。容器关闭顺序上,IHostedService 与单例的释放时机不保证与该单例的发布调用互斥。
  • ExchangeType 只在一处被真正使用:PublishAsync 不设置任何 headers。若某消息类型通过 [MessageRoute(ExchangeType = ExchangeType.Headers)] 声明,Binding 的 arguments 又是 null,队列与交换机之间不存在有效匹配规则,所有发布都会因 unroutable 抛 PublishException。同理,若把 ExchangeType 设为 Direct 却传入与约定不同的 routingKey,会直接抛异常——routingKey 参数只对 topic 约定天然安全。
  • 默认路由键本身带通配符:约定产出的 _defaultRoutingKey 形如 news.article.#(见 DefaultMessageRoutingConvention.cs),发布时把它当作普通 routing key 使用。当前能工作是因为绑定键同形,但语义上是「用匹配模式当路由键」,读日志或做排障时容易误解。
  • Timestamp 的时区换算:(DateTimeOffset)message.Timestamp 对 DateTimeKind.Unspecified 会按本机时区解释。MessageBase.Timestamp 默认是 DateTime.UtcNow(Kind=Utc)所以默认路径正确,但只要调用方手动赋一个 Kind 未标明的时间,消息时间戳就会偏移若干小时,且不会有任何报错。
  • MessageId 不做去重:发布端不校验 MessageId 唯一性,重复投递的兜底完全依赖消费端的 IMessageOutboxStore 状态机。
  • 每条消息一次 LogInformation:高频发布时这是主要的日志开销来源之一,PublishBatchAsync 只在整批完成后记一条,行为不一致。
  • 同一段序列化与属性构造代码在 PublishAsync 与 PublishBatchAsync 中重复了两遍,后续若要加 header(例如 trace id、租户)必须同步改两处,容易被漏改。
评论加载中...