Comment construire Protobuf via Golang

Avec le développement de la technologie Internet, de plus en plus de programmeurs débutants s'intéressent au langage golang. En tant que langage de programmation émergent, Golang est de plus en plus utilisé par les programmeurs. La maîtrise du langage Golang peut aider les programmeurs à développer rapidement des applications de haute qualité, améliorant ainsi leur efficacité au travail. Dans cet article, nous explorerons comment créer protobuf via Golang.

1. Introduction à protobuf

protobuf, le nom complet est Protocol Buffers, est un protocole qui décrit le format des données, le stockage et l'échange de données, et fournit des interfaces pour différents bibliothèque de langages de programmation. protobuf peut sérialiser des données structurées, compresser efficacement l'espace de stockage et présente une bonne évolutivité, ce qui le rend très approprié pour une utilisation sur divers systèmes distribués.

2. Installez protobuf

Pour utiliser protobuf, nous devons d'abord installer protobuf sur le système. Ci-dessous, nous expliquerons comment installer protobuf sur un système Linux.

1. Installer les bibliothèques dépendantes

Avant d'installer protobuf, vous devez d'abord installer certaines bibliothèques dépendantes. Nous pouvons utiliser la commande suivante pour installer les bibliothèques dépendantes :

sudo apt-get update

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

2. Télécharger le code source de protobuf

Nous pouvons aller sur le site officiel de protobuf pour téléchargez le package de code source protobuf : https://github.com/protocolbuffers/protobuf/releases. Sélectionnez la version adaptée à votre système d'exploitation actuel et après le téléchargement, extrayez-la vers le chemin spécifié.

3. Compile protobuf

Exécutez la commande suivante dans le répertoire du code source protobuf décompressé :

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

Si ce qui précède Si toutes les étapes sont exécutées avec succès, alors protobuf a été installé avec succès.

3. Utilisez protobuf

Après avoir installé protobuf, nous pouvons commencer à utiliser protobuf. Voici un exemple simple des étapes à suivre pour utiliser protobuf via golang :

1. Définir la structure des données

Nous devons définir les données dans la structure du fichier .gproto. Par exemple, nous définissons une structure de données Employee, qui est définie comme suit :

syntax = "proto3";

package myproto;

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

Le code ci-dessus définit une structure de données nommée Employee, qui comprend trois champs : nom, identifiant et e-mail. Chaque champ possède un numéro d'identification unique utilisé pour la communication entre différentes implémentations.

2. Générer un fichier golang

Après avoir défini la structure des données, nous devons utiliser le compilateur protobuf pour le convertir en code golang. Utilisez la commande suivante pour générer des fichiers Golang :

protoc --go_out=. employee.proto

où Employee.proto est un fichier de structure de données défini et l'option --go_out indique la génération de code Golang. Cette commande générera le fichier employe.pb.go dans le même répertoire.

3. Utiliser le code golang

Après avoir généré le code golang, nous pouvons l'utiliser en golang. Voici un exemple de programme qui crée un objet Employee, le sérialise, puis le désérialise.

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("序列化和反序列化成功！")
}

Dans le code ci-dessus, nous utilisons les méthodes proto.Marshal et proto.Unmarshal fournies par protobuf pour sérialiser et désérialiser l'objet Employee. Si le programme est exécuté avec succès, alors nous pouvons voir que le résultat de sortie est :

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"
序列化和反序列化成功！

4. Résumé

Dans cet article, nous avons présenté comment construire protobuf via golang. Nous avons d'abord installé la bibliothèque de dépendances protobuf, puis compilé protobuf et enfin utilisé protobuf dans Golang pour la sérialisation et la désérialisation. En plus d'être utilisé dans Golang, protobuf peut également être utilisé dans d'autres langages de programmation tels que Python et Java, ce qui est très approprié pour l'échange de données dans les systèmes distribués. J'espère que cet article pourra aider les programmeurs à mieux apprendre et maîtriser la technologie protobuf.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!