qiezi的学习园地

AS/C/C++/D/Java/JS/Python/Ruby

  C++博客 :: 首页 :: 新随笔 ::  ::  :: 管理 ::

前面简单写了点静态结构,这一次将主要关注动态模型以及调用方式。

这个系列的名字叫“为C++实现一个IDL”,实际上应该叫“为C++实现一个Remoting”可能更好一些,说是IDL,主要是想通过宏,使用简单的类型定义达到自动生成调用代码的目的。

一、首先来看看调用习惯。

从调用习惯入手,主要是因为看到目前有很多库/工具包在调用上都有很多不便之处。假如能在一开始就从这点出发,就能把调用接口设计得更好一些。

先来看看服务端如何开放一个服务。

int main ()
{
    
// 发布为SOAP服务,先生成一个服务容器。
    
// 服务将发布在localhost的7911上,localhost用来绑定loopback网卡。
    SOAPProxy soap_service (7911, “localhost”);

    TestService test_service; 
    soap_service.addService  (“test_service”, 
&test_service);

    TestService service1;
    soap_service.addService (“HelloService”, 
&service1);

    
try{
        soap_service.run ();
    } 
catch (SocketException& e)
    {
    } 
catch (SignalException& e)
    {
    }

    
return 0;
}


我希望就是这么简单,客户端调用有多种方式:
1、 使用服务的IDL定义,直接调用:

int main ()
{
    SOAPProxy soap_service (
7911, “localhost”);

    
try{
        TestService test_service (“test_service”, 
&soap_service);
        test_service.method1 (
/**/);
    } 
catch (SocketException& e)
    {
    }
    
return 0;
}


这种方式比较简单,调用时会检查是否已经连接,然后发送调用请求,并处理调用结果。

2、 服务验证方式:

int main ()
{
    SOAPProxy soap_service (
7911, “localhost”);
    TestService test_service;
    soap_service.getService (“test_service”, 
&test_service);

    
if (test_service)
    {
        
try{
            test_service.method1 (
/**/);
        } 
catch (SocketException& e)
        {
        }
    }
    
return 0;
}


3、 服务发现方式:

int main ()
{
    SOAPProxy soap_service (
7911, “localhost”);
    vector 
<string> services_name = soap_service.getServiceNames ();
    
// 
    IService* test_service = soap_service.getService (“test_service”);
    
if (test_service)
    {
        vector 
<string> methods = test_service->getMethodNames ();
        IMethod
* method = test_service->getMethod (“method1”);
        vector 
<Type*> types = method->getParameterType s()
        method
->addArg (3);
        method
->addArg (4);
        
// 
        method->invoke ();
        
// 
    }
    
return 0;
}


二、基本需求。

简单分析一下,上面一共涉及了哪些类型?
IProxy:
这是所有Proxy类的基类(和接口),它可以容纳多个服务对象,提供服务绑定、服务查询、服务发现、服务验证。
IService:
所有Service类的基类,可以容纳多个方法(Method),提供方法查询、服务验证。
IMethod:
所有Method模板类的基类,容纳多个参数,包括返回值,可通过查询参数类型获得方法的类型定义。
IParameter:
所有参数的基类,包含一个参数类型描述和一个参数值。
IType:
所有类型的基类,预定义了一些基本类型,可自定义类型。

看起来挺多的,其实很难接触到这些,只需要使用宏来定义一个服务,就可以通过模板的类型推导,自动生成这些复杂的定义。

三、调用过程。

以下只简单分析一下同步调用,异步调用将是以后的扩充话题。
根据第二节的3种不同调用过程,简要描述如下:
  1. 直接调用。

    • 生成SOAPProxy,让它连接到远程主机。
    • 生成一个TestService对象,设置远程主机上的服务名称,并指定使用SOAPProxy,也即使用SOAP协议。
    • 调用TestService::method1方法。根据method1的定义,把服务名称、方法名称、各个in参数等打包成一个“集合”,交给SOAPProxy处理。
    • SOAPProxy把这个“集合”转换成SOAP消息,发送到远程主机,阻塞线程。
    • 远程主机上的SOAPProxy对象收到数据,进行解析。当解析出一个服务调用时,把它交给TestService服务处理。
    • TestService解析出一个方法调用,把它交给Method处理。
    • Method解析出各个参数,验证参数类型、完整性等,并执行调用或返回错误。
    • Method调用的返回信息(包括调用结果、返回值、out参数等)被打包成一个“集合”,交给TestService处理。
    • TestService处理后,交给SOAPProxy。
    • SOAPProxy把结果打包成SOAP消息,发回调用端。
    • 调用端解析SOAP消息,把OUT参数值赋给调用者提供的对象,调用完成。

     

  2. 服务验证方式。
    • 生成SOAPProxy,让它连接到远程主机。
    • 生成TestService对象,调用SOAPProxy的getService验证版本。
    • SOAPProxy把TestService对象的信息(名称、成员及基类型等)发送到远程主机,阻塞。
    • 远程主机解析收到的信息,查找服务名,并比较查找到的服务类型与解析得到的类型。
    • 比较结果发回给调用端。
    • 调用端接着采用直接调用的方式,调用远程服务。

    这种方式看起来多了一些操作,不过验证的好处是能够减少调用时的异常。

  3. 服务发现方式。
    • 生成SOAPProxy,让它连接到远程主机。
    • 查询远程开放的服务名称。(可省略)
    • 查找特定服务,得到服务描述信息。
    • 查找服务中的方法,得到方法描述信息。
    • 压入各个参数,并执行调用。
    • 调用前先判断参数是否与描述一致,然后调用SOAPProxy生成SOAP消息,发送到远程主机,阻塞。
    • 远程主机解析出调用。。。后面过程与第1种方式相同,远程主机并不知道客户端使用的是哪种方式来调用。远程主机处理结束,将返回SOAP消息给调用端。
    • 调用端解析出调用结果,并把各个OUT参数的值赋给method对象。

    使用这种方式,调用端不需要服务的类型定义。

四、异步调用/异步分派(AMI/AMD)。

同步调用时,调用端线程需要等待调用结果,服务端线程也要等待调用结束返回,才处理下一个调用。
为了在服务调用期间让线程能做更多的事:
调用端把调用交给线程池完成,并在调用完成后采用某种机制通知线程处理结果,或者直接由线程池中的调用线程调用结果处理函数。这种方式称为AMI(异步方法调用)。
服务端主线程则把接收到的消息解析后,放入处理队列,由线程池去处理调用过程。当调用完成后,结果放入结果队列,由主线程处理成消息,发送回调用端。这种方式称为AMD(异步方法分派)。
调用端和服务端依旧是使用通讯协议来沟通,双方都不知道对方是否采用了异步方式。

AMI和AMD对于静态定义的服务是有影响的,比如下面一个服务:

struct TestService
{
    Method 
<void(in<int>out<int>)> method1;
}


在同步调用时,它的调用方式:

TestService test_service;
int a;
service.method1 (
3, a); // 或者 service.method1 (3, &a),打算兼容这2种方式。


异步调用时,调用方式:

void method1_result (intint);
TestService test_service;
test_service.method1.async_call(
3, method1_result); // 调用完成后,让调用线程去调用method1_result通知调用结果。
// 或者像下面
IMethod* result = test_service.method1.async_call (3);
while (!result->done())  // 还有很多好办法,这里只是为了简单。
{
    sleep (
1);
}
cout 
<< result->getArg(1)->toInt(); 


正如上面演示的一样,异步调用的结果有2种方式去处理。
一是由线程池调用完以后,接着调用一个函数以通知结果。它不需要轮询,不过涉及到了线程问题,增加了一些复杂性。
另一种方式调用结束后,原调用线程在某个适当的“时机”去查询调用结果。这个时机可以是定时查询,也可以是被线程消息通知而去处理。

五、其它。

这一篇加上前一篇,应该是提到了全部的要点。
目前剩下的唯一一个难点,可能是在处理异步调用时,Method的定义。
正如上面演示的,一个方法在同步调用和异步调用时,就有3种调用方式:

service.method1 (3, a);
test_service.method1.async_call(
3, method1_result);
IMethod
* result = test_service.method1.async_call (3);


特别地,它如何根据in和个数和out的个数,产生那2个参数个数匹配的异步调用函数?
再来回顾一下method1的定义:

Method <void(in<int>out<int>)> method1;


显然有一定的复杂性,不过我认为还是可以处理掉的。拿3个参数的偏特化版本来说明:

template <class Ret, class A, class B, class C>
class Method <Out<Ret>(A,B,C)> : public MethodBase <Out<Ret>,A,B,C>
{
};

template 
<class Ret=NullType, class A=NullType, class B=NullType, class C=NullType, class D=NullType, IN_COUNT=InCount< A,B,C,D>::value >
class MethodBase
{
};


通过对MethodBase类的IN_COUNT参数定义偏特化,即可定义出这些不同的版本。

当然仅仅是知道了IN参数的个数,还没有提取出IN参数的类型,所以还不能生成函数的原型,或许需要把typelist加进来了(loki中的那个)。



这是后面要考虑的内容,今天先想到这。

posted on 2005-09-17 19:40 qiezi 阅读(843) 评论(4)  编辑 收藏 引用 所属分类: 自家破烂C++asgard项目