So verwenden Sie gRPC zur Implementierung eines Basisservers und -clients in Golang

gRPC ist ein leistungsstarkes, quelloffenes und universelles Remote-Prozeduraufruf-Framework, das für RPC-Aufrufe in verschiedenen Sprachen und Plattformen geeignet ist. Es verwendet das von Google entwickelte Protobuf-Protokoll für die Datenübertragung, kann die Kommunikation zwischen Server und Client schnell realisieren und bietet umfangreiche Funktionen und Skalierbarkeit. In diesem Artikel wird erläutert, wie Sie mit gRPC grundlegende Server und Clients in Golang implementieren.

1. Installieren Sie gRPC

Bevor wir beginnen, müssen Sie zuerst gRPC und Protobuf installieren. Sie können den folgenden Befehl verwenden:

$ go get -u google.golang.org/grpc
$ go get -u github.com/golang/protobuf/protoc-gen-go

2. Als nächstes müssen wir eine .proto-Datei erstellen Datei definiert uns Die zu übertragenden Daten und die aufzurufende Methode. In diesem Beispiel haben wir eine Datei namens „greet.proto“ erstellt.

syntax = "proto3";

package greet;

service GreetService {
  rpc SayHello (HelloRequest) returns (HelloResponse) {}
}

message HelloRequest {
  string name = 1;
}

message HelloResponse {
  string message = 1;
}

3. Code generieren

GRPC-bezogenen Code über die Protobuf-Datei generieren. Führen Sie den folgenden Befehl aus:

$ protoc -I greet/ greet/greet.proto --go_out=plugins=grpc:greet

Der generierte Code wird im Greet-Verzeichnis gespeichert.

4. Implementieren Sie die Serverseite

In der serverseitigen Implementierung müssen wir die in der Protodatei definierte Serviceschnittstelle implementieren. Wir können die serverseitige Code-Implementierung durch die folgenden Schritte abschließen:

Erstellen Sie einen gRPC-Server

• Registrieren Sie den Dienst
• Führen Sie den Server aus
• Das Folgende ist die Code-Implementierung:

package main

import (
    "context"
    "log"
    "net"

    "google.golang.org/grpc"
    pb "path/to/greet"
)

type server struct {}

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

func main() {
    lis, err := net.Listen("tcp", ":50051")
    if err != nil {
        log.Fatalf("failed to listen: %v", err)
    }
    s := grpc.NewServer()
    pb.RegisterGreetServiceServer(s, &server{})
    if err := s.Serve(lis); err != nil {
        log.Fatalf("failed to serve: %v", err)
    }
}

5. Implementieren Sie den Client

Die Client-Implementierung ist relativ einfach. Wir müssen nur eine Verbindung zum entsprechenden Server herstellen und den Client instanziieren. Anschließend können wir die vom Server bereitgestellten Methoden aufrufen. In der Client-Code-Implementierung müssen Sie zunächst eine Verbindung für die gRPC-Kommunikation erstellen, dann die Verbindung verwenden, um einen Client zu erstellen und die Schnittstellenmethode aufzurufen.

Das Folgende ist die Implementierung des Client-Codes:

package main

import (
    "log"
    "os"
    "context"
    "google.golang.org/grpc"
    pb "path/to/greet"
)

func main() {
    address := "localhost:50051"
    if len(os.Args) > 1 {
        address = os.Args[1]
    }
    conn, err := grpc.Dial(address, grpc.WithInsecure())
    if err != nil {
        log.Fatalf("couldn't connect: %v", err)
    }
    defer conn.Close()

    c := pb.NewGreetServiceClient(conn)

    name := "world"
    if len(os.Args) > 2 {
        name = os.Args[2]
    }
    r, err := c.SayHello(context.Background(), &pb.HelloRequest{Name: name})
    if err != nil {
        log.Fatalf("error: %v", err)
    }
    log.Printf("Greeting: %s", r.Message)
}

6. Testen

Wir haben den Server- und Client-Code implementiert, führen nun den Server aus und starten dann den Client zum Testen.

$ go run greet_server.go

Öffnen Sie nach dem Ausführen des Servers ein Terminal und führen Sie den Client zum Testen aus:

$ go run greet_client.go
Greeting: Hello world

7. Zusammenfassung

In diesem Artikel wird erläutert, wie Sie mit gRPC grundlegende Server und Clients in Golang implementieren. gRPC bietet leistungsstarke Kodierungs- und Dekodierungsfunktionen und unterstützt gleichzeitig mehrere Transportformate, einschließlich JSON und Protokollpufferdaten, wodurch es für verschiedene Arten von Anwendungen geeignet ist. Zum Beispiel verteilte Systeme, umfangreiche Webanwendungen und Spiele usw. Wenn Sie mehr über gRPC erfahren möchten, schauen Sie sich die offizielle Dokumentation an.

Das obige ist der detaillierte Inhalt vonSo verwenden Sie gRPC zur Implementierung eines Basisservers und -clients in Golang. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!