Orleans Broadcast Channel

原创已于 2025-10-18 23:05:45 修改 · 942 阅读

21 ·

CC 4.0 BY-SA版权

文章标签：

#java #spring #开发语言 #c#

于 2025-10-11 16:22:21 首次发布

WINDOWS 同时被 3 个专栏收录

90 篇文章

订阅专栏

Android平台

77 篇文章

订阅专栏

Web开发

36 篇文章

订阅专栏

【投稿赢 iPhone 17】「我的第一个开源项目」故事征集：用代码换C位出道！ 10w+人浏览 1.8k人参与

“扇出”（fan-out）指的是把一条输入消息同时分发给多个下游接收者的过程。对应地，“扇入”（fan-in）是把多路输入汇聚到一路。

在广播实现中，扇出体现在：

BroadcastChannelWriter.Publish 会先查到所有隐式订阅者列表，然后对每个订阅者并发调用其 OnPublished。
fire-and-forget=true：并发发送后不等待任何订阅者完成，最小化发布端时延。
fire-and-forget=false：并发发送并 Task.WhenAll 等待全部订阅者完成，失败会聚合为 AggregateException。

概述

Orleans Broadcast Channel 是 Orleans 框架中的一个重要组件，它提供了一种一对多的消息广播机制。与传统的 Orleans Streams 不同，Broadcast Channel 专门设计用于将消息同时发送给多个订阅者，而不需要显式的订阅管理。

核心特性

1. 隐式订阅 (Implicit Subscriptions)

订阅者通过属性标记自动订阅，无需手动管理订阅生命周期
支持基于命名空间和正则表达式的订阅模式匹配
自动处理订阅者的创建和销毁

2. Fire-and-Forget 模式

默认支持异步非阻塞的消息传递
可配置为同步等待所有订阅者处理完成
提供错误处理和重试机制

3. 类型安全

强类型支持，编译时类型检查
支持泛型消息类型
自动序列化和反序列化

核心组件架构

1. IBroadcastChannelProvider

public interface IBroadcastChannelProvider
{
    IBroadcastChannelWriter<T> GetChannelWriter<T>(ChannelId streamId);
}

提供者接口，负责创建频道写入器
管理频道实例和配置

2. IBroadcastChannelWriter

public interface IBroadcastChannelWriter<T>
{
    Task Publish(T item);
}

消息发布接口
负责将消息广播给所有匹配的订阅者

3. IOnBroadcastChannelSubscribed

public interface IOnBroadcastChannelSubscribed
{
    Task OnSubscribed(IBroadcastChannelSubscription streamSubscription);
}

订阅者必须实现的接口
处理订阅建立和消息接收

4. ImplicitChannelSubscriberTable

维护隐式订阅者表
根据频道命名空间匹配订阅者
缓存订阅者信息以提高性能

配置和设置

1. 服务端配置

builder.AddBroadcastChannel("BroadcastChannel", options =>
{
    options.FireAndForgetDelivery = true; // 默认值
});

2. 客户端配置

clientBuilder.AddBroadcastChannel("BroadcastChannel");

3. 订阅者标记

[ImplicitChannelSubscription("namespace")]
public class MySubscriberGrain : Grain, IOnBroadcastChannelSubscribed
{
    public Task OnSubscribed(IBroadcastChannelSubscription subscription)
    {
        subscription.Attach<MyMessageType>(OnMessageReceived, OnError);
        return Task.CompletedTask;
    }
}

使用场景

系统通知: 向所有相关用户发送系统公告
配置更新: 广播配置变更给所有服务实例
事件分发: 将业务事件分发给多个处理者
状态同步: 同步状态变更给多个客户端

时序图

现在让我创建一个详细的时序图来展示 Orleans Broadcast Channel 的工作流程：

完整的消息发布和接收流程

订阅者注册和匹配流程

命名空间匹配和订阅者发现

关键组件交互图

配置选项对比

实际使用示例

1. 基础配置示例

// 服务端配置
public class Startup
{
    public void ConfigureServices(IServiceCollection services)
    {
        services.AddOrleans(siloBuilder =>
        {
            siloBuilder.AddBroadcastChannel("SystemNotifications", options =>
            {
                options.FireAndForgetDelivery = true; // 异步模式
            });
            
            siloBuilder.AddBroadcastChannel("CriticalUpdates", options =>
            {
                options.FireAndForgetDelivery = false; // 同步模式，等待所有订阅者
            });
        });
    }
}

// 客户端配置
public class ClientStartup
{
    public void ConfigureServices(IServiceCollection services)
    {
        services.AddOrleansClient(clientBuilder =>
        {
            clientBuilder.AddBroadcastChannel("SystemNotifications");
            clientBuilder.AddBroadcastChannel("CriticalUpdates");
        });
    }
}

2. 消息发布示例

public class NotificationService
{
    private readonly IBroadcastChannelProvider _channelProvider;
    
    public NotificationService(IBroadcastChannelProvider channelProvider)
    {
        _channelProvider = channelProvider;
    }
    
    public async Task BroadcastSystemNotification(string message)
    {
        var channelId = ChannelId.Create("system", "notifications");
        var writer = _channelProvider.GetChannelWriter<SystemNotification>(channelId);
        
        var notification = new SystemNotification
        {
            Message = message,
            Timestamp = DateTime.UtcNow,
            Severity = NotificationSeverity.Info
        };
        
        await writer.Publish(notification);
    }
    
    public async Task BroadcastCriticalUpdate(string updateId, string description)
    {
        var channelId = ChannelId.Create("critical", updateId);
        var writer = _channelProvider.GetChannelWriter<CriticalUpdate>(channelId);
        
        var update = new CriticalUpdate
        {
            UpdateId = updateId,
            Description = description,
            Timestamp = DateTime.UtcNow
        };
        
        await writer.Publish(update);
    }
}

3. 订阅者实现示例

// 系统通知订阅者
[ImplicitChannelSubscription("system")]
public class SystemNotificationSubscriber : Grain, IOnBroadcastChannelSubscribed
{
    private readonly ILogger<SystemNotificationSubscriber> _logger;
    
    public SystemNotificationSubscriber(ILogger<SystemNotificationSubscriber> logger)
    {
        _logger = logger;
    }
    
    public Task OnSubscribed(IBroadcastChannelSubscription subscription)
    {
        subscription.Attach<SystemNotification>(
            onPublished: async notification =>
            {
                _logger.LogInformation("收到系统通知: {Message}", notification.Message);
                await ProcessSystemNotification(notification);
            },
            onError: async exception =>
            {
                _logger.LogError(exception, "处理系统通知时发生错误");
            }
        );
        
        return Task.CompletedTask;
    }
    
    private async Task ProcessSystemNotification(SystemNotification notification)
    {
        // 处理系统通知的业务逻辑
        await Task.Delay(100); // 模拟处理时间
    }
}

// 关键更新订阅者 - 使用正则表达式匹配
[RegexImplicitChannelSubscription("critical-.*")]
public class CriticalUpdateSubscriber : Grain, IOnBroadcastChannelSubscribed
{
    private readonly ILogger<CriticalUpdateSubscriber> _logger;
    
    public CriticalUpdateSubscriber(ILogger<CriticalUpdateSubscriber> logger)
    {
        _logger = logger;
    }
    
    public Task OnSubscribed(IBroadcastChannelSubscription subscription)
    {
        subscription.Attach<CriticalUpdate>(
            onPublished: async update =>
            {
                _logger.LogWarning("收到关键更新: {UpdateId} - {Description}", 
                    update.UpdateId, update.Description);
                await ProcessCriticalUpdate(update);
            },
            onError: async exception =>
            {
                _logger.LogError(exception, "处理关键更新时发生错误");
            }
        );
        
        return Task.CompletedTask;
    }
    
    private async Task ProcessCriticalUpdate(CriticalUpdate update)
    {
        // 处理关键更新的业务逻辑
        await Task.Delay(200); // 模拟处理时间
    }
}

4. 消息类型定义

[GenerateSerializer]
public record SystemNotification
{
    [Id(0)] public string Message { get; init; }
    [Id(1)] public DateTime Timestamp { get; init; }
    [Id(2)] public NotificationSeverity Severity { get; init; }
}

[GenerateSerializer]
public record CriticalUpdate
{
    [Id(0)] public string UpdateId { get; init; }
    [Id(1)] public string Description { get; init; }
    [Id(2)] public DateTime Timestamp { get; init; }
}

public enum NotificationSeverity
{
    Info,
    Warning,
    Error,
    Critical
}

5. 高级配置示例

// 自定义频道ID映射器
public class CustomChannelIdMapper : IChannelIdMapper
{
    public string GetGrainKeyId(GrainBindings grainBindings, InternalChannelId channelId)
    {
        // 自定义逻辑：从频道ID中提取用户ID作为Grain Key
        var channelKey = channelId.ChannelId.GetKeyAsString();
        return ExtractUserIdFromChannelKey(channelKey);
    }
    
    private string ExtractUserIdFromChannelKey(string channelKey)
    {
        // 实现自定义的键提取逻辑
        return channelKey.Split('-')[0];
    }
}

// 注册自定义映射器
services.AddKeyedSingleton<IChannelIdMapper, CustomChannelIdMapper>("CustomMapper");

// 使用自定义映射器的订阅者
[ImplicitChannelSubscription("user-notifications", "CustomMapper")]
public class UserNotificationSubscriber : Grain, IOnBroadcastChannelSubscribed
{
    // 实现逻辑...
}