Artikel yang memperkenalkan cara menggunakan gRPC Golang

gRPC ialah rangka kerja RPC sumber terbuka berprestasi tinggi, serba boleh dan terbuka yang dibangunkan dan sumber terbuka oleh Google. gRPC menyokong berbilang bahasa pengaturcaraan, termasuk Golang. Artikel ini akan memperkenalkan cara menggunakan gRPC Golang.

1. Pasang gRPC

Sebelum membangunkan gRPC Golang, anda perlu memasang gRPC terlebih dahulu. Anda boleh memasangnya dengan arahan berikut:

go get -u google.golang.org/grpc

Selepas pemasangan selesai, anda juga perlu memasang gRPC's Go language code generator protoc-gen-go, yang boleh dipasang dengan arahan berikut:

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

2. Cipta fail .proto

Sebelum menggunakan gRPC Golang untuk pembangunan, anda perlu mentakrifkan fail .proto terlebih dahulu. Fail .proto mentakrifkan antara muka perkhidmatan dan format mesej. Berikut ialah contoh fail .proto:

syntax = "proto3";

package helloworld;

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

message HelloRequest {
  string name = 1;
}

message HelloReply {
  string message = 1;
}

• sintaks mentakrifkan versi sintaks yang digunakan oleh fail .proto
• pakej mentakrifkan nama pakej
• perkhidmatan mentakrifkan perkhidmatan
• rpc mentakrifkan kaedah, termasuk permintaan input dan pulangan output
• mesej mentakrifkan format mesej

3. Jana kod bahasa Go

dalam Selepas fail .proto ditakrifkan, anda perlu menggunakan alat protoc untuk menjana kod bahasa Go. Ia boleh dijana dengan arahan berikut:

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

Kod bahasa Go yang dijana akan disimpan dalam direktori helloworld yang ditentukan.

4. Laksanakan pelayan

Selepas menjana kod bahasa Go, anda perlu melaksanakan perkhidmatan tersebut. Berikut ialah contoh perkhidmatan yang melaksanakan kaedah SayHello:

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)
    }
}

• Struktur pelayan yang melaksanakan kaedah SayHello
• Kaedah SayHello menerima konteks (ctx) dan objek HelloRequest sebagai Input, kembalikan objek HelloReply dan ralat
• Buat pelayan gRPC melalui grpc.NewServer()
• Gunakan pb.RegisterGreeterServer untuk mendaftarkan perkhidmatan pada pelayan
• Mulakan pelayan

5. Laksanakan klien

Perkhidmatan boleh dipanggil dengan melaksanakan klien. Berikut ialah contoh klien yang melaksanakan panggilan kaedah SayHello:

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)
}

• Buat sambungan menggunakan kaedah grpc.Dail
• Buat objek GreeterClient c
• Gunakan kaedah c.SayHello untuk meminta perkhidmatan
• Cetak respons perkhidmatan

6. Susun dan jalankan atur cara

Gunakan arahan berikut untuk menyusun program pelayan dan klien:

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

Jalankan program pelayan:

./server

Jalankan program klien:

./client

Ringkasan

Artikel ini memperkenalkan kaedah Penggunaan gRPC Golang termasuk memasang gRPC dan protoc-gen-go, mencipta fail .proto, menjana kod bahasa Go, melaksanakan pelayan dan klien, dan akhirnya menyusun dan menjalankan program. gRPC Golang menyediakan rangka kerja RPC serba boleh berprestasi tinggi yang boleh digunakan untuk komunikasi antara perkhidmatan dalam sistem teragih.

Atas ialah kandungan terperinci Artikel yang memperkenalkan cara menggunakan gRPC Golang. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!