Thrift之TProtocol类体系原理及源码详细解析之类继承架构分析

我的新浪微博:http://weibo.com/freshairbrucewoo

欢迎大家相互交流,共同提高技术。

 

 

这部分相关的类主要实现与协议相关的内容,这里说的协议是指对数据传输格式封装的协议,实现不同的协议来适合不同场景下的数据传输,因为在不同的场景下不同协议对于数据传输来说效率有很大的差别。下面是这个部分相关类的类关系图:

 

由以上类图可以发现所有的协议类都从TProtocol类直接或间接继承,每一个协议类都有一个对应的生产对象工厂(协议工厂)。TProtocol是一个抽象的类,不能直接使用的,它有一个直接子类默认实现了所有方法(空实现),如果我们需要定义自己的数据传输协议可以直接从这个类继承。

第一节 类继承架构分析

为什么需要对这部分的类继承架构进行分析了?上面不是有很清楚的类继承关系图了吗?但是Facebook在实现时并不是简单的这样继承下来就可以了,Facebook为了后期协议的可扩展性和允许其他组织、团队或个人实现自己的数据传输(主要是数据格式的封装)协议,里面多加了一层继承关系,就是类图中的TVirtualProtocol类,从类的名称可以看出这是一个虚的协议。怎样理解这个虚的协议了?通过阅读代码我觉得可以这样理解:因为它定义为一个模板类,这个模板类有两个参数,一个用于数据传输的真正协议,一个是用来继承的,它本身没有对协议具体内容做实现,所以说它是一个虚的协议类。下面我们对这个类继承架构结合代码实现来具体分析。

抽象类TProtocol和默认实现类TProtocolDefaults

抽象类对于每一种数据类型都提供了读写的开始和介绍的方法,这里读写方法应该是针对网络IO读写,不过真正实现网络读写还不是这里的方法,这里方法主要处理数据,例如对数据格式做调整。真正实现网络IO读写是下一章介绍的TTransport相关类实现的,那里还会对传输的方式做相应控制,例如是否压缩。

除了具体的数据类型有写入和读取的方法,消息也是需要通过网络传递,所以也定义了消息的传输读写方法。当然还定义了一些公用的功能,如跳过某一个结构不读、大小端数据格式调整、主机字节序和网络字节序的相互转换等。

1)首先定义纯虚函数:

1 virtual uint32_t writeMessageBegin_virt(const std::string& name,
2 
3                                   const TMessageType messageType,  const int32_t seqid) = 0;
4 
5   virtual uint32_t writeMessageEnd_virt() = 0;
6 
7   virtual uint32_t writeStructBegin_virt(const char* name) = 0;
8 
9   virtual uint32_t writeStructEnd_virt() = 0;

 

2)然后定义调用相应纯虚函数的函数:

 1  uint32_t writeMessageBegin(const std::string& name, const TMessageType messageType, const int32_t seqid) {
 2 
 3     T_VIRTUAL_CALL();//打印调用日志函数
 4 
 5     return writeMessageBegin_virt(name, messageType, seqid);
 6 
 7   }
 8 
 9   uint32_t writeMessageEnd() {
10 
11     T_VIRTUAL_CALL();
12 
13     return writeMessageEnd_virt();
14 
15   }
16 
17   uint32_t writeStructBegin(const char* name) {//写结构体开始
18 
19     T_VIRTUAL_CALL();
20 
21     return writeStructBegin_virt(name);
22 
23   }
24 
25   uint32_t writeStructEnd() {//写结构体结束
26 
27     T_VIRTUAL_CALL();
28 
29     return writeStructEnd_virt();
30 
31   }

 

3)其他公共函数

 

 1  uint32_t skip(TType type) {
 2 
 3     T_VIRTUAL_CALL();
 4 
 5     return skip_virt(type);//跳过数据类型
 6 
 7   }
 8 
 9   virtual uint32_t skip_virt(TType type) {
10 
11     return ::apache::thrift::protocol::skip(*this, type);// 调用此命名空间下全局函数实现
12 
13   }

 

4)全局数据结构定义

 1 enum TType {//Thrift协议支持的数据类型枚举定义
 2 
 3   T_STOP       = 0,
 4 
 5   T_VOID       = 1,
 6 
 7   T_BOOL       = 2,
 8 
 9   T_BYTE       = 3,
10 
11   T_I08        = 3,
12 
13   T_I16        = 6,
14 
15   T_I32        = 8,
16 
17   T_U64        = 9,
18 
19   T_I64        = 10,
20 
21   T_DOUBLE     = 4,
22 
23   T_STRING     = 11,
24 
25   T_UTF7       = 11,
26 
27   T_STRUCT     = 12,
28 
29   T_MAP        = 13,
30 
31   T_SET        = 14,
32 
33   T_LIST       = 15,
34 
35   T_UTF8       = 16,
36 
37   T_UTF16      = 17
38 
39 };
40 
41 enum TMessageType {//thrift支持的消息类型
42 
43   T_CALL       = 1,
44 
45   T_REPLY      = 2,
46 
47   T_EXCEPTION  = 3,
48 
49   T_ONEWAY     = 4//函数的异步调用方式
50 
51 };

 

还定义了一个对应抽象工厂类,用于上产具体的协议对象,这就是设计模式中最常用的抽象工厂设计模式。上面代码只是简单列举了两个写入的函数,还有其他很多相关数据类型的写入和读取函数因为都相同格式定义就没有具体拿出来说明了。

至于默认实现类TProtocolDefaults主要重写了抽象类TProtocol的非虚拟化的方法,这些方法都抛出一个方法为实现(TProtocolException::NOT_IMPLEMENTED)的异常。这样做的主要目的为了下面要讲到的类TVirtualProtocol提供默认的继承基类,从而防止无限递归调用。下面分析TVirtualProtocol类时具体分析如果没有这个默认实现类怎样产生无限递归调用。

虚协议类TVirtualProtocol

首先看看这个特殊的模板类是怎样定义的:

1 template <class Protocol_, class Super_=TProtocolDefaults>
2 
3 class TVirtualProtocol : public Super_ { 
4 
5 ……//省略具体内容
6 
7 }

 

说它特殊我觉得主要是基于两个方面:

1)继承的类可以通过模板参数传递,也就是说你现在没有办法肯定它现在带地继承什么类,只是默认参数值是我们上面介绍的抽象类的默认实现类。

2)类里面的方法实现全部是采用把this指针转换为第一个模板参数的类型然后调用模板参数类型的相关方法。如下面的一个方法的定义:

1   virtual uint32_t writeMessageBegin_virt(const std::string& name,
2 
3                        const TMessageType messageType, const int32_t seqid) {
4 
5     return static_cast<Protocol_*>(this)->writeMessageBegin(name, messageType, seqid);
6 
7   }//实现抽象类的writeMessageBegin_virt方法

 

由上面两个特点可以发现这个类只是提供一个空的架构壳,继承的类可以指定,当然也可以采用默认的,后面分析具体协议实现的时候可以发现大多数协议也确实是采用默认的继承类,且大多数继承这个虚协议的类都是传递第一个参数为自身,也就是调用自己定义的相应函数。如TBinaryProtocolT类的定义,如下:

1 template <class Transport_>
2 
3 class TBinaryProtocolT : public TVirtualProtocol< TBinaryProtocolT<Transport_> > {
4 
5 …….
6 
7 }

 

下面来分析如果不从定义的默认实现类继承,直接从抽象类继承怎样会产生无限递归调用。现在我们假设直接从抽象类继承,那么如果一个指向子类对象的父类(TProtocol)调用writeMessageBegin方法,因为这个方法不是虚拟函数(不会动态绑定)所以就会调用父类的writeMessageBegin方法,然后父类会直接调用它的纯虚函数writeMessageBegin_virt,这个函数就会动态绑定,就会执行子类的实现,在这里就是通过虚协议类TVirtualProtocol实现的,而这个函数又会调用之类的writeMessageBegin方法,如果子类没有实现这个方法,那么就又回到父类的这个方法了,从而产生无限递归调用。那么如果默认是从默认实现类TProtocolDefaults继承,那么就会执行它的writeMessageBegin方法,从而抛出一个异常,就不会产生无限递归调用。

具体协议类或实现自己的协议类

这个就是类继承架构的最后一部分,也就是实现具体的数据传输协议。例如二进制协议类定义如下:

1 template <class Transport_>
2 
3 class TBinaryProtocolT : public TVirtualProtocol< TBinaryProtocolT<Transport_> > { …… }

 

那么这个二进制协议类就不用实现那些虚拟方法了。那些具体的协议实现方式后面详细介绍。

现在对这部分的类继承架构已经分析完毕,后面开始介绍Thrift中实现的几个比较重要的协议。

posted @ 2012-06-05 00:01 蔷薇理想人生 阅读(...) 评论(...) 编辑 收藏