亚洲在线久爱草,狠狠天天香蕉网,天天搞日日干久草,伊人亚洲日本欧美

為了賬號安全，請及時綁定郵箱和手機立即綁定

Protobuf原理詳解：入門級教程

概述

Protobuf是一种由Google开发的数据序列化格式，广泛应用于数据交换领域。本文详细介绍了Protobuf的基本概念、定义方式以及序列化与反序列化过程。文中还探讨了Protobuf原理及其在实际项目中的应用示例，如用户数据存储和传输、日志记录和分析以及API数据传输。

Protobuf简介

Google于2008年开源了Protocol Buffers（简称protobuf），它是一种语言中立、平台独立的结构化数据序列化格式，用于数据交换。protobuf可以将结构化的数据序列化为二进制格式，同时也可以将二进制数据解析为结构化的数据。它广泛应用于各种编程语言和系统中，如C++、Java、Python等，能够极大提高数据传输和存储的效率。protobuf与XML和JSON相比，具有更小的数据体积、更高的序列化和反序列化速度，以及更强的数据结构声明和版本控制能力。

Protobuf的基本概念

protobuf定义了一种结构化数据的描述语言，通过这种语言可以定义数据结构（消息类型）。这种语言的文件扩展名为.proto。在.proto文件中定义的数据结构可以通过protobuf编译器转换为多种编程语言的代码，这些代码可以用来生成和解析protobuf格式的数据。

消息类型

在.proto文件中，最基本的概念是消息类型。消息类型定义了一组字段，这些字段可以是任何基本类型（如整数、字符串等），也可以是其他消息类型的嵌套。例如，下面是一个简单的.proto文件示例，定义了一个名为Person的消息类型，该消息类型包含三个字段：name、id和email。

syntax = "proto3";

message Person {
  string name = 1;
  int32 id = 2;
  string email = 3;
}

在上述定义中，name字段是字符串类型，id字段是整数类型，email字段也是字符串类型。每个字段后面都紧跟一个数字，该数字是字段的唯一标识符，用于序列化和反序列化时的标识。字段的编号必须在1到15之间，以获得更高效的二进制编码。

字段规则

在定义字段时，需要考虑字段规则，常见的字段规则包括optional、required和repeated。这些规则定义了字段在消息中的行为。

  • optional：表示字段是可选的，可以存在也可以不存在。例如，在Person消息类型中，email字段可以是可选的：

    message Person {
string name = 1;
int32 id = 2;
optional string email = 3;
}

  • required：表示字段是必须的，必须存在且只能出现一次。例如，在Person消息类型中，name字段可以是必须的：

    message Person {
required string name = 1;
int32 id = 2;
optional string email = 3;
}
  • repeated：表示字段可以出现多次。例如，在Person消息类型中，phone字段可以是一个重复字段： 
    message Person {
string name = 1;
int32 id = 2;
optional string email = 3;
repeated string phone = 4;
}

字段类型

字段可以是基本类型，也可以是其他消息类型的嵌套。基本类型包括：

  • int32、int64、uint32、uint64：整数类型。
  • float、double：浮点数类型。
  • bool：布尔类型。
  • string：字符串类型。
  • bytes：字节数组类型。

例如，可以定义一个包含嵌套消息的消息类型，如下所示：

message Address {
  string street = 1;
  string city = 2;
}

message Person {
  string name = 1;
  int32 id = 2;
  string email = 3;
  optional Address address = 4;
}

在上面的示例中，Person消息类型包含一个Address消息类型的optional字段，用于表示地址信息。

重复字段

在某些情况下，一个字段可能需要包含多个值。在这种情况下，可以使用重复字段。重复字段通过在字段类型前加上repeated关键字来定义。例如，可以定义一个包含多个电话号码的Person消息类型：

message Person {
  string name = 1;
  int32 id = 2;
  string email = 3;
  repeated string phone = 4;
}

在上面的示例中，phone字段是一个重复字段，可以包含多个电话号码。

Protobuf的定义方式

要使用protobuf，第一步是创建一个.proto文件，定义所需的消息类型。该文件包含了数据的结构化定义，可以被编译成不同编程语言的代码。以下是一个.proto文件的示例，定义了一个简单的消息类型：

syntax = "proto3";
package tutorial;

import "google/protobuf/timestamp.proto";

message Person {
  string name = 1;
  int32 id = 2;
  string email = 3 [default = ""];  // 设置默认值
  optional string address = 4;
  required string phoneNumber = 5;
  repeated string phoneNumbers = 6;
}

message AddressBook {
  repeated Person people = 1;
}

在上面的.proto文件中，定义了两个主要消息类型：Person和AddressBook。

  • Person消息类型包含以下字段：

    • name：字符串类型的姓名。
    • id：整数类型的唯一标识符。
    • email：字符串类型的电子邮件地址。
    • address：一个optional字段，可以存储地址信息。
    • phoneNumber：一个required字段，必须填写电话号码。
    • phoneNumbers：一个repeated字段，可以包含多个电话号码。
  • AddressBook消息类型包含一个Person消息类型的重复字段people，用于存储多个Person对象。

在定义完.proto文件后，需要使用protobuf编译器（protoc）将.proto文件编译成所需编程语言的代码。例如，使用以下命令将.proto文件编译为Java代码：

protoc -I=. --java_out=. addressbook.proto

编译完成后，会生成对应的Java类文件，可以用于序列化和反序列化protobuf格式的数据。

Protobuf的序列化与反序列化过程

protobuf的序列化和反序列化过程分别将结构化的数据转换为二进制格式和从二进制格式恢复为结构化的数据。下面通过示例来展示protobuf的序列化和反序列化过程。

序列化过程

序列化过程将结构化的数据转换为二进制格式。首先需要创建protobuf定义的消息对象，并填充所需的数据。然后，通过protobuf提供的序列化方法将消息对象转换为二进制格式。

例如，使用Java语言，定义一个简单的Person消息类型，并对其进行序列化：

import com.google.protobuf.ByteString;
import tutorial.AddressBookProtos.Person;
import tutorial.AddressBookProtos.Person.PhoneNumber;
import com.google.protobuf.InvalidProtocolBufferException;

public class ProtobufExample {
  public static void main(String[] args) {
    // 创建一个Person对象
    Person.Builder personBuilder = Person.newBuilder();
    personBuilder.setName("John Doe");
    personBuilder.setId(1234);
    personBuilder.setEmail("[email protected]");

    // 创建一个PhoneNumber对象，并添加到Person对象中
    PhoneNumber.Builder phoneBuilder = PhoneNumber.newBuilder();
    phoneBuilder.setNumber("555-4321");
    phoneBuilder.setType(PhoneNumber.Type.HOME);
    personBuilder.addPhones(phoneBuilder.build());

    // 序列化Person对象
    Person person = personBuilder.build();
    byte[] serializedPerson = person.toByteArray();

    // 输出序列化后的数据
    System.out.println("Serialized Person: " + ByteString.copyFrom(serializedPerson));
  }
}

在上面的示例中，首先创建了一个Person对象，并填充了name、id、email和phones字段。然后，通过toByteArray()方法将Person对象序列化为二进制格式。

反序列化过程

反序列化过程将二进制格式的数据转换为结构化的数据。首先需要从二进制数据中解析出protobuf定义的消息对象。然后，可以通过protobuf提供的方法访问解析后的数据。

例如，继续使用Java语言，定义一个简单的Person消息类型，并对其进行反序列化：

import tutorial.AddressBookProtos.Person;
import tutorial.AddressBookProtos.Person.PhoneNumber;
import com.google.protobuf.ByteString;
import com.google.protobuf.InvalidProtocolBufferException;

public class ProtobufExample {
  public static void main(String[] args) {
    // 定义一个序列化的Person对象
    byte[] serializedPerson = new byte[] { 0x0a, 0x0b, ... }; // 示例数据，实际应从文件或网络等来源获取

    try {
      // 反序列化Person对象
      Person person = Person.parseFrom(serializedPerson);

      // 输出反序列化后的数据
      System.out.println("Name: " + person.getName());
      System.out.println("ID: " + person.getId());
      System.out.println("Email: " + person.getEmail());

      for (PhoneNumber phone : person.getPhonesList()) {
        System.out.println("Phone: " + phone.getNumber() + " (" + phone.getType().toString() + ")");
      }
    } catch (InvalidProtocolBufferException e) {
      e.printStackTrace();
    }
  }
}

在上面的示例中，首先定义了一个序列化的Person对象serializedPerson。然后，通过parseFrom()方法将序列化的数据解析为Person对象。解析后的数据可以通过protobuf提供的方法访问，例如getName()、getId()、getEmail()等。此外，还可以通过getPhonesList()方法获取phones字段中的所有电话号码。

Protobuf的优缺点分析

优点

  1. 高效的数据序列化：protobuf采用紧凑的二进制格式，比XML和JSON格式更高效。它能更快速地进行序列化和反序列化，适合网络传输和存储。
  2. 语言中立：protobuf定义了一种数据结构描述语言，可以在多种编程语言中使用。通过protobuf编译器，可以将.proto文件转换为不同编程语言的代码，实现跨语言的数据交换。
  3. 版本兼容性：protobuf提供了向前和向后的兼容性。旧版本的protobuf数据可以被新版本的protobuf解析器解析，新版本的数据也可以被旧版本的解析器解析。这使得在维护和升级过程中不会因为版本变化而影响数据的解析和使用。
  4. 灵活的数据结构定义：protobuf支持多种数据类型，包括基本类型、嵌套结构和重复字段。这种灵活的数据定义方式使protobuf能够适应各种复杂的数据结构需求。
  5. 轻量级且易于使用：protobuf的定义语言简单易懂，学习成本低。同时，protobuf生成的代码也简洁明了，易于理解和使用。
  6. 强大的工具支持：protobuf提供了一系列强大的工具和库，如protobuf编译器、protobuf解析器和protobuf工具链，这些工具可以极大地简化数据处理和交换的过程。

缺点

  1. 学习曲线：虽然protobuf的定义语言简单易懂，但初次接触可能会有一定的学习成本。特别是对于复杂的嵌套结构和版本管理，需要一定的理解和实践。
  2. 类型安全问题：protobuf的定义语言不是强类型语言，因此在序列化和反序列化过程中可能会出现类型错误。虽然protobuf提供了类型检查，但在某些情况下可能无法完全避免类型错误。
  3. 动态性较差：protobuf的数据结构是静态定义的，一旦定义好，就很难在运行时进行修改。这使得protobuf不适合需要高度动态性的应用场景。
  4. 不支持泛型：protobuf不支持泛型数据类型，这意味着在定义数据结构时需要明确指定每个字段的类型。这在某些情况下可能会限制灵活性。
  5. 序列化和反序列化复杂：虽然protobuf的序列化和反序列化速度快，但在某些复杂的应用场景中，需要编写额外的代码来处理数据的转换和解析。
  6. 兼容性问题：虽然protobuf提供了较好的向后和向前兼容性，但在实际应用中，仍然需要谨慎处理版本管理，避免因为版本变化而影响数据解析和使用。
  7. 缺乏元数据信息：protobuf序列化后的数据不包含元数据信息，如字段的名称和类型。这在某些情况下可能会给调试和维护带来不便。

Protobuf在实际项目中的应用示例

应用场景：用户数据存储和传输

在实际项目中，protobuf可以用于存储和传输用户数据，例如用户登录信息、用户偏好设置等。下面是一个简单的示例，展示了如何使用protobuf存储和传输用户登录信息。

首先定义一个.proto文件，定义用户登录信息的消息类型：

syntax = "proto3";

package userauth;

message UserLogin {
  string username = 1;
  string password = 2;
}

然后，使用Java语言，定义一个简单的用户登录信息处理类，包括序列化和反序列化操作：

import com.google.protobuf.InvalidProtocolBufferException;
import userauth.UserLoginProtos.UserLogin;

public class UserLoginExample {
  public static void main(String[] args) {
    // 创建一个UserLogin对象，并填充数据
    UserLogin.Builder userBuilder = UserLogin.newBuilder();
    userBuilder.setUsername("john_doe");
    userBuilder.setPassword("securepassword");

    // 序列化UserLogin对象
    UserLogin userLogin = userBuilder.build();
    byte[] serializedUserLogin = userLogin.toByteArray();

    // 输出序列化后的数据
    System.out.println("Serialized UserLogin: " + new String(serializedUserLogin));

    // 反序列化UserLogin对象
    try {
      UserLogin parsedUserLogin = UserLogin.parseFrom(serializedUserLogin);
      System.out.println("Username: " + parsedUserLogin.getUsername());
      System.out.println("Password: " + parsedUserLogin.getPassword());
    } catch (InvalidProtocolBufferException e) {
      e.printStackTrace();
    }
  }
}

在上面的示例中，首先创建了一个UserLogin对象，并填充了username和password字段。然后，通过toByteArray()方法将UserLogin对象序列化为二进制格式。接着，通过parseFrom()方法将序列化的数据解析为UserLogin对象，并输出解析后的数据。

应用场景：日志记录和分析

protobuf也可以用于日志记录和分析。例如，可以定义一个简单的日志消息类型，包括日志级别、时间戳和日志信息等字段。下面是一个日志记录的示例：

首先定义一个.proto文件，定义日志消息的消息类型：

syntax = "proto3";

package logging;

message LogEntry {
  enum LogLevel {
    INFO = 0;
    WARN = 1;
    ERROR = 2;
  }

  LogLevel level = 1;
  string message = 2;
  string timestamp = 3;
}

然后，使用Java语言，定义一个简单的日志记录类，包括日志记录和序列化操作：

import java.time.Instant;
import java.time.format.DateTimeFormatter;
import com.google.protobuf.InvalidProtocolBufferException;
import logging.LogEntryProtos.LogEntry;

public class LogExample {
  public static void main(String[] args) {
    // 创建一个LogEntry对象，并填充数据
    LogEntry.Builder logBuilder = LogEntry.newBuilder();
    logBuilder.setLevel(LogEntry.LogLevel.ERROR);
    logBuilder.setMessage("An error occurred in the system.");
    logBuilder.setTimestamp(Instant.now().format(DateTimeFormatter.ISO_DATE_TIME));

    // 序列化LogEntry对象
    LogEntry logEntry = logBuilder.build();
    byte[] serializedLogEntry = logEntry.toByteArray();

    // 输出序列化后的数据
    System.out.println("Serialized LogEntry: " + new String(serializedLogEntry));

    // 反序列化LogEntry对象
    try {
      LogEntry parsedLogEntry = LogEntry.parseFrom(serializedLogEntry);
      System.out.println("Level: " + parsedLogEntry.getLevel().toString());
      System.out.println("Message: " + parsedLogEntry.getMessage());
      System.out.println("Timestamp: " + parsedLogEntry.getTimestamp());
    } catch (InvalidProtocolBufferException e) {
      e.printStackTrace();
    }
  }
}

在上面的示例中，首先创建了一个LogEntry对象，并填充了level、message和timestamp字段。然后，通过toByteArray()方法将LogEntry对象序列化为二进制格式。接着，通过parseFrom()方法将序列化的数据解析为LogEntry对象，并输出解析后的数据。

应用场景：API数据传输

在构建API时，protobuf可以用于定义和传输数据结构。例如，可以定义一个简单的API响应消息类型，包括状态码、响应消息和数据等字段。下面是一个API响应的示例：

首先定义一个.proto文件，定义API响应的消息类型：

syntax = "proto3";

package api;

message ApiResponse {
  enum StatusCode {
    OK = 0;
    NOT_FOUND = 1;
    INTERNAL_ERROR = 2;
  }

  StatusCode status = 1;
  string message = 2;
  bytes data = 3;
}

然后，使用Java语言，定义一个简单的API响应类，包括API响应的生成和序列化操作：

import com.google.protobuf.ByteString;
import com.google.protobuf.InvalidProtocolBufferException;
import api.ApiResponseProtos.ApiResponse;

public class ApiExample {
  public static void main(String[] args) {
    // 创建一个ApiResponse对象，并填充数据
    ApiResponse.Builder responseBuilder = ApiResponse.newBuilder();
    responseBuilder.setStatus(ApiResponse.StatusCode.OK);
    responseBuilder.setMessage("Request processed successfully.");
    responseBuilder.setData(ByteString.copyFrom(new byte[] { 0x01, 0x02, 0x03 }));

    // 序列化ApiResponse对象
    ApiResponse apiResponse = responseBuilder.build();
    byte[] serializedApiResponse = apiResponse.toByteArray();

    // 输出序列化后的数据
    System.out.println("Serialized ApiResponse: " + new String(serializedApiResponse));

    // 反序列化ApiResponse对象
    try {
      ApiResponse parsedApiResponse = ApiResponse.parseFrom(serializedApiResponse);
      System.out.println("Status: " + parsedApiResponse.getStatus().toString());
      System.out.println("Message: " + parsedApiResponse.getMessage());
      System.out.println("Data: " + parsedApiResponse.getData().toStringUtf8());
    } catch (InvalidProtocolBufferException e) {
      e.printStackTrace();
    }
  }
}

在上面的示例中，首先创建了一个ApiResponse对象，并填充了status、message和data字段。然后，通过toByteArray()方法将ApiResponse对象序列化为二进制格式。接着，通过parseFrom()方法将序列化的数据解析为ApiResponse对象，并输出解析后的数据。

为了进一步展示protobuf在API数据传输中的应用，这里增加了一个完整的API请求和响应交互示例，包括客户端和服务端的代码：

完整API交互示例（客户端和服务端代码）

首先定义一个.proto文件，定义API请求和响应的消息类型：

syntax = "proto3";

package api;

message ApiRequest {
  string method = 1;
  string url = 2;
  bytes body = 3;
}

message ApiResponse {
  enum StatusCode {
    OK = 0;
    NOT_FOUND = 1;
    INTERNAL_ERROR = 2;
  }

  StatusCode status = 1;
  string message = 2;
  bytes data = 3;
}

然后，使用Python语言，定义一个简单的API客户端和服务端代码，包括请求发送和响应处理：

客户端代码（Python）

from google.protobuf.json_format import MessageToJson
from api_pb2 import ApiRequest, ApiResponse

def send_request(request):
    # 模拟请求发送到服务端
    serialized_request = request.SerializeToString()
    # 模拟服务端响应
    response = ApiResponse()
    response.status = ApiResponse.StatusCode.OK
    response.message = "Request processed successfully."
    response.data = serialized_request
    return response

def main():
    request = ApiRequest()
    request.method = "GET"
    request.url = "http://example.com"
    request.body = b""

    response = send_request(request)
    print(MessageToJson(response))

if __name__ == "__main__":
    main()

服务端代码（Python）

from google.protobuf.json_format import MessageToJson
from api_pb2 import ApiRequest, ApiResponse

def handle_request(request):
    # 处理请求并生成响应
    response = ApiResponse()
    response.status = ApiResponse.StatusCode.OK
    response.message = "Request processed successfully."
    response.data = request.body
    return response

def main():
    # 模拟接收到的请求
    request = ApiRequest()
    request.method = "GET"
    request.url = "http://example.com"
    request.body = b""

    response = handle_request(request)
    print(MessageToJson(response))

if __name__ == "__main__":
    main()

通过这些补充，文章将更加全面和详细，便于读者理解和使用protobuf。

點擊查看更多內容
為 TA 點贊

若覺得本文不錯，就分享一下吧！

評論

作者其他優質文章

正在加載中
  • 推薦
  • 評論
  • 收藏
  • 共同學習，寫下你的評論
感謝您的支持，我會繼續努力的～
掃碼打賞，你說多少就多少
贊賞金額會直接到老師賬戶
支付方式
打開微信掃一掃，即可進行掃碼打賞哦
今天注冊有機會得

100積分直接送

付費專欄免費學

大額優惠券免費領

立即參與 放棄機會
微信客服

購課補貼
聯系客服咨詢優惠詳情

 幫助反饋 APP下載

慕課網APP
您的移動學習伙伴

 公眾號

掃描二維碼
關注慕課網微信公眾號

舉報

0/150
提交
取消