四、ICE服务——RUNTIME核心代码

1  通信器 Ice::Communicator

2  对象适配器

3  Ice::Current 对象

4 Servant 定位器

5 RUNTIME 使用实例

通信器 Ice::Communicator 

Ice run time 的主进入点由本地接口 Ice::Communicator 表示。

Ice::Communicator 的一个实例与一些运行时资源是关联在一起的：

•客户端线程池

•服务器端线程池

•配置属性

•一个日志记录器对象

•一个统计对象

•一个缺省路由器

•一个缺省定位器

•一个插件管理器

•对象适配器

•module Ice {

     local interface Communicator

   {

       string proxyToString(Object* obj);

       Object* stringToProxy(string str);

       ObjectAdapter createObjectAdapter(string name);

       ObjectAdapter createObjectAdapterWithEndpoints(

       string name,

       string endpoints);

       void shutdown();

       void waitForShutdown();

       void destroy()；

  }

  };

对象适配器 

一个通信器含有一个或更多对象适配器。对象适配器处在 Ice run time

和服务器之间的界线上，负有这样一些责任：

• 它把Ice对象映射到到来请求的servant，并把请求分派给每个servant中的

应用代码 （也就是说，对象适配器实现了一个向上调用接口，把 Ice run time 与服务器中的应用代码连接在一起）。

• 它协助进行生命周期操作，使得Ice对象和servant在创建和销毁时不会出

现竞争状况。

• 它提供一个或更多传输端点。客户通过这些端点访问适配器所提供的 Ice

对象 （创建没有端点的对象适配器也是可能的。这样的适配器被用于

双向回调）

•活动 Servant 映射表 

对象适配器

module Ice {

local interface ObjectAdapter {

string getName();

Communicator getCommunicator();

Object* add(Object servant, Identity id);

Object* addWithUUID(Object servant);

void remove(Identity id);

void activate();

void hold();

void waitForHold();

void deactivate();

};

};

Ice::Current 对象 作为服务器端的每个骨架操作的最后一个参数

module Ice {

  local dictionary<string, string> Context;

  enum OperationMode { Normal, \Nonmutating, \Idempotent };

  local struct Current {

  ObjectAdapter adapter;

  Identity id;

  FacetPath facet;

  string operation;

  OperationMode mode;

  Context ctx;

};

};

• 定位器的引入场景

• Servant 定位器的线程保证

• 接口 API

module Ice {

local interface ServantLocator {

Object locate( Current curr,out LocalObject cookie);

void finished( Current curr,Object servant,LocalObject cookie);

void deactivate();

};

};

Servant 定位器注册

module Ice {

local interface ObjectAdapter {

void addServantLocator(ServantLocator locator,

string category);

ServantLocator findServantLocator(string category);

// ...

};

};

RUNTIME 使用实例

 #include <IceBox/IceBox.h>

#include <Ice/Ice.h>

#include <Freeze/Freeze.h>

class AbstractIceBoxService : public ::IceBox::Service

{

public:

  AbstractIceBoxService();

  virtual void start(const ::std::string& , const ::Ice::CommunicatorPtr&, const ::Ice::StringSeq&);

  virtual void stop();

•

private:

  ::Ice::ObjectAdapterPtr _adapter;

  ::Ice::CommunicatorPtr _communicator;

  virtual void startIceService(const Ice::StringSeq args,std::map<std::string,::IceInternal::Handle<Ice::Object> >& objmap) = 0;

  virtual void stopIceService(std::map<std::string,::IceInternal::Handle<Ice::Object> >& objmap) = 0;  std::map<std::string,::IceInternal::Handle<Ice::Object> >m_ServObjmap; 

  std::string m_strVerSion;

};

RUNTIME 使用实例 

void AbstractIceBoxService::start(const string& name, const Ice::CommunicatorPtr& communicator, const Ice::StringSeq& args)

{

    _adapter = communicator->createObjectAdapter(name);

    .......

    startIceService(args,m_ServObjmap);

   char ServName[256] ={0};

  std::map<std::string,::IceInternal::Handle<Ice::Object> >::iterator itr =  m_ServObjmap.begin();  

  while( itr !=  m_ServObjmap.end())

{

        memset(ServName, 0,sizeof(ServName)); 

        snprintf(ServName, sizeof(ServName), "%s%s",itr->first.c_str(),m_strVerSion.c_str());

        _adapter->add(itr->second, communicator->stringToIdentity(ServName));

       ++itr;  }

    _adapter->activate();

    return;

}

class OrderServiceInitException {};

•

class OrderServiceI : public AbstractIceBoxService

{

public:

  OrderServiceI();

private:

RUNTIME 使用实例 

  void InitService()throw (OrderServiceInitException);

•

  virtual void startIceService(const Ice::StringSeq args,std::map<std::string,::IceInternal::Handle<Ice::Object> >& objmap) ;

  virtual void stopIceService(std::map<std::string,::IceInternal::Handle<Ice::Object> >& objmap);

•

  static void* monitor(void* param);

•

};

RUNTIME 使用实例 

ICE_DECLSPEC_EXPORT IceBox::Service*create(Ice::CommunicatorPtr)

{

  return new OrderServiceI;

}

void OrderServiceI::startIceService(const Ice::StringSeq args,std::map<std::string,::IceInternal::Handle<Ice::Object> >& objmap)

{

     InitService(); 

    segi::servcieOrder::tempqueryserver::TemplateQueryPtr TQueryPtr = new TemplateQueryI();

    objmap.insert(std::pair<string ,::IceInternal::Handle<Ice::Object> >("segi.servcieOrder.tempqueryserver.TemplateQuery",TQueryPtr));

   segi::servcieOrder::orderhandleserver::OrderHandlePtr OHandlePtr = new OrderHandleI();

   objmap.insert(std::pair<string ,::IceInternal::Handle<Ice::Object> >("segi.servcieOrder.orderhandleserver.OrderHandle",OHandlePtr));

   segi::servcieOrder::orderqueryserver::OrderQueryPtr OQueryPtr = new OrderQueryI();

   objmap.insert(std::pair<string ,::IceInternal::Handle<Ice::Object> >("segi.servcieOrder.orderqueryserver.OrderQuery",OQueryPtr));

    segi::servcieOrder::Compatibleserver::CompatibleInterfacePtr OCompatibleInterfacePtr = new CompatibleInterfaceI();

    objmap.insert(std::pair<string ,::IceInternal::Handle<Ice::Object>>("segi.servcieOrder.Compatibleserver.CompatibleInterface",OCompatibleInterfacePtr));

   segi::servcieOrder::ordersaveserver::OrderConsumePtr OOrderConsumePtr = new COrderConsumeI();

   objmap.insert(std::pair<string ,::IceInternal::Handle<Ice::Object>>("segi.servcieOrder.ordersaveserver.OrderConsume",OOrderConsumePtr));

}