thrift 的required、optional探究

原因

经常使用thrift来编写rpc通信，但是对下面两个问题还是有些疑惑

1. thrift 的required、optional和不写有什么区别
2. optional不设置isset的话被传输后值？

实验

今天就自己编写代码测试了一下。如下：

定义book.thrift 如下：

namespace cpp codelab

struct Book {
  1: i32 book_id
  2: string name
  3: optional string optional_attr,
  4: optional string optional_default_val_attr = "optional_default_val_attr",
  5: string default_attr,
  8: string default_val_attr = "default_val_attr",
  10: required string required_attr,
  11: required string required_default_val_attr = "equired_default_val_attr",
}

client代码如下：

int main(int argc, char **argv) {
  boost::shared_ptr<TSocket> socket(new TSocket("localhost", 9090));
  boost::shared_ptr<TTransport> transport(new TFramedTransport(socket));
  boost::shared_ptr<TProtocol> protocol(new TBinaryProtocol(transport));

  HelloBookClient client(protocol);
  transport->open();
  Book book;
  book.name = "hello thrift";
  printf("book __isset.name: %d
", book.__isset.name);
  printf("book name: %s
", book.name.c_str());
  printf("book __isset.optional_attr: %d
", book.__isset.optional_attr);
  printf("book optional_attr: %s
", book.optional_attr.c_str());
  printf("book __isset.optional_default_val_attr: %d
",
        book.__isset.optional_default_val_attr);
  printf("book optional_default_val_attr: %s
",
        book.optional_default_val_attr.c_str());
  printf("book __isset.default_attr: %d
", book.__isset.default_attr);
  printf("book default_attr: %s
", book.default_attr.c_str());
  printf("book __isset.default_val_attr: %d
",
      book.__isset.default_val_attr);
printf("book default_val_attr: %s
", book.default_val_attr.c_str());
// printf("book __isset.required_attr: %d
",
//      book.__isset.required_attr);
printf("book required_attr: %s
", book.required_attr.c_str());
// printf("book __isset.required_default_val_attr: %d
",
//     book.__isset.required_default_val_attr);
printf("book required_default_val_attr: %s
",
      book.required_default_val_attr.c_str());

client.ping(book);
transport->close();

return 0;

Server端代码：

class HelloBookHandler : virtual public HelloBookIf {
 public:
  HelloBookHandler() {
    // Your initialization goes here
  }

  void ping(const codelab::Book& book) {
    // Your implementation goes here
    printf("book __isset.name: %d
", book.__isset.name);
    printf("book name: %s
", book.name.c_str());
    printf("book __isset.optional_attr: %d
", book.__isset.optional_attr);
    printf("book optional_attr: %s
", book.optional_attr.c_str());
    printf("book __isset.optional_default_val_attr: %d
",
          book.__isset.optional_default_val_attr);
    printf("book optional_default_val_attr: %s
",
          book.optional_default_val_attr.c_str());
    printf("book __isset.default_attr: %d
", book.__isset.default_attr);
    printf("book default_attr: %s
", book.default_attr.c_str());
    printf("book __isset.default_val_attr: %d
",
          book.__isset.default_val_attr);
    printf("book default_val_attr: %s
", book.default_val_attr.c_str());
    // printf("book __isset.required_attr: %d
",
    //      book.__isset.required_attr);

    printf("book required_attr: %s
", book.required_attr.c_str());
    // printf("book __isset.required_default_val_attr: %d
",
    //     book.__isset.required_default_val_attr);
    printf("book required_default_val_attr: %s
",
          book.required_default_val_attr.c_str());
  }
};

int main(int argc, char **argv) {
  int port = 9090;
  boost::shared_ptr<HelloBookHandler> handler(new HelloBookHandler());
  boost::shared_ptr<TProcessor> processor(new HelloBookProcessor(handler));
  boost::shared_ptr<TServerTransport> serverTransport(new TServerSocket(port));
  boost::shared_ptr<TTransportFactory> transportFactory(
      new TFramedTransportFactory());
  boost::shared_ptr<TProtocolFactory> protocolFactory(new TBinaryProtocolFactory());

  TSimpleServer server(processor, serverTransport,
                       transportFactory, protocolFactory);
  server.serve();
  return 0;
}

Client端执行结果：

Server端执行结果：

 

而对client代码修改如下，

server端的执行结果分别如下：

即没有设置isset为true的时候optional_attr的值到server被丢失了。而设置为true之后才能在server获取到

经过上面的测试，得到以下结论：

1. required字段没有__isset属性， 而默认的(就是既没有required，也没有optional)和optional的属性有该方法。
2. 创建对象的时候，optional和默认的__isset属性为false，同样不设置该属性，而在经过thrift rpc传输之后，server端的默认的__isset属性为true，而optional的__isset的属性为true。
3. 有默认值的属性，不赋值的话，其值就是thrift中的默认值。
4. optional的如果没有设置__isset为true，则经过rpc传输(或者说是经过序列化再反序列化)之后，其值会丢失。

为什么会有上面的结果呢：

原因分析

   查看thrift生成的文件：

其中book_types.h 如下：

/**
 * Autogenerated by Thrift
 *
 * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
 */
#ifndef book_TYPES_H
#define book_TYPES_H

#include <Thrift.h>
#include <TApplicationException.h>
#include <protocol/TProtocol.h>
#include <transport/TTransport.h>



namespace codelab {

typedef struct _Book__isset {
  _Book__isset() : book_id(false), name(false), optional_attr(false), optional_default_val_attr(false), default_attr(false), default_val_attr(false) {}
  bool book_id;
  bool name;
  bool optional_attr;
  bool optional_default_val_attr;
  bool default_attr;
  bool default_val_attr;
} _Book__isset;

class Book {
 public:

  static const char* ascii_fingerprint; // = "EC22AAB82386E1FAA959FB075574467D";
  static const uint8_t binary_fingerprint[16]; // = {0xEC,0x22,0xAA,0xB8,0x23,0x86,0xE1,0xFA,0xA9,0x59,0xFB,0x07,0x55,0x74,0x46,0x7D};

  Book() : book_id(0), name(""), optional_attr(""), optional_default_val_attr("optional_default_val_attr"), default_attr(""), default_val_attr("default_val_attr"), required_attr(""), required_default_val_attr("equired_default_val_attr") {
  }

  virtual ~Book() throw() {}

  int32_t book_id;
  std::string name;
  std::string optional_attr;
  std::string optional_default_val_attr;
  std::string default_attr;
  std::string default_val_attr;
  std::string required_attr;
  std::string required_default_val_attr;

  _Book__isset __isset;

  bool operator == (const Book & rhs) const
  {
    if (!(book_id == rhs.book_id))
      return false;
    if (!(name == rhs.name))
      return false;
    if (__isset.optional_attr != rhs.__isset.optional_attr)
      return false;
    else if (__isset.optional_attr && !(optional_attr == rhs.optional_attr))
      return false;
    if (__isset.optional_default_val_attr != rhs.__isset.optional_default_val_attr)
      return false;
    else if (__isset.optional_default_val_attr && !(optional_default_val_attr == rhs.optional_default_val_attr))
      return false;
    if (!(default_attr == rhs.default_attr))
      return false;
    if (!(default_val_attr == rhs.default_val_attr))
      return false;
    if (!(required_attr == rhs.required_attr))
      return false;
    if (!(required_default_val_attr == rhs.required_default_val_attr))
      return false;
    return true;
  }
  bool operator != (const Book &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const Book & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

} // namespace

#endif

book_types.cpp 文件如下：

/**
 * Autogenerated by Thrift
 *
 * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
 */
#include "codelab/thrift/proto/gen-cpp/book_types.h"

namespace codelab {

const char* Book::ascii_fingerprint = "EC22AAB82386E1FAA959FB075574467D";
const uint8_t Book::binary_fingerprint[16] = {0xEC,0x22,0xAA,0xB8,0x23,0x86,0xE1,0xFA,0xA9,0x59,0xFB,0x07,0x55,0x74,0x46,0x7D};

uint32_t Book::read(::apache::thrift::protocol::TProtocol* iprot) {

  uint32_t xfer = 0;
  std::string fname;
  ::apache::thrift::protocol::TType ftype;
  int16_t fid;

  xfer += iprot->readStructBegin(fname);

  using ::apache::thrift::protocol::TProtocolException;

  bool isset_required_attr = false;
  bool isset_required_default_val_attr = false;

  while (true)
  {
    xfer += iprot->readFieldBegin(fname, ftype, fid);
    if (ftype == ::apache::thrift::protocol::T_STOP) {
      break;
    }
    switch (fid)
    {
      case 1:
        if (ftype == ::apache::thrift::protocol::T_I32) {
          xfer += iprot->readI32(this->book_id);
          this->__isset.book_id = true;
        } else {
          xfer += iprot->skip(ftype);
        }
        break;
      case 2:
        if (ftype == ::apache::thrift::protocol::T_STRING) {
          xfer += iprot->readString(this->name);
          this->__isset.name = true;
        } else {
          xfer += iprot->skip(ftype);
        }
        break;
      case 3:
        if (ftype == ::apache::thrift::protocol::T_STRING) {
          xfer += iprot->readString(this->optional_attr);
          this->__isset.optional_attr = true;
        } else {
          xfer += iprot->skip(ftype);
        }
        break;
      case 4:
        if (ftype == ::apache::thrift::protocol::T_STRING) {
          xfer += iprot->readString(this->optional_default_val_attr);
          this->__isset.optional_default_val_attr = true;
        } else {
          xfer += iprot->skip(ftype);
        }
        break;
      case 5:
        if (ftype == ::apache::thrift::protocol::T_STRING) {
          xfer += iprot->readString(this->default_attr);
          this->__isset.default_attr = true;
        } else {
          xfer += iprot->skip(ftype);
        }
        break;
      case 8:
        if (ftype == ::apache::thrift::protocol::T_STRING) {
          xfer += iprot->readString(this->default_val_attr);
          this->__isset.default_val_attr = true;
        } else {
          xfer += iprot->skip(ftype);
        }
        break;
      case 10:
        if (ftype == ::apache::thrift::protocol::T_STRING) {
          xfer += iprot->readString(this->required_attr);
          isset_required_attr = true;
        } else {
          xfer += iprot->skip(ftype);
        }
        break;
      case 11:
        if (ftype == ::apache::thrift::protocol::T_STRING) {
          xfer += iprot->readString(this->required_default_val_attr);
          isset_required_default_val_attr = true;
        } else {
          xfer += iprot->skip(ftype);
        }
        break;
      default:
        xfer += iprot->skip(ftype);
        break;
    }
    xfer += iprot->readFieldEnd();
  }

  xfer += iprot->readStructEnd();

  if (!isset_required_attr)
    throw TProtocolException(TProtocolException::INVALID_DATA);
  if (!isset_required_default_val_attr)
    throw TProtocolException(TProtocolException::INVALID_DATA);
  return xfer;
}

uint32_t Book::write(::apache::thrift::protocol::TProtocol* oprot) const {
  uint32_t xfer = 0;
  xfer += oprot->writeStructBegin("Book");
  xfer += oprot->writeFieldBegin("book_id", ::apache::thrift::protocol::T_I32, 1);
  xfer += oprot->writeI32(this->book_id);
  xfer += oprot->writeFieldEnd();
  xfer += oprot->writeFieldBegin("name", ::apache::thrift::protocol::T_STRING, 2);
  xfer += oprot->writeString(this->name);
  xfer += oprot->writeFieldEnd();
  if (this->__isset.optional_attr) {
    xfer += oprot->writeFieldBegin("optional_attr", ::apache::thrift::protocol::T_STRING, 3);
    xfer += oprot->writeString(this->optional_attr);
    xfer += oprot->writeFieldEnd();
  }
  if (this->__isset.optional_default_val_attr) {
    xfer += oprot->writeFieldBegin("optional_default_val_attr", ::apache::thrift::protocol::T_STRING, 4);
    xfer += oprot->writeString(this->optional_default_val_attr);
    xfer += oprot->writeFieldEnd();
  }
  xfer += oprot->writeFieldBegin("default_attr", ::apache::thrift::protocol::T_STRING, 5);
  xfer += oprot->writeString(this->default_attr);
  xfer += oprot->writeFieldEnd();
  xfer += oprot->writeFieldBegin("default_val_attr", ::apache::thrift::protocol::T_STRING, 8);
  xfer += oprot->writeString(this->default_val_attr);
  xfer += oprot->writeFieldEnd();
  xfer += oprot->writeFieldBegin("required_attr", ::apache::thrift::protocol::T_STRING, 10);
  xfer += oprot->writeString(this->required_attr);
  xfer += oprot->writeFieldEnd();
  xfer += oprot->writeFieldBegin("required_default_val_attr", ::apache::thrift::protocol::T_STRING, 11);
  xfer += oprot->writeString(this->required_default_val_attr);
  xfer += oprot->writeFieldEnd();
  xfer += oprot->writeFieldStop();
  xfer += oprot->writeStructEnd();
  return xfer;
}

} // namespace

 

仔细查看代码，上面的问题都可以得到答案：

针对第一个问题：可以从 book_types.h中看到，有一个Book_isset的结构体的成员，

而我们看下该_Book__isset结构体的定义如下：

可有看到，该结构体重只包含了非required的属性。因此只有非required属性才有__isset的属性。

针对第二个问题：从_Book_isset的构造函数可以看出，对象在构造的时候，其__isset的属性都是false。而rpc传出的时候就涉及到对象的序列化和反序列化。

就设计该对象的read和write，我们看下相应的函数:

write函数将对象转成字符串。代码如下(限于屏幕值截取部分分析)

从代码可以看出，整个操作以writeStructBegin开始，以writeStructEnd结束。

其对于非optional的字段，是字节调用writeFieldBegin（fileld_name, FieldType, id）; writeType（） writeFieldEnd 方法处理的。

注意这里write时涉及了thrift中定义的序号、类型、和名字。因此thrift序号是不可以随意变动的。

而对于optional的字段则略有不同，其首先需要判断属性的__isset.是否为true，只有为true时才调用相应的write处理。 因此如果optional

字段不设置其__isset，则序列化的时候会不处理，(解答了第四个问题)

反序列就是read操作：

read是write的逆过程：

其从： 开始

读取数据

然后是一个fid的switch逻辑，根据fid来处理对应的属性

在读到STOP的时候终止while循环：

最后是一个

这个read的逻辑是对应的，read的结束如下：

 

在read操作中对于非required字段，读取时将其isset设置为true。这也就是为什么server端isset的值是设置的。

而对于required字段，注意read 最后

其对于required字段会进行check，如果没有，则抛出异常。

因此required字段还有此效果，即必须有该字段。

而第三个问题则从头文件中对象的构造函数可以看出原因。

 

 

到这里，上面的问题就全部都清楚了。