【Unity】基于ProtoBuffer与Socket实现网络传输

最新推荐文章于 2024-07-15 09:40:27 发布

我只是个小透明

最新推荐文章于 2024-07-15 09:40:27 发布

阅读量4.5k

点赞数 3

分类专栏： C#知识 unity 文章标签： socket unity

unity 同时被 2 个专栏收录

16 篇文章 1 订阅

订阅专栏

C#知识

4 篇文章 0 订阅

订阅专栏

1.Unity中使用ProtoBuf

• 导入DLL到Unity中
• 创建网络传输的模型类

using System;
using ProtoBuf;

//添加特性，表示可以被ProtoBuf工具序列化
[ProtoContract]
public class NetModel {
    //添加特性，表示该字段可以被序列化，1可以理解为下标
    [ProtoMember(1)]    
    public int ID;
    [ProtoMember(2)]
    public string Commit;
    [ProtoMember(3)]
    public string Message;
}

• 在Unity中添加测试脚本，介绍ProtoBuf工具的使用。
其中用到了MemorySteam,我的上一篇博客中有简单介绍 http://blog.csdn.net/treepulse/article/details/53463812

using System;
using System.IO;

public class Test : MonoBehaviour {

  void Start () {
      //创建对象
      NetModel item = new NetModel(){ID = 1, Commit = "LanOu", Message = "Unity"};
      //序列化对象
      byte[] temp = Serialize(item);
      //ProtoBuf的优势一：小
      Debug.Log(temp.Length);
      //反序列化为对象
      NetModel result = DeSerialize(temp);
      Debug.Log(result.Message);

  }

  /// <summary>
  /// 将消息序列化为二进制的方法
  /// </summary>
  /// <param name="model">要序列化的对象</param>
  private byte[] Serialize(NetModel model)
  {
      try {
          //涉及格式转换，需要用到流，将二进制序列化到流中
          using (MemoryStream ms = new MemoryStream()) {
              //使用ProtoBuf工具的序列化方法
              ProtoBuf.Serializer.Serialize<NetModel> (ms, model);
              //定义二级制数组，保存序列化后的结果
              byte[] result = new byte[ms.Length];
              //将流的位置设为0，起始点
              ms.Position = 0;
              //将流中的内容读取到二进制数组中
              ms.Read (result, 0, result.Length);
              return result;
          }
      } catch (Exception ex) {
          Debug.Log ("序列化失败: " + ex.ToString());
          return null;
      }
  }

  /// <summary>
  /// 将收到的消息反序列化成对象
  /// </summary>
  /// <returns>The serialize.</returns>
  /// <param name="msg">收到的消息.</param>
  private NetModel DeSerialize(byte[] msg)
  {
      try {
          using (MemoryStream ms = new MemoryStream()) {
              //将消息写入流中
              ms.Write (msg, 0, msg.Length);
              //将流的位置归0
              ms.Position = 0;
              //使用工具反序列化对象
              NetModel result = ProtoBuf.Serializer.Deserialize<NetModel> (ms);
              return result;
          }
          } catch (Exception ex) {        
              Debug.Log("反序列化失败: " + ex.ToString());
              return null;
          }
      }
  }

using在这里用于定义一个范围，在此范围的末尾将释放对象。

using(Connection conn=new Connection(connStr))  {  }  //使用using关键字可及时销毁对象

2.Unity中使用Socket实现实时通信

通信应该实现的功能：
• 1.服务器可以时时监听多个客户端
• 2.服务器可以时时监听某一个客户端消息
• 3.服务器可以时时给某一个客户端发消息

首先我们需要定义一个客户端对象

using System;
using System.Net.Sockets;

/// <summary>
/// 表示一个客户端
/// </summary>
public class NetUserToken {
    //连接客户端的Socket
    public Socket socket;
    //用于存放接收数据
    public byte[] buffer;

    public NetUserToken()
    {
        buffer = new byte[1024];
    }

    /// <summary>
    /// 接受消息
    /// </summary>
    /// <param name="data">Data.</param>
    public void Receive(byte[] data)
    {
        UnityEngine.Debug.Log("接收到消息！");
    }

    /// <summary>
    /// 发送消息
            /// </summary>
    /// <param name="data">Data.</param>
    public void Send(byte[] data)
    {        

    }
}

然后实现我们的服务器代码

using System.Collections;
using System.Collections.Generic;
using System.Net;
using System;
using System.Net.Sockets;

public class NetServer{
    //单例脚本
    public static readonly NetServer Instance = new NetServer();
    //定义tcp服务器
    private Socket server;
    private int maxClient = 10;
    //定义端口
    private int port = 35353;
    //用户池
    private Stack<NetUserToken> pools;
    private NetServer()
    {
        //初始化socket
        server = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
        server.Bind(new IPEndPoint(IPAddress.Any, port));

    }

    //开启服务器
    public void Start()
    {
        server.Listen(maxClient);
        UnityEngine.Debug.Log("Server OK!");
        //实例化客户端的用户池
        pools = new Stack<NetUserToken>(maxClient);
        for(int i = 0; i < maxClient; i++)
        {
            NetUserToken usertoken = new NetUserToken();
            pools.Push(usertoken);
        }
        //可以异步接受客户端, BeginAccept函数的第一个参数是回调函数，当有客户端连接的时候自动调用
        server.BeginAccept (AsyncAccept, null);
    }

    //回调函数， 有客户端连接的时候会自动调用此方法
    private void AsyncAccept(IAsyncResult result)
    {
        try {
            //结束监听，同时获取到客户端
            Socket client = server.EndAccept(result);
            UnityEngine.Debug.Log("有客户端连接");
            //来了一个客户端
            NetUserToken userToken = pools.Pop();
            userToken.socket = client;
            //客户端连接之后，可以接受客户端消息
            BeginReceive(userToken);

            //尾递归，再次监听是否还有其他客户端连入
            server.BeginAccept(AsyncAccept, null);
        } catch (Exception ex) {
            UnityEngine.Debug.Log(ex.ToString());
        }
    }

    //异步监听消息
    private void BeginReceive(NetUserToken userToken)
    {
        try {
            //异步方法
            userToken.socket.BeginReceive(userToken.buffer, 0, userToken.buffer.Length, SocketFlags.None,
                                          EndReceive, userToken);
        } catch (Exception ex) {
            UnityEngine.Debug.Log(ex.ToString());
        }
    }

    //监听到消息之后调用的函数
    private void EndReceive(IAsyncResult result)
    {
        try {
            //取出客户端
            NetUserToken userToken = result.AsyncState as NetUserToken;
            //获取消息的长度
            int len = userToken.socket.EndReceive(result);
            if(len > 0)
            {    
                byte[] data = new byte[len];
                Buffer.BlockCopy(userToken.buffer, 0, data, 0, len);
                //用户接受消息
                userToken.Receive(data);
                //尾递归，再次监听客户端消息
                BeginReceive(userToken);
            }

        } catch (Exception ex) {
            UnityEngine.Debug.Log(ex.ToString());
        }
    }
}

在Unity中开启服务器，并使用C#控制台模拟客户端连接、发送消息操作。
Unity中可以时时监听到消息。

using UnityEngine;
using System.Collections;

public class CreateServer : MonoBehaviour {

    void StartServer () {
        NetServer.Instance.Start();
    }

}

//C#控制台工程

using System;
using System.Net;
using System.Net.Sockets;
using System.IO;
using System.Text;

namespace Temp
{
    class MainClass
    {
        public static void Main (string[] args)
        {
            TcpClient tc = new TcpClient();
            IPEndPoint ip = new IPEndPoint(IPAddress.Parse("127.0.0.1"), 35353);
            tc.Connect(ip);

            if(tc.Connected)
            {
                while(true)
                {

                    string msg = Console.ReadLine();
                    byte[] result = Encoding.UTF8.GetBytes(msg);
                    tc.GetStream().Write(result, 0, result.Length);
                }
            }
            Console.ReadLine();
        }
    }
}

3.数据包的编码和解码

当服务器需要向客户端发送一条很长的数据，服务器会把一条很长的数据分成若干条小数据，多次发送给客户端。

可是，这样就又有另外一个问题，客户端接受到多条数据之后如何解析？
这里其实就是客户端的解码。server发数据一般采用“长度+内容”的格式，Client接收到数据之后，先提取出长度来，然后根据长度判断内容是否发送完毕。

再次重申，用户在发送序列化好的消息的前，需要先编码后再发送消息；
用户在接受消息后，需要解码之后再解析数据（反序列化）。

BinaryWriter和BinaryReader类，它们可以将一个字符或数字按指定个数字节写入，也可以一次读取指定个数字节转为字符或数字。
官方文档：

using UnityEngine;
using System.Collections.Generic;
using System.IO;

/// <summary>
/// 编码和解码
/// </summary>
public class NetEncode {

    /// <summary>
    /// 将数据编码 长度+内容
    /// </summary>
    /// <param name="data">内容</param>
    public static byte[] Encode(byte[] data)
    {
        //整形占四个字节，所以声明一个+4的数组
        byte[] result = new byte[data.Length + 4];
        //使用流将编码写二进制
        MemoryStream ms = new MemoryStream();
        BinaryWriter br = new BinaryWriter(ms);
        br.Write(data.Length);
        br.Write(data);
        //将流中的内容复制到数组中
        System.Buffer.BlockCopy(ms.ToArray(), 0, result, 0, (int)ms.Length);
        br.Close();
        ms.Close();
        return result;
    }

    /// <summary>
    /// 将数据解码
    /// </summary>
    /// <param name="cache">消息队列</param>
    public static byte[] Decode(ref List<byte> cache)
    {
        //首先要获取长度，整形4个字节，如果字节数不足4个字节
        if(cache.Count < 4)
        {
            return null;
        }
        //读取数据
        MemoryStream ms = new MemoryStream(cache.ToArray());
        BinaryReader br = new BinaryReader(ms);
        int len = br.ReadInt32();
        //根据长度，判断内容是否传递完毕
        if(len > ms.Length - ms.Position)
        {
            return null;
        }
        //获取数据
        byte[] result = br.ReadBytes(len);
        //清空消息池
        cache.Clear();
        //将剩余没处理的消息存入消息池
        cache.AddRange(br.ReadBytes((int)ms.Length - (int)ms.Position));

        return result;
    }
}

用户接受数据代码如下：

using System;
using System.Collections.Generic;
using System.Net.Sockets;

/// <summary>
/// 表示一个客户端
/// </summary>
public class NetUserToken {
    //连接客户端的Socket
    public Socket socket;
    //用于存放接收数据
    public byte[] buffer;
    //每次接受和发送数据的大小
    private const int size = 1024;

    //接收数据池
    private List<byte> receiveCache;
    private bool isReceiving;
    //发送数据池
    private Queue<byte[]> sendCache;
    private bool isSending;

    //接收到消息之后的回调
    //Action<T>：只有一个类型为T的参数，无返回值的委托
    public Action<NetModel> receiveCallBack;


    public NetUserToken()
    {
        buffer = new byte[size];
        receiveCache = new List<byte>();
        sendCache = new Queue<byte[]>();
    }

    /// <summary>
    /// 服务器接受客户端发送的消息
    /// </summary>
    /// <param name="data">Data.</param>
    public void Receive(byte[] data)
    {
        UnityEngine.Debug.Log("接收到数据");
        //将接收到的数据放入数据池中
        receiveCache.AddRange(data);
        //如果没在读数据
        if(!isReceiving)
        {
            isReceiving = true;
            ReadData();
        }
    }

    /// <summary>
    /// 读取数据
    /// </summary>
    private void ReadData()
    {
        byte[] data = NetEncode.Decode(ref receiveCache);
        //说明数据保存成功
        if(data != null)
        {
            NetModel item = NetSerilizer.DeSerialize(data);
            UnityEngine.Debug.Log(item.Message);
            if(receiveCallBack != null)
            {
                receiveCallBack(item);
            }
            //尾递归，继续读取数据
            ReadData();
        }
        else
        {
            isReceiving = false;
        }
    }

    /// <summary>
    /// 服务器发送消息给客户端
    /// </summary>
    public void Send()
    {
        try {
            if (sendCache.Count == 0) {
                isSending = false;
                return;    
            }
            byte[] data = sendCache.Dequeue ();
            int count = data.Length / size;
            int len = size;
            for (int i = 0; i < count + 1; i++) {
                if (i == count) {
                    len = data.Length - i * size;
                }
                socket.Send (data, i * size, len, SocketFlags.None);
            }
            UnityEngine.Debug.Log("发送成功!");
            Send ();
        } catch (Exception ex) {
            UnityEngine.Debug.Log(ex.ToString());
        }
    }

    public void WriteSendDate(byte[] data){
        sendCache.Enqueue(data);
        if(!isSending)
        {
            isSending = true;
            Send();
        }
    }
}