HTTP協議即超文字傳送協議(Hypertext Transfer Protocol )，是Web聯網的基礎，HTTP協議是建立在TCP協議之上的一種應用。由於HTTP在每次請求結束後都會主動釋放連線，因此HTTP連線是一種短連線。HTTP遵循請求（Request）/應答（Response）模型。所以一定需要實現請求(Gk8HttpRequest)。同時需要實現返回(Gk8HttpResponse)。在遊戲研發程式設計中HTTP請求型別常用的就是GET和POST。框架設計中就需要實現完成HTTP請求和返回的Gk8HttpClient類。HTTP不管是文字傳輸還是二進位制傳輸Gk8HttpClient類都能相容完成響應的功能。HTTP文字傳輸方便簡潔。實現輕量級通訊的最佳方式。

libCurl作為是一個多協議的便於客戶端使用的URL傳輸庫，基於C語言，提供C語言的API介面。底層通訊都是使用libCurl庫來完成。具體可找相關資料和參閱相關程式碼。C語言封裝開發的優勢就是支援跨平臺。Windows平臺，安卓平臺，IOS平臺。跨平臺遷移程式碼無需再次開發。一勞永逸的解決通訊問題。為了方便開發時HTTP併發和回撥。又實現了Gk8HttpServlet類(httpnet目錄中)。高度封裝的程式碼目的就是易於理解便於使用。

C++實現網路HTTP請求類：Gk8HttpRequest.h

```c++
#ifndef __GK8HTTPREQUEST_H__
#define __GK8HTTPREQUEST_H__

#pragma once
#include "Gk8BaseObj.h"
#include "Gk8ByteMaker.h"
#include "Gk8Str.h"

typedef GK8_VOID (Gk8BaseObj::*HTTPREQUEST_CALLBACK_FUN)(GK8_LPVOID pHttpResponse);

class Gk8HttpRequest
{
public:
	//[定義HTTP請求型別]
	typedef enum
	{
		kHttpGet,
		kHttpPost,
		kHttpUnkown,
	}HttpRequestType;

protected:
	HttpRequestType m_eRequestType;			//[HTTP請求型別]
	Gk8Str m_sHttpUrl;						//[HTTP請求地址]
	Gk8ByteMaker m_iRequestData;			//[HTTP請求資料]
	Gk8BaseObj* m_pTarget;					//[HTTP請求回撥目標物件]
	HTTPREQUEST_CALLBACK_FUN m_pSelector;	//[HTTP請求回撥函式]
public:
	Gk8HttpRequest()
	{
		m_eRequestType=kHttpUnkown;
		m_sHttpUrl.Empty();
		m_iRequestData.Destroy();
		m_pTarget=NULL;
		m_pSelector=NULL;
	};

virtual ~Gk8HttpRequest()
	{
		ClearRequestData();
	};
	inline GK8_VOID ClearRequestData()
	{
		m_iRequestData.Destroy();
	}
	inline GK8_VOID SetRequestType(HttpRequestType eRequestType)
	{
		m_eRequestType=eRequestType;
	};

inline HttpRequestType GetRequestType()
	{
		return m_eRequestType;
	};

inline GK8_VOID SetHttpUrl(GK8_LPCSTR lpHttpUrl)
	{
		m_sHttpUrl=lpHttpUrl;
	};

inline GK8_LPCSTR GetHttpUrl()
	{
		return m_sHttpUrl;
	};

inline GK8_VOID SetRequestData(Gk8ByteMaker* pRequestData)
	{
		pRequestData->ShiftTo(m_iRequestData);
	};

inline Gk8ByteMaker* GetRequestData()
	{
		return &m_iRequestData;
	}

inline GK8_INT GetRequestDataSize()
	{
		return m_iRequestData.GetStreamSize();
	}

inline GK8_VOID SetResponseCallBack(Gk8BaseObj* pTarget,HTTPREQUEST_CALLBACK_FUN pSelector)
	{
		m_pTarget=pTarget;
		m_pSelector=pSelector;
	}

inline Gk8BaseObj* GetTarget()
	{
		return m_pTarget;
	}

inline HTTPREQUEST_CALLBACK_FUN GetSelector()
	{
		return m_pSelector;
	}
};
#endif
```

C++實現網路HTTP返回類：Gk8HttpResponse.h

```c++
#ifndef __GK8HTTPRESPONSE_H__
#define __GK8HTTPRESPONSE_H__

#pragma once
#include "Gk8HttpRequest.h"

class Gk8HttpResponse
{
protected:
	Gk8HttpRequest* m_pHttpRequest;			//[HTTP請求類]
	GK8_BOOL m_bSucceed;					//[HTTP請求反饋成功]
	Gk8ByteMaker m_iResponseData;			//[HTTP請求反饋資料]
	GK8_INT m_nResponseCode;				//[HTTP請求反饋碼]
	Gk8Str m_sErrorBuffer;					//[HTTP請求錯誤資訊]
protected:
	GK8_BOOL InitWithRequest(Gk8HttpRequest* pHttpRequest);

public:

Gk8HttpResponse(Gk8HttpRequest* pHttpRequest)
	{
		m_pHttpRequest=pHttpRequest;
		m_bSucceed=false;
		m_iResponseData.Destroy();
		m_sErrorBuffer.Empty();
	}

virtual ~Gk8HttpResponse()
	{
		if(m_pHttpRequest) delete m_pHttpRequest;
		ClearResponseData();
	}
	inline GK8_VOID ClearResponseData()
	{
		m_iResponseData.Destroy();
	}

inline Gk8HttpRequest* GetHttpRequest()
	{
		return m_pHttpRequest;
	}

inline GK8_VOID SetSucceed(GK8_BOOL bSucceed)
	{
		m_bSucceed=bSucceed;
	};

inline GK8_BOOL IsSucceed()
	{
		return m_bSucceed;
	};

inline GK8_VOID SetResponseData(Gk8ByteMaker* pResponseData)
	{
		pResponseData->ShiftTo(m_iResponseData);
	}

inline Gk8ByteMaker* GetResponseData()
	{
		return &m_iResponseData;
	}

inline GK8_VOID SetResponseCode(GK8_INT nResponseCode)
	{
		m_nResponseCode=nResponseCode;
	}

inline GK8_INT GetResponseCode()
	{
		return m_nResponseCode;
	}

inline GK8_VOID SetErrorBuffer(GK8_LPCSTR lpErrorBuffer)
	{
		m_sErrorBuffer=lpErrorBuffer;
	};

inline GK8_LPCSTR GetErrorBuffer()
	{
		return m_sErrorBuffer;
	}
};

#endif
```

C++實現HTTP通訊類：Gk8HttpClient.h

```c++
#ifndef __GK8HTTPCLIENT_H__
#define __GK8HTTPCLIENT_H__

#pragma once
#include "Gk8HttpRequest.h"
#include "Gk8HttpResponse.h"

class Gk8HttpClient
{
private:
	GK8_INT m_nTimeOutForConnect;		//[連線超時時間]
	GK8_INT m_nTimeOutForRead;			//[讀取超時時間]

private:
	Gk8HttpClient();
	virtual ~Gk8HttpClient();

GK8_BOOL InitThreadSemphore();
public:

inline GK8_VOID SetTimeoutForConnect(GK8_INT nTimeOutForConnect){m_nTimeOutForConnect=nTimeOutForConnect;};
	inline GK8_INT GetTimeoutForConnect(){return m_nTimeOutForConnect;}

inline GK8_VOID SetTimeoutForRead(GK8_INT nTimeOutForRead){m_nTimeOutForRead=nTimeOutForRead;};
	inline GK8_INT GetTimeoutForRead(){return m_nTimeOutForRead;};

GK8_VOID Send(Gk8HttpRequest* pHttpRequest);

GK8_VOID HttpClientTick();
	static Gk8HttpClient* GetInstance();
};
#endif
```

C++實現HTTP通訊類：Gk8HttpClient.cpp

```c++
#include "Gk8HttpClient.h"
#include "curl/curl.h"
#include "Gk8OperSys.h"
#include "Gk8SetMb.cpp"

#include <queue>
#include <pthread.h>
#include <semaphore.h>
#include <errno.h>
#include <fcntl.h>

static Gk8HttpClient* sg_pHttpClient=NULL;		//[靜態HTTP客戶端]

static GK8_BOOL sg_bHttpClientQuit=false;		//[退出HTTP]
static sem_t* sg_pSem=NULL;						//[訊號量的資料型別]
static GK8_INT sg_AsyncRequestCount=0;			//[同步請求數]

//[執行緒及互斥定義]
static pthread_t sg_NetWorkThread;				//[HTTP執行緒]
static pthread_mutex_t sg_RequestQueueMutex;	//[HTTP請求佇列互斥體]
static pthread_mutex_t sg_ResponseQueueMutex;	//[HTTP響應佇列互斥體]

static Gk8SetMb<gk8httprequest> sg_iRequestQueue;		//[HTTP請求佇列]
static Gk8SetMb<gk8httpresponse> sg_iResponseQueue;	//[HTTP響應佇列]

static GK8_CHAR sg_szErrorBuf[CURL_ERROR_SIZE];			//[錯誤資訊]
static Gk8Str sg_iErrorStr;

typedef size_t (*HTTPWRITE_CALLBACK)(GK8_LPVOID lpData,size_t nSize,size_t nMemBlock,GK8_LPVOID lpResponseData);

#if (GK8_TARGET_PLATFORM==GK8_PLATFORM_IOS)
#define GK8_ASYNC_HTTPREQUEST_USE_NAMED_SEMAPHORE 1
#else
#define GK8_ASYNC_HTTPREQUEST_USE_NAMED_SEMAPHORE 0
#endif

#if GK8_ASYNC_HTTPREQUEST_USE_NAMED_SEMAPHORE
#define GK8_ASYNC_HTTPREQUEST_SEMAPHORE "Gk8HttpAsync"
#else
static sem_t sg_iSem;
#endif

GK8_BOOL ConfigureCURL(CURL* pCurl);
GK8_INT ProcessGetTask(Gk8HttpRequest* pHttpRequest,HTTPWRITE_CALLBACK lpCallBack,GK8_LPVOID lpStream,GK8_LPINT lpResponseCode);
GK8_INT ProcessPostTask(Gk8HttpRequest* pHttpRequest,HTTPWRITE_CALLBACK lpCallBack,GK8_LPVOID lpStream,GK8_LPINT lpResponseCode);

//[接收HTTP資料]
size_t WriteHttpData(GK8_LPVOID lpData,size_t nSize,size_t nMemBlock,GK8_LPVOID lpResponseData)
{
	Gk8ByteMaker* pResponseData=(Gk8ByteMaker*)lpResponseData;
	size_t nLength=nSize*nMemBlock;
	pResponseData->WriteBuf(lpData,(GK8_INT)nLength);
	return nLength;
}

//[設定CURL超時屬性設定]
GK8_BOOL ConfigureCURL(CURL* pCurl)
{
	if(!pCurl) return false;

CURLcode nCurlCode=curl_easy_setopt(pCurl,CURLOPT_ERRORBUFFER,sg_szErrorBuf);
	if(nCurlCode!=CURLE_OK) return false;

nCurlCode=curl_easy_setopt(pCurl,CURLOPT_TIMEOUT,Gk8HttpClient::GetInstance()->GetTimeoutForRead());
	if(nCurlCode!=CURLE_OK) return false;

nCurlCode=curl_easy_setopt(pCurl,CURLOPT_CONNECTTIMEOUT,Gk8HttpClient::GetInstance()->GetTimeoutForConnect());
	if(nCurlCode!=CURLE_OK) return false;
	
	curl_easy_setopt(pCurl,CURLOPT_SSL_VERIFYPEER,0L);
	curl_easy_setopt(pCurl,CURLOPT_SSL_VERIFYHOST,0L);

curl_easy_setopt(pCurl,CURLOPT_NOSIGNAL,1L);
	return true;
}

//[處理Get請求]
GK8_INT ProcessGetTask(Gk8HttpRequest* pHttpRequest,HTTPWRITE_CALLBACK lpCallBack,GK8_LPVOID lpStream,GK8_LPINT lpResponseCode)
{
	CURLcode nCurlCode=CURL_LAST;
	CURL* pCurl=curl_easy_init();
	
	do
	{
		if(!ConfigureCURL(pCurl)) break;

nCurlCode=curl_easy_setopt(pCurl,CURLOPT_URL,pHttpRequest->GetHttpUrl());
		if(nCurlCode!=CURLE_OK) break;
		
		nCurlCode=curl_easy_setopt(pCurl,CURLOPT_WRITEFUNCTION,lpCallBack);
		if(nCurlCode!=CURLE_OK) break;

nCurlCode=curl_easy_setopt(pCurl,CURLOPT_WRITEDATA,lpStream);
		if(nCurlCode!=CURLE_OK) break;
		
		nCurlCode=curl_easy_setopt(pCurl,CURLOPT_FOLLOWLOCATION,true);
		if(nCurlCode!=CURLE_OK) break;

nCurlCode=curl_easy_setopt(pCurl,CURLOPT_USERAGENT,"libcurl-agent/1.0");
		if(nCurlCode!=CURLE_OK) break;

nCurlCode=curl_easy_perform(pCurl);
		if(nCurlCode!=CURLE_OK) break;

nCurlCode=curl_easy_getinfo(pCurl,CURLINFO_RESPONSE_CODE,lpResponseCode);
		//[200:指示客服端的請求已經成功收到，解析，接受]
		if(nCurlCode!=CURLE_OK||*lpResponseCode!=200)
		{
			nCurlCode=CURLE_HTTP_RETURNED_ERROR;
		}
	}while(0);
	
	if(pCurl) curl_easy_cleanup(pCurl);

return (nCurlCode==CURLE_OK?0:1);
}

//[處理POST請求:流的行事發出]
GK8_INT ProcessPostTask(Gk8HttpRequest* pHttpRequest,HTTPWRITE_CALLBACK lpCallBack,GK8_LPVOID lpStream,GK8_LPINT lpResponseCode)
{
	CURLcode nCurlCode=CURL_LAST;
	CURL* pCurl=curl_easy_init();

do
	{
		if(!ConfigureCURL(pCurl)) break;

nCurlCode=curl_easy_setopt(pCurl,CURLOPT_URL,pHttpRequest->GetHttpUrl());
		if(nCurlCode!=CURLE_OK) break;

nCurlCode=curl_easy_setopt(pCurl,CURLOPT_WRITEFUNCTION,lpCallBack);
		if(nCurlCode!=CURLE_OK) break;

nCurlCode=curl_easy_setopt(pCurl,CURLOPT_WRITEDATA,lpStream);
		if(nCurlCode!=CURLE_OK) break;

nCurlCode=curl_easy_setopt(pCurl,CURLOPT_POST,1);
		if(nCurlCode!=CURLE_OK) break;

nCurlCode=curl_easy_setopt(pCurl,CURLOPT_POSTFIELDS,pHttpRequest->GetRequestData()->GetBuf());
		if(nCurlCode!=CURLE_OK) break;

nCurlCode=curl_easy_setopt(pCurl,CURLOPT_POSTFIELDSIZE,pHttpRequest->GetRequestDataSize());
		if(nCurlCode!=CURLE_OK) break;

nCurlCode=curl_easy_perform(pCurl);
		if(nCurlCode!=CURLE_OK) break;

nCurlCode=curl_easy_getinfo(pCurl,CURLINFO_RESPONSE_CODE,lpResponseCode);
		
		if(nCurlCode!=CURLE_OK||*lpResponseCode!=200)
		{
			nCurlCode=CURLE_HTTP_RETURNED_ERROR;
		}
	}while(0);
	if(pCurl) curl_easy_cleanup(pCurl);

return (nCurlCode==CURLE_OK?0:1);
}

//[建立網路執行緒]
static GK8_LPVOID NetWorkThread(GK8_LPVOID lpData)
{
	Gk8HttpRequest* pHttpRequest=NULL;
	Gk8HttpResponse* pHttpResponse=NULL;

while(true)
	{
		//Wait for http request tasks from main thread
		GK8_INT nSemWaitRet=sem_wait(sg_pSem);
		if(nSemWaitRet<0)
		{
			_GK8ERR<GetRequestType())
		{
			case Gk8HttpRequest::kHttpGet:
				nRetValue=ProcessGetTask(pHttpRequest,WriteHttpData,pHttpResponse->GetResponseData(),&nResponseCode);
				break;
			case Gk8HttpRequest::kHttpPost:
				nRetValue=ProcessPostTask(pHttpRequest,WriteHttpData,pHttpResponse->GetResponseData(),&nResponseCode);
				break;
			default:
				_GK8ERR<SetResponseCode(nResponseCode);
		//[清除請求中的二進位制資料]
		pHttpRequest->ClearRequestData();

if(nRetValue!=0)
		{
			pHttpResponse->SetSucceed(false);
			sg_iErrorStr=sg_szErrorBuf;
			pHttpResponse->SetErrorBuffer(sg_iErrorStr);
		}else
		{
			pHttpResponse->SetSucceed(true);
		}

pthread_mutex_lock(&sg_ResponseQueueMutex);
		sg_iResponseQueue.AddItem(pHttpResponse);
		pthread_mutex_unlock(&sg_ResponseQueueMutex);
	}

sg_AsyncRequestCount-=sg_iRequestQueue.GetSize();
	pthread_mutex_lock(&sg_RequestQueueMutex);
	sg_iRequestQueue.Clear();
	pthread_mutex_unlock(&sg_RequestQueueMutex);
	
	if(sg_pSem!=NULL)
	{
#if GK8_ASYNC_HTTPREQUEST_USE_NAMED_SEMAPHORE
		sem_unlink(GK8_ASYNC_HTTPREQUEST_SEMAPHORE);
		sem_close(sg_pSem);
#else
		sem_destroy(sg_pSem);
#endif
		sg_pSem=NULL;

pthread_mutex_destroy(&sg_RequestQueueMutex);
		pthread_mutex_destroy(&sg_ResponseQueueMutex);

//[依次刪除資料]
		GK8_INT nIndex;
		for(nIndex=0;nIndex<sg_irequestqueue.getsize phttprequest="sg_iRequestQueue.GetItemAt(nIndex);" delete="" for="" phttpresponse="sg_iResponseQueue.GetItemAt(nIndex);" sg_irequestqueue.destroy="" sg_iresponsequeue.destroy="" pthread_exit="" return="" gk8httpclient::gk8httpclient="" :m_ntimeoutforread="" gk8httpclient::="" sg_bhttpclientquit="true;" if="" sem_post="" gk8_bool="" gk8httpclient::initthreadsemphore="" true="" gk8_async_httprequest_use_named_semaphore="" sg_psem="sem_open(GK8_ASYNC_HTTPREQUEST_SEMAPHORE,O_CREAT,0644,0);" _gk8err="" httprequest="" semaphore="" failed="" false="" gk8_int="" nsemret="sem_init(&sg_iSem,0,0);" pthread_mutex_init="" pthread_create="" pthread_detach="" gk8_void="" gk8httpclient::send="" pthread_mutex_lock="" sg_irequestqueue.additem="" pthread_mutex_unlock="" gk8httpclient="" gk8httpclient::getinstance="" sg_phttpclient="new" gk8httpclient::httpclienttick="" gk8httpresponse="">0)
	{
		pHttpResponse=sg_iResponseQueue.GetItemAt(0);
		sg_iResponseQueue.RemoveItemAt(0);
	}
	pthread_mutex_unlock(&sg_ResponseQueueMutex);
	
	if(pHttpResponse)
	{
		--sg_AsyncRequestCount;
		Gk8HttpRequest* pHttpRequest=pHttpResponse->GetHttpRequest();
		Gk8BaseObj* pTarget=pHttpRequest->GetTarget();
		HTTPREQUEST_CALLBACK_FUN pSelector=pHttpRequest->GetSelector();

//[回撥處理:記錄資料]
		if(pTarget&&pSelector)
		{
			(pTarget->*pSelector)(pHttpResponse);
		}
		//[銷燬請求資料]
		delete pHttpResponse;
	}
}
```

C++實現Servlet類：Gk8HttpServlet.h

```c++
#ifndef __GK8HTTPSERVICE_H__
#define __GK8HTTPSERVICE_H__

#pragma once
#include "curl/curl.h"
#include "Gk8HttpClient.h"
#include "Gk8HttpRequest.h"
#include "Gk8HttpResponse.h"

class Gk8HttpServlet:public Gk8BaseObj
{
	DECLARE_TOSPP_MAP;
private:
	Gk8Str m_sHttpUrl;				//[HTTP請求地址]
	Gk8ByteMaker m_iRequestData;	//[HTTP請求資料]
	Gk8Var m_iHttpCallVar;			//[HTTP回撥資訊]

GK8_VOID ServletRequestCompleted(GK8_LPVOID lpHttpResponse);
public:
	Gk8HttpServlet();
	~Gk8HttpServlet();

GK8_VOID TOSPPFUNC SendHttpMessage(GK8_LPCSTR lpHttpData,Gk8Var& iHttpCallVar);
};
#endif
```

C++實現Servlet類：Gk8HttpServlet.cpp

```c++
#include "Gk8HttpServlet.h"
#include "Gk8OperSys.h"
#include "Gk8Helper.h"

static Gk8Str sg_iReceiveMessageEvent("OnReceiveMessage");//[接收網路資訊]

#define HTTPSERVLET_FAIL		0		//[HTTP請求失敗]
#define HTTPSERVLET_SUCC		1		//[HTTP請求成功]

/////////////////////////////////////////////CLASS-TOLUA////////////////////////////////////////////////////
TOLUA_CLASS_COLLECT_FUNC(Gk8HttpServlet)

BEGIN_TOLUA_CLASS_FUNC(Gk8HttpServlet,NewObj)
	if(!CheckToLuaFunParam(L,"NewObj",Gk8Var()<<isusertable return="" gk8httpservlet="" phttpservlet="(Gk8HttpServlet*)Mtolua_new((Gk8HttpServlet)());" tolua_pushusertype="" if="" tolua_register_gc="" end_tolua_class_func="" begin_tolua_class_func="">SendHttpMessage(TOLUAGETSTRING(2),TOLUAGETFUNEX(L,3,0));
END_TOLUA_CLASS_FUNC

//[啟動註冊類的全部TOLUA函式]
BEGIN_TOLUA_FUN_MAP(Gk8HttpServlet)
	TOLUA_CLASS(Gk8HttpServlet,Gk8BaseObj,"[網路類]","[HTTP請求類]")
	TOLUA_CLASS_FUNC(Gk8HttpServlet,NewObj,"[Gk8HttpServlet* NewObj(GK8_BOOL ifLocal=false)?建立Gk8HttpServlet物件]")
	TOLUA_CLASS_FUNC(Gk8HttpServlet,SendHttpMessage,"[GK8_VOID SendHttpMessage(GK8_LPCSTR lpHttpData,iHttpCallVar)?傳送HTTP請求,字串模式]")
END_TOLUA_FUN_MAP

/////////////////////////////////////////////CLASS-TOSPP////////////////////////////////////////////////////
BEGIN_TOSPP_MAP(Gk8HttpServlet,Gk8BaseObj)
	TOSPP_FUNC(Gk8HttpServlet,SendHttpMessage,' ',"s&v","SendHttpMessage(lpHttpData,iHttpCallVar)")
END_TOSPP_MAP()
/////////////////////////////////////////////////////////////////////////////////////////////////

Gk8HttpServlet::Gk8HttpServlet()
{

}

Gk8HttpServlet::~Gk8HttpServlet()
{

}

//[傳送HTTP請求注意編碼問題]
GK8_VOID Gk8HttpServlet::SendHttpMessage(GK8_LPCSTR lpHttpData,Gk8Var& iHttpCallVar)
{
	m_sHttpUrl=lpHttpData;
	//[註冊指令碼回撥訊息]
	m_iHttpCallVar=iHttpCallVar;
	Gk8Var iEmptyVar;
	if(m_iHttpCallVar.GetSize()==1 && m_iHttpCallVar[0].IfInt()) SetEvent(sg_iReceiveMessageEvent,m_iHttpCallVar[0],iEmptyVar);
	Gk8HttpRequest* pHttpRequest=new Gk8HttpRequest();
	pHttpRequest->SetRequestType(Gk8HttpRequest::kHttpGet);
	pHttpRequest->SetHttpUrl(m_sHttpUrl);
	pHttpRequest->SetResponseCallBack(this,(HTTPREQUEST_CALLBACK_FUN)&Gk8HttpServlet::ServletRequestCompleted);
	pHttpRequest->SetRequestData(&m_iRequestData);

Gk8HttpClient::GetInstance()->Send(pHttpRequest);
}

//[HTTP請求資訊回撥]
GK8_VOID Gk8HttpServlet::ServletRequestCompleted(GK8_LPVOID lpHttpResponse)
{
	Gk8HttpResponse* pHttpResponse=(Gk8HttpResponse*)lpHttpResponse;
	if(!pHttpResponse) return;

//[把伺服器資料派遣到指令碼中]
	GK8_INT nFailCode=HTTPSERVLET_SUCC;
	Gk8Str iResponstStr;
	if(!pHttpResponse->IsSucceed())
	{
		_GK8ERR<GetErrorBuffer()<<cr iresponststr="UnKown Error" nfailcode="HTTPSERVLET_FAIL;" gk8bytemaker="" presponsedata="pHttpResponse-">GetResponseData();
		iResponstStr.BinToStr(pResponseData->GetBuf(),pResponseData->GetStreamSize());
	}

if(m_iHttpCallVar.GetSize()==1)
	{
		RunEventWithArgs(sg_iReceiveMessageEvent,iResponstStr);
	}else
	{
		if(!m_iHttpCallVar[0].IfPtr()||!IfObjPtr(m_iHttpCallVar[0].GetPtr(),m_iHttpCallVar[0].GetPtrId())) return;

Gk8Obj* pBindObj=m_iHttpCallVar[0].GetSafePtr();
		Gk8Var iParamVar;
		iParamVar<<nfailcode pbindobj-="">OnCall(m_iHttpCallVar[1],iParamVar);
	}
	//[直接刪除本身]
	SafeDeleteObj(this);
}
```</nfailcode></cr></isusertable></sg_irequestqueue.getsize></gk8httpresponse></gk8httprequest></fcntl.h></errno.h></semaphore.h></pthread.h></queue>

網路通訊3：HTTP實現文字傳輸

相關文章