遊戲開發中需要動態下載資源。甚至支援熱更新修復程式碼。都需要引擎支援檔案下載功能。寫個基於http協議的多執行緒檔案下載器。用第三方庫如何選擇問題？如何實現介面方便呼叫問題？等等。其實前面也多次用到libcurl。libcurl作為是一個多協議的便於客戶端使用的URL傳輸庫。libcurl已經非常靈活。介面設計的非常細。完全可以滿足需求。

這裡分享一個基於libcurl的HTTP封裝類，其功能包括：同步的(HTTP/HTTPS)GET、POST請求，以及檔案下載和進度報告。透過網路通訊1-5中通訊相關的方式。遊戲開發中用到的通訊基本都囊括了。引擎底層已經具備了強大的通訊能力和提供完善的介面。後續的重點就是如何使用好介面。和提高開發效率。尤其是團隊中多人參與研發。如何高效協助的問題。必然需要完整的工具鏈實現網路訊息生成。使真正開發者無需關注底層。只需依葫蘆畫瓢接收和傳送訊息即可。但作為遊戲開發者還是需要多花些精力去實現下。知識大爆炸時代更需要組織程式碼能力強的人才。儘量減少程式碼程式設計的時間。

C++實現下載器類：Gk8HttpLoader.h

```c++
#ifndef __GK8HTTPLOADER_H__
#define __GK8HTTPLOADER_H__

#pragma once
#include "Gk8BaseObj.h"
#include "Gk8ByteMaker.h"
#include "curl/curl.h"

#define	GK8LOADER_COUNT		0x0001
#define	GK8LOADER_SIZE		0x0002
#define	GK8LOADER_ONESIZE	0x0003

class Gk8HttpLoader:public Gk8BaseObj
{
	DECLARE_TOSPP_MAP;
private:
	GK8_BOOL m_bLoading;				//是否正在檔案下載
	Gk8ByteMaker m_iFileBufData;		//[檔案BUFF資料]

GK8_INT m_nLoadShowCase;			//[下載顯示模式:1個數進度,2整體大小進度,3單個大小進度]
	Gk8Var m_iLoadProgressCallVar;
	Gk8Var m_iLoadFinishCallVar;

GK8_INT m_nLoadFileCount;			//[已下載檔案個數]
	GK8_INT m_nSumFileCount;			//[總檔案個數]

GK8_INT m_nLoadFileSize;			//[已下載檔案大小]
	GK8_INT m_nSumFileSize;				//[總檔案大小]

private:
	GK8_BOOL InitLoaderThreadSemphore();

public:
	Gk8HttpLoader();
	virtual ~Gk8HttpLoader();
	 
	static Gk8HttpLoader* GetInstance();
	GK8_VOID Destroy();
	GK8_VOID TOSPPFUNC AddLoaderFile(GK8_LPCSTR lpFileName,GK8_LPCSTR lpLoaderUrl,GK8_LPCSTR lpLocalFile,GK8_INT nFileSize);
	GK8_VOID TOSPPFUNC SetHttpLoad(GK8_INT nLoadShowCase,Gk8Var& iLoadProgressCallVar,Gk8Var& iLoadFinishCallVar);
	GK8_VOID TOSPPFUNC HttpLoaderFile();
	;
	GK8_VOID OnProgress(GK8_LPVOID lpLoaderData,GK8_CDOUBLE dlTotal,GK8_CDOUBLE dlNow);
	GK8_VOID ShowLoadBar(GK8_LPVOID lpLoaderData);

GK8_VOID HttpLoaderTick();
};

#endif
```

C++實現下載器類：Gk8HttpLoader.cpp

```c++
#include "Gk8HttpLoader.h"
#include "Gk8OperSys.h"
#include "Gk8SetMb.cpp"
#include "Gk8BufEntry.cpp"
#include "Gk8FileUtil.h"

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

typedef	struct tagLOADERDATA
{
	GK8_UINT nNameId;						//[檔名ID]
	GK8_LPCSTR pFileName;					//[下載檔名]
	GK8_LPCSTR pLoaderUrl;					//[下載HTTP URL]
	GK8_LPCSTR pLocalFile;					//[本地檔案存放地]
	GK8_INT nFileSize;						//[檔案大小]
	Gk8ByteMaker* pFileBufData;				//[檔案BUFF資料]
	GK8_BOOL bSucceed;						//[HTTP下載請求反饋成功]
	GK8_INT nResponseCode;					//[HTTP下載請求反饋碼]
	Gk8Str sErrorBuffer;					//[HTTP下載請求錯誤資訊]
}LOADERDATA,*LPLOADERDATA;

static Gk8Str sg_iLoadProgressEvent("OnLoadProgress");	//[下載進度資訊]
static Gk8Str sg_iLoadFinishEvent("OnLoadFinish");		//[下載完成資訊]

static Gk8HttpLoader* sg_pHttpLoader=NULL;		//[靜態HTTP下載器]
static Gk8BufEntry<loaderdata>* s_pLoaderCache=NULL;

static GK8_BOOL sg_bHttpLoaderQuit=false;		//[退出HTTP下載器]
static sem_t* sg_pLoaderSem=NULL;				//[訊號量的資料型別]

//[執行緒及互斥定義]
static pthread_t sg_LoaderNetWorkThread;				//[HTTP下載執行緒]
static pthread_mutex_t sg_RequestLoaderMutex;			//[HTTP請求下載互斥體]
static pthread_mutex_t sg_ResponseLoaderMutex;			//[HTTP響應下載互斥體]

static Gk8SetMb<lploaderdata> sg_iRequestLoaderQueue;	//[HTTP下載請求佇列]
static Gk8SetMb<lploaderdata> sg_iResponseLoaderQueue;	//[HTTP下載響應佇列]

static GK8_CHAR sg_szLoaderErrorBuf[CURL_ERROR_SIZE];			//[錯誤資訊]
static Gk8Str sg_iLoaderErrorStr;

typedef size_t (*HTTPLOADERWRITE_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_iLoaderSem;
#endif

GK8_INT ProcessLoaderTask(LPLOADERDATA pHttpLoaderResponse,HTTPLOADERWRITE_CALLBACK lpCallBack,GK8_LPINT lpResponseCode);

//[接收HTTP下載資料]
size_t WriteHttpLoaderData(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;
}

//[進度回撥]
size_t HandleLoaderProgress(GK8_LPVOID lpBuffer,GK8_DOUBLE dlTotal,GK8_DOUBLE dlNow,GK8_DOUBLE ulTotal,GK8_DOUBLE ulNow)
{
	LPLOADERDATA pHttpLoaderResponse=(LPLOADERDATA)lpBuffer;
	Gk8HttpLoader* pHttpLoader=Gk8HttpLoader::GetInstance();
	pHttpLoader->OnProgress(pHttpLoaderResponse,dlTotal,dlNow);
	return 0;
}

//[處理POST請求:流的行事發出]
GK8_INT ProcessLoaderTask(LPLOADERDATA pHttpLoaderResponse,HTTPLOADERWRITE_CALLBACK lpWriteCallBack,GK8_LPINT lpResponseCode)
{
	CURLcode nCurlCode=CURL_LAST;
	CURL* pCurl=curl_easy_init();
	do
	{
		//遠端URL,支援HTTP,HTTPS,FTP
		nCurlCode=curl_easy_setopt(pCurl,CURLOPT_URL,pHttpLoaderResponse->pLoaderUrl);
		if(nCurlCode!=CURLE_OK) break;

//設定User-Agent
		Gk8Str iUserAgentStr="Mozilla/5.0 (Windows NT 6.1; WOW64; rv:13.0) Gecko/20100101 Firefox/13.0.1";
		nCurlCode=curl_easy_setopt(pCurl,CURLOPT_USERAGENT,iUserAgentStr);
		if(nCurlCode!=CURLE_OK) break;

//設定重定向的最大次數
		nCurlCode=curl_easy_setopt(pCurl,CURLOPT_MAXREDIRS,5);
		if(nCurlCode!=CURLE_OK) break;

//設定301,302跳轉跟隨location
		nCurlCode=curl_easy_setopt(pCurl,CURLOPT_FOLLOWLOCATION,1);
		if(nCurlCode!=CURLE_OK) break;

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

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

//下載內容回撥函式
		nCurlCode=curl_easy_setopt(pCurl,CURLOPT_WRITEFUNCTION,lpWriteCallBack);
		if(nCurlCode!=CURLE_OK) break;

nCurlCode=curl_easy_setopt(pCurl,CURLOPT_WRITEDATA,pHttpLoaderResponse->pFileBufData);
		if(nCurlCode!=CURLE_OK) break;

//進度回撥函式
		nCurlCode=curl_easy_setopt(pCurl,CURLOPT_NOPROGRESS, 0);
		if(nCurlCode!=CURLE_OK) break;

nCurlCode=curl_easy_setopt(pCurl,CURLOPT_PROGRESSDATA,pHttpLoaderResponse);
		if(nCurlCode!=CURLE_OK) break;

nCurlCode=curl_easy_setopt(pCurl,CURLOPT_PROGRESSFUNCTION,HandleLoaderProgress);
		if(nCurlCode!=CURLE_OK) break;

//跳過伺服器SSL驗證,不使用CA證書
		nCurlCode=curl_easy_setopt(pCurl,CURLOPT_SSL_VERIFYPEER,0L);
		if(nCurlCode!=CURLE_OK) break;

//驗證伺服器端傳送的證書,預設是2(高),1(中),0(禁用)
		nCurlCode=curl_easy_setopt(pCurl,CURLOPT_SSL_VERIFYHOST,0L);
		if(nCurlCode!=CURLE_OK) break;

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

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 LoaderNetWorkThread(GK8_LPVOID lpData)
{
	LPLOADERDATA pHttpLoaderRequest=NULL;
	LPLOADERDATA pHttpLoaderResponse=NULL;

while(true)
	{
		//Wait for http request tasks from main thread
		GK8_INT nSemWaitRet=sem_wait(sg_pLoaderSem);
		if(nSemWaitRet<0)
		{
			_GK8ERR<pFileBufData->ClearStream();

//[第二步:libCurl同步請求]
		//pHttpLoaderResponse=new LOADERDATA();
		//memcpy(pHttpLoaderResponse,pHttpLoaderRequest,sizeof(LOADERDATA));
		pHttpLoaderResponse=pHttpLoaderRequest;
		GK8_INT nResponseCode=-1;
		GK8_INT nRetValue=0;

nRetValue=ProcessLoaderTask(pHttpLoaderResponse,WriteHttpLoaderData,&nResponseCode);

pHttpLoaderResponse->nResponseCode=nResponseCode;
		if(nRetValue!=0)
		{
			pHttpLoaderResponse->bSucceed=false;
			sg_iLoaderErrorStr=sg_szLoaderErrorBuf;
			pHttpLoaderResponse->sErrorBuffer=sg_iLoaderErrorStr;
		}else
		{
			pHttpLoaderResponse->bSucceed=true;
		}

pthread_mutex_lock(&sg_ResponseLoaderMutex);
		sg_iResponseLoaderQueue.AddItem(pHttpLoaderResponse);
		pthread_mutex_unlock(&sg_ResponseLoaderMutex);
	}
	pthread_mutex_lock(&sg_RequestLoaderMutex);
	sg_iRequestLoaderQueue.Clear();
	pthread_mutex_unlock(&sg_RequestLoaderMutex);

if(sg_pLoaderSem!=NULL)
	{
#if GK8_ASYNC_HTTPREQUEST_USE_NAMED_SEMAPHORE
		sem_unlink(GK8_ASYNC_HTTPREQUEST_SEMAPHORE);
		sem_close(sg_pLoaderSem);
#else
		sem_destroy(sg_pLoaderSem);
#endif
		sg_pLoaderSem=NULL;

pthread_mutex_destroy(&sg_RequestLoaderMutex);
		pthread_mutex_destroy(&sg_ResponseLoaderMutex);

//[依次刪除資料]
		GK8_INT nIndex;
		for(nIndex=0;nIndex<sg_irequestloaderqueue.getsize phttploaderrequest="sg_iRequestLoaderQueue.GetItemAt(nIndex);" delete="" for="" phttploaderresponse="sg_iResponseLoaderQueue.GetItemAt(nIndex);" sg_irequestloaderqueue.destroy="" sg_iresponseloaderqueue.destroy="" pthread_exit="" return="" begin_tospp_map="" tospp_func="" end_tospp_map="" begin_tospp_static_fun_map="" tospp_static_func="" getinstance="" end_tospp_static_fun_map="" gk8httploader::gk8httploader="" m_bloading="false;" m_nloadshowcase="1;" m_nloadfilecount="0;" m_nsumfilecount="0;" m_nloadfilesize="0;" m_nsumfilesize="0;" s_ploadercache="new" gk8bufentry="">;
}

Gk8HttpLoader::~Gk8HttpLoader()
{
	sg_bHttpLoaderQuit=true;
	if(sg_pLoaderSem!=NULL)
	{
		sem_post(sg_pLoaderSem);
	}
	Destroy();
}
//[初始化執行緒]
GK8_BOOL Gk8HttpLoader::InitLoaderThreadSemphore()
{
	if(sg_pLoaderSem!=NULL)
	{
		return true;
	}else
	{
#if GK8_ASYNC_HTTPREQUEST_USE_NAMED_SEMAPHORE
		sg_pLoaderSem=sem_open(GK8_ASYNC_HTTPREQUEST_SEMAPHORE,O_CREAT,0644,0);
		if(sg_pLoaderSem==SEM_FAILED)
		{
			_GK8ERR<AddEntryWithNameId(nNameId);
	lpLoaderData->nNameId=nNameId;
	lpLoaderData->pFileName=lpFileName;
	lpLoaderData->pLoaderUrl=lpLoaderUrl;
	lpLoaderData->pLocalFile=lpLocalFile;
	lpLoaderData->nFileSize=nFileSize;
	lpLoaderData->pFileBufData=&m_iFileBufData;

//[準備顯示資料]
	m_nSumFileCount++;
	m_nSumFileSize+=nFileSize;
	m_iFileBufData.WriteAlloc(nFileSize);
}

GK8_VOID Gk8HttpLoader::SetHttpLoad(GK8_INT nLoadShowCase,Gk8Var& iLoadProgressCallVar,Gk8Var& iLoadFinishCallVar)
{
	m_nLoadShowCase=nLoadShowCase;
	m_iLoadProgressCallVar=iLoadProgressCallVar;
	m_iLoadFinishCallVar=iLoadFinishCallVar;

Gk8Var iEmptyVar;
	if(iLoadProgressCallVar.GetSize()==1 && iLoadProgressCallVar[0].IfInt()) SetEvent(sg_iLoadProgressEvent,iLoadProgressCallVar[0],iEmptyVar);
	if(iLoadFinishCallVar.GetSize()==1 && iLoadFinishCallVar[0].IfInt()) SetEvent(sg_iLoadFinishEvent,iLoadFinishCallVar[0],iEmptyVar);
}

//[開始HTTP下載檔案]
GK8_VOID Gk8HttpLoader::HttpLoaderFile()
{
	//正在下載中
	if(m_bLoading) return;
	if(s_pLoaderCache->GetBufNum()<1)
	{
		//[通知指令碼下載完成]
		static Gk8Var sl_iParamVar;
		sl_iParamVar.RemoveAll();
		if(m_iLoadFinishCallVar.GetSize()==1)
		{
			RunEventWithArgs(sg_iLoadFinishEvent,sl_iParamVar);
		}else
		{
			if(!m_iLoadFinishCallVar[0].IfPtr()||!IfObjPtr(m_iLoadFinishCallVar[0].GetPtr(),m_iLoadFinishCallVar[0].GetPtrId())) return;

Gk8Obj* pBindObj=m_iLoadFinishCallVar[0].GetSafePtr();

pBindObj->OnCall(m_iLoadFinishCallVar[1],sl_iParamVar);
		}
		m_nLoadFileCount=0;
		m_nSumFileCount=0;

m_nLoadFileSize=0;
		m_nSumFileSize=0;
		return;
	}
	LPLOADERDATA lpLoaderData=s_pLoaderCache->GetBufEntryAt(0);
	if(false==InitLoaderThreadSemphore()) return;
	if(!lpLoaderData) return;
	m_bLoading=true;
	pthread_mutex_lock(&sg_RequestLoaderMutex);
	sg_iRequestLoaderQueue.AddItem(lpLoaderData);
	pthread_mutex_unlock(&sg_RequestLoaderMutex);

sem_post(sg_pLoaderSem);
}
//[處理進度條]
GK8_VOID Gk8HttpLoader::OnProgress(GK8_LPVOID lpLoaderData,GK8_CDOUBLE dlTotal,GK8_CDOUBLE dlNow)
{
	LPLOADERDATA pLoaderData=(LPLOADERDATA)lpLoaderData;

static Gk8Var sl_iParamVar;
	sl_iParamVar.RemoveAll();
	sl_iParamVar<<m_nloadshowcase>pFileName<<m_nloadfilecount if="" runeventwithargs="" return="" gk8obj="" pbindobj="m_iLoadProgressCallVar[0].GetSafePtr();" pbindobj-="">OnCall(m_iLoadProgressCallVar[1],sl_iParamVar);
	}
}
//[顯示進度條]
GK8_VOID Gk8HttpLoader::ShowLoadBar(GK8_LPVOID lpLoaderData)
{
	LPLOADERDATA pLoaderData=(LPLOADERDATA)lpLoaderData;
	GK8_DOUBLE dlTotal=pLoaderData->nFileSize;
	GK8_DOUBLE dlNow=pLoaderData->nFileSize;
	OnProgress(lpLoaderData,dlTotal,dlNow);
}
//[獲取HTTP下載器單例]
Gk8HttpLoader* Gk8HttpLoader::GetInstance()
{
	if(sg_pHttpLoader==NULL) sg_pHttpLoader=new Gk8HttpLoader();
	return sg_pHttpLoader;
}

GK8_VOID Gk8HttpLoader::Destroy()
{
	if(s_pLoaderCache!=NULL)
	{
		delete s_pLoaderCache;
		s_pLoaderCache=NULL;
	}
}
//[HTTP下載器響應幀控制]
GK8_VOID Gk8HttpLoader::HttpLoaderTick()
{
	if(sg_pLoaderSem==NULL) return;

LPLOADERDATA pLoaderData=NULL;

pthread_mutex_lock(&sg_ResponseLoaderMutex);
	if(sg_iResponseLoaderQueue.GetSize()>0)
	{
		pLoaderData=sg_iResponseLoaderQueue.GetItemAt(0);
		sg_iResponseLoaderQueue.RemoveItemAt(0);
	}
	pthread_mutex_unlock(&sg_ResponseLoaderMutex);

if(!pLoaderData) return;

//[把伺服器資料派遣到指令碼中]
	Gk8Str iResponstStr;
	if(!pLoaderData->bSucceed)
	{
		_GK8ERR<sErrorBuffer<nResponseCode<<cr iresponststr="UnKown Error" gk8file="" ifile="" if="">pLocalFile,Gk8File::modeWriteAbs))
		{
			iFile.Write(pLoaderData->pFileBufData->GetBuf(),pLoaderData->pFileBufData->GetStreamSize());
			iFile.Close();
		}
	}
	m_nLoadFileCount++;
	ShowLoadBar(pLoaderData);
	m_nLoadFileSize+=pLoaderData->nFileSize;

//移除已下載資料:繼續下載
	s_pLoaderCache->RemoveEntryWithNameId(pLoaderData->nNameId);
	m_bLoading=false;
	HttpLoaderFile();
}
```</cr></m_nloadfilecount></m_nloadshowcase></sg_irequestloaderqueue.getsize></lploaderdata></lploaderdata></loaderdata></fcntl.h></errno.h></semaphore.h></pthread.h></queue>

網路通訊5：HTTP下載器

相關文章