ZeroC ICE的远程调用框架

想搞清楚slice为我们生成了什么样的框架代码，就先搞明白Ice的远程调用框架暗中为我们做了些什么？

Ice将Ice Object的方法调用分为三个阶段（或步骤），分别是begin，process和end。如下图：

或者说Ice将一次完整的Ice Object方法调用划分成上面三个阶段。基于上面的划分，又将三个阶段应用到远程调用中。其中将begin和end阶段应用在Object Proxy端，而process阶段应用在Object Servant端。远程调用实质在应用ActiveObject模式，模式有两个角色分别是代理Proxy以及主动对象ActiveObject。之所以叫主动对象，是因为对象的执行不在控制线程上，而是有自己专有的线程去执行它的方法。访问主动对象，只能通过其代理在调用方的控制线程上向主动对象发出调用请求。由于应用了ActiveObject模式，调用方和对象执行不在同一线程（，包括不同主机上的线程）。因此产生了同步和异步的问题。所以同样需要应用Future模式。而这个Future的实现就由AsyncResult来担当。

现在我们就很清楚slice会为我们生成哪些框架性的代码了。

slice为我们生成上面三阶段的框架代码，begin，process和end三个阶段。begin和end阶段的代码放在代理端（Proxy），也就是stub存根；而process阶段的代码放在饲服端（Servant），也就是skeleton骨架。

毫无疑问地，begin阶段的框架代码就是为我们完成如何将请求包装成消息包，并发送出去。end阶段的框架代码就是为我们完成如何将回来的响应拆装出结果。所以每一个接口方法，都会在stub类生成一个_iceI_begin_Method的方法，以及五个简单包装使用它的参数重载版本begin_Method的方法，一个end_Method的方法，最后还有一个调用的简易版本Method，这个简易版本的Method只是简单地在使用end_Method(begin_Method())。你也可以自行组织begin和end阶段的函数来完成一次请求。

process阶段的框架代码理所当然地会放在skeleton端。为什么叫做skeleton骨架，那看它为我们完成了什么工作。它为我们提供了一个_iceDispatch分派调用的函数，它将请求分派到目标的接口方法入口，并交给接口方法的实现体去执行调用。换句话说，每个接口方法，都会在skeleton类生成一个_iceD_Method的入口成员函数，以及一个空的Method虚成员函数。_iceD_Method为我们完成请求参数的拆装，以及输出参数的准备，然后调用Method虚成员函数，最后将结果包装成响应消息包。在这个skeleton骨架中，我们要做的就是如何去实现虚成员函数Method。我们从生成的函数名字就可以加深印象，_iceD_Method就是由_iceDispatch分派调用请求时调用到的入口，这个入口又为我们完成几个框架步骤的工作，并调用我们的实现的虚函数。

另外一点要注意，在上面说到的框架并没有涉及网络的通讯操作（发送，接收或侦听）。因为网络服务是由Communicator提供，并不是调用框架的一部分，而框架依赖的环境的一个服务。

还有一点要注意的是，返回结果和out方向的参数并不是分开特别看待的，返回结果与out方向的参数都是响应消息中的payload，请参数《ZeroC ICE的协议》，encpas部分。返回结果是默认是第一个out方向参数，我们所有定义的out方向参数都向后顺延一个位置。

每个skeleton骨架类都会为我们自动实现ice_id，ice_ids，ice_isA和ice_ping接口方法。

下面是以Ice项目包中test/acm为例的代码参考：

::Test::TestIntfPrx getTestIntf(const ::Ice::Context& context = ::Ice::noExplicitContext)
    {
        return end_getTestIntf(_iceI_begin_getTestIntf(context, ::IceInternal::dummyCallback, 0, true));
    }

    ::Ice::AsyncResultPtr begin_getTestIntf(const ::Ice::Context& context = ::Ice::noExplicitContext)
    {
        return _iceI_begin_getTestIntf(context, ::IceInternal::dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_getTestIntf(const ::Ice::CallbackPtr& del, const ::Ice::LocalObjectPtr& cookie = 0)
    {
        return _iceI_begin_getTestIntf(::Ice::noExplicitContext, del, cookie);
    }

    ::Ice::AsyncResultPtr begin_getTestIntf(const ::Ice::Context& context, const ::Ice::CallbackPtr& del, const ::Ice::LocalObjectPtr& cookie = 0)
    {
        return _iceI_begin_getTestIntf(context, del, cookie);
    }

    ::Ice::AsyncResultPtr begin_getTestIntf(const ::Test::Callback_RemoteObjectAdapter_getTestIntfPtr& del, const ::Ice::LocalObjectPtr& cookie = 0)
    {
        return _iceI_begin_getTestIntf(::Ice::noExplicitContext, del, cookie);
    }

    ::Ice::AsyncResultPtr begin_getTestIntf(const ::Ice::Context& context, const ::Test::Callback_RemoteObjectAdapter_getTestIntfPtr& del, const ::Ice::LocalObjectPtr& cookie = 0)
    {
        return _iceI_begin_getTestIntf(context, del, cookie);
    }

    ::Test::TestIntfPrx end_getTestIntf(const ::Ice::AsyncResultPtr&);
    
private:

    ::Ice::AsyncResultPtr _iceI_begin_getTestIntf(const ::Ice::Context&, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr& cookie = 0, bool sync = false);
    

::Ice::AsyncResultPtr
IceProxy::Test::RemoteObjectAdapter::_iceI_begin_getTestIntf(const ::Ice::Context& context, const ::IceInternal::CallbackBasePtr& del, const ::Ice::LocalObjectPtr& cookie, bool sync)
{
    _checkTwowayOnly(iceC_Test_RemoteObjectAdapter_getTestIntf_name, sync);
    ::IceInternal::OutgoingAsyncPtr result = new ::IceInternal::CallbackOutgoing(this, iceC_Test_RemoteObjectAdapter_getTestIntf_name, del, cookie, sync);
    try
    {
        result->prepare(iceC_Test_RemoteObjectAdapter_getTestIntf_name, ::Ice::Normal, context);
        result->writeEmptyParams();
        result->invoke(iceC_Test_RemoteObjectAdapter_getTestIntf_name);
    }
    catch(const ::Ice::Exception& ex)
    {
        result->abort(ex);
    }
    return result;
}

::Test::TestIntfPrx
IceProxy::Test::RemoteObjectAdapter::end_getTestIntf(const ::Ice::AsyncResultPtr& result)
{
    ::Ice::AsyncResult::check(result, this, iceC_Test_RemoteObjectAdapter_getTestIntf_name);
    ::Test::TestIntfPrx ret;
    if(!result->waitForResponse())
    {
        try
        {
            result->throwUserException();
        }
        catch(const ::Ice::UserException& ex)
        {
            throw ::Ice::UnknownUserException(__FILE__, __LINE__, ex.ice_id());
        }
    }
    ::Ice::InputStream* istr = result->startReadParams();
    istr->read(ret);
    result->endReadParams();
    return ret;
}

bool
Test::RemoteObjectAdapter::_iceDispatch(::IceInternal::Incoming& in, const ::Ice::Current& current)
{
    ::std::pair<const ::std::string*, const ::std::string*> r = ::std::equal_range(iceC_Test_RemoteObjectAdapter_all, iceC_Test_RemoteObjectAdapter_all + 8, current.operation);
    if(r.first == r.second)
    {
        throw ::Ice::OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
    }

    switch(r.first - iceC_Test_RemoteObjectAdapter_all)
    {
        case 0:
        {
            return _iceD_activate(in, current);
        }
        case 1:
        {
            return _iceD_deactivate(in, current);
        }
        case 2:
        {
            return _iceD_getTestIntf(in, current);
        }
        case 3:
        {
            return _iceD_hold(in, current);
        }
        case 4:
        {
            return _iceD_ice_id(in, current);
        }
        case 5:
        {
            return _iceD_ice_ids(in, current);
        }
        case 6:
        {
            return _iceD_ice_isA(in, current);
        }
        case 7:
        {
            return _iceD_ice_ping(in, current);
        }
        default:
        {
            assert(false);
            throw ::Ice::OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
        }
    }
}

bool
Test::RemoteObjectAdapter::_iceD_getTestIntf(::IceInternal::Incoming& inS, const ::Ice::Current& current)
{
    _iceCheckMode(::Ice::Normal, current.mode);
    inS.readEmptyParams();
    ::Test::TestIntfPrx ret = this->getTestIntf(current);
    ::Ice::OutputStream* ostr = inS.startWriteParams();
    ostr->write(ret);
    inS.endWriteParams();
    return false;
}

class RemoteObjectAdapter : public virtual ::Ice::Object
{
public:

   // ...

    virtual ::Test::TestIntfPrx getTestIntf(const ::Ice::Current& = ::Ice::noExplicitCurrent) = 0;
    bool _iceD_getTestIntf(::IceInternal::Incoming&, const ::Ice::Current&);

    // other generated code by slice

    virtual bool _iceDispatch(::IceInternal::Incoming&, const ::Ice::Current&);

protected:

    virtual void _iceWriteImpl(::Ice::OutputStream*) const;
    virtual void _iceReadImpl(::Ice::InputStream*);
};

我们除了使用slice为我们生成的stub类的begin和end函数来进行Ice Object的请求调用外，还可以使用::IceProxy::Ice::object提供的通常版本ice_invoke来完成调用。ice_invoke也是分为begin和end两个阶段，分别对应有函数begin_ice_invoke以及end_ice_invoke。之所以是通用版本，是因为你必须要构建Operation对象，而且接受的参数并不是不逐个逐个地接受的，而是作为两条序列化的流。也就是说，如果使用invoke版本来进行请求调用，你必须手动完成参数的序列包装，和结果的反序列拆装。

bool
IceProxy::Ice::Object::ice_invoke(const string& operation,
                                  OperationMode mode,
                                  const vector<Byte>& inEncaps,
                                  vector<Byte>& outEncaps,
                                  const Context& context)
{
    pair<const Byte*, const Byte*> inPair;
    if(inEncaps.empty())
    {
        inPair.first = inPair.second = 0;
    }
    else
    {
        inPair.first = &inEncaps[0];
        inPair.second = inPair.first + inEncaps.size();
    }
    return ice_invoke(operation, mode, inPair, outEncaps, context);
}

AsyncResultPtr
IceProxy::Ice::Object::_iceI_begin_ice_invoke(const string& operation,
                                          OperationMode mode,
                                          const vector<Byte>& inEncaps,
                                          const Context& ctx,
                                          const ::IceInternal::CallbackBasePtr& del,
                                          const ::Ice::LocalObjectPtr& cookie,
                                          bool sync)
{
    pair<const Byte*, const Byte*> inPair;
    if(inEncaps.empty())
    {
        inPair.first = inPair.second = 0;
    }
    else
    {
        inPair.first = &inEncaps[0];
        inPair.second = inPair.first + inEncaps.size();
    }
    return _iceI_begin_ice_invoke(operation, mode, inPair, ctx, del, cookie);
}

bool
IceProxy::Ice::Object::end_ice_invoke(vector<Byte>& outEncaps, const AsyncResultPtr& result)
{
    AsyncResult::check(result, this, ice_invoke_name);
    bool ok = result->waitForResponse();
    if(_reference->getMode() == Reference::ModeTwoway)
    {
        const Byte* v;
        Int sz;
        result->readParamEncaps(v, sz);
        vector<Byte>(v, v + sz).swap(outEncaps);
    }
    return ok;
}

AsyncResultPtr
IceProxy::Ice::Object::_iceI_begin_ice_invoke(const string& operation,
                                          OperationMode mode,
                                          const pair<const Byte*, const Byte*>& inEncaps,
                                          const Context& ctx,
                                          const ::IceInternal::CallbackBasePtr& del,
                                          const ::Ice::LocalObjectPtr& cookie,
                                          bool sync)
{
    OutgoingAsyncPtr result = new CallbackOutgoing(this, ice_invoke_name, del, cookie, sync);
    try
    {
        result->prepare(operation, mode, ctx);
        result->writeParamEncaps(inEncaps.first, static_cast<Int>(inEncaps.second - inEncaps.first));
        result->invoke(operation);
    }
    catch(const Exception& ex)
    {
        result->abort(ex);
    }
    return result;
}

bool
IceProxy::Ice::Object::_iceI_end_ice_invoke(pair<const Byte*, const Byte*>& outEncaps, const AsyncResultPtr& result)
{
    AsyncResult::check(result, this, ice_invoke_name);
    bool ok = result->waitForResponse();
    if(_reference->getMode() == Reference::ModeTwoway)
    {
        Int sz;
        result->readParamEncaps(outEncaps.first, sz);
        outEncaps.second = outEncaps.first + sz;
    }
    return ok;
}

这里的inEncaps以及outEncaps的最终版本是pair<const Byte*, const Byte*>类型，其实是一个encaps数组的iter_begin以及iter_end。由于一个encaps只是stream中的一段，没有具体的固定（长度的）类型，所以一个encaps数组也就是一系列一段段的流，它的数组容器就是这一段段的流的总流。