SocketHelper類

主要的通訊類，socket的管理放在這裡

下面說一下一些主要的方法

1.連線伺服器，這個都寫了比較詳細的註釋，一看就會明白

    /// <summary>
    /// 連線伺服器
    /// </summary>
    /// <returns>The connect.</returns>
    /// <param name="serverIp">Server ip.</param>
    /// <param name="serverPort">Server port.</param>
    /// <param name="connectCallback">Connect callback.</param>
    /// <param name="connectFailedCallback">Connect failed callback.</param>
    public void Connect(string serverIp,int serverPort,ConnectCallback connectCallback,ConnectCallback connectFailedCallback){
		connectDelegate = connectCallback;
		connectFailedDelegate = connectFailedCallback;

		//採用TCP方式連線  
		socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);  

		//伺服器IP地址  
        IPAddress address = IPAddress.Parse(serverIp);  

		//伺服器埠  
        IPEndPoint endpoint = new IPEndPoint(address,serverPort);  

		//非同步連線,連線成功呼叫connectCallback方法  
		IAsyncResult result = socket.BeginConnect(endpoint, new AsyncCallback(ConnectedCallback), socket);  

		//這裡做一個超時的監測，當連線超過5秒還沒成功表示超時  
		bool success = result.AsyncWaitHandle.WaitOne(5000, true);  
		if (!success)  
		{  
			//超時  
			Closed();  
			if(connectFailedDelegate != null){
				connectFailedDelegate();
			}
		}  
		else  
		{  
			//與socket建立連線成功，開啟執行緒接受服務端資料。  
			isStopReceive = false;
			Thread thread = new Thread(new ThreadStart(ReceiveSorket));  
			thread.IsBackground = true;  
			thread.Start();  
		}  

	}
 

首先從傳送佇列中取出要傳送的資料，然後對資料進行序列化，轉為2進位制資料，然後在資料最前端加上資料的長度，以便於伺服器進行粘包的處理。

	private void Send(){
		if(socket == null){
			return;
		}
		if (!socket.Connected)  
		{  
			Closed();
			return;  
		}  
		try  
		{  
			Request req = sendDataQueue.Dequeue();

			DataStream bufferWriter = new DataStream(true);
			req.Serialize(bufferWriter);
			byte[] msg = bufferWriter.ToByteArray();

			byte[] buffer = new byte[msg.Length + 4];
			DataStream writer = new DataStream(buffer, true);

			writer.WriteInt32((uint)msg.Length);//增加資料長度
			writer.WriteRaw(msg);

			byte[] data = writer.ToByteArray();

			IAsyncResult asyncSend = socket.BeginSend(data, 0, data.Length, SocketFlags.None, new AsyncCallback(SendCallback), socket);  
			bool success = asyncSend.AsyncWaitHandle.WaitOne(5000, true);  
			if (!success)  
			{  
				Closed(); 
			}  
		}  
		catch  (Exception e)
		{  
            Debug.Log("send error : " + e.ToString());
		} 
	}
 

3.接收資料

接收資料是一個獨立的執行緒，連線伺服器成功後開啟的。如果接收到資料，會把資料放進DataHolder進行處理，然後根據DataHolder判斷是否接收到完整資料，以解決粘包等問題。

這裡由於接收到資料時並沒有在主執行緒中，所以我們先把資料放入接收佇列，在主執行緒的update方法中，對資料進行解析以及分發工作。

private void ReceiveSorket(){
		mDataHolder.Reset();
		while(!isStopReceive){
			if (!socket.Connected)  
			{  
				//與伺服器斷開連線跳出迴圈  
                Debug.Log("Failed to clientSocket server.");  
				socket.Close();  
				break;  
			}  

			try  
			{  
				//接受資料儲存至bytes當中  
				byte[] bytes = new byte[4096];  
				//Receive方法中會一直等待服務端回發訊息  
				//如果沒有回發會一直在這裡等著。  

				int i = socket.Receive(bytes); 

				if (i <= 0)  
				{  
					socket.Close();  
					break;  
				}  
				mDataHolder.PushData(bytes, i);

				while(mDataHolder.IsFinished()){
					dataQueue.Enqueue(mDataHolder.mRecvData);

					mDataHolder.RemoveFromHead();
				}
			}  
			catch (Exception e)  
			{  
                Debug.Log("Failed to clientSocket error." + e);  
				socket.Close();  
				break;  
			}  
		}
	}
 

//接收到資料放入資料佇列，按順序取出
	void Update(){
		if(dataQueue.Count > 0){
			Resp resp = ProtoManager.Instance.TryDeserialize(dataQueue.Dequeue());
		}

		if(sendDataQueue.Count > 0){
			Send();
		}
	}

DataHolder

此類用來管理接收到的資料，並處理粘包和丟包的情況，主要就是根據資料長度對資料進行裁切。

通過此方法儲存收到的伺服器資料，放入資料快取中

    public void PushData(byte[] data, int length)
    {
        if (mRecvDataCache == null)
            mRecvDataCache = new byte[length];

        if (this.Count + length > this.Capacity)//current capacity is not enough, enlarge the cache
        {
            byte[] newArr = new byte[this.Count + length];
            mRecvDataCache.CopyTo(newArr, 0);
            mRecvDataCache = newArr;
        }

        Array.Copy(data, 0, mRecvDataCache, mTail + 1, length);
        mTail += length;
    }

此方法判斷接收到的資料是否完整，這裡需要伺服器在資料頭4位裝入資料長度，如果接收到完整資料，則將資料複製出一份供外部獲取。

public bool IsFinished()
    {
        if (this.Count == 0)
        {
            //skip if no data is currently in the cache
            return false;
        }

        if (this.Count >= 4)
        {
            DataStream reader = new DataStream(mRecvDataCache, true);
            packLen = (int)reader.ReadInt32();
            if (packLen > 0)
            {
                if (this.Count - 4 >= packLen)
                {
                    mRecvData = new byte[packLen];
                    Array.Copy(mRecvDataCache, 4, mRecvData, 0, packLen);
                    return true;
                }

                return false;
            }
            return false;
        }

        return false;
    }

    public void RemoveFromHead()
    {
        int countToRemove = packLen + 4;
        if (countToRemove > 0 && this.Count - countToRemove > 0)
        {
            Array.Copy(mRecvDataCache, countToRemove, mRecvDataCache, 0, this.Count - countToRemove);
        }
        mTail -= countToRemove;
    }

ProtoManager

用來管理所有協議，進行訊息的解析以及分發。

所有Resp需要在這裡註冊，以便接收到資料時進行解析

	public void AddProtocol<T>(int protocol) where T: Resp, new()
	{
		if (mProtocolMapping.ContainsKey(protocol))
		{
			mProtocolMapping.Remove(protocol);
		}

		mProtocolMapping.Add(protocol, 
			(stream) => {
				T data = new T();
				data.Deserialize(stream);
				return data;
			});
	}

/// <summary>
	/// 新增代理，在接受到伺服器資料時會下發資料
	/// </summary>
	/// <param name="protocol">Protocol.</param>
	/// <param name="d">D.</param>
	public void AddRespDelegate(int protocol,responseDelegate d){
		List<responseDelegate>  dels ;
		if (mDelegateMapping.ContainsKey(protocol))
		{
			dels = mDelegateMapping[protocol];
			for(int i = 0 ; i < dels.Count ; i ++){
				if(dels[i] == d){
					return;
				}
			}
		}else{
			dels = new List<responseDelegate>();
			mDelegateMapping.Add(protocol,dels);
		}
		dels.Add(d);

	}

	public Resp TryDeserialize(byte[] buffer)
	{
		DataStream stream = new DataStream(buffer, true);

		int protocol = stream.ReadSInt32();
		Resp ret = null;
		if (mProtocolMapping.ContainsKey(protocol))
		{
			ret = mProtocolMapping[protocol](stream);
			if(ret != null){
				if(mDelegateMapping.ContainsKey(protocol)){
					List<responseDelegate> dels = mDelegateMapping[protocol];
					for(int i = 0 ; i < dels.Count ; i ++){
						dels[i](ret);
					}
				}
			}
		}else{
            Debug.Log("no register protocol : " + protocol +"!please reg to RegisterResp.");
		}

		return ret;
	}

DataStream

此類進行傳送以及接收的資料流的處理，包含了資料大小端的設定以及資料流的讀取和寫入方法。

Request

基礎的請求訊息，所有要傳送的請求訊息繼承此類

子類必須實現協議獲取的方法，返回此請求所對應的協議

public virtual int GetProtocol(){
        Debug.LogError("can't get Protocol");
		return 0;
	}

	public virtual void Serialize(DataStream writer)
	{
		writer.WriteSInt32(GetProtocol());
		writer.WriteByte(0);
	}

Resp

基礎的返回訊息，所有伺服器返回的訊息繼承此類

子類必須實現協議獲取的方法，返回此請求所對應的協議

	public virtual int GetProtocol(){
        	Debug.LogError("can't get Protocol");
		return 0;
	}

反序列化方法

	public virtual void Deserialize(DataStream reader)
	{
	}

之後我會更新一片實際應用的文章，以及伺服器端的相關內容。