网络消息处理通信与协议

最新推荐文章于 2023-03-17 10:09:45 发布
最新推荐文章于 2023-03-17 10:09:45 发布
阅读量431 收藏 1
点赞数
分类专栏： 系统制作
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lfanyize/article/details/109624929
版权

通讯组件划分
1.NetworkClient（网络客户端用于客户端进行收发消息） & TcpSocketListener（用于服务器进行客户端监听、接受与响应消息）
2.封包处理器 PackageHandle 封包与协议的转换
3.消息分发器 MessageDistributer 若接收到网络客户端传来的消息，负责将这个消息分发到服务器各个模块中
4.消息分配处理 MessageDispatch 消息分发器，仅仅是将传过来的消息进行分发，并不会管消息是什么，至于哪一个消息分发给谁，是通过消息分配处理统筹的

NetClient实现细节
1.

public void Init(string serverIP, int port)//1.
        {
            this.address = new IPEndPoint(IPAddress.Parse(serverIP), port);//用指定的地址和端口号初始化IPEndPoint的新实例
        }

public void Connect(int times = DEF_TRY_CONNECT_TIMES)//2.判断当前有无连接，或者是否已经实例化socket
        {
            if (this.connecting)
            {
                return;
            }

            if (this.clientSocket != null)
            {
                this.clientSocket.Close();
            }
            if (this.address == default(IPEndPoint))
            {
                throw new Exception("Please Init first.");
            }
            Debug.Log("DoConnect");
            this.connecting = true;
            this.lastSendTime = 0;

            this.DoConnect();
        }

void DoConnect()//3。以上都没有，真正开始连接
        {
            Debug.Log("NetClient.DoConnect on " + this.address.ToString());
            try
            {
                if (this.clientSocket != null)
                {
                    this.clientSocket.Close();
                }

                this.clientSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
                this.clientSocket.Blocking = true;//阻塞到这里

                Debug.Log(string.Format("Connect[{0}] to server {1}", this.retryTimes, this.address) + "\n");
                IAsyncResult result = this.clientSocket.BeginConnect(this.address, null, null);//异步连接
                bool success = result.AsyncWaitHandle.WaitOne(NetConnectTimeout);
                if (success)
                {
                    this.clientSocket.EndConnect(result);//结束挂起的连接请求
                }
            }
            catch(SocketException ex)
            {
                if(ex.SocketErrorCode == SocketError.ConnectionRefused)
                {
                    this.CloseConnection(NET_ERROR_FAIL_TO_CONNECT);
                }
                Debug.LogErrorFormat("DoConnect SocketException:[{0},{1},{2}]{3} ", ex.ErrorCode,ex.SocketErrorCode,ex.NativeErrorCode, ex.ToString()); 
            }
            catch (Exception e)
            {
                Debug.Log("DoConnect Exception:" + e.ToString() + "\n");
            }

            if (this.clientSocket.Connected)
            {
                this.clientSocket.Blocking = false;//停止阻塞
                this.RaiseConnected(0, "Success");
            }
            else
            {
                this.retryTimes++;
                if (this.retryTimes >= this.retryTimesTotal)
                {
                    this.RaiseConnected(1, "Cannot connect to server");
                }
            }
            this.connecting = false;
        }
public void CloseConnection(int errCode)
        {
            Debug.LogWarning("CloseConnection(), errorCode: " + errCode.ToString());
            this.connecting = false;
            if (this.clientSocket != null)
            {
                this.clientSocket.Close();
            }

            //清空缓冲区
            MessageDistributer.Instance.Clear();
            this.sendQueue.Clear();

            this.receiveBuffer.Position = 0;
            this.sendBuffer.Position = sendOffset = 0;
        }

public void Update()
        {
            if (!running)
            {
                return;
            }

            if (this.KeepConnect())//判断一下当前连接的状态
            {
                if (this.ProcessRecv())
                {
                    if (this.Connected)
                    {
                        this.ProcessSend();
                        this.ProceeMessage();
                    }
                }
            }
        }
bool KeepConnect()
        {
            if (this.connecting)
            {
                return false;
            }
            if (this.address == null)
                return false;

            if (this.Connected)
            {
                return true;
            }

            if (this.retryTimes < this.retryTimesTotal)
            {
                this.Connect();
            }
            return false;
        }
bool ProcessRecv()
        {
            bool ret = false;
            try
            {
                if (this.clientSocket.Blocking)
                {
                    Debug.Log("this.clientSocket.Blocking = true\n");
                }
                bool error = this.clientSocket.Poll(0, SelectMode.SelectError);//判断是否有错误信息
                if (error)
                {
                    Debug.Log("ProcessRecv Poll SelectError\n");
                    this.CloseConnection(NET_ERROR_SEND_EXCEPTION);
                    return false;
                }

                ret = this.clientSocket.Poll(0, SelectMode.SelectRead);//如果没有错误，开始读取信息
                if (ret)
                {
                    int n = this.clientSocket.Receive(this.receiveBuffer.GetBuffer(), 0, this.receiveBuffer.Capacity, SocketFlags.None);//如果有数据，开始读取信息
                    if (n <= 0)
                    {
                        this.CloseConnection(NET_ERROR_ZERO_BYTE);
                        return false;
                    }

                    this.packageHandler.ReceiveData(this.receiveBuffer.GetBuffer(), 0, n);

                }
            }
            catch (Exception e)
            {
                Debug.Log("ProcessReceive exception:" + e.ToString() + "\n");
                this.CloseConnection(NET_ERROR_ILLEGAL_PACKAGE);
                return false;
            }
            return true;
        }  
bool ProcessSend()
        {
            bool ret = false;
            try
            {
                if (this.clientSocket.Blocking)
                {
                    Debug.Log("this.clientSocket.Blocking = true\n");
                }
                bool error = this.clientSocket.Poll(0, SelectMode.SelectError);
                if (error)
                {
                    Debug.Log("ProcessSend Poll SelectError\n");
                    this.CloseConnection(NET_ERROR_SEND_EXCEPTION);
                    return false;
                }
                ret = this.clientSocket.Poll(0, SelectMode.SelectWrite);
                if (ret)
                {
                    //sendStream exist data
                    if (this.sendBuffer.Position > this.sendOffset)
                    {
                        int bufsize = (int)(this.sendBuffer.Position - this.sendOffset);
                        int n = this.clientSocket.Send(this.sendBuffer.GetBuffer(), this.sendOffset, bufsize, SocketFlags.None);
                        if (n <= 0)
                        {
                            this.CloseConnection(NET_ERROR_ZERO_BYTE);
                            return false;
                        }
                        this.sendOffset += n;
                        if (this.sendOffset >= this.sendBuffer.Position)//确保数据接受完全
                        {
                            this.sendOffset = 0;
                            this.sendBuffer.Position = 0;
                            this.sendQueue.Dequeue();//remove message when send complete
                        }
                    }
                    else//如果没有可写的数据，发送队列中的消息
                    {
                        //fetch package from sendQueue
                        if (this.sendQueue.Count > 0)
                        {
                            NetMessage message = this.sendQueue.Peek();
                            byte[] package = PackageHandler.PackMessage(message);
                            //byte[] package = PackageHandler.PackMessage(message);
                            this.sendBuffer.Write(package, 0, package.Length);
                        }
                    }
                }
            }
            catch (Exception e)
            {
                Debug.Log("ProcessSend exception:" + e.ToString() + "\n");
                this.CloseConnection(NET_ERROR_SEND_EXCEPTION);
                return false;
            }

            return true;
        }              
void ProceeMessage()
        {
            MessageDistributer.Instance.Distribute();
        }

封包处理器（PackageHandler数据处理）部分函数细节

  1. ReceiveData(byte[] data ,int offset, int count)
public void ReceiveData(byte[] data,int offset,int count)
        {
            if(stream.Position + count > stream.Capacity)
            {
                throw new Exception("PackageHandler write buffer overflow");
            }
            stream.Write(data, offset, count);//data 写入数据的数据缓冲区 offset 字节偏移量   count 最多写入的字节数

            ParsePackage();
        }
bool ParsePackage()
        {
            if (readOffset + 4 < stream.Position)
            {
                int packageSize = BitConverter.ToInt32(stream.GetBuffer(), readOffset);
                if (packageSize + readOffset + 4 <= stream.Position)
                {//包有效

                    SkillBridge.Message.NetMessage message = UnpackMessage(stream.GetBuffer(), this.readOffset + 4, packageSize);
                    if (message == null)
                    {
                        throw new Exception("PackageHandler ParsePackage faild,invalid package");
                    }
                    MessageDistributer<T>.Instance.ReceiveMessage(this.sender, message);
                    this.readOffset += (packageSize + 4);
                    return ParsePackage();
                }
            }

            //未接收完/要结束了
            if (this.readOffset > 0)
            {
                long size = stream.Position - this.readOffset;
                if (this.readOffset < stream.Position)
                {
                    Array.Copy(stream.GetBuffer(), this.readOffset, stream.GetBuffer(), 0, stream.Position - this.readOffset);
                }
                //Reset Stream
                this.readOffset = 0;
                stream.Position = size;
                stream.SetLength(size);
            }
            return true;
        }     
public static SkillBridge.Message.NetMessage UnpackMessage(byte[] packet,int offset,int length)
        {
            SkillBridge.Message.NetMessage message = null;
            using (MemoryStream ms = new MemoryStream(packet, offset, length))
            {
                message = ProtoBuf.Serializer.Deserialize<SkillBridge.Message.NetMessage>(ms);
            }
            return message;
        }

消息分发器
使用Dictionary<string,Delegate> 进行存储与订阅
使用队列来存储消息
当一次性分发队列中所有消息的时候

public void Distribute()
        {
            if (this.messageQueue.Count == 0)
            {
                return;
            }

            while (this.messageQueue.Count > 0)
            {
                MessageArgs package = this.messageQueue.Dequeue();
                if (package.message.Request != null)
                    MessageDispatch<T>.Instance.Dispatch(package.sender, package.message.Request);
                if (package.message.Response != null)
                    MessageDispatch<T>.Instance.Dispatch(package.sender, package.message.Response);
            }
        }

消息分配处理

public class MessageDispatch<T> : Singleton<MessageDispatch<T>>
    {
        public void Dispatch(T sender, SkillBridge.Message.NetMessageResponse message)
        {
            if (message.mapEntitySync != null) { MessageDistributer<T>.Instance.RaiseEvent(sender, message.mapEntitySync); }   
        }

        public void Dispatch(T sender, SkillBridge.Message.NetMessageRequest message)
        {
            if (message.mapTeleport != null) { MessageDistributer<T>.Instance.RaiseEvent(sender, message.mapTeleport); }
            
        }
    }

这里只列出了本人已经看懂的部分，剩下的可能以后追加。

Break The Sky
关注
专栏目录
服务器框架——网络消息协议
行走
06-18 363
一、介绍 用于服务器和客户端应用层之间的协议，通过定义的协议，可以将接收的数据转发给相应的模块，相应模块可以将数据按照约定的结构进行解析。 二、协议体 2.1 消息码定义 消息码分为：分类消息码，主消息码，子消息码 2.2 消息码作用 消息码用于消息转发，将消息一层一层传给对应模块。消息码作用介绍： 分类消息码，用于网关服转发消息，网关服通过分类消息码，将消息发送给对应的服务器 主消息码，将消息转发给对应模块 子消息码，一个模块中定义的消息码，用于处理一个具体某个逻辑 在这三种模.
网络协议消息分片
陈嘉怡的专栏
12-05 2378
很多人对网络大消息分片比较困惑，主要是一般情况下应用层消息不会超出发送窗口缓存（可以设置64k字节）。但实际上tcp/ip协议对所有超出分片字节的网络消息都会进行分片、编号。在应用层的自定义协议，使用tcp协议的情况下，大消息分片要编号，依赖tcp协议向上提供的有序特性并检查编号的递增性，（否则不是同一个消息，有可能是对端网络连接断开等原因），需要有结束标记。
【极】P3-1 网络消息处理_通讯与协议（客户端通信）
weixin_46172181的博客
08-19 551
这次了解的是项目通讯组件，大概过了一遍各个通讯组件的作用以及怎么互相通信调用的提示：以下是本篇文章正文内容，下面案例可供参考大概的了解了客户端的链接流程，底层没有过度的深入，目前只知道这些代码有什么用就行。
节点服务器信息,节点信息及消息处理(广播与组播)
weixin_30710457的博客
09-19 308
01.节点服务器.服务器中间件属性提取 ==> TSysReporter (参考19.系统状态报告) a.节点综合运行状态获取; ==> 用于节点服务管理器等工具； ** 取节点服务器的运行状态: FetchNodeStatus(TQBParcel) 1 ConnectToParent 2 OnlineSonNodes ...
Unity学习_网络消息处理
StayAwake
08-17 714
just notes
网络通信与协议理解
王聚涛的专栏
06-04 2631
一、通信协议是什么？ 1、网络通信协议，是一种网络通信语言，为了连接不同操作系统和硬件体系结构提供通信支持。目的是实现通讯双方（发送方和接收方）能正确无障碍的理解要通信的内容。好比一个广东人和一个山西人打招呼，同样说你好，用方言说的话双方都不懂，那么这时候大家就约定都是用普通话，那么广东人说话山西人懂，山西人说话广东人也能懂，这么就可以愉快的聊天了。同理，计算机之间也需要有一定的约定才能实现正确的发送和接收信息。 2、网络通信协议三要素，语义（表达的意思），语法（表达的形式，接收，格式），时序（事件发生
计算机网络通信协议
qq_46219566的博客
08-02 4631
计算机网络通信协议
C#解决socket粘包问题，通信提供了一个自定义通信协议类MsgProtol，该类封装了打包和解包方法，可以解决分包和粘包问题
最新发布
06-13
C#解决socket通信过程中粘包分包问题，本项目是一个只有6个C#代码文件的开源小工程，用来学习基于TCP的套接字通信包，可以自定义通信协议，处理分包和粘包，内置一个服务端和客户端的套接字程序，也有测试代码和对应...
java网络编程之通信协议【一】
会者定离，一期一祈
03-16 2443
1.软件结构 C/S结构 ：全称为Client/Server结构，是指客户端和服务器结构。常见程序有ＱＱ、迅雷等软件。 B/S结构 ：全称为Browser/Server结构，是指浏览器和服务器结构。常见浏览器有谷歌浏览器、火狐浏览器，IE浏览器等。 两种架构各有优势，但是无论哪种架构，都离不开网络的支持。 网络编程，就是在一定的协议下，实现两台计算机的通信的程序。 2.网络通信协议 通过计算机网络可以使多台计算机实现连接，位于同一个网络中的计算机在进行连接和通信时需要遵守一定的规则。 在计算机网络中，这
北斗2.1通信协议
09-20
2. **错误检测与纠正**：为了提高数据传输的准确性，北斗2.1通信协议引入了更为强大的错误检测与纠正机制，即使在网络环境恶劣的情况下也能保证数据的正确传输。 3. **安全加密技术**：北斗2.1通信协议增加了对数据...
MMORPG极世界 -- 网络消息处理（学习内容）
Bad_boy_yang的博客
03-17 514
客户端现在已经发出消息，想要在服务端收到消息首先在服务端的Service文件中新建一个类Hello WorldService，为其添加代码，使其成为单例。首先在Unity中创建一个空场景，在创建一个空物体，起名为NetClient，并为其挂上脚本Net Client。在自己添加一个脚本Log，挂载在灯光上，这样可以一启动便触发。最后一步在MessageDispatch中进行消息分发。接下来将刚生成的文件放到客户端目录下进行替换。替换以后就可以在Log脚本里进行消息发送。下一步在协议中添加测试消息。
C#阻塞队列BlockingCollection
dotNET跨平台
11-29 5891
BlockingCollection是一个比较冷门的类，我们先看下官方对这个类的定义：简单来说，BlockingCollection就是一个线程安全的阻塞队列，利用阻塞这个特性，我们可以...
【Ceph】Ceph源码分析之Async模块
小鱼菜鸟的博客
01-15 166
原文：https://blog.csdn.net/hawkerou/article/details/65449957 1、异步通信核心模块EventCenter+Epoll 概述 EventCenter是Async异步消息通信的核心模块，通过事件／回调模型向上提供异步消息通信，每个Async下的worker线程负责处理一个EventCenter的事...
网络通信优化之通信协议：如何优化RPC网络通信？
木卯的专栏
04-23 519
RPC 通信是大型服务框架的核心 我们经常讨论微服务，首要应该了解的就是微服务的核心到底是什么，这样我们在做技术选型时，才能更准确地把握需求。 就我个人理解，我认为微服务的核心是远程通信和服务治理。远程通信提供了服务之间通信的桥梁，服务治理则提供了服务的后勤保障。所以，我们在做技术选型时，更多要考虑的是这两个核心的需求。 服务的拆分增加了通信的成本，特别是在一些抢购或者促销的业务场景中，如果服务之间存在方法调用，比如，抢购成功之后需要调用订单系统、支付系统、券包系统等，这种远程通信就很容易成为系统的瓶颈。所
RPG游戏-道具系统
qq_43008645的博客
10-07 1287
public enum ItemFuncition //物品功能 {get;set;get;set;get;set;get;set;get;set;get;set;get;set;get;set;get;set;get;set;get;set;} } }
【极】P4网络消息处理_通讯与协议（客户端通信）
weixin_46172181的博客
08-21 564
完成项目的注册登录系统，了解与服务器进行交互以及数据校验，为了方面这边就用注释的方式来阐述。基本流程大概这样，ET框架基本上把底层封装好了，我们只需要调用相应的方法即可，简简单单，没有脑袋。
C# + Socket断线重连 整理
热门推荐
蛰伏--当你不够强大时，就不要放弃努力
05-15 2万+
Socket 连接异常之"由于目标机器积极拒绝，无法连接(System.Net.Sockets.SocketException:Connection refused)" 1.如果是采用TCP/udp协议进行连接,检查windows防火墙是否开放相应SocketTCP/udp端口; 简单的检测方法是关闭windows防火墙后再试; 2.检查防火墙软件是否开放相应SocketTCP/udp端口; 简单的检测方法是关闭防火墙软件后再试; 3.如果服务器端和客户端均在本机上运行,则将相应的 serv...
【从零开始游戏开发】Unity 前后端网络通信该如何搭建？注释解答 | 全面总结 |建议收藏
qq_21407523的博客
11-06 2114
【从零开始游戏开发】Unity 前后端网络通信该如何搭建？注释解答 | 全面总结 |建议收藏
PPP协议详解：点对点通信与网络配置
点到点协议（PPP，Point-to-Point Protocol）是一种用于在两个对等实体之间建立数据包传输连接的通信协议，常见于拨号互联网连接、广域网（WAN）链接以及路由器之间的连接。PPP设计的主要目标是提供简单而灵活的连接...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值