Unity + Socket + Protobuf+异步+粘包拆包断包 之 一

最新推荐文章于 2024-09-30 17:29:00 发布
最新推荐文章于 2024-09-30 17:29:00 发布
阅读量3.2k 收藏 16
点赞数 3
分类专栏： Unity3D
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yy1042001041/article/details/81131079
版权

最近项目要用到Socket，遇到一些坑，比如频繁发消息 收消息，会产生粘包拆包等问题，还有断线重连的问题。

*** 项目工程在这里***

  • 首先 是 定义了 SocketClient.cs,

    构造函数中初始化地址和端口：

 public SocketClient(string ip, int port)
        {
            SocketState = SocketState.Idle;
            IPHostEntry hostInfo = Dns.GetHostEntry(ip);
            IPAddress mIp = hostInfo.AddressList[0];
            ipEndPoint = new IPEndPoint(mIp, port);
        }

Dns.GetHostEntry 支持域名转换成ip地址。

  • 异步连接服务器：

    clientSocket.BeginConnect(ipEndPoint, OnConnectCallBack, this);
    OnConnectCallBack这个函数 是连接成功或失败的回调函数。

  • 连接服务器成功：

    开始监听接受消息

/// <summary>
         /// 开始接收消息
         /// </summary>
         private void StartReceive()
         {
            if (!clientSocket.Connected)
            {
                return;
            }
            clientSocket.BeginReceive(Buffer, 0, Buffer.Length, SocketFlags.None, OnReceiveDataComplete, this);
         }

这边Buffer 是一个固定长度为1024的byte[]对象，OnReceiveDataComplete函数是接受到消息，会把接受到的数据存入Buffer中。

 /// <summary>
        /// 数据接收完成的回调函数
        /// </summary>
        private void OnReceiveDataComplete(IAsyncResult ar)
        {
            int ByteRead = 0;
            try
            {
                //接收完毕消息后的字节数
                ByteRead = clientSocket.EndReceive(ar);
            }
            catch (Exception ex)
            {
                Debug.LogError(string.Format("[SocketClient] ex is {0}.", ex));
            }
            byte[] data = new byte[ByteRead];
            Array.Copy(Buffer, 0, data, 0, ByteRead);
            // 触发接收消息事件
            if (ReceiveMessageCompleted != null)
            {
                ReceiveMessageCompleted(this, new SocketEventArgs(data));
            }
            StartReceive();
        }

ByteRead = clientSocket.EndReceive(ar);可以获取此次消息的长度，然后把Buffer中数据截取拷贝到data对象中 已被下面ReceiveMessageCompleted处理。然后继续下一次的监听消息。

  • 发消息给服务器：
/// <summary>
        /// 发送消息
        /// </summary>
        /// <param name="data">要传递的消息内容[字节数组]</param>
        public void OnSendMessage(byte[] data)
        {
            var stream = new MemoryStream();
            stream.Write(data, 0, data.Length);
            var all = stream.ToArray();
            stream.Close();
            try
            {
                clientSocket.BeginSend(all, 0, all.Length, SocketFlags.None, OnSendMessageComplete, all);
            }
            catch (Exception ex)
            {
                Reconnect();
                Debug.LogError(string.Format("[OnSendMessage] ex is {0}", ex));
            }
            
        }

同样是异步操作，OnSendMessageComplete是发送回掉函数。

下面我将展示部分代码：
首先 是 定义了 SocketClient.cs:

using System;
using System.IO;
using System.Net;
using System.Net.Sockets;
using System.Threading;
using UnityEngine;

namespace YY.SocketClient
{
    public enum SocketState
    {
        Idle,
        Connecting,
        Connented,
        DisConnecting,
        DisConnected
    }
    public class SocketClient
    {
        public SocketState SocketState { get; private set; }
        private Socket clientSocket;
        public bool IsConnected
        {
            get
            {
                if(clientSocket != null && clientSocket.Connected)
                {
                    this.SocketState = SocketState.Connented;
                }
                else
                {
                    if(this.SocketState != SocketState.Connecting)
                    {
                        this.SocketState = SocketState.DisConnected;
                    }
                }
                return clientSocket != null && clientSocket.Connected;
            }
        }
        private Thread threadReceive;
        private IPEndPoint ipEndPoint;
        private bool isReconnect = false;
        private byte[] Buffer = new byte[1024];
        /// <summary>
        /// 连接远程地址完成事件
        /// </summary>
        public event EventHandler<SocketEventArgs> ConnectCompleted;

        /// <summary>
        /// 事件消息接收完成
        /// </summary>
        public event EventHandler<SocketEventArgs> ReceiveMessageCompleted;

        /// <summary>
        /// 发送消息完成
        /// </summary>
        public event EventHandler<SocketEventArgs> SendMessageCompleted;

        public Action ConnectedAction { get; set; }
        public Action ReconnectToServer { get; set; }
        public SocketClient(string ip, int port)
        {
            SocketState = SocketState.Idle;
            IPHostEntry hostInfo = Dns.GetHostEntry(ip);
            IPAddress mIp = hostInfo.AddressList[0];
            ipEndPoint = new IPEndPoint(mIp, port);
        }

        /// <summary>
        /// 发送连接请求
        /// </summary>
        public void SendConnect()
        {
            SocketState = SocketState.Connecting;
            Connect();
        }
        
        /// <summary>
        /// 连接指定IP和端口的服务器
        /// </summary>
        /// <param name="ip"></param>
        /// <param name="port"></param>
        private bool Connect()
        {
            //("开始连接服务器" + ipEndPoint);
            try
            {
                clientSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
                clientSocket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.KeepAlive, true);
                Debug.LogError("开始连接服务器");
                clientSocket.BeginConnect(ipEndPoint, OnConnectCallBack, this);
                

                //("连接服务器成功" + ipEndPoint);
                return true;
            }
            catch (Exception ex)
            {
                //("连接服务器失败" + ex + ipEndPoint);
                return false;
            }
        }
        /// <summary>
        /// 连接的回调函数
        /// </summary>
        /// <param name="ar"></param>
        private void OnConnectCallBack(IAsyncResult ar)
        {
            Debug.LogError(string.Format("连接服务器返回状态 = {0}", ar.AsyncState));
            SocketState = clientSocket.Connected ? SocketState.Connented : SocketState.DisConnected;
            if (!clientSocket.Connected)
            {
                return;
            }
            Debug.LogError(string.Format("连接服务器成功 = {0}", ar.AsyncState));
            if (this.ConnectedAction != null)
            {
                this.ConnectedAction();
            }
            if (isReconnect)
            {
                isReconnect = false;
                if(ReconnectToServer!= null)
                {
                    this.ReconnectToServer();
                }
            }
            clientSocket.EndConnect(ar);
            if (ConnectCompleted != null)
            {
                ConnectCompleted(this, new SocketEventArgs());
            }
            
            StartReceive();
        }
         /// <summary>
         /// 开始接收消息
         /// </summary>
         private void StartReceive()
         {
            if (!clientSocket.Connected)
            {
                return;
            }
            clientSocket.BeginReceive(Buffer, 0, Buffer.Length, SocketFlags.None, OnReceiveDataComplete, this);
         }

        /// <summary>
        /// 数据接收完成的回调函数
        /// </summary>
        private void OnReceiveDataComplete(IAsyncResult ar)
        {
            int ByteRead = 0;
            try
            {
                //接收完毕消息后的字节数
                ByteRead = clientSocket.EndReceive(ar);
            }
            catch (Exception ex)
            {
                Debug.LogError(string.Format("[SocketClient] ex is {0}.", ex));
            }
            byte[] data = new byte[ByteRead];
            Array.Copy(Buffer, 0, data, 0, ByteRead);
            // 触发接收消息事件
            if (ReceiveMessageCompleted != null)
            {
                ReceiveMessageCompleted(this, new SocketEventArgs(data));
            }
            StartReceive();
        }
        #region Send Message
 
        

        /// <summary>
        /// 发送消息
        /// </summary>
        /// <param name="data">要传递的消息内容[字节数组]</param>
        public void OnSendMessage(byte[] data)
        {
            var stream = new MemoryStream();
            stream.Write(data, 0, data.Length);
            var all = stream.ToArray();
            stream.Close();
            try
            {
                clientSocket.BeginSend(all, 0, all.Length, SocketFlags.None, OnSendMessageComplete, all);
            }
            catch (Exception ex)
            {
                Reconnect();
                Debug.LogError(string.Format("[OnSendMessage] ex is {0}", ex));
            }
            
        }

        /// <summary>
        /// 发送消息完成的回调函数
        /// </summary>
        /// <param name="ar"></param>
        private void OnSendMessageComplete(IAsyncResult ar)
        {
            var data = ar.AsyncState as byte[];
            SocketError socketError;
            clientSocket.EndSend(ar, out socketError);
            if (socketError != SocketError.Success)
            {
                clientSocket.Disconnect(false);
                throw new SocketException((int)socketError);
            }
            if (SendMessageCompleted != null)
            {
                SendMessageCompleted(this, new SocketEventArgs(data));
            }
        }
 
         #endregion

        public void Reconnect()
        {            
            if (this.SocketState == SocketState.Connecting || this.SocketState == SocketState.Connented)
            {
                return;
            }
            isReconnect = true;
            if (threadReceive != null && threadReceive.IsAlive)
            {
                threadReceive.Abort();
            }
            if (null != clientSocket && clientSocket.Connected)
            {
                clientSocket.Shutdown(SocketShutdown.Both);
                clientSocket.Disconnect(true);
                clientSocket.Close();

            }
            SendConnect();
        }
        

        public void OnApplicationQuit()
        {
            if (threadReceive != null)
            {
                threadReceive.Abort();
            }
            if(this.clientSocket!= null)
            {
                this.clientSocket.Shutdown(SocketShutdown.Both);
                this.clientSocket.Disconnect(true);
                this.clientSocket.Close();
            }
            
        }
    }

     #region Event
 
     /// <summary>
     /// Simple socket event args
     /// </summary>
     public class SocketEventArgs : EventArgs
     {
 
         public SocketEventArgs()
         {
         }
 
         public SocketEventArgs(byte[] data) : this()
         {
             Data = data;
         }
 
         /// <summary>
         /// 相关的数据
         /// </summary>
         public byte[] Data { get; private set; }
 
     }
 
     #endregion
}
奶酪烤面包
关注
专栏目录
Unity + Socket + Protobuff+异步+粘包拆包断包_V2
02-21
本项目"Unity + Socket + Protobuff+异步+粘包拆包断包_V2"聚焦于解决在使用Socket进行网络通信时常见的问题，如粘包、拆包、断包以及断线重连等，同时结合了Protocol Buffers（Protobuff）这一高效的数据序列化协议...
1007.protobuf序列化string数据遇'\0'截断问题
写给自己的笔记
06-06 2388
背景: 使用protobuf在进行序列化的过程 中碰到一个，比较恶心的问题，将xx 对象序列化为 str 时，反序列化，得不到正确的结果。问题具有一定的偶然性，和xx对象的数据有关，调试好久，才发现问题所在。 解决方案: sMainFrame 是序列化之后的string对象，大小为sMainFrame.size(); 此时 根据数据的不同， 进行测...
protobuf 安装 及 使用
liuyinxing的博客
11-10 2635
protobuf 安装及使用
Unity中Socket_TCP异步连接，加入断线检测以及重连功能（服务端客户端源码）
最新发布
ForKnowledgeMe的博客
09-30 768
【代码】Unity中Socket_TCP异步连接，加入断线检测以及重连功能。
Unity + Socket + Protobuf+异步+粘包拆包断包 之 二
奶酪的博客
07-20 1113
上章讲了SocketClinet的结构这次讲一讲怎么使用它。 我们新建一个SocketManager 来管理SocketClinet. SocketManager 是个单例，就不讲单例的知识点，想了解的可以去百度。 初始化时 创建一个Socket Clinet public void Init(string address,int port) { ...
Netty编解码&粘包拆包&心跳机制&断线自动重连
weixin_40406012的博客
02-26 838
Netty编解码 粘包拆包 心跳机制 断线自动重连
Unity+Grpc+Protobuf
12-07
1、内容包含protobuf已经grpc的简单协议，以及生成协议代码的工具。2、unity的测试场景，简单的创建服务器已经客户端连接服务端的代码。
Unity+protobuf+Socket通信
06-18
整合Unity+Protobuf+Socket的一个游戏案例，里面包括服务器和客户端各一个socket,通过线程管理来保证多个连接请求同步。案例简单，但在实际开发中很常用。通过稍微修改，就可以用在实际项目里。编程语言是C#，都加了...
Unity+SignalR实实时通信
01-03
本资源实现了Unity+SignalR实现实时通信,封装简单易懂,支持源码自行扩展修改,希望能为大家提供到帮助
Unity+UMR SDK
03-29
Rokid UMR SDK（Rokid Unity MR SDK） 是 Rokid 为Unity开发者提供的XR开发工具包，提供基于Rokid XR 平台的空间渲染、空间定位、空间交互能力。 UMR SDK 目前提供以下能力，包括：空间定位&跟踪、虚实交互、Camera...
unity实现Socket通讯（内含tcp粘包/拆包解决）
12-25
通过socket通讯实现服务器与客户端的连接。首先服务器利用udp广播发送自己的ip地址，客户端在收到广播后通过此ip以tcp连接的方式连接服务器来通讯。
Netty傻瓜教程（三）：拆包、粘包。用神器protobuf！
weixin_34239169的博客
02-22 572
2019独角兽企业重金招聘Python工程师标准>>> ...
Unity处理Socket粘包拆包
大猪的博客
06-21 348
现在游戏协议的数据格式基本上都是用protobuf协议格式，而protobuf最后会转换为二进制，所以这个例子实现逻辑的也是二进制的处理。处理粘包拆包的逻辑主要是在DecodePackage方法中。
Unity + Socket + Protobuf+异步+粘包拆包断包 之 三
奶酪的博客
07-20 1276
前面讲了SocketClient的结构，和 SocketManager的结构，本次讲一讲接下来的用法； SocketMono的代码如下 using Fitness.SocketClient; using System.Collections; using System.Collections.Generic; using UnityEngine; public class SocketM...
Unity + Socket + Protobuf+异步+粘包拆包断包 之 四
奶酪的博客
07-20 2909
Protobuff是对消息体进行序列化和反序列化的操作。 先建一个消息体文件msg.proto syntax = &amp;amp;amp;amp;quot;proto3&amp;amp;amp;amp;quot;; package com.shapejoy.remotecontrol.proto; enum Event { NULL = 0; HEART = 1; RECONNECTION = 3; DE
netty心跳、protobuf数据格式、粘包拆包、业务逻辑
秋叶清风的博客
06-17 671
netty 心跳、拆包粘包
Unity TCPSocket粘包和拆包问题
qq_38721111的博客
06-02 3074
问题产生 一个完整的业务可能会被TCP拆分成多个包进行发送，也有可能把多个小的包封装成一个大的数据包发送，这个就是TCP的拆包和封包问题。 下面可以看一张图，是客户端向服务端发送包： 1. 第一种情况，Data1和Data2都分开发送到了Server端，没有产生粘包和拆包的情况。 2. 第二种情况，Data1和Data2数据粘在了一起，打成了一个大的包发送到Server端，这个情况就是粘包。 3. 第三种情况，Data2被分离成Data2_1和Data2_2，并且Data2_1在Data1之前到达
Unity学习之Socket通信
qingtian_111的博客
10-12 5523
简单的socket通信学习笔记
unity socket粘包拆包
06-06
Unity中使用Socket进行网络通信时，会遇到粘包和拆包的问题。粘包指发送方发送的数据较大，接收方接收的数据却被拼接在一起，导致数据处理异常；拆包则是发送方发送的数据被分成几个包发送，接收方却只接收到部分...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值