Unity网络服务器搭建【中高级】

2016-01-22 本文已影响3699人欣羽馨予

前言

众所周知，网络游戏中，服务器的搭建尤为重要，无论是授权服务器，还是非授权服务器，它都承担着很大一部分的数据处理。今天，给大家分享一个中高级的小服务器搭建，当然也是在Unity上实现的，可以迁移为服务，外部程序等。其中加入了对象的序列化与反序列化，数据包的封包与拆包，细细品味，别有一番滋味。

服务器基础搭建

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

  //实时消息处理委托
  public delegate void NetEventHandler (string msg);

  public class NetUtility
  {
      //单例
      public static readonly NetUtility Instance = new NetUtility ();
      //消息回调
      private NetEventHandler ReceiveCallback;
      //服务器Tcp
      private TcpListener tcpServer;
      //客户端Tcp
      private TcpClient tcpClient;
      //缓冲区
      private byte[] buffer;
      //缓存数据组
      private List<byte> cache;
      //网络节点
      private IPEndPoint serverIPEndPoint;

      /// <summary>
      /// 设置网络节点
      /// </summary>
      /// <param name="ep">网络节点.</param>
      public void SetIpAddressAndPort (IPEndPoint ep)
      {
          //只写网络节点
          serverIPEndPoint = ep;
      }
      /// <summary>
      /// 设置委托
      /// </summary>
      /// <param name="handler">消息委托.</param>
      public void SetDelegate (NetEventHandler handler)
      {
          //只写赋值回调
          ReceiveCallback = handler;
      }
      /// <summary>
      /// Initializes a new instance of the <see cref="NetUtility"/> class.
      /// </summary>
      private NetUtility ()
      {
          //服务器实例
          tcpServer = new TcpListener (IPAddress.Any, 23456);
          //客户端实例
          tcpClient = new TcpClient (AddressFamily.InterNetwork);
          //缓冲区初始化
          buffer = new byte[1024];
          //缓存数据组实例
          cache = new List<byte> ();
          //默认网络节点
          serverIPEndPoint = new IPEndPoint (IPAddress.Parse ("127.0.0.1"), 23456);
      }

服务器部分

  #region Server Part:
  /// <summary>
  /// 开启服务器
  /// </summary>
  public void ServerStart ()
  {
      //开启服务器
      tcpServer.Start (10);
      //服务器开启提示
      ReceiveCallback ("Server Has Init!");
      //开始异步接受客户端的连接请求
      tcpServer.BeginAcceptTcpClient (AsyncAccept, null);
  }
  /// <summary>
  /// 异步连接回调
  /// </summary>
  /// <param name="ar">Ar.</param>
  void AsyncAccept (System.IAsyncResult ar)
  {
      //接受到客户端的异步连接请求
      tcpClient = tcpServer.EndAcceptTcpClient (ar);
      //有新的客户端连接提示
      ReceiveCallback ("Accept Client :" + tcpClient.Client.RemoteEndPoint.ToString ());
      //异步接收消息
      tcpClient.Client.BeginReceive (buffer, 0, 1024, SocketFlags.None, AsyncReceive, tcpClient.Client);
      //异步接受客户端请求尾递归
      tcpServer.BeginAcceptTcpClient (AsyncAccept, null);
  }
  /// <summary>
  /// 异步接收消息回调
  /// </summary>
  /// <param name="ar">Ar.</param>
  void AsyncReceive (System.IAsyncResult ar)
  {
      //获取消息套接字
      Socket workingClient = ar.AsyncState as Socket;
      //完成接收
      int msgLength = workingClient.EndReceive (ar);
      //如果接收到了数据
      if (msgLength > 0) {
          //消息接收提示
          ReceiveCallback ("ReceiveData : " + msgLength + "bytes");
          //临时缓冲区
          byte[] tempBuffer = new byte[msgLength];
          //拷贝数据到临时缓冲区
          Buffer.BlockCopy (buffer, 0, tempBuffer, 0, msgLength);
          //数据放到缓存数据组队尾
          cache.AddRange (tempBuffer); 
          //拆包解析
          byte[] result = LengthDecode (ref cache);
          //如果已经接收完全部数据
          if (result != null) {
              //开始反序列化数据
              NetModel resultModel = DeSerialize (result);
              //TODO:Object Processing!
              //数据对象结果提示
              ReceiveCallback ("Object Result IP : " + resultModel.senderIp);
              ReceiveCallback ("Object Result Content : " + resultModel.content);
              ReceiveCallback ("Object Result Time : " + resultModel.time);
          }
          //消息未接收全，继续接收
          tcpClient.Client.BeginReceive (buffer, 0, 1024, SocketFlags.None, AsyncReceive, tcpClient.Client);
      }

  }
  #endregion

客户端部分

  #region Client Part
  /// <summary>
  /// 客户端连接
  /// </summary>
  public void ClientConnnect ()
  {
      //连接到服务器
      tcpClient.Connect (serverIPEndPoint);
      //连接到服务器提示
      ReceiveCallback ("Has Connect To Server : " + serverIPEndPoint.Address.ToString ());
  }
  /// <summary>
  /// 发送消息
  /// </summary>
  /// <param name="model">Model.</param>
  public void SendMsg (NetModel model)
  {
      //将数据对象序列化
      buffer = Serialize (model);
      //将序列化后的数据加字节头
      buffer = LengthEncode (buffer);
      //拆分数据，多次发送
      for (int i = 0; i < buffer.Length/1024 + 1; i++) {
          //满发送，1KB
          int needSendBytes = 1024;
          //最后一次发送，剩余字节
          if (i == buffer.Length / 1024) {
              //计算剩余字节
              needSendBytes = buffer.Length - i * 1024;
          }
          //发送本次数据
          tcpClient.GetStream ().Write (buffer, i * 1024, needSendBytes);
      }
  }
  #endregion

公共方法

  #region Public Function
  /// <summary>
  /// 数据加字节头操作
  /// </summary>
  /// <returns>数据结果.</returns>
  /// <param name="data">源数据.</param>
  byte[] LengthEncode (byte[] data)
  {
      //内存流实例
      using (MemoryStream ms = new MemoryStream()) {
          //二进制流写操作实例
          using (BinaryWriter bw = new BinaryWriter(ms)) {
              //先写入字节长度
              bw.Write (data.Length);
              //再写入所有数据
              bw.Write (data);
              //临时结果
              byte[] result = new byte[ms.Length];
              //将写好的流数据放入临时结果
              Buffer.BlockCopy (ms.GetBuffer (), 0, result, 0, (int)ms.Length);
              //返回临时结果
              return result;
          }
      }
  }
  /// <summary>
  /// 数据解析，拆解字节头，获取数据.
  /// </summary>
  /// <returns>源数据.</returns>
  /// <param name="cache">缓存数据.</param>
  byte[] LengthDecode (ref List<byte> cache)
  {
      //如果字节数小于4，出现异常
      if (cache.Count < 4)
          return null;
      //内存流实例
      using (MemoryStream ms = new MemoryStream(cache.ToArray())) {
          //二进制流读操作实例
          using (BinaryReader br = new BinaryReader(ms)) {
              //先读取数据长度，一个int值
              int realMsgLength = br.ReadInt32 ();
              //如果未接收全数据，下次继续接收
              if (realMsgLength > ms.Length - ms.Position) {
                  return null;
              }
              //接收完，读取所有数据
              byte[] result = br.ReadBytes (realMsgLength);
              //清空缓存
              cache.Clear ();
              //返回结果
              return result;
          }
      }
  }
  /// <summary>
  /// 序列化数据.
  /// </summary>
  /// <param name="mod">数据对象.</param>
  private byte[] Serialize (NetModel mod)
  {
      try {
          //内存流实例
          using (MemoryStream ms = new MemoryStream()) {
              //ProtoBuf协议序列化数据对象
              ProtoBuf.Serializer.Serialize<NetModel> (ms, mod);
              //创建临时结果数组
              byte[] result = new byte[ms.Length];
              //调整游标位置为0
              ms.Position = 0;
              //开始读取，从0到尾
              ms.Read (result, 0, result.Length);
              //返回结果
              return result;
          }
      } catch (Exception ex) {
          
          Debug.Log ("Error:" + ex.ToString ());
          return null;
      }
  }
  
  /// <summary>
  /// 反序列化数据.
  /// </summary>
  /// <returns>数据对象.</returns>
  /// <param name="data">源数据.</param>
  private NetModel DeSerialize (byte[] data)
  {
      try {
          //内存流实例
          using (MemoryStream ms = new MemoryStream(data)) {
              //调整游标位置
              ms.Position = 0;
              //ProtoBuf协议反序列化数据
              NetModel mod = ProtoBuf.Serializer.Deserialize<NetModel> (ms);
              //返回数据对象
              return mod;
              
          }
      } catch (Exception ex) {
          Debug.Log ("Error: " + ex.ToString ());
          return null;
      }
  }
  #endregion

服务器实现

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

  /// <summary>
  /// 服务器实现.
  /// </summary>
  public class ServerDemo : MonoBehaviour
  {
      //临时消息接收
      string currentMsg = "";
      Vector2 scrollViewPosition;

      void Start ()
      {
          scrollViewPosition = Vector2.zero;
          //消息委托
          NetUtility.Instance.SetDelegate ((string msg) => {
              Debug.Log (msg);
              currentMsg += msg + "\r\n";
          });
          //开启服务器
          NetUtility.Instance.ServerStart ();
      }

      void OnGUI ()
      {
          scrollViewPosition = GUILayout.BeginScrollView (scrollViewPosition, GUILayout.Width (300), GUILayout.Height (300));
          //消息展示
          GUILayout.Label (currentMsg);
          GUILayout.EndScrollView ();
      }
  }

客户端实现

  using UnityEngine;
  using System.Collections;
  using System.Text;
  using System;
  /// <summary>
  /// 客户端实现
  /// </summary>
  public class ClientDemo : MonoBehaviour
  {
      //待解析地址
      public string wwwAddress = "";

      void Start ()
      {
          //消息处理
          NetUtility.Instance.SetDelegate ((string msg) => {
              Debug.Log (msg + "\r\n");
          });
          //连接服务器
          NetUtility.Instance.ClientConnnect ();
          //开启协程
          StartCoroutine (ServerStart ());
      }

      IEnumerator ServerStart ()
      {
          //加载网页数据
          WWW www = new WWW (wwwAddress);
          yield return www;
          //编码获取内容
          string content = UTF8Encoding.UTF8.GetString (www.bytes);
          //内容测试
          Debug.Log (content);
          //待发送对象
          NetModel nm = new NetModel ();
          //消息体
          nm.senderIp = "127.0.0.1";
          nm.content = content;
          nm.time = DateTime.Now.ToString ();
          //发送数据对象
          NetUtility.Instance.SendMsg (nm);
      }
  }

结果图

结果图
Demo下载：链接: http://pan.baidu.com/s/1mhgUALy 密码: u36k

结束语

文中的ProtoBuf是跨平台的，可以跨平台传输对象。本文使用的是传输层的协议，有兴趣的同学可以使用网络层协议Socket实现，本文后续还会有网络游戏传输协议的内容，同学们随时关注。

Unity网络服务器搭建【中高级】

前言

结束语

猜你喜欢

热点阅读