關於ASP.NET Core WebSocket實現集羣的思考

前言

提到WebSocket相信大家都聽說過，它的初衷是爲了解決客戶端瀏覽器與服務端進行雙向通信，是在單個TCP連接上進行全雙工通訊的協議。在沒有WebSocket之前只能通過瀏覽器到服務端的請求應答模式比如輪詢，來實現服務端的變更響應到客戶端，現在服務端也可以主動發送數據到客戶端瀏覽器。WebSocket協議和Http協議平行，都屬於TCP/IP四層模型中的第四層應用層。由於WebSocket握手階段採用HTTP協議,所以也需要進行跨域處理。它的協議標識是ws或wss對應了常規標識和安全通信協議標識。本文重點並不是介紹WebSocket協議相關，而是提供一種基於ASP.NET Core原生WebSocket的方式實現集羣的實現思路。關於這套思路其實很早之前我就構思過了，只是之前一直沒有系統的整理出來，本篇文章就來和大家分享一下，由於主要是提供一種思路，所以涉及到具體細節或者業務相關的可能沒有體現出來，還望大家理解。

實現

咱們的重點關鍵字就是兩個WebSocket和集羣，實現的框架便是基於ASP.NET Core,我也基於golang實現了一套,本文涉及到的相關源碼和golang版本的實現都已上傳至我的github,具體倉庫地址可以轉到文末自行跳轉到#示例源碼中查看。既然涉及到集羣，這裏咱們就用nginx作爲反向代理，來搭建一個集羣實例。大致的示例結構如下圖所示redis在這裏扮演的角色呢，是用來處理Server端的消息相互傳遞用的，主要是使用的redis的pub/sub功能來實現的，這裏便涉及到幾個核心問題

首先，集羣狀態每個用戶被分發到具體的哪臺服務器上是不得而知的
其次，處在不同Server端的不同用戶間的相互通信是需要一個傳遞媒介
最後，針對不同的場景比如單發消息、分組消息、全部通知等要有不同的處理策略

這裏需要考慮的是，如果需要搭建實時通信服務器的話，需要注意集羣的隔離性，主要是和核心業務進行隔離，畢竟WebSocket需要保持長鏈接、且消息的大小需要評估。

上面提到了redis的主要功能就是用來傳遞消息用的，畢竟每個server服務器是無狀態的。這當然不是必須的，任何可以進行消息分發的中間件都可以，比如消息隊列rabbitmq、kafka、rocketmq、mqtt等，甚至只要能把要處理的消息存儲起來都可以比如緩存甚至是關係型數據庫等等。這壓力使用redis主要是因爲操作起來簡單、輕量級、靈活，讓大家關注點在思路上，而不是使用中案件的代碼上。

nginx配置

通過上面的圖我們可以看到，我們這裏構建集羣示例使用的nginx，如果讓nginx支持WebSocket的話，需要額外的配置，這個在網上有很多相關的文章介紹，這裏就來列一下咱們示例的nginx配置，在配置文件nginx.conf裏

//上游服務器地址也就是websocket服務的真實地址
upstream wsbackend {
    server 127.0.0.1:5001;
    server 127.0.0.1:5678;
}

server {
    listen       5000;
    server_name  localhost;

    location ~/chat/{
        //upstream地址
        proxy_pass http://wsbackend;
        proxy_connect_timeout 60s; 
        proxy_read_timeout 3600s;
        proxy_send_timeout 3600s;
        //記得轉發避免踩坑
        proxy_set_header Host $host;
        proxy_http_version 1.1; 
        //http升級成websocket協議的頭標識
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection "Upgrade";
    }
}

這套配置呢，在搜索引擎上能收到很多，不過不妨礙我把使用的粘貼出來。這一套親測有效，也是我使用的配置，請放心使用。個人認爲如果是線上環境採用的負載均衡策略可以選擇ip_hash的方式，保證同一個ip的客戶端用戶可以分發到一臺WebSocket實例中去，這樣的話能儘量避免使用redis的用戶頻道做消息傳遞。好了，接下來準備開始展示具體實現的代碼了。

一對一發送

首先介紹的就是一對一發送的情況，也就是我把消息發給你，聊天的時候私聊的情況。這裏呢涉及到兩種情況

如果你需要通信的客戶端和你連接在一個Server端裏，這樣的話可以直接在鏈接裏找到這個端的通信實例直接發送。
如果你需要通信的客戶端和你不在一個Server端裏，這個時候咱們就需要藉助redis的pub/sub的功能，把消息傳遞給另一個Server端。

咱們通過一張圖大致的展示一下它的工作方式

解釋一下，每個客戶端註冊到WebSocket服務裏的時候會在redis裏訂閱一個user:用戶唯一標識的頻道，這個頻道用於接收和當前WebSocket連接不在一個服務端的其他WebSocket發送過來的消息。每次發送消息的時候你會知道你要發送給誰，不在當前服務器的話則發送到redis的user:用戶唯一標識頻道，這樣的話目標WebSocket就能收到消息了。首先是注入相關的依賴項，這裏我使用的redis客戶端是freeredis，主要是因爲操作起來簡單,具體實現代碼如下

var builder = WebApplication.CreateBuilder(args);
//註冊freeredis
builder.Services.AddSingleton(provider => {
    var logger = provider.GetService<ILogger<WebSocketChannelHandler>>();
    RedisClient cli = new RedisClient("127.0.0.1:6379");
    cli.Notice += (s, e) => logger?.LogInformation(e.Log);
    return cli;
});
//註冊WebSocket具體操作的類
builder.Services.AddSingleton<WebSocketHandler>();
builder.Services.AddControllers();

var app = builder.Build();

var webSocketOptions = new WebSocketOptions
{
    KeepAliveInterval = TimeSpan.FromMinutes(2)
};
//註冊WebSocket中間件
app.UseWebSockets(webSocketOptions);

app.MapGet("/", () => "Hello World!");
app.MapControllers();

app.Run();

接下來我們定義一個Controller用來處理WebSocket請求

public class WebSocketController : ControllerBase
{
    private readonly ILogger<WebSocketController> _logger;
    private readonly WebSocketHandler _socketHandler;

    public WebSocketController(ILogger<WebSocketController> logger, WebSocketHandler socketHandler, WebSocketChannelHandler webSocketChannelHandler)
    {
        _logger = logger;
        _socketHandler = socketHandler;
    }
    
    //這裏的id代表當前連接的客戶端唯一標識比如用戶唯一標識
    [HttpGet("/chat/user/{id}")]
    public async Task ChatUser(string id)
    {
        //判斷是否是WebSocket請求
        if (HttpContext.WebSockets.IsWebSocketRequest)
        {
            _logger.LogInformation($"user:{id}-{Request.HttpContext.Connection.RemoteIpAddress}:{Request.HttpContext.Connection.RemotePort} join");

            var webSocket = await HttpContext.WebSockets.AcceptWebSocketAsync();
            //處理請求相關
            await _socketHandler.Handle(id, webSocket);
        }
        else
        {
            HttpContext.Response.StatusCode = StatusCodes.Status400BadRequest;
        }
    }
}

這裏的WebSocketHandler是用來處理具體邏輯用的，咱們看一下相關代碼

public class WebSocketHandler:IDisposable
{
    //存儲當前服務用戶的集合
    private readonly UserConnection UserConnection = new();
    //redis頻道前綴
    private readonly string userPrefix = "user:";
    //用戶對應的redis頻道
    private readonly ConcurrentDictionary<string, IDisposable> _disposables = new();

    private readonly ILogger<WebSocketHandler> _logger;
    //redis客戶端
    private readonly RedisClient _redisClient;

    public WebSocketHandler(ILogger<WebSocketHandler> logger, RedisClient redisClient)
    {
        _logger = logger;
        _redisClient = redisClient;
    }

    public async Task Handle(string id, WebSocket webSocket)
    {
        //把當前用戶連接存儲起來
        _ = UserConnection.GetOrAdd(id, webSocket);
        //訂閱一個當前用戶的頻道
        await SubMsg($"{userPrefix}{id}");

        var buffer = new byte[1024 * 4];
        //接收發送過來的消息，這個方法是阻塞的，如果沒收到消息則一直阻塞
        var receiveResult = await webSocket.ReceiveAsync(new ArraySegment<byte>(buffer), CancellationToken.None);
        //循環接收消息
        while (webSocket.State == WebSocketState.Open)
        {
            try
            {
                //因爲緩衝區長度是固定的所以要獲取實際長度
                string msg = Encoding.UTF8.GetString(buffer[..receiveResult.Count]).TrimEnd('\0');
                //接收的到消息轉換成實體
                MsgBody msgBody = JsonConvert.DeserializeObject<MsgBody>(msg);
                //發送到其他客戶端的數據
                byte[] sendByte = Encoding.UTF8.GetBytes($"user {id} send:{msgBody.Msg}");
                _logger.LogInformation($"user {id} send:{msgBody.Msg}");
                 
                //判斷目標客戶端是否在當前當前服務，如果在當前服務直接扎到目標連接直接發送
                if (UserConnection.TryGetValue(msgBody.Id, out var targetSocket))
                {
                    if (targetSocket.State == WebSocketState.Open)
                    {
                        await targetSocket.SendAsync(new ArraySegment<byte>(sendByte, 0, sendByte.Length), receiveResult.MessageType, true, CancellationToken.None);
                    }
                }
                else
                {
                    //如果要發送的目標端不在當前服務，則發送給目標redis端的頻道
                    ChannelMsgBody channelMsgBody = new ChannelMsgBody { FromId = id, ToId = msgBody.Id, Msg = msgBody.Msg };
                    //目標的redis頻道
                    _redisClient.Publish($"{userPrefix}{msgBody.Id}", JsonConvert.SerializeObject(channelMsgBody));
                }
                
                //繼續阻塞循環接收消息
                receiveResult = await webSocket.ReceiveAsync(new ArraySegment<byte>(buffer), CancellationToken.None);
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, ex.Message);
                break;
            }
        }
        
        //循環結束意味着當前端已經退出
        //從當前用戶的集合移除當前用戶
        _ = UserConnection.TryRemove(id, out _);
        //關閉當前WebSocket連接
        await webSocket.CloseAsync(receiveResult.CloseStatus.Value, receiveResult.CloseStatusDescription, CancellationToken.None);
        //在當前訂閱集合移除當前用戶
        _disposables.TryRemove($"{userPrefix}{id}", out var disposable);
        //關閉當前用戶的通道
        disposable.Dispose();
    }

    private async Task SubMsg(string channel)
    {
        //訂閱當前用戶頻道
        var sub = _redisClient.Subscribe(channel,  async (channel, data) => {
            //接收過來當前頻道數據，說明發送端不在當前服務
            ChannelMsgBody msgBody = JsonConvert.DeserializeObject<ChannelMsgBody>(data.ToString());
            byte[] sendByte = Encoding.UTF8.GetBytes($"user {msgBody.FromId} send:{msgBody.Msg}");
            //在當前服務找到目標的WebSocket連接併發送消息
            if (UserConnection.TryGetValue(msgBody.ToId, out var targetSocket))
            {
                if (targetSocket.State == WebSocketState.Open)
                {
                    await targetSocket.SendAsync(new ArraySegment<byte>(sendByte, 0, sendByte.Length), WebSocketMessageType.Text, true, CancellationToken.None);
                }
            }
        });
        //把redis訂閱頻道添加到集合中
        _disposables.TryAdd(channel, sub);
    }
    
    //程序退出的時候取消當前服務訂閱的redis頻道
    public void Dispose()
    {
        foreach (var disposable in _disposables)
        {
            disposable.Value.Dispose();
        }

        _disposables.Clear();
    }
}

這裏涉及到幾個輔助相關的類，其中UserConnection類是存儲註冊到當前服務的連接，MsgBody類用來接受客戶端發送過來的消息，ChannelMsgBody是用來發送redis頻道的相關消息，因爲要把相關消息通過redis發佈出去，咱們列一下這幾個類的相關代碼

//註冊到當前服務的連接
public class UserConnection : IEnumerable<KeyValuePair<string, WebSocket>>
{
    //存儲用戶唯一標識和WebSocket的對應關係
    private ConcurrentDictionary<string, WebSocket> _users = new ConcurrentDictionary<string, WebSocket>();

    //當前服務的用戶數量
    public int Count => _users.Count;

    public WebSocket GetOrAdd(string userId, WebSocket webSocket)
    {
        return _users.GetOrAdd(userId, webSocket);
    }

    public bool TryGetValue(string userId, out WebSocket webSocket)
    {
        return _users.TryGetValue(userId, out webSocket);
    }

    public bool TryRemove(string userId, out WebSocket webSocket)
    {
        return _users.TryRemove(userId, out webSocket);
    }

    public void Clear()
    {
        _users.Clear();
    }

    public IEnumerator<KeyValuePair<string, WebSocket>> GetEnumerator()
    {
        return _users.GetEnumerator();
    }

    IEnumerator IEnumerable.GetEnumerator()
    {
        return this.GetEnumerator();
    }
}

//客戶端消息
public class MsgBody
{
    //目標用戶標識
    public string Id { get; set; }
    //要發送的消息
    public string Msg { get; set; }
}

//頻道訂閱消息
public class ChannelMsgBody
{
    //用戶標識
    public string FromId { get; set; }
    //目標用戶標識，也就是要發送給誰
    public string ToId { get; set; }
    //要發送的消息
    public string Msg { get; set; }
}

這樣的話關於一對一發送消息的相關邏輯就實現完成了，啓動兩個Server端，由於nginx默認的負載均衡策略是輪詢，所以註冊兩個用戶的話會被分發到不同的服務裏去用Postman連接三個連接唯一標識分別是1、2、3，模擬一下消息發送，效果如下,發送效果
接收效果

羣組發送

上面我們展示了一對一發送的情況，接下來我們來看一下，羣組發送的情況。羣組發送的話就是隻要大家都加入一個羣組，只要客戶端在羣組裏發送一條消息，則註冊到當前羣組內的所有客戶端都可以收到消息。相對於一對一的情況就是如果當前WebSocket服務端如果存在用戶加入某個羣組，則當前當前WebSocket服務端則可以訂閱一個group:羣組唯一標識的redis頻道，集羣中的其他WebSocket服務器通過這個redis頻道接收羣組消息，通過一張圖描述一下羣組的實現方式相對於一對一要簡單一點

發送端可以不用考慮當前服務中的客戶端連接，一股腦的交給redis把消息發佈出去
如果有WebSocket服務中的用戶訂閱了當前分組則可以接受消息，獲取組內的用戶循環發送消息

展示一下代碼實現的方式,首先是定義一個action用於表示羣組的相關場景

//包含兩個標識一個是組別標識一個是註冊到組別的用戶
[HttpGet("/chat/group/{groupId}/{userId}")]
public async Task ChatGroup(string groupId, string userId)
{
    if (HttpContext.WebSockets.IsWebSocketRequest)
    {
        _logger.LogInformation($"group:{groupId} user:{userId}-{Request.HttpContext.Connection.RemoteIpAddress}:{Request.HttpContext.Connection.RemotePort} join");

        var webSocket = await HttpContext.WebSockets.AcceptWebSocketAsync();
        //調用HandleGroup處理羣組相關的消息
        await _socketHandler.HandleGroup(groupId, userId, webSocket);
    }
    else
    {
        HttpContext.Response.StatusCode = StatusCodes.Status400BadRequest;
    }
}

接下來看一下HandleGroup的相關邏輯，還是在WebSocketHandler類中，看一下代碼實現

public class WebSocketHandler:IDisposable
{
    private readonly UserConnection UserConnection = new();
    private readonly GroupUser GroupUser = new();
    private readonly SemaphoreSlim _lock = new(1, 1);
    private readonly ConcurrentDictionary<string, IDisposable> _disposables = new();
    private readonly string groupPrefix = "group:";

    private readonly ILogger<WebSocketHandler> _logger;
    private readonly RedisClient _redisClient;

    public WebSocketHandler(ILogger<WebSocketHandler> logger, RedisClient redisClient)
    {
        _logger = logger;
        _redisClient = redisClient;
    }

    public async Task HandleGroup(string groupId, string userId, WebSocket webSocket)
    {
        //因爲羣組的集合可能會存在很多用戶一起訪問所以限制訪問數量
        await _lock.WaitAsync();
        //初始化羣組容器 羣唯一標識爲key 羣員容器爲value
        var currentGroup = GroupUser.Groups.GetOrAdd(groupId, new UserConnection { });
        //當前用戶加入當前羣組
        _ = currentGroup.GetOrAdd(userId, webSocket);
        //只有有當前WebSocket服務的第一個加入當前組的時候纔去訂閱羣組頻道
        //如果不限制的話則會出現如果當前WebSocket服務有多個用戶在一個組內則會重複收到redis消息
        if (currentGroup.Count == 1)
        {
            //訂閱redis頻道
            await SubGroupMsg($"{groupPrefix}{groupId}");
        }

        _lock.Release();

        var buffer = new byte[1024 * 4];
        //阻塞接收WebSocket消息
        var receiveResult = await webSocket.ReceiveAsync(new ArraySegment<byte>(buffer), CancellationToken.None);
        //服務不退出的話則一直等待接收
        while (webSocket.State == WebSocketState.Open)
        {
            try
            {
                string msg = Encoding.UTF8.GetString(buffer[..receiveResult.Count]).TrimEnd('\0');
                _logger.LogInformation($"group 【{groupId}】 user 【{userId}】 send:{msg}");

                //組裝redis頻道發佈的消息，目標爲羣組標識
                ChannelMsgBody channelMsgBody = new ChannelMsgBody { FromId = userId, ToId = groupId, Msg = msg };
                //通過redis發佈消息
                _redisClient.Publish($"{groupPrefix}{groupId}", JsonConvert.SerializeObject(channelMsgBody));

                receiveResult = await webSocket.ReceiveAsync(new ArraySegment<byte>(buffer), CancellationToken.None);
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, ex.Message);
                break;
            }
        }
        //如果客戶端退出則在當前羣組集合刪除當前用戶
        _ = currentGroup.TryRemove(userId, out _);
        await webSocket.CloseAsync(receiveResult.CloseStatus.Value, receiveResult.CloseStatusDescription, CancellationToken.None);
    }

    private async Task SubGroupMsg(string channel)
    {
        var sub = _redisClient.Subscribe(channel, async (channel, data) => {
            ChannelMsgBody msgBody = JsonConvert.DeserializeObject<ChannelMsgBody>(data.ToString());
            byte[] sendByte = Encoding.UTF8.GetBytes($"group 【{msgBody.ToId}】 user 【{msgBody.FromId}】 send:{msgBody.Msg}");

            //在當前WebSocket服務器找到當前羣組裏的用戶
            GroupUser.Groups.TryGetValue(msgBody.ToId, out var currentGroup);
            //循環當前WebSocket服務器裏的用戶發送消息
            foreach (var user in currentGroup)
            {
                //不用給自己發送了
                if (user.Key == msgBody.FromId)
                {
                    continue;
                }

                if (user.Value.State == WebSocketState.Open)
                {
                    await user.Value.SendAsync(new ArraySegment<byte>(sendByte, 0, sendByte.Length), WebSocketMessageType.Text, true, CancellationToken.None);
                }
            }
        });
        //把當前頻道加入訂閱集合
        _disposables.TryAdd(channel, sub);
    }
}

這裏涉及到了GroupUser類，是來存儲羣組和羣組用戶的對應關係的，定義如下

public class GroupUser
{
    //key爲羣組的唯一標識
    public ConcurrentDictionary<string, UserConnection> Groups = new ConcurrentDictionary<string, UserConnection>();
}

演示一下把兩個用戶添加到一個羣組內，然後發送接收消息的場景，用戶u1發送
用戶u2接收

發送所有人

發送給所有用戶的邏輯比較簡單，不用考慮到用戶限制，只要用戶連接到了WebSocket集羣則都可以接收到這個消息，大致工作方式如下圖所示這個比較簡單，咱們直接看實現代碼，首先是定義一個地址，用於發佈消息

//把用戶註冊進去
[HttpGet("/chat/all/{id}")]
public async Task ChatAll(string id)
{
    if (HttpContext.WebSockets.IsWebSocketRequest)
    {
        _logger.LogInformation($"all user:{id}-{Request.HttpContext.Connection.RemoteIpAddress}:{Request.HttpContext.Connection.RemotePort} join");

        var webSocket = await HttpContext.WebSockets.AcceptWebSocketAsync();
        await _socketHandler.HandleAll(id, webSocket);
    }
    else
    {
        HttpContext.Response.StatusCode = StatusCodes.Status400BadRequest;
    }
}

具體的實現邏輯還是在HandleGroup類裏，是HandleAll方法，看一下具體實現

public class WebSocketHandler:IDisposable
{
    private readonly UserConnection AllConnection = new();
    private readonly ConcurrentDictionary<string, IDisposable> _disposables = new();
    private readonly string all = "all";

    private readonly ILogger<WebSocketHandler> _logger;
    private readonly RedisClient _redisClient;

    public WebSocketHandler(ILogger<WebSocketHandler> logger, RedisClient redisClient)
    {
        _logger = logger;
        _redisClient = redisClient;
    }

    public async Task HandleAll(string id, WebSocket webSocket)
    {
        await _lock.WaitAsync();
        //把用戶加入用戶集合
        _ = AllConnection.GetOrAdd(id, webSocket);
        //WebSocket集羣中的每個服務只定義一次
        if (AllConnection.Count == 1)
        {
            await SubAllMsg(all);
        }

        _lock.Release();

        var buffer = new byte[1024 * 4];
        //阻塞接收信息
        var receiveResult = await webSocket.ReceiveAsync(new ArraySegment<byte>(buffer), CancellationToken.None);
        while (webSocket.State == WebSocketState.Open)
        {
            try
            {
                string msg = Encoding.UTF8.GetString(buffer[..receiveResult.Count]).TrimEnd('\0');
                _logger.LogInformation($"user {id} send:{msg}");
                //獲取接收信息
                ChannelMsgBody channelMsgBody = new ChannelMsgBody { FromId = id, Msg = msg };
                //把消息通過redis發佈到集羣中的其他服務
                _redisClient.Publish(all, JsonConvert.SerializeObject(channelMsgBody));
  
                receiveResult = await webSocket.ReceiveAsync(new ArraySegment<byte>(buffer), CancellationToken.None);
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, ex.Message);
                break;
            }
        }
        //用戶退出則刪除集合中的當前用戶信息
        _ = AllConnection.TryRemove(id, out _);
        await webSocket.CloseAsync(receiveResult.CloseStatus.Value, receiveResult.CloseStatusDescription, CancellationToken.None);
    }

    private async Task SubAllMsg(string channel)
    {
        var sub = _redisClient.Subscribe(channel, async (channel, data) => {
            ChannelMsgBody msgBody = JsonConvert.DeserializeObject<ChannelMsgBody>(data.ToString());
            byte[] sendByte = Encoding.UTF8.GetBytes($"user 【{msgBody.FromId}】 send all:{msgBody.Msg}");
            //接收到消息後遍歷用戶集合把消息發送給所有用戶
            foreach (var user in AllConnection)
            {   
                //如果包含當前用戶跳過
                if (user.Key == msgBody.FromId)
                {
                    continue;
                }

                if (user.Value.State == WebSocketState.Open)
                {
                    await user.Value.SendAsync(new ArraySegment<byte>(sendByte, 0, sendByte.Length), WebSocketMessageType.Text, true, CancellationToken.None);
                }
            }
        });
        _disposables.TryAdd(channel, sub);
    }
}

效果在這裏就不展示了，和羣組的效果是類似的，只是一個是部分用戶，一個是全部的用戶。

整合到一起

上面我們分別展示了一對一、羣組、所有人的場景，但是實際使用的時候，每個用戶只需要註冊到WebSocket集羣一次也就是保持一個連接即可，而不是一對一一個連接、註冊羣組一個連接、所有消息的時候一個連接。所以我們需要把上面的演示整合一下，一個用戶只需要連接到WebSocket集羣一次即可，至於發送給誰，加入什麼羣組，接收全部消息等都是連接後通過一些標識區分的，而不必每個類型的操作都註冊一次，就和微信和QQ一樣我只要登錄了即可，至於其他操作都是靠數據標識區分的。接下來咱們就整合一下代碼達到這個效果，大致的思路是

用戶連接到WebSocket集羣，把用戶和連接保存到當前WebSocket服務器的用戶集合中去。
一對一發送的時候，只需要在具體的服務器中找到具體的客戶端發送消息
羣組的時候，先把當前用戶標識加入羣組集合即可，接收消息的時候根據羣組集合裏的用戶標識去用戶集合裏去拿具體的WebSocket連接發送消息
全員消息的時候，直接遍歷集羣中的每個WebSocket服務裏的用戶集合裏的WebSocket連接訓話發送消息

這樣的話就保證了每個客戶端用戶在集羣中只會綁定一個連接，首先還是單獨定義一個action，用於讓客戶端用戶連接上來，具體實現代碼如下所示

public class WebSocketChannelController : ControllerBase
{
    private readonly ILogger<WebSocketController> _logger;
    private readonly WebSocketChannelHandler _webSocketChannelHandler;

    public WebSocketChannelController(ILogger<WebSocketController> logger, WebSocketChannelHandler webSocketChannelHandler)
    {
        _logger = logger;
        _webSocketChannelHandler = webSocketChannelHandler;
    }

    //只需要把當前用戶連接到服務即可
    [HttpGet("/chat/channel/{id}")]
    public async Task Channel(string id)
    {
        if (HttpContext.WebSockets.IsWebSocketRequest)
        {
            _logger.LogInformation($"user:{id}-{Request.HttpContext.Connection.RemoteIpAddress}:{Request.HttpContext.Connection.RemotePort} join");

            var webSocket = await HttpContext.WebSockets.AcceptWebSocketAsync();
            await _webSocketChannelHandler.HandleChannel(id, webSocket);
        }
        else
        {
            HttpContext.Response.StatusCode = StatusCodes.Status400BadRequest;
        }
    }
}

接下來看一下WebSocketChannelHandler類的HandleChannel方法實現，用於處理不同的消息，比如一對一、羣組、全員消息等不同類型的消息

public class WebSocketChannelHandler : IDisposable
{
    //用於存儲當前WebSocket服務器鏈接上來的所有用戶對應關係
    private readonly UserConnection UserConnection = new();
    //用於存儲羣組和用戶關係，用戶集合採用HashSet保證每個用戶只加入一個羣組一次
    private readonly ConcurrentDictionary<string, HashSet<string>> GroupUser = new ConcurrentDictionary<string, HashSet<string>>();
    private readonly SemaphoreSlim _lock = new(1, 1);
    //存放redis訂閱實例
    private readonly ConcurrentDictionary<string, IDisposable> _disposables = new();

    //一對一redis頻道前綴
    private readonly string userPrefix = "user:";
    //羣組redis頻道前綴
    private readonly string groupPrefix = "group:";
    //全員redis頻道
    private readonly string all = "all";

    private readonly ILogger<WebSocketHandler> _logger;
    private readonly RedisClient _redisClient;

    public WebSocketChannelHandler(ILogger<WebSocketHandler> logger, RedisClient redisClient)
    {
        _logger = logger;
        _redisClient = redisClient;
    }

    public async Task HandleChannel(string id, WebSocket webSocket)
    {
        await _lock.WaitAsync();

        //每次連接進來就添加到用戶集合
        _ = UserConnection.GetOrAdd(id, webSocket);
        
        //每個WebSocket服務實例只需要訂閱一次全員消息頻道
        await SubMsg($"{userPrefix}{id}");
        if (UserConnection.Count == 1)
        {
            await SubAllMsg(all);
        }

        _lock.Release();
        var buffer = new byte[1024 * 4];
        //接收客戶端消息
        var receiveResult = await webSocket.ReceiveAsync(new ArraySegment<byte>(buffer), CancellationToken.None);

        while (webSocket.State == WebSocketState.Open)
        {
            try
            {
                string msg = Encoding.UTF8.GetString(buffer[..receiveResult.Count]).TrimEnd('\0');
                //讀取客戶端消息
                ChannelData channelData = JsonConvert.DeserializeObject<ChannelData>(msg);
                //判斷消息類型
                switch (channelData.Method)
                {
                    //一對一
                    case "One":
                        await HandleOne(id, channelData.MsgBody, receiveResult);
                        break;
                    //把用戶加入羣組
                    case "UserGroup":
                        await AddUserGroup(id, channelData.Group, webSocket);
                        break;
                    //處理羣組消息
                    case "Group":
                        await HandleGroup(channelData.Group, id, webSocket, channelData.MsgBody);
                        break;
                    //處理全員消息
                    default:
                        await HandleAll(id, channelData.MsgBody);
                        break;
                }

                receiveResult = await webSocket.ReceiveAsync(new ArraySegment<byte>(buffer), CancellationToken.None);
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, ex.Message);
                break;
            }
        }

        await webSocket.CloseAsync(receiveResult.CloseStatus.Value, receiveResult.CloseStatusDescription, CancellationToken.None);

        //在羣組中移除當前用戶
        foreach (var users in GroupUser.Values)
        {
            lock (users)
            {
                users.Remove(id);
            }
        }
        //當前客戶端用戶退出則移除連接
        _ = UserConnection.TryRemove(id, out _);
        //取消用戶頻道訂閱
        _disposables.Remove($"{userPrefix}{id}", out var sub);
        sub?.Dispose();
    }

    public void Dispose()
    {
        foreach (var disposable in _disposables)
        {
            disposable.Value.Dispose();
        }

        _disposables.Clear();
    }
}

這裏涉及到了ChannelData類是用於接收客戶端消息的類模板，具體定義如下

public class ChannelData
{
    //消息類型 比如一對一 羣組 全員
    public string Method { get; set; }
    //羣組標識
    public string Group { get; set; }
    //消息體
    public object MsgBody { get; set; }
}

類中並不會包含當前用戶信息，因爲連接到當前服務的時候已經提供了客戶端唯一標識。結合上面的處理代碼我們可以看出，客戶端用戶連接到WebSocket實例之後，先註冊當前用戶的redis訂閱頻道並且當前實例僅註冊一次全員消息的redis頻道，用於處理非當前實例註冊客戶端的一對一消息處理和全員消息處理，然後等待接收客戶端消息，根據客戶端消息的消息類型來判斷是進行一對一、羣組、或者全員的消息類型處理，它的工作流程入下圖所示由代碼和上面的流程圖可知，它根據不同的標識去處理不同類型的消息，接下來我們可以看下每種消息類型的處理方式。

一對一處理

首先是一對一的消息處理情況，看一下具體的處理邏輯，首先是一對一發布消息

 private async Task HandleOne(string id, object msg, WebSocketReceiveResult receiveResult)
 {
    MsgBody msgBody = JsonConvert.DeserializeObject<MsgBody>(JsonConvert.SerializeObject(msg));
    byte[] sendByte = Encoding.UTF8.GetBytes($"user {id} send:{msgBody.Msg}");
    _logger.LogInformation($"user {id} send:{msgBody.Msg}");

    //判斷目標用戶是否在當前WebSocket服務器
    if (UserConnection.TryGetValue(msgBody.Id, out var targetSocket))
    {
        if (targetSocket.State == WebSocketState.Open)
        {
            await targetSocket.SendAsync(new ArraySegment<byte>(sendByte, 0, sendByte.Length), receiveResult.MessageType, true, CancellationToken.None);
        }
    }
    else
    {
        //如果不在當前服務器，則直接把消息發佈到具體的用戶頻道去，由具體用戶去訂閱
        ChannelMsgBody channelMsgBody = new ChannelMsgBody { FromId = id, ToId = msgBody.Id, Msg = msgBody.Msg };
        _redisClient.Publish($"{userPrefix}{msgBody.Id}", JsonConvert.SerializeObject(channelMsgBody));
    }
}

接下來是用於處理訂閱其他用戶發送過來消息的邏輯，這個和整合之前的邏輯是一致的，在當前服務器中找到用戶對應的連接，發送消息

private async Task SubMsg(string channel)
{
    var sub = _redisClient.Subscribe(channel, async (channel, data) =>
    {
        ChannelMsgBody msgBody = JsonConvert.DeserializeObject<ChannelMsgBody>(data.ToString());
        byte[] sendByte = Encoding.UTF8.GetBytes($"user {msgBody.FromId} send:{msgBody.Msg}");
        if (UserConnection.TryGetValue(msgBody.ToId, out var targetSocket))
        {
            if (targetSocket.State == WebSocketState.Open)
            {
                await targetSocket.SendAsync(new ArraySegment<byte>(sendByte, 0, sendByte.Length), WebSocketMessageType.Text, true, CancellationToken.None);
            }
            else
            {
                _ = UserConnection.TryRemove(msgBody.FromId, out _);
            }
        }
    });
    //把訂閱實例加入集合
    _disposables.TryAdd(channel, sub);
}

如果給某個用戶發送消息則可以使用如下的消息格式

{"Method":"One", "MsgBody":{"Id":"2","Msg":"Hello"}}

Method爲One代表着是私聊一對一的情況，消息體內Id爲要發送給的具體用戶標識和消息體。

羣組處理

接下來看羣組處理方式，這個和之前的邏輯是有出入的，首先是用戶要先加入到某個羣組然後才能接收羣組消息或者在羣組中發送消息，之前是一個用戶對應多個連接，整合了之後集羣中每個用戶只關聯唯一的一個WebSocket連接，首先看用戶加入羣組的邏輯

private async Task AddUserGroup(string user, string group, WebSocket webSocket)
{
    //獲取羣組信息
    var currentGroup = GroupUser.GetOrAdd(group, new HashSet<string>());

    lock (currentGroup)
    {
       //把用戶標識加入當前組
        _ = currentGroup.Add(user);
    }

    //每個組的redis頻道，在每臺WebSocket服務器實例只註冊一次訂閱
    if (currentGroup.Count == 1)
    {
        //訂閱當前組消息
        await SubGroupMsg($"{groupPrefix}{group}");
    }
    
    string addMsg = $"user 【{user}】 add  to group 【{group}】";
    byte[] sendByte = Encoding.UTF8.GetBytes(addMsg);
    await webSocket.SendAsync(new ArraySegment<byte>(sendByte, 0, sendByte.Length), WebSocketMessageType.Text, true, CancellationToken.None);
    //如果有用戶加入羣組，則通知其他羣成員
    ChannelMsgBody channelMsgBody = new ChannelMsgBody { FromId = user, ToId = group, Msg = addMsg };
    _redisClient.Publish($"{groupPrefix}{group}", JsonConvert.SerializeObject(channelMsgBody));
}

用戶想要在羣組內發消息，則必須先加入到一個具體的羣組內，具體的加入羣組的格式如下

{"Method":"UserGroup", "Group":"g1"}

Method爲UserGroup代表着用戶加入羣組的業務類型，Group代表着你要加入的羣組唯一標識。接下來就看下，用戶發送羣組消息的邏輯了

private async Task HandleGroup(string groupId, string userId, WebSocket webSocket, object msgBody)
{
    //判斷羣組是否存在
    var hasValue = GroupUser.TryGetValue(groupId, out var users);
    if (!hasValue)
    {
        byte[] sendByte = Encoding.UTF8.GetBytes($"group【{groupId}】 not exists");
        await webSocket.SendAsync(new ArraySegment<byte>(sendByte, 0, sendByte.Length), WebSocketMessageType.Text, true, CancellationToken.None);
        return;
    }

    //只有加入到當前羣組，才能在羣組內發送消息
    if (!users.Contains(userId))
    {
        byte[] sendByte = Encoding.UTF8.GetBytes($"user 【{userId}】 not in 【{groupId}】");
        await webSocket.SendAsync(new ArraySegment<byte>(sendByte, 0, sendByte.Length), WebSocketMessageType.Text, true, CancellationToken.None);
        return;
    }

    _logger.LogInformation($"group 【{groupId}】 user 【{userId}】 send:{msgBody}");

    //發送羣組消息
    ChannelMsgBody channelMsgBody = new ChannelMsgBody { FromId = userId, ToId = groupId, Msg = msgBody.ToString() };
    _redisClient.Publish($"{groupPrefix}{groupId}", JsonConvert.SerializeObject(channelMsgBody));
}

加入羣組之後則可以發送和接收羣組內的消息了，給羣組發送消息的格式如下

{"Method":"Group", "Group":"g1", "MsgBody":"Hi All"}

Method爲Group代表着用戶加入羣組的業務類型，Group則代表你要發送到具體的羣組的唯一標識，MsgBody則是發送到羣組內的消息。最後再來看下訂閱羣組內消息的情況，也就是處理羣組消息的邏輯

private async Task SubGroupMsg(string channel)
{
    var sub = _redisClient.Subscribe(channel, async (channel, data) =>
    {
        //接收羣組訂閱消息
        ChannelMsgBody msgBody = JsonConvert.DeserializeObject<ChannelMsgBody>(data.ToString());
        byte[] sendByte = Encoding.UTF8.GetBytes($"group 【{msgBody.ToId}】 user 【{msgBody.FromId}】 send:{msgBody.Msg}");
        
        //獲取當前服務器實例中當前羣組的所有用戶連接
        GroupUser.TryGetValue(msgBody.ToId, out var currentGroup);
        foreach (var user in currentGroup)
        {
            if (user == msgBody.FromId)
            {
                continue;
            }
            
            //通過羣組內的用戶標識去用戶集合獲取用戶集合裏的用戶唯一連接發送消息
            if (UserConnection.TryGetValue(user, out var targetSocket) && targetSocket.State == WebSocketState.Open)
            {
                await targetSocket.SendAsync(new ArraySegment<byte>(sendByte, 0, sendByte.Length), WebSocketMessageType.Text, true, CancellationToken.None);
            }
            else
            {
                currentGroup.Remove(user);
            }
        }
    });
    _disposables.TryAdd(channel, sub);
}

全員消息處理

全員消息處理相對來說思路比較簡單，因爲當服務啓動的時候就會監聽redis的全員消息頻道，這樣的話具體的實現也就只包含發送和接收全員消息了，首先看一下全員消息發送的邏輯

private async Task HandleAll(string id, object msgBody)
{
    _logger.LogInformation($"user {id} send:{msgBody}");

    //直接給redis的全員頻道發送消息
    ChannelMsgBody channelMsgBody = new ChannelMsgBody { FromId = id, Msg = msgBody.ToString() };
    _redisClient.Publish(all, JsonConvert.SerializeObject(channelMsgBody));
}

全員消息的發送數據格式如下所示

{"Method":"All", "MsgBody":"Hello All"}

Method爲All代表着全員消息類型，MsgBody則代表着具體消息。接收消息出裏同樣很簡單，訂閱redis全員消息頻道，然後遍歷當前WebSocket服務器實例內的所有用戶獲取連接發送消息，具體邏輯如下

private async Task SubAllMsg(string channel)
{
    var sub = _redisClient.Subscribe(channel, async (channel, data) =>
    {
        ChannelMsgBody msgBody = JsonConvert.DeserializeObject<ChannelMsgBody>(data.ToString());
        byte[] sendByte = Encoding.UTF8.GetBytes($"user 【{msgBody.FromId}】 send all:{msgBody.Msg}");
        //獲取當前服務器實例內所有用戶的連接
        foreach (var user in UserConnection)
        {
            //不給自己發送消息，因爲發送的時候可以通過具體的業務代碼處理
            if (user.Key == msgBody.FromId)
            {
                continue;
            }
            
            //給每個用戶發送消息
            if (user.Value.State == WebSocketState.Open)
            {
                await user.Value.SendAsync(new ArraySegment<byte>(sendByte, 0, sendByte.Length), WebSocketMessageType.Text, true, CancellationToken.None);
            }
            else
            {
                _ = UserConnection.TryRemove(user.Key, out _);
            }
        }
    });
    _disposables.TryAdd(channel, sub);
}

示例源碼

由於篇幅有限，沒辦法設計到全部的相關源碼，因此在這裏貼出來github相關的地址，方便大家查看和運行源碼。相關的源碼我這裏實現了兩個版本，一個是基於asp.net core的版本，一個是基於golang的版本。兩份源碼的實現思路是一致的，所以這兩份代碼可以運行在一套集羣示例裏，配置在一套nginx裏，並且連接到同一個redis實例裏即可

asp.net core源碼示例 https://github.com/softlgl/WebsocketCluster
golang源碼示例 https://github.com/softlgl/websocket-cluster

倉庫裏還涉及到本人閒暇之餘開源的其他倉庫，由於本人能力有限難登大雅之堂，就不做廣告了，有興趣的同學可以自行瀏覽一下。

總結

本文基於ASP.NET Core框架提供了一個基於WebSocket做集羣的示例，由於思想是通用的，所以基於這個思路樓主也實現了golang版本。其實在之前就想自己動手搞一搞關於WebSocket集羣方面的設計，本篇文章算是對之前想法的一個落地操作。其核心思路文章已經做了相關介紹，由於這些只是博主關於構思的實現，可能有很多細節尚未體現到，還希望大家多多理解。其核心思路總結一下

首先是，利用可以構建WebSocket服務的框架，在當前服務實例中保存當前客戶端用戶和WebSocket的連接關係
如果消息的目標客戶端不在當前服務器，可以利用redis頻道、消息隊列相關、甚至是數據庫類的共享回話發送的消息，由目標服務器獲取目標是否屬於自己的ws會話
本文設計的思路使用的是無狀態的方式，即WebSocket服務實例之間不存在直接的消息通信和相互的服務地址存儲，當然也可以利用redis等存儲在線用戶信息等，這個可以參考具體業務自行設計

讀萬卷書,行萬里路。在這個時刻都在變化點的環境裏，唯有不斷的進化自己，多接觸多嘗試不用的事物，多擴展自己的認知思維，方能構建自己的底層邏輯。畢竟越底層越抽象，越通用越抽象。面對未知的挑戰，自身作爲自己堅強的後盾，可能纔會讓自己更踏實。

👇歡迎掃碼關注我的公衆號👇

關於ASP.NET Core WebSocket實現集羣的思考

前言

實現

nginx配置

一對一發送

羣組發送

發送所有人

整合到一起

一對一處理

羣組處理

全員消息處理

示例源碼

總結

體驗Semantic Kernel圖片內容識別

細聊ASP.NET Core WebAPI格式化程序

基於C# Socket實現的簡單的Redis客戶端

細聊C# AsyncLocal如何在異步間進行數據流轉

由C# yield return引發的思考

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結