《Unity網(wǎng)絡(luò)游戲?qū)崙?zhàn)》Chapter4: 收發(fā)數(shù)據(jù)流（1）

1、介紹

前面的章節(jié)中制作的小游戲中并沒有處理TCP數(shù)據(jù)流的粘包拆包的問題伟件。這一節(jié)對其進行處理。程序采用簡單的Echo程序议经。解決粘包問題采用的方法為長度法斧账。

2谴返、客戶端

采用異步socket進行數(shù)據(jù)的收發(fā)。接收數(shù)據(jù)的處理思路為：1咧织、判斷接收緩沖區(qū)的數(shù)據(jù)長度是否超過設(shè)定的數(shù)據(jù)長度包頭headerSize嗓袱，如果超過則讀取包頭長度，解析出數(shù)據(jù)包的長度习绢；然后判斷當前緩沖區(qū)的字節(jié)數(shù)是否大于等于一個數(shù)據(jù)包渠抹，若是則處理，否則繼續(xù)接收闪萄。

直接上代碼：

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

public class Echo : MonoBehaviour
{
    Socket socket;

    int bufferSize = 1024;

    byte[] recvBuff;

    int bufferCount = 0;

    int headerSize = 4;

    bool startSendMsg = false;

    private void Start()
    {
        recvBuff = new byte[bufferSize];
        socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
        socket.Connect("127.0.0.1", 8888);
        socket.BeginReceive(recvBuff, bufferCount, bufferSize - bufferCount, SocketFlags.None,
            ReceiveCallBack, socket);
    }

    void ReceiveCallBack(IAsyncResult ar)
    {
        try
        {
            Socket socket = (Socket)ar.AsyncState;

            int count = socket.EndReceive(ar);

            bufferCount += count;

            HandleReceiveData();

            socket.BeginReceive(recvBuff, bufferCount, bufferSize - bufferCount, SocketFlags.None,
                ReceiveCallBack, socket);
        }
        catch (SocketException ex)
        {
            Debug.Log("socket receive failed" + ex.ToString());
        }
    }

    void HandleReceiveData()
    {
        Debug.Log("接收緩沖區(qū)字節(jié)數(shù) =" + bufferCount);

        // 檢查數(shù)據(jù)長度是否超過包頭
        if (bufferCount < headerSize)
            return;

        // 讀取包頭長度 -- 從緩沖區(qū)的開頭讀取4字節(jié)
        int bodyLength = BitConverter.ToInt32(recvBuff, 0);

        // 檢查是否足夠一條信息
        if (bufferCount < headerSize + bodyLength)
            return;

        // 處理一條消息
        string data = System.Text.Encoding.UTF8.GetString(recvBuff, headerSize, bodyLength);
        Debug.Log("receive data = " + data);

        // 更新緩沖區(qū)信息
        int start = headerSize + bodyLength;
        // 移動的字節(jié)數(shù)
        int count = bufferCount - start;
        // 緩沖區(qū)前移 -- Copy函數(shù)對應(yīng)C/C++中的memmove, 不是memcopy 
        // 相當于將緩沖區(qū)的數(shù)據(jù)從start開始的count字節(jié)數(shù)據(jù)往前推到0
        Array.Copy(recvBuff, start, recvBuff, 0, count);
        bufferCount -= start;

        // 繼續(xù)處理消息
        HandleReceiveData();
    }

    public void Send()
    {
        // 發(fā)送數(shù)據(jù)
        string sendStr= "hello Python";

        // 組裝消息
        byte[] bodyBytes = System.Text.Encoding.Default.GetBytes(sendStr);
        short length = (short)bodyBytes.Length;
        byte[] lenBytes = BitConverter.GetBytes(length);
        byte[] sendBytes = lenBytes.Concat(bodyBytes).ToArray();

        // 異步Send
        socket.BeginSend(sendBytes, 0, sendBytes.Length, SocketFlags.None, SendCallBack, socket);

        string sendata = BitConverter.ToString(sendBytes);

        Debug.Log("Send body length: " + length);
        Debug.Log("Send data: " + sendata);
    }

    public void SendCallBack(IAsyncResult ar)
    {
        Socket socket = (Socket)ar.AsyncState;

        int count = socket.EndSend(ar);

        // startSendMsg = false;

        // 后續(xù)處理
    }

    public void OnButtonStartClick()
    {
        startSendMsg = true;
    }

    private void Update()
    {
        if (!startSendMsg)
            return;

        Send();
    }

}

在原書上的包頭設(shè)定的字節(jié)數(shù)為2字節(jié)梧却，但是因為我使用的服務(wù)器是用python編寫，在python中使用struct打包字節(jié)流的時候败去，int數(shù)據(jù)占4字節(jié)篮幢，并且好像沒有int16這樣的數(shù)據(jù)類型，所以這里的headerSize設(shè)定為4字節(jié)为迈。

3、服務(wù)端

服務(wù)端直接上代碼缺菌，即插即用：

# Handle The TCP problem
import socket
import time
import struct

def parse_msg_length(head):
    # 解析頭兩個字節(jié)的包頭大小葫辐，得到數(shù)據(jù)包的長度。
    # 因為recv直接返回的是字符串伴郁，所以需要用ord將其轉(zhuǎn)換為數(shù)值類型
    # 因為是2個字節(jié)耿战，一個字節(jié)是2**8=256，相當于256進制
    length = 0
    for i in range(len(head)):
        length += ord(head[i]) * 256 ** i
    return length

def handle_message(read_buffer):
    # 判斷緩沖區(qū)大小是否大于包頭大小
    buffer_count = len(read_buffer)
    if buffer_count < head_size:
        return False, 0
    # 判斷緩沖區(qū)中是否存夠了一條完整的數(shù)據(jù)
    msg_body_size = parse_msg_length(read_buffer[0:head_size])
    if buffer_count < head_size + msg_body_size:
        return False, 0
    # 處理數(shù)據(jù)
    data = read_buffer[head_size:msg_body_size+head_size]
    print 'data:', data
    # 返回焊傅，將已經(jīng)處理的數(shù)據(jù)丟棄
    return True, msg_body_size

# server socket
ip = "127.0.0.1"
port = 8888
server_address = (ip, port)
buffer_size = 1024
head_size = 2
server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server.bind(server_address)
server.listen(1)
read_buffer = ""

print "Waiting for Connection."
while True:
    connection, client_address = server.accept()
    print "client connected: ", client_address
    while True:
        try:
            # 將發(fā)送的數(shù)據(jù)用struct類型打包成字節(jié)流
            msg_body = "Hello Unity"
            pack_format = 'I' + str(len(msg_body)) + 's'
            send_data = (len(msg_body), msg_body)
            send_bytes = struct.pack(pack_format, *send_data)
            connection.send(send_bytes)
            # time.sleep(1)
            # 接收數(shù)據(jù)剂陡，recv返回的是字符串，直接加在read_buffer后狐胎，字符串作為緩沖區(qū)
            # 字符串作為緩沖區(qū)的好處就是不需要數(shù)據(jù)包的大小超過了緩沖區(qū)的大小而導(dǎo)致要擴容
            receive_data = connection.recv(buffer_size)
            if receive_data:
                read_buffer += receive_data
                result, length = handle_message(read_buffer)
                if result:
                    read_buffer = read_buffer[head_size + length:]
                else:
                    pass
                print 'read_buffer: ', read_buffer
            else:
                connection.close()
                break
        except socket.error:
            connection.close()

4鸭栖、結(jié)語

后續(xù)還要處理的問題有：大小端兼容、send發(fā)包不完整以及線程沖突的問題握巢。
好好學習天天向上晕鹊！