Analisis ringkas tentang cara memasang dan menggunakan grpc dalam golang

Golang ialah bahasa pengaturcaraan yang popular dan kini semakin ramai orang menggunakannya untuk membangunkan pelbagai jenis aplikasi. Untuk menjadikan Golang lebih berskala, Google membangunkan rangka kerja RPC berprestasi tinggi yang dipanggil gRPC. gRPC menggunakan Penampan Protokol sebagai alat pesirilan lalai, yang menjadikannya lebih cekap dan mempunyai overhed yang lebih rendah daripada rangka kerja RPC yang lain. Dalam artikel ini, kami akan menerangkan cara memasang gRPC dan cara menggunakannya dengan Golang.

1. Pasang gRPC

Golang memerlukan dua langkah untuk memasang gRPC: mula-mula pasang Protocol Buffers, dan kemudian pasang gRPC.

1. Pasang Penampan Protokol
   Anda boleh melangkau langkah ini jika anda telah memasang Penampan Protokol. Jika tidak, anda boleh memuat turun dan memasang versi yang sesuai untuk sistem pengendalian anda daripada: https://github.com/protocolbuffers/protobuf/releases.
2. Pasang gRPC
   Selepas anda berjaya memasang Protocol Buffers, anda boleh menggunakan arahan berikut untuk memasang gRPC:

$ go get -u google.golang.org/grpc

Selepas pemasangan selesai, anda boleh memasangnya dalam $GOPATH/src Cari kod sumber gRPC dalam direktori /google.golang.org/grpc.

2. Gunakan gRPC

Selepas anda memasang gRPC, anda boleh menggunakannya untuk komunikasi RPC di Golang. Begini cara untuk mencipta klien dan pelayan asas menggunakan gRPC:

1. Mentakrifkan perkhidmatan

Pertama, anda perlu mentakrifkan perkhidmatan anda dalam fail .proto. Berikut ialah contoh mudah:

syntax = "proto3";

package greeter;

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

message HelloRequest {
    string name = 1;
}

message HelloReply {
    string message = 1;
}

Kod di atas mentakrifkan perkhidmatan yang dipanggil Greeter, yang mengandungi panggilan RPC yang dipanggil SayHello. Panggilan RPC ini menerima objek HelloRequest sebagai parameter dan mengembalikan objek HelloReply sebagai nilai pulangan.

2. Jana kod

Setelah anda menentukan fail .proto anda, anda perlu menggunakan pengkompil Protocol Buffers untuk menjana kod. Anda boleh menjana kod menggunakan arahan berikut:

$ protoc --go_out=plugins=grpc:. *.proto

Kod yang dijana akan disimpan dalam direktori yang sama dengan fail .proto.

3. Melaksanakan pelayan

Seterusnya, anda perlu menulis kod yang melaksanakan pelayan. Berikut ialah contoh mudah:

package main

import (
    "context"
    "log"
    "net"

    "google.golang.org/grpc"
    pb "github.com/example/greeter"
)

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 {
        log.Fatalf("failed to listen: %v", err)
    }
    s := grpc.NewServer()
    pb.RegisterGreeterServer(s, &server{})
    log.Printf("Listening on %s", port)
    if err := s.Serve(lis); err != nil {
        log.Fatalf("failed to serve: %v", err)
    }
}

Kod di atas melaksanakan perkhidmatan bernama Greeter dan melaksanakan panggilan RPC SayHello. Panggilan ini menggabungkan rentetan "Hello" dengan nama yang dibekalkan klien dan mengembalikannya.

4. Melaksanakan klien

Akhir sekali, anda perlu menulis kod klien untuk menggunakan perkhidmatan yang disediakan oleh pelayan. Berikut ialah contoh mudah:

package main

import (
    "context"
    "log"

    "google.golang.org/grpc"
    pb "github.com/example/greeter"
)

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 := pb.NewGreeterClient(conn)

    name := "world"
    r, err := c.SayHello(context.Background(), &pb.HelloRequest{Name: name})
    if err != nil {
        log.Fatalf("could not greet: %v", err)
    }
    log.Printf("Greeting: %s", r.Message)
}

Kod di atas mencipta klien gRPC dan memanggil kaedah SayHello pelayan.

Kesimpulan

Menggunakan gRPC boleh menjadikan aplikasi Golang lebih berskala dan berprestasi. Memasang dan menggunakan gRPC adalah sangat mudah dan hanya memerlukan beberapa langkah. Dengan mengikuti langkah di atas, anda akan dapat membuat panggilan RPC dengan lebih mudah di Golang menggunakan gRPC dan berkomunikasi dengan sistem lain dengan cara yang cekap.

Atas ialah kandungan terperinci Analisis ringkas tentang cara memasang dan menggunakan grpc dalam golang. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!