Wie man Protobuf durch Golang baut

Mit der Entwicklung der Internet-Technologie interessieren sich immer mehr Programmieranfänger für die Golang-Sprache. Als aufstrebende Programmiersprache wird Golang zunehmend von Programmierern verwendet. Kenntnisse der Golang-Sprache können Programmierern dabei helfen, schnell qualitativ hochwertige Anwendungen zu entwickeln und so ihre Arbeitseffizienz zu verbessern. In diesem Artikel werden wir untersuchen, wie man Protobuf durch Golang aufbaut.

1. Einführung in Protobuf

Protobuf, vollständiger Name Protocol Buffers, ist ein Protokoll, das Datenformat, Datenspeicherung und Datenaustausch beschreibt und Schnittstellenbibliotheken für verschiedene Programmiersprachen bereitstellt. Protobuf kann strukturierte Daten serialisieren, den Speicherplatz effektiv komprimieren und verfügt über eine gute Skalierbarkeit, wodurch es sich sehr gut für den Einsatz auf verschiedenen verteilten Systemen eignet.

2. Protobuf installieren

Um Protobuf zu verwenden, müssen wir zuerst Protobuf auf dem System installieren. Im Folgenden stellen wir vor, wie man Protobuf auf einem Linux-System installiert.

1. Abhängige Bibliotheken installieren

Bevor Sie Protobuf installieren, müssen Sie zunächst einige abhängige Bibliotheken installieren. Wir können den folgenden Befehl verwenden, um abhängige Bibliotheken zu installieren:

sudo apt-get update

sudo apt-get install autoconf automake libtool curl make g++ unzip

2. Protobuf-Quellcode herunterladen

Wir können auf die offizielle Website von Protobuf gehen, um das Protobuf-Quellcodepaket herunterzuladen: https://github.com/protocolbuffers/protobuf /Veröffentlichungen. Wählen Sie die für Ihr aktuelles Betriebssystem geeignete Version aus und extrahieren Sie sie nach dem Herunterladen in den angegebenen Pfad.

3. Protobuf kompilieren

Führen Sie den folgenden Befehl im dekomprimierten Protobuf-Quellcodeverzeichnis aus:

./autogen.sh
./configure
make
make check
sudo make install
sudo ldconfig

Wenn die obigen Schritte erfolgreich ausgeführt werden, wurde Protobuf erfolgreich installiert.

3. Protobuf verwenden

Nach der Installation von Protobuf können wir mit der Verwendung von Protobuf beginnen. Das Folgende ist ein einfaches Beispiel für die Schritte zur Verwendung von Protobuf über Golang:

1. Definieren Sie die Datenstruktur

Wir müssen die Datenstruktur in der .gproto-Datei definieren. Beispielsweise definieren wir eine Employee-Datenstruktur, die wie folgt definiert ist:

syntax = "proto3";

package myproto;

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

Der obige Code definiert eine Datenstruktur namens Employee, die drei Felder enthält: Name, ID und E-Mail. Jedes Feld verfügt über eine eindeutige Identifikationsnummer, die für die Kommunikation zwischen verschiedenen Implementierungen verwendet wird.

2. Golang-Datei generieren

Nachdem wir die Datenstruktur definiert haben, müssen wir sie mit dem Protobuf-Compiler in Golang-Code konvertieren. Verwenden Sie den folgenden Befehl, um Golang-Dateien zu generieren:

protoc --go_out=. employee.proto

wobei Employee.proto eine definierte Datenstrukturdatei ist und die Option --go_out die Generierung von Golang-Code angibt. Dieser Befehl generiert die Datei „employee.pb.go“ im selben Verzeichnis.

3. Golang-Code verwenden

Nachdem wir den Golang-Code generiert haben, können wir ihn in Golang verwenden. Im Folgenden finden Sie ein Beispielprogramm, das ein Employee-Objekt erstellt, es serialisiert und anschließend deserialisiert.

package main

import (
    "bytes"
    "fmt"
    "myproto"
    "strconv"

    "github.com/golang/protobuf/proto"
)

func main() {
    // 创建一个Employee对象
    employee := &myproto.Employee{
        Name: "张三",
        Id:   10001,
        Email: "zhangsan@qq.com",
    }
    fmt.Println("Employee对象：", employee)

    // 将Employee对象序列化为二进制数据
    data, err := proto.Marshal(employee)
    if err != nil {
        fmt.Println("序列化失败：", err)
        return
    }
    fmt.Println("序列化后的二进制数据：", data)

    // 将二进制数据反序列化为Employee对象
    newEmployee := &myproto.Employee{}
    err = proto.Unmarshal(data, newEmployee)
    if err != nil {
        fmt.Println("反序列化失败：", err)
        return
    }
    fmt.Println("反序列化后的Employee对象：", newEmployee)

    // 检查序列化和反序列化是否成功
    if newEmployee.Name != employee.Name ||
        newEmployee.Id != employee.Id ||
        newEmployee.Email != employee.Email {
        fmt.Println("反序列化结果与原始对象不一致！")
        return
    }
    fmt.Println("序列化和反序列化成功！")
}

Im obigen Code verwenden wir die von protobuf bereitgestellten Methoden proto.Marshal und proto.Unmarshal, um das Employee-Objekt zu serialisieren und zu deserialisieren. Wenn das Programm erfolgreich ausgeführt wird, können wir sehen, dass das Ausgabeergebnis wie folgt lautet:

Employee对象： name:"张三" id:10001 email:"zhangsan@qq.com"
序列化后的二进制数据： [10 6 230 181 139 229 173 151 16 1 26 12 122 104 97 110 103 115 97 110 64 113 113 46 99 111 109]
反序列化后的Employee对象： name:"张三" id:10001 email:"zhangsan@qq.com"
序列化和反序列化成功！

IV Zusammenfassung

In diesem Artikel haben wir vorgestellt, wie man Protobuf über Golang erstellt. Zuerst haben wir die von Protobuf abhängige Bibliothek installiert, dann Protobuf kompiliert und schließlich Protobuf in Golang für die Serialisierung und Deserialisierung verwendet. Neben der Verwendung in Golang kann Protobuf auch in anderen Programmiersprachen wie Python und Java verwendet werden, was sich sehr gut für den Datenaustausch in verteilten Systemen eignet. Ich hoffe, dass dieser Artikel Programmierern helfen kann, die Protobuf-Technologie besser zu erlernen und zu beherrschen.

Das obige ist der detaillierte Inhalt vonWie man Protobuf durch Golang baut. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!