Ice笔记--服务端的Slice-to-C++

namespace Ice
{
   class Application
   {
    public:
       Application();
       virtual ~Application();
       int main(int, char * [], const char * = 0);
       virtual int run(int, char * []) = 0;
       static const char * appName();
       static CommunicatorPtr communicator();
       // ...
    };
}

        2.2）实现并使用继承自Ice::application的子类

          Ice::Application 能够确保你的程序适当地结束Ice run time，不管服务器是正常终止，还是因为对异常或信号作出响应而终止的。因此建议在所有应用程序中使用这个类。

         其程序代码的实现大致如下：          

#include <Ice/Ice.h>
 
class MyApplication : virtual public Ice::Application {
public:
    virtual int run(int, char * [])
    {
    // Server code here...
    return 0;
    }
};
 
int main(int argc, char * argv[])
{
    MyApplication app;
    return app.main(argc, argv);
}

       2.3）使用Ice::Service类

          相对于Ice::application类来说，建议使用Ice::Service的情况会比较少。当应用可能需要作为Unix 看守（daemon）或Win32 服务运行在系统一级时，Ice::Service可以提供相关功能实现。

          这里不再详细介绍Ice::Service。详细资料可以参考 《Ice-1.3.0_cn.pdf》第10章中的内容。

二、接口的映射

   1）骨架类

    在客户端，接口映射到代理类（参见5.12 节）。在服务器端，接口映射到骨架类。对于相应的接口上的每个操作，骨架类都有一个对应的纯虚方法。

    例如，有一个Node接口的定义：

module Filesystem
{
    interface Node
    {
        nonmutating string name();
    };
    // ...
};

 Slice 编译器为这个接口生成这样的定义：

namespace Filesystem
{
    class Node : virtual public   Ice::Object
    {
    public:
    virtual std::string name(const Ice::Current & = Ice::Current()) const = 0;
    // ...
    };
    // ...
}

   下面是骨架类的几点特性：

    • 和客户端一样，Slice 模块映射到名字相同的C++ 名字空间，所以骨架类定义会放在名字空间Filesystem 中。

    • 骨架类的名字与Slice 接口的名字（Node）相同。

    • 对于Slice 接口中的每个操作，骨架类都有一个对应的纯虚成员函数。

    • 骨架类是抽象基类，因为它的成员函数是纯虚函数。

    • 骨架类继承自Ice::Object （这个类形成了Ice 对象层次的根）。

   2）Servant类

   要给Ice 对象提供实现，我们必须创建servant 类，继承对应的骨架类。例

   如，要为Node 接口创建servant，可以编写：

#include <Filesystem.h> // Slice-generated header
class NodeI : public virtual Filesystem::Node
{
public:
    NodeI(const std::string &);
    virtual std::string name(const Ice::Current &) const;
private:
    std::string _name;
};

       2.1）实例化servant

         首先在堆上创建一个显得NodeI实例，把它的地址赋值给类型为NodeIPtr的智能指针：

typedef IceUtil::Handle<NodeI> NodeIPtr; 
NodeIPtr servant = new NodeI("Fred"); 

        使用智能指针的好处是避免偶然发生内存泄露。

      2.2）创建标识

        每一个Ice对象都需要一个标识。在使用同一个对象适配器的所有servant中，该标识必须是唯一的。Ice 对象标识是一种结构，下面是它的Slice 定义： 

module Ice{  
	struct Identity   
	{//对象的完整标识由Identity 的name 和category 域组成       
		string name;    
		string category;  
	};   
	// ...
}; 

     2.3）激活servant

        只有在你显式地把servant 告知对象适配器之后， Ice run time 才会知道这个servant 的存在。要激活servant，就要调用对象适配器的add 操作：

void activateServant(const string & name){  
	NodePtr servant = new NodeI(name); // Refcount == 1  
	Ice::Identity id;   
	id.name = name;   
	_adapter->add(servant, id); // Refcount == 2
} // Refcount == 1

调用对象适配器的add 操作，会把servant 指针和servant 的标识增加到适配器的servant 映射表中，并把“Ice 对象的代理”与“服务器内存中的正确的servant 实例”链接在一起。

        同时Ice也提供了addwithUUID()函数，只要一步，就可以生成一个UUID、并把servant 增加到servant 映射表中。这样就避免了额外创建标识的操作。重写上面的函数

void activateServant(const string & name){  
	NodePtr servant = new NodeI(name); 
	_adapter->addWithUUID(servant);
}

   2.4）创建代理

       一旦我们激活了Ice 对象的servant，服务器就可以处理针对这个对象的客户请求了。但是，只有拥有了对象的代理，客户才能访问该对象。

       而象适配器含有创建代理所需的全部详细资料：寻址信息和协议信息，还有对象标识。对象适配器的add 和addWithUUID servant 激活操作会返回对应的Ice 对

       象的一个代理。这意味着，我们可以编写：

typedef IceUtil::Handle<NodeI>NodeIPtr;
NodeIPtr servant = new NodeI(name);
NodePrx proxy = NodePrx::uncheckedCast(_adapter->addWithUUID(servant));
// Pass proxy to client...

        在此我们需要使用uncheckedCast，因为addWithUUID 返回的代理的类型是Ice::ObjectPrx。

三、传递参数和抛出异常

   1）参数传递

      服务器端的参数传递所遵循的规则和客户端一样：

          • in 参数通过值或const 引用传递。

          • out 参数通过引用传递。

          • 返回值通过值传递。

      例子说明：

interface Example
{
    string op(string sin, out string sout);
};

为这个接口生成的骨架类：

class Example : virtual public ::Ice::Object
{
public:
    virtual std::stringop(const std::string &, std::string &,
    const Ice::Current & = Ice::Current()) = 0;
    // ...
};

    2）引发异常

        要从操作实现中抛出异常，你只需实例化异常，初始化，然后抛出它。例如：

void Filesystem::FileI::write(const Filesystem::Lines & text,const Ice::Current &)
{   
	// Try to write the file contents here...   
	// Assume we are out of space...  
	if (error) 
	{      
		Filesystem::GenericError e;    
		e.reason = "file too large";    
		throw e;   
	}
};