IceE+Qt实现简易的文件传输

已于 2022-11-27 01:11:34 修改
阅读量1k 收藏 6
点赞数 2
分类专栏： qt知识 zeroc-ice 文章标签： Zeroc-Ice IceE QT c++ 通信中间件
于 2020-01-04 12:22:10 首次发布
本文为CSDN“py_free-物联智能”博主原创文章，未经博主允许不得转载。
本文链接：https://blog.csdn.net/py8105/article/details/103831062
版权

Zeroc-Ice是一个大而全面的跨平台中间件技术框架，但是很多项目场景仅仅需要其中间件通信能力即可，下面我们采用Zeroc-Ice其裁剪过的IceE实现简单的文件传输实现，IceE在嵌入式领域使用更多，另外QT在嵌入式可视化界面开发也受欢迎，两者结合一起实现一个简要的 demo，展示IceE如何实现通信。

1）下载IceE，依据其编译帮助文件说明编译所在平台所需语言的依赖库，本文采用IceE-1.3.0的早期版本:（IceE-1.3.0.zip-嵌入式代码类资源-CSDN下载）

，其文件结构如下图，能在当前绝大多数嵌入式系统适用。当然，如果已经部署或编译好了Zeroc-Ice，直接采用Zeroc-Ice一样能实现本文测试样例，即使是最新的3.7版本Zeroc-Ice一样可行，仅需要其通信能力。

2）编译出 IceE的头文件和静态库，本文采用vs2010和g++4.4.7编译器编译，下来构建通信接口文件RCI.ice，该接口文件定义了文件描述信息和文件传输相关接口函数，具体如下：

#ifndef _IEVENT_ICE
#define _IEVENT_ICE

#include <IceE/Identity.ice>

module RCI
{
/********自定义数据结构*********//
	struct RCIFileBinary
	{
		string filename;
		int    startpos;
		int    filesize;
		string filebuf;
		int    buflen;
	};

	sequence<string> RCISeqList;
*******接口*******/	
	interface RCIAccess
	{	
//***元素是数据处理方法***//	
		/*
		getFileByConf:
		描述：
			请求开始读取原始数据文件数据。
		参数：
			file:		文件名；；
			replyid:	服务端返回的应答编号；
		返回值：
			true: 表示成功;
			false:表示失败.
		*/
		bool getFileByConf(string file,out int replyid);	

		/*
		nextFileData:
		描述：
			获取原始数据信息。
		参数：
			replyid:	服务端返回的应答编号；
			filedata:	用于缓存返回的数据；
		返回值：
			true：	表示成功；
			false： 表示失败。
		*/
		bool nextFileData(int replyid,out RCIFileBinary filedata);

		/*
		getRawDataDir:
		描述：
			获取原始数据文件目录信息。
		参数：
			dirlist:	用于存储所有满足条件的文件名容器；
		返回值：
			true: 表示成功获取到文件列表;
			false:表示失败.
		*/
		bool getRawDataDir(out RCISeqList dirlist);
	};	
};

#endif

3）根据RCI.ice生成需要编译语言的实际接口源码文件，本文要和Qt结合，因此会采用slice2cppe.exe来编译c++源码，因此进入 RCI.ice所在目录，执行命令如下：

D:/work/ICE_test/IceE-1.3.0/cpp/bin/slice2cppe.exe -ID:/work/ICE_test/IceE-1.3.0/slice RCI.ice

最好是把该命令写入到脚本中，如ICE.bat，这样方便使用，当然也可以添加其他命令，如将生成源码拷贝到指定目录等

执行命令生成RCI.h/RCI.cpp源码文件

4）安装好QT，建议如果要在生产环境的嵌入式系统使用，采用类似于4.7,4.8的版本，防止有些嵌入式系统不支持更高级的QT版本，类似c++11/14/17,也慎重选择，本文测试时安装在win7下的QT4.8版本，并采用vs2010编译成了静态库，linux下测试是redehat6.5版本，qt4.8同样静态编译,g++是4.4版本的。

OK，看看本文测试工程的目录结构如下

client        #客户端
IceE          #IceE头文件
IceE-1.3.0    #IceE源码包
IceRc         #ice通信接口文件、脚本及生成代码
Lib           #编译好的win/linux的IceE库
server        #服务端

5）先构建服务端的pro工程文件，ICEServer.h/ICEServer.cpp是基于RCI.h/RCI.cpp编写的真正实现通信接口的源文件，如下：

QT      +=  core

CONFIG += qt warn_on debug_and_release
CONFIG += console
CONFIG += static

DESTDIR = bin
ProDir=..

INCLUDEPATH              += $$ProDir
INCLUDEPATH              += $$ProDir/IceRc 
INCLUDEPATH              += $$ProDir/server/IceSrc

win32{
    DEFINES +=  QTWIN_32 \
                ICE_API_EXPORTS \
                ICEE_STATIC_LIBS \
                WIN32_LEAN_AND_MEAN \
                QT_CORE_LIB \
                QT_GUI_LIB \
                QT_NETWORK_LIB \
                QT_HAVE_MMX \ 
                QT_HAVE_3DNOW \
                QT_HAVE_SSE \
                QT_HAVE_MMXEXT \
                QT_HAVE_SSE2 \
                QT_THREAD_SUPPORT \
                QT_LARGEFILE_SUPPORT \
                WIN32 \
                _UNICODE \

    DEFINES -= VSWIN_32 \
}

unix{
    DEFINES +=  ICE_API_EXPORTS \
            ICEE_STATIC_LIBS \
            QT_CORE_LIB \
}

CONFIG(debug, debug|release) {
    TARGET = ICEServer_debug
    CONFIG += console
    OBJECTS_DIR             = debug/obj
    MOC_DIR                 = debug/moc
    DEFINES                 += _DEBUG
} else {
    TARGET = ICEServer_release
    OBJECTS_DIR             = release/obj
    MOC_DIR                 = release/moc
    DEFINES                 += NODEBUG
}

win32:LIBS += Rpcrt4.lib
win32:CONFIG(debug, debug|release) {
    win32:LIBS             += $$ProDir/Lib/debug/icee_staticd100.lib
} else {
    win32:LIBS             += $$ProDir/Lib/release/icee_static100.lib
}
unix{
    LIBS       += -L"$$ProDir/Lib/linux" -lIceE_4.4
}
#代码
HEADERS +=  $$ProDir/IceRc/RCI.h 
HEADERS +=  IceSrc/ICEServer.h 
SOURCES +=  $$ProDir/IceRc/RCI.cpp 
SOURCES +=  IceSrc/ICEServer.cpp 

SOURCES +=  main.cpp

服务端实现代码接口及涉及的源码如下

bin            #执行文件输出目录
IceSrc         #ICEServer.h、ICEServer.cpp接口文件存储目录
ICEServer.pro  #工程文件
main.cpp       #

main.cpp


#include <IceE/IceE.h>
#include "IceSrc/ICEServer.h"

using namespace std;

int run(int argc, char* argv[], const Ice::CommunicatorPtr& communicator)
{
    if(argc > 1)
    {
        fprintf(stderr, "%s: too many arguments\n", argv[0]);
        return EXIT_FAILURE;
    }
    fprintf(stderr, "%s: create Adapte now! \n", argv[0]);
    Ice::ObjectAdapterPtr adapter = communicator->createObjectAdapter("RCI");
    ::RCI::RCIAccessPtr object = new RCIAccessI;
    adapter->add(object, communicator->stringToIdentity("RCI"));
    adapter->activate();
    fprintf(stderr, "%s: Adapte be activated now! \n", argv[0]);
    communicator->waitForShutdown();
    return EXIT_SUCCESS;
}

int main(int argc, char* argv[])
{
    int status;
    Ice::CommunicatorPtr communicator;

    try
    {
        Ice::InitializationData initData;
        initData.properties = Ice::createProperties();
        initData.properties->load("config");
        communicator = Ice::initialize(argc, argv, initData);
        status = run(argc, argv, communicator);
    }
    catch(const Ice::Exception& ex)
    {
        fprintf(stderr, "%s\n", ex.toString().c_str());
        status = EXIT_FAILURE;
    }catch (const std::string & msg) {
        fprintf(stderr, "%s\n", msg.c_str());
        status = EXIT_FAILURE; 
    } catch (const char * msg) { 
        fprintf(stderr, "%s\n", msg);
        status = EXIT_FAILURE; 
    } 

    if(communicator)
    {
        try
        {
            communicator->destroy();
        }
        catch(const Ice::Exception& ex)
        {
            fprintf(stderr, "%s\n", ex.toString().c_str());
            status = EXIT_FAILURE;
        }
    }

    return status;
}

ICEServer.h

#ifndef ICECLIENT_H
#define ICECLIENT_H

#include "RCI.h"

#include <queue>
#include <IceE/IceE.h> 
#include <IceE/Thread.h>
#include <IceE/Mutex.h>

struct HanderArg
{
	::std::string  path;
};

class FileDataReadThread : public IceUtil::Thread
{
public:
	FileDataReadThread(HanderArg args);
	~FileDataReadThread();

	virtual void run();

	int getgloop();
	time_t getlasttime();
	bool emptybuffer();
	bool getfirstdata(::RCI::RCIFileBinary & filedataitem);
private:
	int gloop;
	time_t 	lasttime;
	HanderArg arglist;
	std::queue< ::RCI::RCIFileBinary > filedatals;
	IceUtil::Mutex mutexrdls;
};

typedef IceUtil::Handle<FileDataReadThread > FileDataReadThreadPtr;

class FDReadManageThread : public IceUtil::Thread
{
public:
	FDReadManageThread();
	~FDReadManageThread();

	virtual void run();

	bool createrequest(HanderArg args, int &replyid);
	bool getrequest(int reqid, ::RCI::RCIFileBinary& filedataitem);
private:
	std::list<FileDataReadThreadPtr> requestlist;
	IceUtil::Mutex listMutex;
};

typedef IceUtil::Handle<FDReadManageThread> FDReadManageThreadPtr;

// using namespace std;
class RCIAccessI : public RCI::RCIAccess { 
public:
	RCIAccessI();
	virtual ~RCIAccessI();
public:
	virtual bool getFileByConf(const ::std::string&
		, ::Ice::Int&
		, const ::Ice::Current& = ::Ice::Current());
	virtual bool nextFileData(::Ice::Int
		, ::RCI::RCIFileBinary&
		, const ::Ice::Current& = ::Ice::Current());
	virtual bool getRawDataDir(::RCI::RCISeqList&
		, const ::Ice::Current& = ::Ice::Current());
private:
	void init();
private:
	FDReadManageThreadPtr fdmgthptr;
};

#endif //ICECLIENT_H

ICEServer.cpp

#include "ICEServer.h"

#include <stdio.h>
#include <stdlib.h>

#ifdef __linux__ 
#include <sys/io.h>
#include <sys/time.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#endif

#ifdef WIN32
#include <io.h>
#include <time.h>
#endif

#define CONTINUEINTERVAL 10000 //秒

#ifdef __linux__ 
	#define INT32 int
	#define UINT32 unsigned int
	#define O_BINARY 0
#endif

#define MAX_QUEUESIZE 100
/*
**将字符串按指定标识分段
*/
bool string_divide( std::vector<std::string> &_strlist,const std::string src,const std::string div)
{
	std::string _src = src;
	std::string::size_type _pos = _src.find(div);
	while(std::string::npos != _pos)
	{
		std::string _buf = "";
		_buf = _src.substr(0,_pos);
		_strlist.push_back(_buf);
		_src = _src.erase(0,_pos+div.size());
		_pos = _src.find(div.c_str());
	}
	if(!_src.empty()){
		_strlist.push_back(_src);
	}
	return true;
};

long fsize(FILE *stream)
{
    long curpos, length;
    curpos = ftell(stream);
    fseek(stream, 0L, SEEK_END);
    length = ftell(stream);
    fseek(stream, curpos, SEEK_SET);
    return length;
};

FileDataReadThread::FileDataReadThread(HanderArg args)
	: IceUtil::Thread()
{
	arglist = args;		
	gloop = 1;
	lasttime = time(NULL);
}

FileDataReadThread::~FileDataReadThread()
{

}

int FileDataReadThread::getgloop()
{
	return gloop;
}

time_t FileDataReadThread::getlasttime()
{
	return lasttime;
}
bool FileDataReadThread::emptybuffer()
{
	return filedatals.empty();
}
bool FileDataReadThread::getfirstdata(::RCI::RCIFileBinary & filedataitem)
{
	bool ret = false;
	while (1==gloop&&filedatals.empty())
	{
		IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(10)); 
	}
	if (!filedatals.empty()){
	    mutexrdls.lock();
	    filedataitem = filedatals.front();
	    filedatals.pop();
	    mutexrdls.unlock();		
	    ret = true;
	}

	lasttime = time(NULL);

	return ret;
}

void FileDataReadThread::run()
{
	while(1==gloop)
	{
		::RCI::RCISeqList dirlist;
		dirlist.push_back(arglist.path);

		for (int i = 0; i < dirlist.size(); i++)
		{
			fprintf(stderr, "FILE: %s\n",dirlist[i].c_str());

			std::string filename = dirlist[i];
			std::vector<std::string> _strlist;
        	string_divide(_strlist,filename,"/");
        	if (_strlist.size()>1)
        	{
        		filename = _strlist[_strlist.size()-1];
        	}
		//
        	FILE *fd = NULL; //需要注意
			fd  = fopen(dirlist[i].c_str(),"rb");  
		    if(NULL==fd){   
		        printf("open %s failed!\n",dirlist[i].c_str());
		        break;
		    }
		    UINT32 filesize = fsize(fd);
		    fseek(fd,0,SEEK_SET);
		    printf("filesize: %d \n", filesize);
		    UINT32 pos = 0;
		    while(pos<filesize)
		    {
			    while(filedatals.size()>MAX_QUEUESIZE)
			    {
			    	IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(100)); 
			    }

		    	unsigned char data[1024] = {0};
			    memset(data,0,1024);
			    // printf("tell(fd) = %d \n",tell(fd) );
			    INT32 readlen = fread(data,sizeof(char),1024,fd);
			    if(!(readlen == 1024||(pos+readlen)==ftell(fd)))
			    { 
			        printf("read pcap data failed! return %d , wish:%d \n"
			        	, readlen, 1024);
			        break;
			    }
			    ::RCI::RCIFileBinary filedataitem;
			    filedataitem.filename = filename;
			    filedataitem.startpos = pos;
			    filedataitem.filesize = filesize;
			    filedataitem.buflen	= readlen;
			    filedataitem.filebuf = std::string((char*)data,readlen);
			    // printf("pos:%d buf: %d\n", filedataitem.startpos,filedataitem.buflen);
			    pos += readlen;
			    	
			    mutexrdls.lock();
			    filedatals.push(filedataitem);
			    mutexrdls.unlock();    	
		    }
		    fclose(fd);
		    printf("file: %s be dealwith finish!\n",dirlist[i].c_str() );
	    }	
	    gloop = 0;	
		IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(10)); 
	}
}

/
FDReadManageThread::FDReadManageThread()
	: IceUtil::Thread()
{

}
FDReadManageThread::~FDReadManageThread()
{

}

void FDReadManageThread::run()
{
	while(1)
	{
		listMutex.lock();
		std::list<FileDataReadThreadPtr>::iterator it = requestlist.begin();
		while(it!=requestlist.end()){
			if (time(NULL)>((*it)->getlasttime()+CONTINUEINTERVAL)
				||(0==(*it)->getgloop()&&(*it)->emptybuffer()))
			{
				(*it)->getThreadControl().join();
				it = requestlist.erase(it);
			}else{
				it++;
			}
		}	
		listMutex.unlock();
		IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(100));
	}
}

bool FDReadManageThread::createrequest(HanderArg args, int &replyid)
{
	bool ret = true;
	replyid = -1;
	try{
		FileDataReadThreadPtr readthread = new FileDataReadThread(args); 
		readthread->start();
		replyid = readthread->getThreadControl().id();
		listMutex.lock();
		requestlist.push_back(readthread);
		listMutex.unlock();
		// printf("create reqid:%d \n", replyid);
	}catch(const Ice::Exception& ex){
        fprintf(stderr, "%s\n", ex.toString().c_str());
        ret = false;
    }

	return ret;
}

bool FDReadManageThread::getrequest(int reqid, ::RCI::RCIFileBinary& filedataitem)
{
	bool ret = false;
	// printf("reqid:%d\n", reqid );
	listMutex.lock();
	std::list<FileDataReadThreadPtr>::iterator it = requestlist.begin();
	while(it!=requestlist.end()){
		// printf("check reqid: %d \n", (*it)->getThreadControl().id());
		if (reqid == (*it)->getThreadControl().id())
		{
			ret = (*it)->getfirstdata(filedataitem);
			// printf("getrequest return :%d \n", ret);
			break;
		}
		it++;	
	}
	listMutex.unlock();
	return ret;
}


RCIAccessI::RCIAccessI()
	: RCI::RCIAccess()
{
	init();
}

RCIAccessI::~RCIAccessI()
{
	fdmgthptr->getThreadControl().join();
}

void RCIAccessI::init()
{
	fdmgthptr = new FDReadManageThread();
	fdmgthptr->start();
}

bool RCIAccessI::getFileByConf(const ::std::string& path
	, ::Ice::Int& replyid
	, const ::Ice::Current& )
{
	HanderArg args;
	args.path = path;

	return fdmgthptr->createrequest(args,replyid);
}
bool RCIAccessI::nextFileData(::Ice::Int replyid
	, ::RCI::RCIFileBinary& filedataitem
	, const ::Ice::Current& )
{
	return fdmgthptr->getrequest(replyid,filedataitem);
}

bool RCIAccessI::getRawDataDir(::RCI::RCISeqList& dirlist
	, const ::Ice::Current& )
{
	dirlist.push_back("data/1009843804.bin"); 
	dirlist.push_back("data/TNET003c30fe5c230c98bd.bin"); 
	return true;
}

6）构建客户端的pro工程文件，ICEClient.h/ICEClient.cpp是基于RCI.h/RCI.cpp编写的真正实现通信接口的源文件，如下：

QT      +=  core

CONFIG += qt warn_on debug_and_release
CONFIG += console
CONFIG += static

DESTDIR = bin
ProDir=..

INCLUDEPATH              += $$ProDir
INCLUDEPATH              += $$ProDir/IceRc 
INCLUDEPATH              += $$ProDir/clinet/IceSrc

win32{
    DEFINES +=  QTWIN_32 \
                ICE_API_EXPORTS \
                ICEE_STATIC_LIBS \
                WIN32_LEAN_AND_MEAN \
                QT_CORE_LIB \
                QT_GUI_LIB \
                QT_NETWORK_LIB \
                QT_HAVE_MMX \ 
                QT_HAVE_3DNOW \
                QT_HAVE_SSE \
                QT_HAVE_MMXEXT \
                QT_HAVE_SSE2 \
                QT_THREAD_SUPPORT \
                QT_LARGEFILE_SUPPORT \
                WIN32 \
                _UNICODE \

    DEFINES -= VSWIN_32 \
}

unix{
    DEFINES +=  ICE_API_EXPORTS \
            ICEE_STATIC_LIBS \
            QT_CORE_LIB \
}

CONFIG(debug, debug|release) {
    TARGET = ICEClient_debug
    CONFIG += console
    OBJECTS_DIR             = debug/obj
    MOC_DIR                 = debug/moc
    DEFINES                 += _DEBUG
} else {
    TARGET = ICEClient_release
    OBJECTS_DIR             = release/obj
    MOC_DIR                 = release/moc
    DEFINES                 += NODEBUG
}
win32:LIBS += Rpcrt4.lib
win32:CONFIG(debug, debug|release) {
    win32:LIBS             += $$ProDir/Lib/debug/icee_staticd100.lib
} else {
    win32:LIBS             += $$ProDir/Lib/release/icee_static100.lib
}
unix{
    LIBS       += -L"$$ProDir/Lib/linux" -lIceE_4.4
}
#源码
HEADERS +=  $$ProDir/IceRc/RCI.h 
HEADERS +=  IceSrc/ICEClient.h 

SOURCES +=  $$ProDir/IceRc/RCI.cpp 
SOURCES +=  IceSrc/ICEClient.cpp 

SOURCES +=  main.cpp

客户端实现代码接口及涉及的源码如下：

bin            #执行文件输出目录
IceSrc         #ICEClient.h、ICEClient.cpp接口文件存储目录
ICEClient.pro  #工程文件
main.cpp       #

main.cpp源码:

#include <IceE/IceE.h>
#include "IceSrc/ICEClient.h"

extern bool EXITSTAT = true;

int main(int argc, char * argv[]) 
{ 
    EXITSTAT  = true;
    ICEClient *ptrICEClient = new ICEClient(argc,argv);
    ptrICEClient->start();
    while(EXITSTAT){
    	#ifdef WIN32
        ::Sleep(100);
        #else
        ::sleep(1);
        #endif
    }
    return 0;
}

ICEClient.h源码：

#ifndef ICECLIENT_H
#define ICECLIENT_H

#include <IceE/IceE.h> 
#include <IceE/thread.h>
#include <vector>

#include "RCI.h"

using namespace std;

class ICEClient : public IceUtil::Thread
{
public:
	ICEClient(int argc, char* argv[]);
	~ICEClient();

	virtual void run();
private:
	void init(int argc, char* argv[]);
	void destroy();

	void getDir();
	void getFile();
private:
	Ice::CommunicatorPtr communicator;
	::RCI::RCIAccessPrx twoway;

	std::vector<std::string> fileList;
};
#endif //ICECLIENT_H

ICEClient.cpp源码:

#include "ICEClient.h"

#include <stdio.h>
#include <fcntl.h>

#ifdef WIN32
#include <io.h>
#include <time.h>
#include <conio.h>
#endif

#ifdef __linux__
#include <sys/time.h>
#endif

extern bool EXITSTAT;

ICEClient::ICEClient(int argc, char* argv[])
{
    init(argc,argv);
}

ICEClient::~ICEClient()
{
    this->destroy();
}

void ICEClient::init(int argc, char* argv[])
{
    try
    {
        Ice::InitializationData initData;
        initData.properties = Ice::createProperties();
        initData.properties->load("config");
        communicator = Ice::initialize(argc, argv, initData);
        if(argc > 1)
        {
            fprintf(stderr, "%s: too many arguments\n", argv[0]);
            return ;
        }
        fprintf(stderr,"create client now! \n");
        Ice::PropertiesPtr properties = communicator->getProperties();
        const char* proxyProperty = "RCI.Proxy";
        string proxy = properties->getProperty(proxyProperty);
        if(proxy.empty())
        {
            fprintf(stderr, "%s: property `%s' not set\n", argv[0], proxyProperty);
            return ;
        }else{
            fprintf(stderr, "%s: property `%s' has be seted \n", argv[0], proxyProperty);
        }

        Ice::ObjectPrx base = communicator->stringToProxy(proxy);
        fprintf(stderr,"checkedCast now! \n");
        twoway = ::RCI::RCIAccessPrx::checkedCast(base->ice_twoway()->ice_timeout(-1));
        if(!twoway)
        {
            fprintf(stderr, "%s: invalid proxy\n", argv[0]);
            return ;
        }else{
            fprintf(stderr, "%s: right proxy\n", argv[0]);
        }
        ::RCI::RCIAccessPrx oneway = twoway->ice_oneway();
    #ifdef ICEE_HAS_BATCH
        ::RCI::RCIAccessPrx batchOneway = twoway->ice_batchOneway();
    #endif
        fprintf(stderr,"connet server! \n");        
    }
    catch(const Ice::Exception& ex)
    {
        fprintf(stderr, "%s\n", ex.toString().c_str());
    }
}

void ICEClient::destroy()
{
    if(communicator)
    {
        try
        {
            communicator->destroy();
        }
        catch(const Ice::Exception& ex)
        {
            fprintf(stderr, "%s\n", ex.toString().c_str());
        }
    }
}

void ICEClient::run()
{
    char c = EOF;
    while(c != 'x')
    {
        c = getchar();
        fprintf(stderr, "you import: %c \n", c);
        switch(c)
        {
            case 'a':
                getDir();
                break;
            case 'b':
                getFile();
                break;
            default:
                break;
        }
        IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(10)); 
    }
    EXITSTAT = false;
}

void ICEClient::getDir()
{
	try{
        ::RCI::RCISeqList dirlist;
    	twoway->getRawDataDir(dirlist); 
        fileList.clear();
    	for (int i = 0; i < dirlist.size(); i++)
		{
            fileList.push_back(dirlist[i]);
			fprintf(stderr, "FILE: %s \n",dirlist[i].c_str());
		}
    }catch(const Ice::Exception& ex){
        fprintf(stderr, "%s\n", ex.toString().c_str());
    }
}

void ICEClient::getFile()
{
	try{	
        if (fileList.empty())
        {
            return;
        }	
    	int replyid = -1;
        //本测试中只读取第一个文件传输测试
    	bool ret = twoway->getFileByConf(fileList[0],replyid); 
    	if (ret)
    	{
    		IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(100)); 
    		int rf = -1;
    		std::string file = "";
    		::RCI::RCIFileBinary filedata;
    		time_t tf= time(NULL);
    		while(twoway->nextFileData(replyid,filedata))
    		{
    			if (file!=filedata.filename||-1==rf)
    			{
    				file = filedata.filename;
    				if (-1!=rf)
    				{
    					close(rf);
    					rf = -1;
    					char buffer[256] = {0};
    					printf(buffer,"file: %s read finish\n",file.c_str());
    				}
                    #ifdef WIN32
    				rf = open(file.c_str(),O_CREAT|O_RDWR|O_BINARY);
                    #else
                    rf = open(file.c_str(),O_CREAT|O_RDWR,S_IRWXU);
                    #endif
    				if (rf<0)
    				{
    					// printf("create file failed\n" );
                        char errorbuf[256] = {0};
                        printf(errorbuf, "create file (%s) error with msg is: %s\n",file.c_str(),strerror(errno));
    					// fprintf(stderr, "create file (%s) error with msg is: %s\n",file.c_str(),strerror(errno));
    					break;
    				}else{
    					lseek(rf,0,SEEK_SET);
    					char buffer[256] = {0};
    					printf(buffer,"start read file: %s \n",file.c_str());
    				}
    			}
    			write(rf, filedata.filebuf.c_str(), filedata.buflen);
                // IceUtil::ThreadControl::sleep(IceUtil::Time::milliSeconds(1)); 
    		}
    		if (-1!=rf)
    		{
    			close(rf);
    		}
    		int ll = (int)(time(NULL) - tf);
            char buftime[256] = {0};
		    printf(buftime,"time lval = %d s\n", ll);
    	}					
	}catch(const Ice::Exception& ex){
        fprintf(stderr, "%s\n", ex.toString().c_str());
    }
}

7）编译qt工程，注意在win下，需要启动类似于Qt 4.8 64-bit for Desktop (MSVC 2010）命令窗口进入服务端和客户端运行：

qmake -o Makefile ICEClient.pro && make debug | make release(win use nmake)

qmake -o Makefile ICEServer.pro && make debug | make release(win use nmake)

8）配置IceE通信的配置文件，本文测试服务端和客户端都在一台电脑上，仅做简要配置：

服务端的config文件，放置在服务程序所在目录：

#
# The server creates one single object adapter with the name
# "RCI". The following line sets the endpoints for this
# adapter.
#
RCI.Endpoints=tcp -p 10005

#
# Warn about connection exceptions
#
Ice.Warn.Connections=1

#
# Network Tracing
#
# 0 = no network tracing
# 1 = trace connection establishment and closure
# 2 = like 1, but more detailed
# 3 = like 2, but also trace data transfer
#
#Ice.Trace.Network=1

#
# Protocol Tracing
#
# 0 = no protocol tracing
# 1 = trace protocol messages
#
#Ice.Trace.Protocol=1

客户端的config文件，放置在客户端程序所在目录：

#
# The client reads this property to create the reference to the
# "RCI" object in the server.
#
RCI.Proxy=RCI:tcp -p 10005

#
# Warn about connection exceptions
#
Ice.Warn.Connections=1

#
# Network Tracing
#
# 0 = no network tracing
# 1 = trace connection establishment and closure
# 2 = like 1, but more detailed
# 3 = like 2, but also trace data transfer
#
#Ice.Trace.Network=1

#
# Protocol Tracing
#
# 0 = no protocol tracing
# 1 = trace protocol messages
#
#Ice.Trace.Protocol=1

运行测试，在服务端执行文件下构建 data目录，放置一些测试文件，启动服务，然后在启动客户端，测试截图如下：

由此可见如果仅仅采用Zeroc-Ice的通信能力，采用IceE足够，并能快速实现跨平台、跨语言的通信交互，并 IceE也支持域名方式配置实现通信，搭建简要的云端服务也足够，喜欢的可以在此基础上进一步拓展。

py_free-物联智能
关注
专栏目录
Qt与Ice混合编程实现网络传输功能
Esonpo的专栏
08-27 2368
最近项目预研发现pc客户端与服务器之间数据传输可能需要用到Ice中间件，所以特意专门学习了下Ice中间件的编程，关于Ice的介绍网上可以搜罗，下面是我贴出来的参考文章：ICE客户端与服务器通讯
Qt调用Ice框架实现通信
xiaoxin_guoguo的博客
04-05 2888
一.Ice是什么        ICE是ZEROC的开源通信协议产品，是一个面向对象的中间件，使我们能够以最小的代价构建分布式应用程序。ICE使我们专注于应用逻辑的开发，它来处理所有底层的网络接口编程，这样我们就不用去考虑这样的细节：打开网络连接、网络数据传输的序列化与反序列化、连接失败的尝试次数等。二.在Qt中嵌入Ice框架在Qt中调用Ice通信框架时，是先启动Ice框架，再在Ice中run()...
基于ICE中间件实现的传文件
09-27
基于ICE中间件实现的传文件 InstallService UpdateService dllICE
ICE作为文件传输的方法
rockieyung的专栏
05-21 4567
ICE作为文件传输的方法杨友江2005年6月【摘要】许多客户端/服务器软件都需要在服务器和客户端之间传输文件，有许多方法可以用来传输文件，如ftp，文件共享，但是都有各自的缺点。本文描述一种使用ICE的IcePatch2服务来作为文件传输的方法，该方法特别适用于使用ICE作为开发平台的软件的文件传输。【关键词】ICE IcePatch2 文件传输一、问题的提出许多客
ZeroC ICE 文件传输
stone8761的专栏
07-10 1622
    ZeroC ICE提供一种打补丁方式，名为IcePatch2。基本功能就是通过ICE通讯将服务器上的最近软件部署到各个客户端中，这间接的实现了文件传输功能，下面就介绍基于ICE 3.7版本的IcePatch2基本操作：1、创建文件hello.txt，执行icepatch2calc(后面的'.'表示当前文件)。压缩文件并创建校验文件:$ mkdir server$ cd server$ ec...
Qt调用Ice实现一对一通信
wb175208的专栏
11-18 900
一、版本 Qt版本：Qt5.10_x64 Ice版本：3.7.4 二、效果 三、实现 1.服务端核心代码： #pragma once #include <QObject> #include <Ice/Application.h> class IceApp:public Ice::Application { public: IceApp(); ~IceApp(); virtual int run(int argc, char* argv[])override; }; #i
ICeE-开源
04-28
**正文** 标题 "ICeE-开源" 指向的是一款名为 ICeE 的开源软件，它专门设计用于管理和处理秀丽隐杆线虫（Caenorhabditis...通过提供的 ICeE_2.10 文件，用户可以下载并体验这一版本的软件，了解其具体实现和操作方式。
IceE-1.3.0.zip
01-04
ICE 是指ZeroC公司的ICE（Internet Communications Engine）中件间。对于客户端和服务端程序的开发提供了很大的便利。而IceE则是ICE的嵌入式版，在ICE的基础上进行了裁剪。本资源是IceE最早期的一个成熟版本。
Vxworks 移植icee1.3
07-08
IceE1.3.0 中间件当前版本并没有直接支持Vxworks，本文的移植是基于vxworks6.6，用 的仿真器是Wind River Workbench,版本为3.3.5。 Icee 下载网址：https://zeroc.com/downloads/archive/ice-e/1.3.0，需要下载IceE-...
ICEE’12_34_dfig_energy_Different_dfigwind_windenergy_
10-02
文件"ICEE’12_34.pdf"很可能是这篇论文的全文，包含了深入的技术细节、实验结果和性能评估。读者可以通过阅读这篇论文来了解DFIG的工作原理，不同调制技术的实施细节，以及这些技术如何影响风能转换系统的整体性能...
slice2qt ice3.5.1 qt5.30版本
10-16
qt使用ice时需要的代码转换工具。之前网上的版本最多支持到qt4.3，本版本支持qt5.3.0 ice3.5.1，应该是目前最新的版本。修改和增加的功能是手动修改的，并不一定适用所有项目，需要根据具体情况修改部分代码。
Ice二进制传输的例子
07-31
这是一个Ice的例子，可以采用string来传输二进制的图片之类的数据，非常好用，不敢独享，希望与大家共享，有问题，请联系buptxu@qq.com
QtGui接收Ice回调消息示例工程
06-03
使用QtGui界面来接收Ice服务回调的消息
ice 的样例文件
08-09
ice 的样例文件
ICEE’12_21_12.21_windenergy_SIMULINK_
09-29
标题“ICEE’12_21_12.21_windenergy_SIMULINK_”表明这是一项关于风能转换中双馈感应发电机（DFIG）高级控制的研究，且使用了MATLAB的SIMULINK工具进行模拟。描述“Advanced control of a doubly-fed induction ...
传输中间件
weixin_34332905的博客
09-25 300
传输中间件 分布式信息系统的规模越来越大，功能越来越复杂，属于不同业务部门和社会部门的系统的联系也越来越密切。在不同数据中心间进行数据共享、信息交流和协同作业的需求越来越高。数据的共享传递，信息的沟通和作业的配合需要有稳定的通道和有效的方案。传输中间件应运而生。 最早，服务于分布式应用系统的传输工具是消息中间件。 消息中间件是面向“消息”的运输管道，类似操作系统的消息队...
ICE流传输
u012498660的专栏
10-29 1993
ICE流传输 1、 使用ICE流传输 ICE会话如下： 步骤一：初始化pj_ice_stans_cfg结构。 步骤二：通过pj_ice_strans_create()函数创建ice实例；该函数主要需要下列参数： a、pj_ice_strans_cfg参数--配置参数（控制是否收集候选地址）； b、支持组件数--组件总数（暂时理解为2，一为音频一为视频）； c、pj_ice_stra
Ice简介+Qt代码示例
weixin_30409849的博客
04-15 581
1、ICE是什么？ ICE是ZEROC的开源通信协议产品，它的全称是：The Internet Communications Engine，翻译为中文是互联网通信引擎，是一个面向对象的中间件，它封装并实现了底层的通讯逻辑，使我们能够方便的构建分布式应用程序。相对于只面向WINDOWS系统微软的.NET（以及原来的DCOM）、复杂的CORBA及性能较差的WEB SERVICE...
提升认知Ad Hoc网络效率：ICEE路由算法与干扰能量优化
PU）的干扰约束，确保不会对已分配的频谱资源造成过多干扰，而且还考虑到了CR节点自身数据传输的持续时间限制，这样可以减少因频繁切换频道而引发的传输中断，从而节省了用于故障重传的能量。 在路由算法的设计上...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

py_free-物联智能

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值