java中proto文件怎么引入另一个proto文件 proto文件怎么写

转载

mob64ca14106f2f 2023-12-25 07:09:06

1. 定义 .proto 文件：

首先我们需要编写一个 proto 文件，定义我们程序中需要处理的结构化数据，在 protobuf 的术语中，结构化数据被称为 Message。proto 文件非常类似 java 或者 C 语言的数据定义，可以使用 C或 C++风格的注释,下面是proto文件的例子

package tutorial;
option java_package = "com.example.tutorial";
option java_outer_classname = "AddressBookProtos";
message Person {
  required string name = 1;
  required int32 id = 2; // Unique ID number for this person.
  optional string email = 3;
enum PhoneType {
  MOBILE = 0;
  HOME = 1;
  WORK = 2;
}
message PhoneNumber {
     required string number = 1;
     optional PhoneType type = 2 [default = HOME];
}
repeated PhoneNumber phone = 4;
}
// Our address book file is just one of these.
message AddressBook {
    repeated Person person = 1;
}

一个 proto 文件主要包含 package定义、 message定义和属性定义三个部分，还有一些可选项。

1.1 定义 package

Package在 c++中对应 namespace。对于 Java，包声明符会变为 java 的一个包，除非在 .proto 文件中提供了一个明确有 java_package。

1.2 定义 message

Message在 C++中对应 class。Message中定义的全部属性在 class中全部为 private 的。

Message的嵌套使用可以嵌套定义，也可以采用先定义再使用的方式。

Message的定义末尾可以采用 java方式在末尾不加“ ;”，也可以采用 C++定义方式在末尾加上“;”，这两种方式都兼容，建议采用 java定义方式。

向.proto 文件添加注释，可以使用 C/C++/java风格的双斜杠（ // ）语法格式。

1.3 定义属性

属性定义分为四部分：标注 +类型+属性名 +属性顺序号 +[默认值 ]，其示意如下所示

java中proto文件怎么引入另一个proto文件 proto文件怎么写_java

其中属性名与 C++和 java语言类似，不再解释；下面分别对标注、类型和属性顺序号加以详细介绍。其中包名和消息名以及其中变量名均采用 java 的命名规则——驼峰式命名法。

1.3.1 标注

标注包括“ required”、“optional”、“repeated”三种，其中

required 表示该属性为必选属性，否则对应的 message“未初始化”，debug 模式下导致断言， release模式下解析失败；

optional 表示该属性为可选属性，不指定，使用默认值（ int 或者 char 数据类型默认为 0,string 默认为空， bool 默认为 false，嵌套 message默认为构造，枚举则为第一个）

repeated 表示该属性为重复字段，可看作是动态数组，类似于 C++中的 vector。

如果为 optional 属性，发送端没有包含该属性，则接收端在解析式采用默认值。对于默认值，如果已设置默认值，则采用默认值，如果未设置，则类型特定的默认值为使用，例如 string 的默认值为 ” ”。

1.3.2 类型

Protobuf 的属性基本包含了 c++需要的所有基本属性类型。

java中proto文件怎么引入另一个proto文件 proto文件怎么写_字段_02

1.3.2.1 Union 类型定义

Protobuf 没有提供 union 类型，如果希望使用 union 类型，可以采用 enum 和 optional 属性定义的方式。例如，如果已经定义了 Foo、Bar、Baz等 message，则可以采用如下定义。

message OneMessage {
 enum Type { FOO = 1; BAR = 2; BAZ = 3; }
 // Identifies which field is filled in.
 required Type type = 1;
 // One of the following will be filled in.
 optional Foo foo = 2;
 optional Bar bar = 3;
 optional Baz baz = 4;
}

1.3.3 属性顺序号

属性顺序号是 protobuf 为了提高数据的压缩和可选性等功能定义的，需要按照顺序进行定义，且不允许有重复。

1.4. 其他

1.4.1 import 可选项

Import 可选项用于包含其它 proto 文件中定义的 message或 enum等。标准格式如下

import “phonetype.proto ”;

使用时，import 的文件必须与当前文件处于同一个文件夹下， protoc 无法完成不处于同一个文件夹下的 import 选项。

1.4.2 packed

packed (field option): 如果该选项在一个整型基本类型上被设置为真，则采用更紧凑的编码方式。当然使用该值并不会对数值造成任何损失。在 2.3.0 版本之前，解析器将会忽略那些非期望的包装值。因此，它不可能在不破坏现有框架的兼容性上而改变压缩格式。在 2.3.0 之后，这种改变将是安全的，解析器能够接受上述两种格式，但是在处理 protobuf 老版本程序时，还是要多留意一下。

repeated int32 samples = 4 [packed=true];

1.4.3 default

[default = default_value]: optional 类型的字段，如果在序列化时没有被设置，或者是老版本的消息中根本不存在该字段，那么在反序列化该类型的消息是， optional 的字段将被赋予类型相关的缺省值，如 bool 被设置为 false，int32 被设置为 0。Protocol Buffer 也支持自定义的缺省值，如：

optional int32 result_per_page = 3 [default = 10];

1.5 大数据量使用建议

在使用过程中发现，对于大数据量的协议报文（循环超过10000 条），如果 repeated 修饰的属性为对象类型（诸如 message 、Bytes、string 等称为“对象类型”，其余的诸如 int32、 int64、float 等等称为“原始类型” ）时，效率非常低，而且占用的进程内存也非常大，建议采用如下方式优化。

1.5.1 repeated message类型

在 message 中对 repeated 标识的 message类型的字段需要做大量 ADD操作时，可以考虑尽量避免嵌套 message或者减少嵌套的 message个数。实例如下所示：

java中proto文件怎么引入另一个proto文件 proto文件怎么写_java_03

1.5.2 repeated raw 类型

在 message中对 repeated 标识的原始数据类型的字段需要做大量 ADD操作（例如超过3千）时，可以考虑预分配数据空间，避免重复大量地分配空间。实例如下所示：

java中proto文件怎么引入另一个proto文件 proto文件怎么写_java_04

1.5.3 repeated Bytes类型

在 protobuf 中，Bytes基于 C++ STL中的 string 实现，因为 string 内存管理的原因，程序空间往往较大。所以应用如果有很多 repeated Bytes类型的字段的话，进程显示耗用大量内存，这与 vector的情况基本一致。

1.6 Protocol Buffer 消息升级原则

在实际的开发中会存在这样一种应用场景，即消息格式因为某些需求的变化而不得不进行必要的升级，但是有些使用原有消息格式的应用程序暂时又不能被立刻升级，这便要求我们在升级消息格式时要遵守一定的规则，从而可以保证基于新老消息格式的新老程序同时运行。规则如下：

1. 不要修改已经存在字段的标签号。

2. 任何新添加的字段必须是 optional 和 repeated 限定符，否则无法保证新老程序在互相传递消息时的消息兼容性。

3. 在原有的消息中，不能移除已经存在的 required 字段，optional 和 repeated 类型的字段可以被移除，但是他们之前使用的标签号必须被保留，不能被新的字段重用。

4. int32、uint32、int64、uint64 和 bool 等类型之间是兼容的， sint32 和 sint64 是兼容的，string 和 bytes 是兼容的， fixed32 和 sfixed32，以及 fixed64 和 sfixed64之间是兼容的，这意味着如果想修改原有字段的类型时，为了保证兼容性，只能将其修改为与其原有类型兼容的类型，否则就将打破新老消息格式的兼容性。

5. optional 和 repeated 限定符也是相互兼容的。

第2章编译 .proto文件

可以通过定义好的 .proto 文件来生成 Java、Python、C++代码，需要基于 .proto 文件运行 protocol buffer 编译器 protoc。运行的命令如下所示：

protoc --proto_path=IMPORT_PATH --cpp_out=DST_DIR --java_out=DST_DIR --python_out=DST_DIR path/to/file.proto

MPORT_PATH声明了一个 .proto 文件所在的具体目录。如果忽略该值，则使用当前目录。

如果有多个目录则可以对 --proto_path 写多次，它们将会顺序的被访问并执行导入。 -I=IMPORT_PATH是它的简化形式。

当然也可以提供一个或多个输出路径： --cpp_out 在目标目录 DST_DIR 中产生 C++ 代码，

你必须提供一个或多个 .proto 文件作为输入。多个 .proto 文件能够一次全部声明。虽然这些文件是相对于当前目录来命名的，每个文件必须在一个 IMPORT_PATH中，只有如此编译器才可以决定它的标准名称。

第3章使用 message

3.1 类成员变量的访问

在生成的 .h 文件中定义了类成员的访问方法。例如，对于 Person类，定义了 name、id、 email、phone 等成员的访问方法。获取成员变量值直接采用使用成员变量名（全部为小写），设置成员变量值，使用在成员变量名前加 set_的方法。

对于普通成员变量（ required 和 optional）提供 has_方法判断变量值是否被设置；提供 clear_方法清除设置的变量值。

对于 string 类型，提供多种 set_方法，其参数不同。同时，提供了一个 mutable_方法，返回变量值的可修改指针。

对于 repeated 变量，提供了其它一些特殊的方法：

_size方法：返回 repeated field’s size

通过下脚标访问其中的数组成员组

通过 mutable_的方法返回指针

_add 方法：增加一个成员。

// name
inline bool has_name() const;
inline void clear_name();
inline const ::std::string& name() const;
inline void set_name(const ::std::string& value);
inline void set_name(const char* value);
inline ::std::string* mutable_name();
// id
inline bool has_id() const;
inline void clear_id();
inline int32_t id() const;
inline void set_id(int32_t value);
// email
inline bool has_email() const;
inline void clear_email();
inline const ::std::string& email() const;
inline void set_email(const ::std::string& value);
inline void set_email(const char* value);
inline ::std::string* mutable_email();
// phone
inline int phone_size() const;
inline void clear_phone();
inline const ::google::protobuf::RepeatedPtrField< ::tutorial::Person_PhoneNumber >& phone() const;
inline ::google::protobuf::RepeatedPtrField< ::tutorial::Person_PhoneNumber >* mutable_phone(); 
inline const ::tutorial::Person_PhoneNumber& phone(int index) const;
inline ::tutorial::Person_PhoneNumber* mutable_phone(int index);
inline ::tutorial::Person_PhoneNumber* add_phone();

3.2 标准 message 方法

生成的 .h 文件中的 class都继承自 ::google::protobuf::Message 类，Message类提供了一些方法可以检查或者操作整个 message，包括

bool IsInitialized() const; 检查是否所有 required 变量都已经初始化；

string DebugString() const; 返回 message的可阅读的表示，主要用于调试程序；

void CopyFrom(const Person& from); 使用一个 message的值覆盖本message；

void Clear(); 清空 message的所有成员变量值。

3.3 编码和解码函数

每个 message类都提供了写入和读取 message数据的方法，包括

bool SerializeToString(string* output) const; 把 message编码进 output 。

bool ParseFromString(const string& data); 从 string 解码到 message

bool SerializeToArray(char* buf,int size) const; 把 message编码进数组 buf.

bool ParseFromArray(const char* buf,int size); 把 buf 解码到 message。此解码方法效率较 ParseFromString高很多，所以一般用这种方法解码。

bool SerializeToOstream(ostream* output) const; 把 message编码进 ostream

bool ParseFromIstream(istream* input); 从 istream 解码到 message

备注：发送接收端所使用的加码解码方法不一定非得配对，即发送端用 SerializeToString 接收端不一定非得用 ParseFromString ，可以使用其他解码方法。

例子：

简单 message 生成的 C++代码

这里先定义一个最简单的 message，其中只是包含原始类型的字段。

option optimize_for = LITE_RUNTIME;
message LogonReqMessage {
required int64 acctID = 1; 
required string passwd = 2;
}

由于我们在 MyMessage 文件中定义选项 optimize_for 的值为 LITE_RUNTIME，因此由该 .proto 文件生成的所有 C++类的父类均为 ::google::protobuf::MessageLite ，而非::google::protobuf::Message。MessageLite类是 Message的父类，在 MessageLite中将缺少 Protocol Buffer 对反射的支持，而此类功能均在 Message类中提供了具体的实现。使用 LITE 版本的 Protocol Buffer。这样不仅可以得到更高编码效率，而且生成代码编译后所占用的资源也会更少，至于反射所能带来的灵活性和极易扩展性。下面我们来看一下由 message LogonReqMessage生成的 C++类的部分声明，以及常用方法的说明性注释。

class LogonReqMessage : public ::google::protobuf::MessageLite {
public:
LogonReqMessage();
virtual ~LogonReqMessage();
// implements Message ----------------------------------------------
// 下面的成员函数均实现自 MessageLite 中的虚函数。
// 创建一个新的 LogonReqMessage对象，等同于 clone。
LogonReqMessage* New() const;
// 用另外一个 LogonReqMessage对象初始化当前对象，等同于赋值操作符重载（ operator=）
void CopyFrom(const LogonReqMessage& from);
// 清空当前对象中的所有数据，既将所有成员变量置为未初始化状态。
void Clear();
// 判断当前状态是否已经初始化。
bool IsInitialized() const;
// 在给当前对象的所有变量赋值之后，获取该对象序列化后所需要的字节数。
int ByteSize() const;
// 获取当前对象的类型名称。
::std::string GetTypeName() const;
// required int64 acctID = 1;
// 下面的成员函数都是因 message中定义的 acctID 字段而生成。
// 这个静态成员表示 AcctID 的标签值。命名规则是 k + FieldName(驼峰规则) + FieldNumber。
static const int kAcctIDFieldNumber = 1;
// 如果 acctID字段已经被设置返回 true ，否则 false。
inline bool has_acctid() const;
// 执行该函数后 has_acctid 函数将返回 false，而下面的 acctid 函数则返回 acctID 的缺省值。
inline void clear_acctid();
// 返回 acctid 字段的当前值，如果没有设置则返回 int64 类型的缺省值。
inline ::google::protobuf::int64 acctid() const; 
// 为 acctid 字段设置新值，调用该函数后 has_acctid 函数将返回 true。
inline void set_acctid(::google::protobuf::int64 value);
// required string passwd = 2;
// 下面的成员函数都是因 message中定义的 passwd 字段而生成。这里生成的函数和上面 acctid
// 生成的那组函数基本相似。因此这里只是列出差异部分。
static const int kPasswdFieldNumber = 2;
inline bool has_passwd() const;
inline void clear_passwd();
inline const ::std::string& passwd() const;
inline void set_passwd(const ::std::string& value);
// 对于字符串类型字段设置 const char* 类型的变量值。
inline void set_passwd(const char* value);
inline void set_passwd(const char* value, size_t size);
// 可以通过返回值直接给 passwd 对象赋值。在调用该函数之后 has_passwd 将返回 true。
inline ::std::string* mutable_passwd();
// 释放当前对象对 passwd 字段的所有权，同时返回 passwd 字段对象指针。调用此函数之后， passwd 字段对象
// 的所有权将移交给调用者。此后再调用 has_passwd 函数时将返回 false。
inline ::std::string* release_passwd();
private:
... ...
};

下面是读写 LogonReqMessage对象的 C++测试代码和说明性注释

void testSimpleMessage()
{
printf("==================This is simple message.================\n");
// 序列化 LogonReqMessage对象到指定的内存区域。
LogonReqMessage logonReq;
logonReq.set_acctid(20);
logonReq.set_passwd("Hello World");
// 提前获取对象序列化所占用的空间并进行一次性分配，从而避免多次分配
// 而造成的性能开销。通过该种方式，还可以将序列化后的数据进行加密。
// 之后再进行持久化，或是发送到远端。
int length = logonReq.ByteSize();
char* buf = new char[length];
logonReq.SerializeToArray(buf,length);
// 从内存中读取并反序列化 LogonReqMessage对象，同时将结果打印出来。
LogonReqMessage logonReq2;
logonReq2.ParseFromArray(buf,length);
printf("acctID = %I64d, password = %s\n",logonReq2.acctid(),logonReq2.passwd().c_str());
delete [] buf;
}

3.5 嵌套 message 生成的 C++代码

enum UserStatus {
OFFLINE = 0;
ONLINE = 1;
}
enum LoginResult {
LOGON_RESULT_SUCCESS = 0;
LOGON_RESULT_NOTEXIST = 1;
LOGON_RESULT_ERROR_PASSWD = 2;
LOGON_RESULT_ALREADY_LOGON = 3;
LOGON_RESULT_SERVER_ERROR = 4;
}
message UserInfo {
required int64 acctID = 1;
required string name = 2;
required UserStatus status = 3;
}
message LogonRespMessage {
required LoginResult logonResult = 1;
required UserInfo userInfo = 2; // 这里嵌套了 UserInfo 消息。
}

对于上述消息生成的 C++代码，UserInfo 因为只是包含了原始类型字段，因此和上例中的 LogonReqMessage没有太多的差别，这里也就不在重复列出了。由于 LogonRespMessage 消息中嵌套了 UserInfo类型的字段，在这里我们将仅仅给出该消息生成的 C++代码和关键性注释。

class LogonRespMessage : public ::google::protobuf::MessageLite {
public:
LogonRespMessage();
virtual ~LogonRespMessage();
// implements Message ----------------------------------------------
... ... // 这部分函数和之前的例子一样。
// required .LoginResult logonResult = 1;
// 下面的成员函数都是因 message中定义的 logonResult 字段而生成。
// 这一点和前面的例子基本相同，只是类型换做了枚举类型 LoginResult。
static const int kLogonResultFieldNumber = 1;
inline bool has_logonresult() const; 
inline void clear_logonresult();
inline LoginResult logonresult() const;
inline void set_logonresult(LoginResult value);
// required .UserInfo userInfo = 2;
// 下面的成员函数都是因 message中定义的 UserInfo 字段而生成。
// 这里只是列出和非消息类型字段差异的部分。
static const int kUserInfoFieldNumber = 2;
inline bool has_userinfo() const;
inline void clear_userinfo();
inline const ::UserInfo& userinfo() const;
// 可以看到该类并没有生成用于设置和修改 userInfo 字段 set_userinfo 函数，而是将该工作
// 交给了下面的 mutable_userinfo 函数。因此每当调用函数之后， Protocol Buffer 都会认为
// 该字段的值已经被设置了，同时 has_userinfo 函数亦将返回 true。在实际编码中，我们可以
// 通过该函数返回 userInfo 字段的内部指针，并基于该指针完成 userInfo 成员变量的初始化工作。
inline ::UserInfo* mutable_userinfo();
inline ::UserInfo* release_userinfo();
private:
... ...
};

下面是读写 LogonRespMessage对象的 C++测试代码和说明性注释

void testNestedMessage()
{
printf("==================This is nested message.================\n");
LogonRespMessage logonResp;
logonResp.set_logonresult(LOGON_RESULT_SUCCESS);
// 如上所述，通过 mutable_userinfo 函数返回 userInfo 字段的指针，之后再初始化该对象指针。
UserInfo* userInfo = logonResp.mutable_userinfo();
userInfo->set_acctid(200);
userInfo->set_name("Tester");
userInfo->set_status(OFFLINE);
int length = logonResp.ByteSize();
char* buf = new char[length];
logonResp.SerializeToArray(buf,length);
LogonRespMessage logonResp2;
logonResp2.ParseFromArray(buf,length);
printf("LogonResult = %d, UserInfo->acctID = %I64d, UserInfo->name = %s, UserInfo->status = %d\n"
,logonResp2.logonresult(),logonResp2.userinfo().acctid(),logonResp2.userinfo().name().c_str(),logonResp2.userinfo()
.status());
delete [] buf;
}

3.6 repeated 嵌套 message 生成的 C++代码

message BuddyInfo {
required UserInfo userInfo = 1;
required int32 groupID = 2;
}
message RetrieveBuddiesResp {
required int32 buddiesCnt = 1;
repeated BuddyInfo buddiesInfo = 2;
}

对于上述消息生成的代码，我们将只是针对 RetrieveBuddiesResp消息所对应的 C++代码进行详细说明，其余部分和前面小节的例子基本相同，可直接参照。而对于 RetrieveBuddiesResp类中的代码，我们也仅仅是对 buddiesInfo 字段生成的代码进行更为详细的解释。

class RetrieveBuddiesResp : public ::google::protobuf::MessageLite {
public:
RetrieveBuddiesResp();
virtual ~RetrieveBuddiesResp();
... ... // 其余代码的功能性注释均可参照前面的例子。
// repeated .BuddyInfo buddiesInfo = 2;
static const int kBuddiesInfoFieldNumber = 2;
// 返回数组中成员的数量。
inline int buddiesinfo_size() const;
// 清空数组中的所有已初始化成员，调用该函数后， buddiesinfo_size 函数将返回 0。
inline void clear_buddiesinfo();
// 返回数组中指定下标所包含元素的引用。
inline const ::BuddyInfo& buddiesinfo(int index) const;
// 返回数组中指定下标所包含元素的指针，通过该方式可直接修改元素的值信息。
inline ::BuddyInfo* mutable_buddiesinfo(int index);
// 像数组中添加一个新元素。返回值即为新增的元素，可直接对其进行初始化。
inline ::BuddyInfo* add_buddiesinfo();
// 获取 buddiesInfo 字段所表示的容器，该函数返回的容器仅用于遍历并读取，不能直接修改。
inline const ::google::protobuf::RepeatedPtrField< ::BuddyInfo >&
buddiesinfo() const;
// 获取 buddiesInfo 字段所表示的容器指针，该函数返回的容器指针可用于遍历和直接修改。
inline ::google::protobuf::RepeatedPtrField< ::BuddyInfo >*
mutable_buddiesinfo(); 
private:
... ...
};

下面是读写 RetrieveBuddiesResp对象的 C++测试代码和说明性注释

void testRepeatedMessage()
{
printf("==================This is repeated message.================\n");
RetrieveBuddiesResp retrieveResp;
retrieveResp.set_buddiescnt(2);
BuddyInfo* buddyInfo = retrieveResp.add_buddiesinfo();
buddyInfo->set_groupid(20);
UserInfo* userInfo = buddyInfo->mutable_userinfo();
userInfo->set_acctid(200);
userInfo->set_name("user1");
userInfo->set_status(OFFLINE);
buddyInfo = retrieveResp.add_buddiesinfo();
buddyInfo->set_groupid(21);
userInfo = buddyInfo->mutable_userinfo();
userInfo->set_acctid(201);
userInfo->set_name("user2");
userInfo->set_status(ONLINE);
int length = retrieveResp.ByteSize();
char* buf = new char[length];
retrieveResp.SerializeToArray(buf,length);
RetrieveBuddiesResp retrieveResp2;
retrieveResp2.ParseFromArray(buf,length);
printf("BuddiesCount = %d\n",retrieveResp2.buddiescnt());
printf("Repeated Size = %d\n",retrieveResp2.buddiesinfo_size());
// 这里仅提供了通过容器迭代器的方式遍历数组元素的测试代码。
// 事实上，通过 buddiesinfo_size 和 buddiesinfo 函数亦可循环遍历。
RepeatedPtrField<BuddyInfo>* buddiesInfo = retrieveResp2.mutable_buddiesinfo();
RepeatedPtrField<BuddyInfo>::iterator it = buddiesInfo->begin();
for (; it != buddiesInfo->end(); ++it) {
printf("BuddyInfo->groupID = %d\n", it->groupid());
printf("UserInfo->acctID = %I64d, UserInfo->name = %s, UserInfo->status = %d\n"
, it->userinfo().acctid(), it->userinfo().name().c_str(),it->userinfo().status());
}
delete [] buf;
}

3.7 写入 message

#include"addressbook.pb.h"
#include<iostream>
#include<unistd.h>
#include<sys/types.h>
#include<sys/stat.h>
#include<fcntl.h>
#include<stdio.h>
#include<string.h>
#include<sys/socket.h>
#include<netinet/in.h>
#include<arpa/inet.h>
#include<stdlib.h>
#include<string>
using namespace std;
{
// 填充消息
void PromptInput(tutorial::Person* person){
person->set_id(2008);
person->set_name("Joe");
person->set_email("joepayne@163.com");
int i=0;
while(i<3){
tutorial::Person::PhoneNumber* phone_number=person->add_phone(); 
phone_number->set_number("13051889399");
phone_number->set_type(tutorial::Person::MOBILE);
i++;
}
}
}
int main(){
{
// 建立 SOCKET连接
}
int n=0;
tutorial::AddressBook msg1;
PromptInput(msg1.add_person());
string s;
int uSize;
{
// 发送 1 个消息包
while(n<1){
// 两次发送过程
{
 msg1.SerializeToString(&s);
// 把消息包的长度发送出去
usize=s.size();
write(sockfd,&uSize,sizeof(uSize));
// 把消息包发送出去
// 注意如果消息数据比较大的话，一次 IO写操作不能写完，那就需要自己另作处理了
write(sockfd,s.data(),s.size());
}
// 输出包的大小
cout<<"Message size:"<<uSize<<endl;
n++;
}
return 0;
}

3.8 读出 message

#include"addressbook.pb.h"
#include<iostream>
#include<unistd.h>
#include<sys/types.h> 
#include<sys/stat.h>
#include<fcntl.h>
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<sys/socket.h>
#include<netinet/in.h>
#include<arpa/inet.h>
#include<stdlib.h>
using namespace std;
// 列出消息中的所有数据
void List(const tutorial::AddressBook& address_book){
for(int i=0;i<address_book.person_size();i++){
const tutorial::Person& person=address_book.person(i);
cout<<"Person ID:"<<person.id()<<endl;
cout<<"Name:"<<person.name()<<endl;
if(person.has_email()){
cout<<"E-mail address:"<<person.email()<<endl;
}
for(int j=0;j<person.phone_size();j++){
const tutorial::Person::PhoneNumber& phone_number=person.phone(j);
switch(phone_number.type()){
case tutorial::Person::MOBILE:
cout<<"Mobile phone:";
break;
case tutorial::Person::HOME:
cout<<"Home phone:";
break;
case tutorial::Person::WORK:
cout<<"WOrk Phone:";
break;
}
cout<<phone_number.number()<<endl;
}
}
}
int main(){
{
// 建立连接
}
tutorial::AddressBook msg2; 
int uLen;
char* uData;
int nRead;
{
// 读取数据
// 先读取消息包的长度信息
while((nRead=read(connfd,&uLen,sizeof(uLen)))>0){
cout<<"The length of the message is:"<<uLen<<endl;
// 根据消息包的长度信息，分配适当大小的缓冲区来接收消息包数据
uData=(char*)malloc(uLen);
// 注意此次 read 可能一次性读不完一个包，如果包比较大的话，这样的话就得自己再做进一步处
理
read(connfd,uData,uLen);
// 解码操 作，从 缓冲 区中解 到 msg2 消息空间中去， 此 处用 ParseFromArray 而没有使用ParseFromString 因为前者的效率相对于后者效率要高很多。
if(!msg2.ParseFromArray(uData,uLen)){
cout<<”Parse failed!”<<endl;
return -1;
}
free(uData);
uData=NULL;
// 输出消息的数据信息
List(msg2);
}
}
return 0;
}

附录：驼峰命名法

驼峰命名法就是当变量名或函式名是由一个或多个单字连结在一起，而构成的唯一识别字时，第一个单字以小写字母开始；第二个单字的首字母大写或每一个单字的首字母都采用大写字母，例如：myFirstName、 myLastName，这样的变量名看上去就像骆驼峰一样此起彼伏，故得名。

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。