Développement Golang : comment utiliser gRPC pour réaliser une communication multilingue

Développement Golang : Comment utiliser gRPC pour réaliser une communication multilingue

Aperçu :
Dans le développement de logiciels modernes, la communication inter-systèmes entre différents langages est très courante. Afin de résoudre ce problème, Google a ouvert le framework gRPC, qui est un framework d'appel de procédure à distance (RPC) multilingue hautes performances. Cet article expliquera comment utiliser gRPC dans le développement Golang et aidera les lecteurs à comprendre comment établir une communication multilingue grâce à des exemples de code spécifiques.

Qu'est-ce que gRPC ?
gRPC (gRPC Remote Procedure Call) est un framework d'appel de procédure à distance (RPC) multilingue, open source et hautes performances. Il est développé sur la base du protocole de sérialisation Protocol Buffers (ProtoBuf en abrégé) de Google. En définissant les types de services et de messages, gRPC peut facilement générer du code côté client et côté serveur dans différentes langues pour établir une communication entre différentes langues.

Préparation de l'environnement :
Avant de commencer, assurez-vous d'avoir installé l'environnement de développement de Golang et gRPC. Vous pouvez installer les outils de développement gRPC et les plug-ins Golang via la documentation officielle.

Étape 1 : Définir le fichier .proto
Le fichier .proto est l'un des cœurs de gRPC et est utilisé pour définir les services et les types de messages. Nous pouvons utiliser le langage ProtoBuf pour définir des structures de données et des services.

Ce qui suit est un exemple simple de fichier .proto qui définit un service HelloWorld, y compris une méthode SayHello. Le paramètre d'entrée est un message HelloRequest et renvoie un message HelloResponse.

syntax = "proto3";

package helloworld;

service Greeter {
  rpc SayHello (HelloRequest) returns (HelloResponse);
}

message HelloRequest {
  string name = 1;
}

message HelloResponse {
  string message = 1;
}

Étape 2 : Générer du code
Après avoir défini le fichier .proto, nous pouvons utiliser le protocole du compilateur de protocole fourni par gRPC pour générer du code côté client et serveur dans le langage correspondant.

Exécutez la commande suivante dans le terminal pour générer du code Golang :

protoc -I=./protos --go_out=plugins=grpc:./protos ./protos/helloworld.proto

Cette commande générera un fichier helloworld.pb.go basé sur le répertoire où se trouve le fichier .proto. C'est le code que nous utiliserons plus tard.

Étape 3 : Écrire du code côté serveur
Ensuite, nous utilisons Golang pour écrire du code côté serveur. Tout d’abord, nous devons importer gRPC et le fichier .pb.go généré automatiquement.

package main

import (
    "context"
    "fmt"
    "log"
    "net"

    "github.com/example/protos"
    "google.golang.org/grpc"
)

const (
    port = ":50051"
)

type server struct{}

func (s *server) SayHello(ctx context.Context, in *protos.HelloRequest) (*protos.HelloResponse, error) {
    return &protos.HelloResponse{Message: "Hello " + in.Name}, nil
}

func main() {
    lis, err := net.Listen("tcp", port)
    if err != nil {
        log.Fatalf("failed to listen: %v", err)
    }
    s := grpc.NewServer()
    protos.RegisterGreeterServer(s, &server{})
    fmt.Println("Server started on port" + port)
    if err := s.Serve(lis); err != nil {
        log.Fatalf("failed to serve: %v", err)
    }
}

Dans le code ci-dessus, nous définissons une structure nommée server et implémentons la méthode SayHello que nous avons définie dans le fichier .proto. Parmi elles, la méthode SayHello reçoit un paramètre de type HelloRequest et renvoie une réponse de type HelloResponse.

Étape 4 : Écrire le code client
Ensuite, nous utilisons Golang pour écrire le code client. Tout d’abord, vous devez également importer gRPC et le fichier .pb.go généré automatiquement.

package main

import (
    "context"
    "fmt"
    "log"

    "github.com/example/protos"
    "google.golang.org/grpc"
)

const (
    address = "localhost:50051"
)

func main() {
    conn, err := grpc.Dial(address, grpc.WithInsecure())
    if err != nil {
        log.Fatalf("did not connect: %v", err)
    }
    defer conn.Close()
    c := protos.NewGreeterClient(conn)
    name := "World"
    r, err := c.SayHello(context.Background(), &protos.HelloRequest{Name: name})
    if err != nil {
        log.Fatalf("could not greet: %v", err)
    }
    log.Printf("Greeting: %s", r.Message)
    fmt.Println("Client finished")
}

Dans le code ci-dessus, nous utilisons grpc.Dial pour établir une connexion avec le serveur et créer un GreeterClient pour appeler la méthode SayHello. Ensuite, affichez le contenu du message renvoyé par le serveur.

Étape 5 : Exécuter le code
Enfin, nous exécutons ces deux morceaux de code pour le tester. Commencez par démarrer le code côté serveur, puis démarrez le code côté client.

Vous verrez le serveur imprimer « Serveur démarré sur le port : 50051 » et le client imprimer « Salutation : Hello World ». Cela signifie que le serveur a reçu avec succès la demande du client et a renvoyé une réponse correcte.

Résumé :
En utilisant le framework gRPC, nous pouvons facilement réaliser une communication multilingue. Dans cet article, nous montrons comment développer à l'aide de gRPC dans Golang grâce à un exemple de code spécifique. Vous pouvez définir des messages et des services en fonction de vos besoins et écrire du code côté serveur et côté client pour permettre la communication multilingue. J'espère que cet article pourra vous aider à comprendre et à utiliser le framework gRPC.

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!