1、ICE是什么？
ICE是ZEROC的開源通信協議產品，它的全稱是：The Internet Communications Engine，翻譯為中文是互聯網通信引擎，是一個面向物件的中間件，它封裝并實作了底層的通訊邏輯，使我們能夠方便的構建分布式應用程式，相對于只面向WINDOWS系統微軟的.NET（以及原來的DCOM）、復雜的CORBA及性能較差的WEB SERVICE等分布式方案，ICE很好的解決了這些中間件的不足：它支持不同的系統，如WINDOWS、LINUX等，支持在多種開發語言上使用，如C++、C、JAVA、RUBY、PYTHON、VB等，服務端可以是上面提到的任何一種語言實作的，客戶端也可以根據自己的實際情況選擇不同的語言實作，如服務端采用C語言實作，而客戶端采用JAVA語言實作等，
2: ICE的安裝和示例
2.1 ICE安裝
ICE官網：https://zeroc.com,點擊download后選擇合適的平臺/開發環境即可,Ubuntu18.04的安裝如下圖，
notes: 注意ICE3.7.2與3.6.x版本差異較大，頭檔案不互相兼容，選用時需注意客戶端/服務端ICE版本的一致性，避免代碼無法編譯通過，
2.2： hello world代碼示例
官網的helloworld程式，詳見官網目錄https://doc.zeroc.com/ice/3.7/hello-world-application
首先創建一個slice檔案Printer.ice，并將程式需要遠程呼叫的介面寫入其中，對于hello world程式，slice檔案可按如下來寫：
module Demo { interface Printer { void printString(string s); } }
下面我們以C++（c++11）為例，分別實作服務端和客戶端，首先，我們使用slice2cpp將ice檔案轉換成C++可使用的.h和.cpp檔案，其中.h檔案中包含了我們需要遠程呼叫的介面定義以及ICE封裝，最主要的有Printer和PrinterPrx類，分別是服務端需要實作的具體物件和客戶端使用的代理，其中PrinterPrx代理類中還提供了printStringAsync異步呼叫方法，
slice2cpp Printer.ice
服務端需要實作Printer類的介面，并創建本地創建，之后添加到ice配接器上，以便客戶端遠程呼叫，具體實作代碼如下：
#include <Ice/Ice.h> #include <Printer.h> using namespace std; using namespace Demo; class PrinterI : public Printer { public: virtual void printString(string s, const Ice::Current&) override; }; void PrinterI::printString(string s, const Ice::Current&) { cout << s << endl; } int main(int argc, char* argv[]) { try { Ice::CommunicatorHolder ich(argc, argv); auto adapter = ich->createObjectAdapterWithEndpoints("SimplePrinterAdapter", "default -h localhost -p 10000"); auto servant = make_shared<PrinterI>(); adapter->add(servant, Ice::stringToIdentity("SimplePrinter")); adapter->activate(); ich->waitForShutdown(); } catch(const std::exception& e) { cerr << e.what() << endl; return 1; } return 0; }
客戶端需要創建遠程物件的代理，并通過代理進行遠程呼叫，代碼如下：
#include <Ice/Ice.h> #include <Printer.h> #include <stdexcept> using namespace std; using namespace Demo; int main(int argc, char* argv[]) { try { Ice::CommunicatorHolder ich(argc, argv); auto base = ich->stringToProxy("SimplePrinter:default -p 10000"); auto printer = Ice::checkedCast<PrinterPrx>(base); if(!printer) { throw std::runtime_error("Invalid proxy"); } printer->printString("Hello World!"); } catch(const std::exception& e) { cerr << e.what() << endl; return 1; } return 0; }
上面的demo演示了ice遠程呼叫的基本作業方式，ICE介面的詳細解釋既可通過ICE官網查看，也可在安裝ICE后查看相應的頭檔案注釋，然而實際工程中我們需要對ice進行配置，處理網路例外，在服務端進行回呼，穿透防火墻，進行執行緒調度等作業，雖然在ICE的chat demo中有介紹這些作業，然而其demo中引入了Glacier2 rooter中session的使用，而github中代碼復雜度更高，相反，以上這些作業不通過Glacier2 rooter也能完美的解決，詳見如下代碼及注釋，
完整可運行的Qt工程（可復用的ICE通信模板）可參考https://github.com/leaf-yyl/ice_template
ICE 檔案： 定義了一個服務端需要提供的服務 以及一個客戶端需要的回呼
module Demo { interface ServerService { void requireService(string ident, string s); } interface ClientCallback { void callback(string s); } }
server端代碼 ： 服務器端worker物件提供具體的服務， ice_manager物件負責ic模塊的管理，并接收客戶端請求，這些請求會在不同的ICE執行緒中接收到，然后通過postevent函式最終全部轉發到
worker的作業執行緒并依序處理，如果提供的服務是執行緒安全的且需要高并發，那么可以去除這一步以獲得高性能，相反，如果worker提供的服務不是執行緒安全的，或者worker中存在執行緒相關的資源
（例如python解釋器等），則必須通過事件回圈或者訊息佇列將ICE執行緒收到的客戶端請求匯總到worker執行緒統一處理，
#include <QEvent> #include <QObject> #include <QCoreApplication> #include <stdexcept> #include <Ice/Ice.h> #include "Printer.h" using namespace std; class CustomEvent : public QEvent { public: explicit CustomEvent(Type type) :QEvent(type) { } enum PMAlgoEventType { CustomEvent_RequireService = 0x00000001, }; string m_params; Demo::ClientCallbackPrxPtr m_callback; }; class ServerI : public Demo::ServerService { public: ServerI(){} /* Use event loop implement in QObject by Qt to post client requirements to user thread. * May be replaced by event loop in pure C++, handler in java and so on. */ void setImplement(QObject *implement) { m_implement = implement; } void requireService(string ident, string s, const ::Ice::Current& current) override { /* we donot generate the client requirement here, but post it to main thread as this function is called in ice server threads. * When the interface is not thread safe or time-consuming, or has thread associated context like python interpreter, we must post * it to a constant thread managered by ourself to avoid running exceptions. * ident : client object identification, used to build bidirectional connection to cross firewall and local network * s : params used for servcie */ CustomEvent *e = new CustomEvent(QEvent::Type(QEvent::User + CustomEvent::CustomEvent_RequireService)); e->m_params = s; e->m_callback = Ice::uncheckedCast<Demo::ClientCallbackPrx>(current.con->createProxy(Ice::stringToIdentity(ident))); QCoreApplication::postEvent(m_implement, e); } private: QObject *m_implement; }; class IceManager { public: IceManager() { /* set up global ice configurations, here we just set thread pool to 2 to avoid deadlock on ice callback, * other settings are configurable as the same. */ Ice::PropertiesPtr props0 = Ice::createProperties(); props0->setProperty("Ice.ThreadPool.Server.Size", "2"); props0->setProperty("Ice.ThreadPool.Server.SizeMax", "2"); props0->setProperty("Ice.ThreadPool.Client.Size", "2"); props0->setProperty("Ice.ThreadPool.Client.SizeMax", "2"); props0->setProperty("Ice.Trace.ThreadPool", "1"); Ice::InitializationData id; id.properties = props0; m_ich = Ice::CommunicatorHolder(id); } bool setImplement(QObject *implement) { try { /* create server object and add it to ice adapter to receive client requirements. * The adapter identification is used for ice pack service, we donot use it now. * The endpoints is the location url where client can access to require service. * The servant identification is used to identify servant as we can add multiple servants to one adapter. */ shared_ptr<ServerI> servant = make_shared<ServerI>(); servant->setImplement(implement); auto adapter = m_ich->createObjectAdapterWithEndpoints("ServerAdapter", "default -h localhost -p 10000"); adapter->add(servant, Ice::stringToIdentity("Server")); adapter->activate(); } catch (const exception &e) { cout << "Failed to create ice server object, error-->%s" << e.what() << endl; return false; } return true; } private: Ice::CommunicatorHolder m_ich; }; class MainWorker : public QObject { public: MainWorker(QObject *parent = nullptr) : QObject(parent) {} protected: /* Receive client requirements and deliver to associated servcie function */ void customEvent(QEvent *e) { CustomEvent *event = (CustomEvent *)e; int type = event->type() - QEvent::User; if (CustomEvent::CustomEvent_RequireService == type) { renderService(event->m_params, event->m_callback); } else { cout << "Unrecognized event type-->" << type << "!" << endl; } } private: /* a simple implement */ void renderService(const string& s, const Demo::ClientCallbackPrxPtr& callback) { cout << s << endl; callback->callback("Requirement done!"); } }; int main(int argc, char *argv[]) { QCoreApplication a(argc, argv); MainWorker worker(&a); IceManager ice_manager; ice_manager.setImplement(&worker); return a.exec(); }
client端 頭檔案代碼：客戶端基本上與服務端類似， 但是多了一個主動發起請求的IceRequirer類，并在IceRequirer中設定鏈接引數等創建保活的ICE鏈接，達到與服務端的雙向通信，具體原因
見代碼注釋，
#ifndef HELPER_H #define HELPER_H #include <QTimer> #include <QEvent> #include <QObject> #include <QThread> #include <QCoreApplication> #include <stdexcept> #include <Ice/Ice.h> #include "Printer.h" using namespace std; /* custom event used for event loop */ class CustomEvent : public QEvent { public: explicit CustomEvent(Type type) :QEvent(type) {} enum PMAlgoEventType { CustomEvent_RequireCallback = 0x00000001, }; string m_params; }; class ClientI : public Demo::ClientCallback { public: ClientI(){} /* Use event loop implement in QObject by Qt to post client requirements to user thread. * May be replaced by event loop in pure C++, handler in java and so on. */ void setImplement(QObject *implement) { m_server_implement = implement; } void callback(string s, const ::Ice::Current&) override { /* we donot generate the client requirement here, but post it to main thread as this function is called in ice server threads. * When the interface is not thread safe or time-consuming, or has thread associated context like python interpreter, we must post * it to a constant thread managered by ourself to avoid running exceptions. * s : params used for servcie */ CustomEvent *e = new CustomEvent(QEvent::Type(QEvent::User + CustomEvent::CustomEvent_RequireCallback)); e->m_params = s; QCoreApplication::postEvent(m_server_implement, e); } private: QObject *m_server_implement; }; class ServerRequirer : public QObject { Q_OBJECT public: explicit ServerRequirer(const Ice::CommunicatorHolder &ich, const Ice::ObjectAdapterPtr &adapter, const string& ident) { m_ic = ich.communicator(); m_adapter = adapter; m_ident = ident; } public slots: void slot_requireServcie(const string& s) { if (nullptr == m_server_prx.get()) { /* connection is not established, try to establish connection first */ try { auto base = m_ic->stringToProxy("Server:default -h localhost -p 10000"); m_server_prx = Ice::checkedCast<Demo::ServerServicePrx>(base); if(nullptr != m_server_prx.get()) { /* set up eseential configurations on Ice connection to keep this connection alive */ m_server_prx->ice_getConnection()->setACM(Ice::nullopt, Ice::ACMClose::CloseOff, Ice::ACMHeartbeat::HeartbeatAlways); m_server_prx->ice_getConnection()->setAdapter(m_adapter); } } catch(const exception& e) { cerr << e.what() << endl; } } if (nullptr != m_server_prx.get()) { try { /* require remote object call via object proxy */ m_server_prx->requireService(m_ident, s); } catch(const exception& e) { /* connection lost, reset it and re-establish it on next call */ cerr << e.what() << endl; m_server_prx.reset(); } } } private: string m_ident; Ice::CommunicatorPtr m_ic; Ice::ObjectAdapterPtr m_adapter; Demo::ServerServicePrxPtr m_server_prx; }; class IceManager : public QThread { Q_OBJECT public: /* Craete ice global communicator and manager ice requirement. * Server requirements are posted in seperate thread as they may be time-consuming * Local object that implements callback is identified through bidirectional connection instead of * creating a new connection fron server to client, as client may be defensed behind firewall or local network. */ IceManager() { /* register qt meta type */ qRegisterMetaType<string>("string"); /* set up global ice configurations, here we just set thread pool to 2 to avoid deadlock on ice callback, * other settings are configurable as the same. */ Ice::PropertiesPtr props0 = Ice::createProperties(); props0->setProperty("Ice.ThreadPool.Server.Size", "2"); props0->setProperty("Ice.ThreadPool.Server.SizeMax", "2"); props0->setProperty("Ice.ThreadPool.Client.Size", "2"); props0->setProperty("Ice.ThreadPool.Client.SizeMax", "2"); props0->setProperty("Ice.Trace.ThreadPool", "1"); /* create global ice communicator */ Ice::InitializationData id; id.properties = props0; m_ich = Ice::CommunicatorHolder(id); } bool start(QObject *implement) { try { /* create client object and add it to ice adapter to receive server callbacks. * The adapter is created without identification as we donot access it by endpoints. * Instead, we pass it through the connection established with server to build a bidirectional connection. */ m_ident = "Client"; shared_ptr<ClientI> servant = make_shared<ClientI>(); servant->setImplement(implement); m_adapter = m_ich->createObjectAdapter(""); m_adapter->add(servant, Ice::stringToIdentity(m_ident)); m_adapter->activate(); } catch (const exception &e) { cout << "Failed to create ice object, error-->%s" << e.what() << endl; return false; } /* create ice service requirer in seperate thread, as network request may be time-consuming */ m_requirer = new ServerRequirer(m_ich, m_adapter, m_ident); m_requirer->moveToThread(this); connect(this, SIGNAL(signal_requireService(string)), m_requirer, SLOT(slot_requireServcie(string))); QThread::start(); return true; } public slots: void slot_requireService() { string s("Hello world!"); emit signal_requireService(s); } signals: void signal_requireService(string s); private: Ice::CommunicatorHolder m_ich; Ice::ObjectAdapterPtr m_adapter; string m_ident; /* local object identification */ ServerRequirer *m_requirer; }; class MainWorker : public QObject { public: MainWorker(QObject *parent = nullptr) : QObject(parent) {} protected: /* Receive callbacks from server and deliver to associated callback function */ void customEvent(QEvent *e) { CustomEvent *event = (CustomEvent *)e; int type = event->type() - QEvent::User; if (CustomEvent::CustomEvent_RequireCallback == type) { renderCallback(event->m_params); } else { cout << "Unrecognized event type-->" << type << "!" << endl; } } private: /* a simple implement */ void renderCallback(const string& s) { cout << s << endl; } }; #endif // HELPER_H
client main檔案代碼
#include "helper.h" int main(int argc, char *argv[]) { QCoreApplication a(argc, argv); /* local worker */ MainWorker worker(&a); /* ice service manager */ IceManager ice_manager; ice_manager.start(&worker); /* require serve service every 3 seconds */ QTimer timer; QObject::connect(&timer, SIGNAL(timeout()), &ice_manager, SLOT(slot_requireService())); timer.start(3 * 1000); return a.exec(); }
轉載請註明出處，本文鏈接：https://www.uj5u.com/qita/213776.html
標籤：其他