Unity3D 游戏引擎之C#使用Socket与HTTP连接server数据传输包

近期比較忙。有段时间没写博客拉。近期项目中须要使用HTTP与Socket。雨松MOMO把自己这段时间学习的资料整理一下。

有关Socket与HTTP的基础知识MOMO就不赘述拉，不懂得朋友自己谷歌吧。我们项目的需求是在登录的时候使用HTTP请求。游戏中其他的请求都用Socket请求。比方人物移动同步坐标。同步关卡等等。

1.Socket

Socket不要写在脚本上。假设写在脚本上游戏场景一旦切换，那么这条脚本会被释放掉。Socket会断开连接。

场景切换完成后须要又一次在与server建立Socket连接，这样会非常麻烦。所以我们须要把Socket写在一个单例的类中，不用继承MonoBehaviour。这个样例我模拟一下。主角在游戏中移动，时时向服务端发送当前坐标，当server返回同步坐标时角色開始同步服务端新角色坐标。

Socket在发送消息的时候採用的是字节数组，也就是说不管你的数据是 int float short object 都会将这些数据类型先转换成byte[] 。 眼下在处理发送的地方我使用的是数据包。也就是把（角色坐标）结构体object转换成byte[]发送， 这就牵扯一个问题， 怎样把结构体转成字节数组， 怎样把字节数组回转成结构体。请大家接续阅读。答案就在后面，哇咔咔。

直接上代码

JFSocket.cs 该单例类不要绑定在不论什么对象上

1. using UnityEngine;
2. using System.Collections;
3. using System;
4. using System.Threading;
5. using System.Text;
6. using System.Net;
7. using System.Net.Sockets;
8. using System.Collections.Generic;
9. using System.IO;
10. using System.Runtime.InteropServices;
11. using System.Runtime.Serialization;
12. using System.Runtime.Serialization.Formatters.Binary;
13. public class JFSocket
14. {
15. //Socket客户端对象
16. private Socket clientSocket;
17. //JFPackage.WorldPackage是我封装的结构体。
18. //在与server交互的时候会传递这个结构体
19. //当客户端接到到server返回的数据包时。我把结构体add存在链表中。
20. public List<JFPackage.WorldPackage> worldpackage;
21. //单例模式
22. private static JFSocket instance;
23. public static JFSocket GetInstance()
24. {
25. if (instance == null)
26. {
27. instance = new JFSocket();
28. }
29. return instance;
30. }
31. //单例的构造函数
32. JFSocket()
33. {
34. //创建Socket对象， 这里我的连接类型是TCP
35. clientSocket = new Socket (AddressFamily.InterNetwork,SocketType.Stream,ProtocolType.Tcp);
36. //serverIP地址
37. IPAddress ipAddress = IPAddress.Parse ("192.168.1.100");
38. //serverport
39. IPEndPoint ipEndpoint = new IPEndPoint (ipAddress, 10060);
40. //这是一个异步的建立连接，当连接建立成功时调用connectCallback方法
41. IAsyncResult result = clientSocket.BeginConnect (ipEndpoint,new AsyncCallback (connectCallback),clientSocket);
42. //这里做一个超时的监測，当连接超过5秒还没成功表示超时
43. bool success = result.AsyncWaitHandle.WaitOne( 5000, true );
44. if ( !success )
45. {
46. //超时
47. Closed();
48. Debug.Log("connect Time Out");
49. }else
50. {
51. //与socket建立连接成功，开启线程接受服务端数据。
52. worldpackage = new List<JFPackage.WorldPackage>();
53. Thread thread = new Thread(new ThreadStart(ReceiveSorket));
54. thread.IsBackground = true;
55. thread.Start();
56. }
57. }
58. private void connectCallback(IAsyncResult asyncConnect)
59. {
60. Debug.Log("connectSuccess");
61. }
62. private void ReceiveSorket()
63. {
64. //在这个线程中接受server返回的数据
65. while (true)
66. {
67. if(!clientSocket.Connected)
68. {
69. //与server断开连接跳出循环
70. Debug.Log("Failed to clientSocket server.");
71. clientSocket.Close();
72. break;
73. }
74. try
75. {
76. //接受数据保存至bytes其中
77. byte[] bytes = new byte[4096];
78. //Receive方法中会一直等待服务端回发消息
79. //假设没有回发会一直在这里等着。
80. int i = clientSocket.Receive(bytes);
81. if(i <= 0)
82. {
83. clientSocket.Close();
84. break;
85. }
86. //这里条件可依据你的情况来推断。

87. //由于我眼下的项目先要监測包头长度，
88. //我的包头长度是2，所以我这里有一个推断
89. if(bytes.Length > 2)
90. {
91. SplitPackage(bytes,0);
92. }else
93. {
94. Debug.Log("length is not  >  2");
95. }
96. }
97. catch (Exception e)
98. {
99. Debug.Log("Failed to clientSocket error." + e);
100. clientSocket.Close();
101. break;
102. }
103. }
104. }
105. private void SplitPackage(byte[] bytes , int index)
106. {
107. //在这里进行拆包。由于一次返回的数据包的数量是不定的
108. //所以须要给数据包进行查分。
109. while(true)
110. {
111. //包头是2个字节
112. byte[] head = new byte[2];
113. int headLengthIndex = index + 2;
114. //把数据包的前两个字节拷贝出来
115. Array.Copy(bytes,index,head,0,2);
116. //计算包头的长度
117. short length = BitConverter.ToInt16(head,0);
118. //当包头的长度大于0 那么须要依次把同样长度的byte数组拷贝出来
119. if(length > 0)
120. {
121. byte[] data = new byte[length];
122. //拷贝出这个包的所有字节数
123. Array.Copy(bytes,headLengthIndex,data,0,length);
124. //把数据包中的字节数组强制转换成数据包的结构体
125. //BytesToStruct()方法就是用来转换的
126. //这里须要和你们的服务端程序商议。
127. JFPackage.WorldPackage wp = new JFPackage.WorldPackage();
128. wp = (JFPackage.WorldPackage)BytesToStruct(data,wp.GetType());
129. //把每一个包的结构体对象加入至链表中。
130. worldpackage.Add(wp);
131. //将索引指向下一个包的包头
132. index  =  headLengthIndex + length;
133. }else
134. {
135. //假设包头为0表示没有包了。那么跳出循环
136. break;
137. }
138. }
139. }
140. //向服务端发送一条字符串
141. //一般不会发送字符串 应该是发送数据包
142. public void SendMessage(string str)
143. {
144. byte[] msg = Encoding.UTF8.GetBytes(str);
145. if(!clientSocket.Connected)
146. {
147. clientSocket.Close();
148. return;
149. }
150. try
151. {
152. //int i = clientSocket.Send(msg);
153. IAsyncResult asyncSend = clientSocket.BeginSend (msg,0,msg.Length,SocketFlags.None,new AsyncCallback (sendCallback),clientSocket);
154. bool success = asyncSend.AsyncWaitHandle.WaitOne( 5000, true );
155. if ( !success )
156. {
157. clientSocket.Close();
158. Debug.Log("Failed to SendMessage server.");
159. }
160. }
161. catch
162. {
163. Debug.Log("send message error" );
164. }
165. }
166. //向服务端发送数据包，也就是一个结构体对象
167. public void SendMessage(object obj)
168. {
169. if(!clientSocket.Connected)
170. {
171. clientSocket.Close();
172. return;
173. }
174. try
175. {
176. //先得到数据包的长度
177. short size = (short)Marshal.SizeOf(obj);
178. //把数据包的长度写入byte数组中
179. byte [] head = BitConverter.GetBytes(size);
180. //把结构体对象转换成数据包，也就是字节数组
181. byte[] data = StructToBytes(obj);
182. //此时就有了两个字节数组。一个是标记数据包的长度字节数组， 一个是数据包字节数组，
183. //同一时候把这两个字节数组合并成一个字节数组
184. byte[] newByte = new byte[head.Length + data.Length];
185. Array.Copy(head,0,newByte,0,head.Length);
186. Array.Copy(data,0,newByte,head.Length, data.Length);
187. //计算出新的字节数组的长度
188. int length = Marshal.SizeOf(size) + Marshal.SizeOf(obj);
189. //向服务端异步发送这个字节数组
190. IAsyncResult asyncSend = clientSocket.BeginSend (newByte,0,length,SocketFlags.None,new AsyncCallback (sendCallback),clientSocket);
191. //监測超时
192. bool success = asyncSend.AsyncWaitHandle.WaitOne( 5000, true );
193. if ( !success )
194. {
195. clientSocket.Close();
196. Debug.Log("Time Out !");
197. }
198. }
199. catch (Exception e)
200. {
201. Debug.Log("send message error: " + e );
202. }
203. }
204. //结构体转字节数组
205. public byte[] StructToBytes(object structObj)
206. {
207. int size = Marshal.SizeOf(structObj);
208. IntPtr buffer =  Marshal.AllocHGlobal(size);
209. try
210. {
211. Marshal.StructureToPtr(structObj,buffer,false);
212. byte[]  bytes  =   new byte[size];
213. Marshal.Copy(buffer, bytes,0,size);
214. return   bytes;
215. }
216. finally
217. {
218. Marshal.FreeHGlobal(buffer);
219. }
220. }
221. //字节数组转结构体
222. public object BytesToStruct(byte[] bytes,   Type   strcutType)
223. {
224. int size = Marshal.SizeOf(strcutType);
225. IntPtr buffer = Marshal.AllocHGlobal(size);
226. try
227. {
228. Marshal.Copy(bytes,0,buffer,size);
229. return  Marshal.PtrToStructure(buffer,   strcutType);
230. }
231. finally
232. {
233. Marshal.FreeHGlobal(buffer);
234. }
235. }
236. private void sendCallback (IAsyncResult asyncSend)
237. {
238. }
239. //关闭Socket
240. public void Closed()
241. {
242. if(clientSocket != null && clientSocket.Connected)
243. {
244. clientSocket.Shutdown(SocketShutdown.Both);
245. clientSocket.Close();
246. }
247. clientSocket = null;
248. }
249. }

为了与服务端达成默契，推断数据包是否完毕。我们须要在数据包中定义包头 。包头通常是这个数据包的长度，也就是结构体对象的长度。正如代码中我们把两个数据类型 short 和 object 合并成一个新的字节数组。

然后是数据包结构体的定义。须要注意假设你在做IOS和Android的话数据包中不要包括数组，不然在结构体转换byte数组的时候会出错。

Marshal.StructureToPtr () error : Attempting to JIT compile method

JFPackage.cs

1. using UnityEngine;
2. using System.Collections;
3. using System.Runtime.InteropServices;
4. public class JFPackage
5. {
6. //结构体序列化
7. [System.Serializable]
8. //4字节对齐 iphone 和 android上能够1字节对齐
9. [StructLayout(LayoutKind.Sequential, Pack = 4)]
10. public struct WorldPackage
11. {
12. public byte mEquipID;
13. public byte mAnimationID;
14. public byte mHP;
15. public short mPosx;
16. public short mPosy;
17. public short mPosz;
18. public short mRosx;
19. public short mRosy;
20. public short mRosz;
21. public WorldPackage(short posx,short posy,short posz, short rosx, short rosy, short rosz,byte equipID,byte animationID,byte hp)
22. {
23. mPosx = posx;
24. mPosy = posy;
25. mPosz = posz;
26. mRosx = rosx;
27. mRosy = rosy;
28. mRosz = rosz;
29. mEquipID = equipID;
30. mAnimationID = animationID;
31. mHP = hp;
32. }
33. };
34. }

在脚本中运行发送数据包的动作，在Start方法中得到Socket对象。

1. public JFSocket mJFsorket;
2. void Start ()
3. {
4. mJFsorket = JFSocket.GetInstance();
5. }

让角色发生移动的时候。调用该方法向服务端发送数据。

1. void SendPlayerWorldMessage()
2. {
3. //组成新的结构体对象，包含主角坐标旋转等。
4. Vector3 PlayerTransform = transform.localPosition;
5. Vector3 PlayerRotation = transform.localRotation.eulerAngles;
6. //用short的话是2字节。为了节省包的长度。这里乘以100 避免使用float 4字节。

   当server接受到的时候小数点向前移动两位就是真实的float数据

7. short px =  (short)(PlayerTransform.x*100);
8. short py =  (short)(PlayerTransform.y*100);
9. short pz =  (short)(PlayerTransform.z*100);
10. short rx =  (short)(PlayerRotation.x*100);
11. short ry =  (short)(PlayerRotation.y*100);
12. short rz =  (short)(PlayerRotation.z*100);
13. byte equipID = 1;
14. byte animationID =9;
15. byte hp = 2;
16. JFPackage.WorldPackage wordPackage = new JFPackage.WorldPackage(px,py,pz,rx,ry,rz,equipID,animationID,hp);
17. //通过Socket发送结构体对象
18. mJFsorket.SendMessage(wordPackage);
19. }

接着就是client同步server的数据，眼下是測试阶段所以写的比較简陋，只是原理都是一样的。

哇咔咔！！

1. //上次同步时间
2. private float mSynchronous;
3. void Update ()
4. {
5. mSynchronous +=Time.deltaTime;
6. //在Update中每0.5s的时候同步一次
7. if(mSynchronous > 0.5f)
8. {
9. int count = mJFsorket.worldpackage.Count;
10. //当接受到的数据包长度大于0 開始同步
11. if(count > 0)
12. {
13. //遍历数据包中 每一个点的坐标
14. foreach(JFPackage.WorldPackage wp in mJFsorket.worldpackage)
15. {
16. float x = (float)(wp.mPosx / 100.0f);
17. float y = (float)(wp.mPosy /100.0f);
18. float z = (float)(wp.mPosz /100.0f);
19. Debug.Log("x = " + x + " y = " + y+" z = " + z);
20. //同步主角的新坐标
21. mPlayer.transform.position = new Vector3 (x,y,z);
22. }
23. //清空数据包链表
24. mJFsorket.worldpackage.Clear();
25. }
26. mSynchronous = 0;
27. }
28. }

主角移动的同一时候。通过Socket时时同步坐标喔。。

有没有感觉这个牛头人很帅气 哈哈哈。

对于Socket的使用，我相信没有比MSDN更加具体的了。

有关Socket 同步请求异步请求的地方能够參照MSDN  链接地址给出来了，好好学习吧，嘿嘿。 msdn.microsoft.com/zh-cn/library/system.net.sockets.socket.aspx

上述代码中我使用的是Thread() 没有使用协同任务StartCoroutine() 。原因是协同任务必须要继承MonoBehaviour，而且该脚本要绑定在游戏对象身上。问题绑定在游戏对象身上切换场景的时候这个脚本必定会释放，那么Socket肯定会断开连接。所以我须要用Thread，而且协同任务它并非严格意义上的多线程。

2.HTTP

HTTP请求在Unity我相信用的会更少一些，由于HTTP会比SOCKET慢非常多，由于它每次请求完都会断开。废话不说了， 我用HTTP请求制作用户的登录。

用HTTP请求直接使用Unity自带的www类就能够，由于HTTP请求仅仅有登录才会有， 所以我就在脚本中来完毕， 使用 www 类 和 协同任务StartCoroutine()。

1. using UnityEngine;
2. using System.Collections;
3. using System.Collections.Generic;
4. public class LoginGlobe : MonoBehaviour {
5. void Start ()
6. {
7. //GET请求
8. StartCoroutine(GET("http://xuanyusong.com/"));
9. }
10. void Update ()
11. {
12. }
13. void OnGUI()
14. {
15. }
16. //登录
17. public void LoginPressed()
18. {
19. //登录请求 POST 把參数写在字典用 通过www类来请求
20. Dictionary<string,string> dic = new Dictionary<string, string> ();
21. //參数
22. dic.Add("action","0");
23. dic.Add("usrname","xys");
24. dic.Add("psw","123456");
25. StartCoroutine(POST("http://192.168.1.12/login.php",dic));
26. }
27. //注冊
28. public void SingInPressed()
29. {
30. //注冊请求 POST
31. Dictionary<string,string> dic = new Dictionary<string, string> ();
32. dic.Add("action","1");
33. dic.Add("usrname","xys");
34. dic.Add("psw","123456");
35. StartCoroutine(POST("http://192.168.1.12/login.php",dic));
36. }
37. //POST请求
38. IEnumerator POST(string url, Dictionary<string,string> post)
39. {
40. WWWForm form = new WWWForm();
41. foreach(KeyValuePair<string,string> post_arg in post)
42. {
43. form.AddField(post_arg.Key, post_arg.Value);
44. }
45. WWW www = new WWW(url, form);
46. yield return www;
47. if (www.error != null)
48. {
49. //POST请求失败
50. Debug.Log("error is :"+ www.error);
51. } else
52. {
53. //POST请求成功
54. Debug.Log("request ok : " + www.text);
55. }
56. }
57. //GET请求
58. IEnumerator GET(string url)
59. {
60. WWW www = new WWW (url);
61. yield return www;
62. if (www.error != null)
63. {
64. //GET请求失败
65. Debug.Log("error is :"+ www.error);
66. } else
67. {
68. //GET请求成功
69. Debug.Log("request ok : " + www.text);
70. }
71. }
72. }

假设想通过HTTP传递二进制流的话 能够使用 以下的方法。

1. WWWForm wwwForm = new WWWForm();
2. byte[] byteStream = System.Text.Encoding.Default.GetBytes(stream);
3. wwwForm.AddBinaryData("post", byteStream);
4. www = new WWW(Address, wwwForm);

眼下Socket数据包还是没有进行加密算法。后期我会补上。

欢迎讨论。互相学习互相进度 加油，蛤蛤。

下载地址我不贴了。由于没有服务端的东西 执行也看不到效果。

希望大家学习愉快， 我们下次再见！