Ein Artikel, der die Verwendung von gRPC Golang vorstellt

gRPC ist ein leistungsstarkes, vielseitiges Open-Source-RPC-Framework, das von Google entwickelt und als Open-Source-Lösung bereitgestellt wird. gRPC unterstützt mehrere Programmiersprachen, einschließlich Golang. In diesem Artikel wird die Verwendung von gRPC Golang vorgestellt.

1. Installieren Sie gRPC

Bevor Sie gRPC Golang entwickeln, müssen Sie zuerst gRPC installieren. Sie können es mit dem folgenden Befehl installieren:

go get -u google.golang.org/grpc

Nach Abschluss der Installation müssen Sie auch den Go-Sprachcodegenerator protoc-gen-go von gRPC installieren, der mit dem folgenden Befehl installiert werden kann: # 🎜🎜#

go get -u github.com/golang/protobuf/protoc-gen-go

2. Erstellen Sie eine .proto-Datei

Bevor Sie gRPC Golang für die Entwicklung verwenden, müssen Sie zunächst die .proto-Datei definieren. Die .proto-Datei definiert die Serviceschnittstelle und das Nachrichtenformat. Das Folgende ist ein Beispiel für eine .proto-Datei:

syntax = "proto3";

package helloworld;

service Greeter {
  rpc SayHello (HelloRequest) returns (HelloReply) {}
}

message HelloRequest {
  string name = 1;
}

message HelloReply {
  string message = 1;
}

syntax definiert die von der .proto-Datei verwendete Syntaxversion
• package definiert den Paketnamen #🎜 🎜##🎜🎜 #service definiert einen Dienst
• rpc definiert eine Methode, einschließlich Anforderungseingabe und Rückgabeausgabe
• message definiert das Format der Nachricht
• #🎜 🎜#
三, Go-Sprachcode generieren
• Nachdem die .proto-Datei definiert wurde, müssen Sie das Protoc-Tool verwenden, um Go-Sprachcode zu generieren. Es kann mit dem folgenden Befehl generiert werden:

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

Der generierte Go-Sprachcode wird im angegebenen Verzeichnis helloworld gespeichert.

4. Implementieren Sie den Server

Nachdem Sie den Go-Sprachcode generiert haben, müssen Sie den Dienst implementieren. Das Folgende ist ein Beispiel für einen Dienst, der die SayHello-Methode implementiert:

package main

import (
    "context"
    "fmt"
    "net"

    "google.golang.org/grpc"
    pb "github.com/your_username/helloworld"
)

const (
    port = ":50051"
)

type server struct{}

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

func main() {
    lis, err := net.Listen("tcp", port)
    if err != nil {
        fmt.Printf("failed to listen: %v", err)
        return
    }
    s := grpc.NewServer()
    pb.RegisterGreeterServer(s, &server{})
    fmt.Printf("server listening at %v", lis.Addr())
    if err := s.Serve(lis); err != nil {
        fmt.Printf("failed to serve: %v", err)
    }
}

Die Serverstruktur, die die SayHello-Methode implementiert

Die SayHello-Methode empfängt einen Kontext ( ctx) und ein HelloRequest-Objekt als Eingabe, gibt ein HelloReply-Objekt und einen Fehler zurück

• Erstellen Sie einen gRPC-Server über grpc.NewServer()
• Verwenden Sie pb.RegisterGreeterServer, um den Dienst zu registrieren zum Server#🎜🎜 #
Starten Sie den Server
• 5. Implementieren Sie den Client
• Durch die Implementierung des Clients können Sie den Dienst aufrufen. Das Folgende ist ein Beispiel für einen Client, der den Aufruf der SayHello-Methode implementiert:

package main

import (
    "context"
    "log"
    "os"
    "time"

    "google.golang.org/grpc"
    pb "github.com/your_username/helloworld"
)

const (
    address     = "localhost:50051"
    defaultName = "world"
)

func main() {
    // Set up a connection to the server.
    conn, err := grpc.Dial(address, grpc.WithInsecure(), grpc.WithTimeout(10*time.Second))
    if err != nil {
        log.Fatalf("did not connect: %v", err)
    }
    defer conn.Close()
    c := pb.NewGreeterClient(conn)

    // Contact the server and print out its response.
    name := defaultName
    if len(os.Args) > 1 {
        name = os.Args[1]
    }
    ctx, cancel := context.WithTimeout(context.Background(), time.Second)
    defer cancel()
    r, err := c.SayHello(ctx, &pb.HelloRequest{Name: name})
    if err != nil {
        log.Fatalf("could not greet: %v", err)
    }
    log.Printf("Greeting: %s", r.Message)
}

Verwenden Sie die grpc.Dial-Methode, um eine Verbindung zu erstellen.

Erstellen Sie ein GreeterClient-Objekt c

Verwenden Sie die c.SayHello-Methode, um einen Dienst anzufordern
• Dienstantwort drucken
• 6. Kompilieren Sie das Programm und führen Sie es aus
• Verwenden Sie den folgenden Befehl, um die Server- und Client-Programme zu kompilieren:

go build -o server ./server/main.go
go build -o client ./client/main.go

Führen Sie das Serverprogramm aus:

./server

Führen Sie das Client-Programm aus:

./client

# 🎜🎜# 7. Zusammenfassung# 🎜🎜#In diesem Artikel wird die Verwendung von gRPC Golang vorgestellt, einschließlich der Installation von gRPC und protoc-gen-go, der Erstellung von .proto-Dateien, der Generierung von Go-Sprachcode, der Implementierung von Server und Client und schließlich Kompilieren und Ausführen des Programms. gRPC Golang bietet ein leistungsstarkes, vielseitiges RPC-Framework, das für die Kommunikation zwischen Diensten in verteilten Systemen verwendet werden kann.

Das obige ist der detaillierte Inhalt vonEin Artikel, der die Verwendung von gRPC Golang vorstellt. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!