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\n", book.__isset.name);
  printf("book name: %s\n", book.name.c_str());
  printf("book __isset.optional_attr: %d\n", book.__isset.optional_attr);
  printf("book optional_attr: %s\n", book.optional_attr.c_str());
  printf("book __isset.optional_default_val_attr: %d\n",
        book.__isset.optional_default_val_attr);
  printf("book optional_default_val_attr: %s\n",
        book.optional_default_val_attr.c_str());
  printf("book __isset.default_attr: %d\n", book.__isset.default_attr);
  printf("book default_attr: %s\n", book.default_attr.c_str());
  printf("book __isset.default_val_attr: %d\n",
      book.__isset.default_val_attr);
printf("book default_val_attr: %s\n", book.default_val_attr.c_str());
// printf("book __isset.required_attr: %d\n",
//      book.__isset.required_attr);
printf("book required_attr: %s\n", book.required_attr.c_str());
// printf("book __isset.required_default_val_attr: %d\n",
//     book.__isset.required_default_val_attr);
printf("book required_default_val_attr: %s\n",
      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\n", book.__isset.name);
    printf("book name: %s\n", book.name.c_str());
    printf("book __isset.optional_attr: %d\n", book.__isset.optional_attr);
    printf("book optional_attr: %s\n", book.optional_attr.c_str());
    printf("book __isset.optional_default_val_attr: %d\n",
          book.__isset.optional_default_val_attr);
    printf("book optional_default_val_attr: %s\n",
          book.optional_default_val_attr.c_str());
    printf("book __isset.default_attr: %d\n", book.__isset.default_attr);
    printf("book default_attr: %s\n", book.default_attr.c_str());
    printf("book __isset.default_val_attr: %d\n",
          book.__isset.default_val_attr);
    printf("book default_val_attr: %s\n", book.default_val_attr.c_str());
    // printf("book __isset.required_attr: %d\n",
    //      book.__isset.required_attr);

    printf("book required_attr: %s\n", book.required_attr.c_str());
    // printf("book __isset.required_default_val_attr: %d\n",
    //     book.__isset.required_default_val_attr);
    printf("book required_default_val_attr: %s\n",
          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字段還有此效果，即必須有該字段。

而 第三個問題則從頭文件中對象的構造函數可以看出原因。

 

 

到這里，上面的問題就全部都清楚了。