Pembangunan Golang: Cara menggunakan gRPC untuk mencapai komunikasi merentas bahasa

Pembangunan Golang: Cara menggunakan gRPC untuk mencapai komunikasi silang bahasa

Ikhtisar:
Dalam pembangunan perisian moden, komunikasi antara sistem antara bahasa yang berbeza adalah sangat biasa. Untuk menyelesaikan masalah ini, rangka kerja gRPC sumber terbuka Google, yang merupakan rangka kerja panggilan prosedur jauh (RPC) berprestasi tinggi merentas bahasa. Artikel ini akan memperkenalkan cara menggunakan gRPC dalam pembangunan Golang dan membantu pembaca memahami cara mencapai komunikasi merentas bahasa melalui contoh kod tertentu.

Apakah itu gRPC?
gRPC (gRPC Remote Procedure Call) ialah rangka kerja panggilan prosedur jauh (RPC) berprestasi tinggi, sumber terbuka, merentas bahasa. Ia dibangunkan berdasarkan Protokol Penampan Google (ProtoBuf untuk pendek) protokol bersiri. Dengan mentakrifkan jenis perkhidmatan dan mesej, gRPC boleh menjana kod sisi klien dan pelayan dengan mudah dalam pelbagai bahasa untuk mencapai komunikasi antara bahasa yang berbeza.

Persediaan persekitaran:
Sebelum bermula, pastikan anda telah memasang persekitaran pembangunan Golang dan gRPC. Anda boleh memasang alat pembangunan gRPC dan pemalam Golang melalui dokumentasi rasmi.

Langkah 1: Tentukan fail .proto
.fail proto ialah salah satu teras gRPC dan digunakan untuk menentukan perkhidmatan dan jenis mesej. Kami boleh menggunakan bahasa ProtoBuf untuk mentakrifkan struktur dan perkhidmatan data.

Berikut ialah contoh mudah fail .proto yang mentakrifkan perkhidmatan HelloWorld, termasuk kaedah SayHello Parameter input ialah mesej HelloRequest dan mengembalikan mesej HelloResponse.

syntax = "proto3";

package helloworld;

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

message HelloRequest {
  string name = 1;
}

message HelloResponse {
  string message = 1;
}

Langkah 2: Jana kod
Selepas menentukan fail .proto, kita boleh menggunakan protok pengkompil protokol yang disediakan oleh gRPC untuk menjana kod sisi klien dan pelayan dalam bahasa yang sepadan.

Laksanakan arahan berikut dalam terminal untuk menjana kod Golang:

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

Arahan ini akan menghasilkan fail helloworld.pb.go berdasarkan direktori di mana fail .proto berada.

Langkah 3: Tulis kod sebelah pelayan
Seterusnya, kami menggunakan Golang untuk menulis kod sebelah pelayan. Pertama, kita perlu mengimport gRPC dan fail .pb.go yang dijana secara automatik.

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

Dalam kod di atas, kami mentakrifkan struktur bernama pelayan dan melaksanakan kaedah SayHello yang kami takrifkan dalam fail .proto. Antaranya, kaedah SayHello menerima parameter jenis HelloRequest dan mengembalikan respons jenis HelloResponse.

Langkah 4: Tulis kod pelanggan
Seterusnya, kami menggunakan Golang untuk menulis kod pelanggan. Pertama, anda juga perlu mengimport gRPC dan fail .pb.go yang dijana secara automatik.

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

Dalam kod di atas, kami menggunakan grpc.Dial untuk mewujudkan sambungan dengan pelayan dan mencipta GreeterClient untuk memanggil kaedah SayHello. Kemudian, keluarkan kandungan mesej yang dikembalikan oleh pelayan.

Langkah 5: Jalankan kod
Akhir sekali, kami menjalankan dua keping kod ini untuk mengujinya. Mula-mula, mulakan kod sebelah pelayan, dan kemudian mulakan kod sebelah klien.

Anda akan melihat pelayan mencetak "Pelayan bermula pada port: 50051" dan pelanggan mencetak "Salam: Hello World". Ini bermakna pelayan berjaya menerima permintaan pelanggan dan mengembalikan respons yang betul.

Ringkasan:
Dengan menggunakan rangka kerja gRPC, kita boleh mencapai komunikasi merentas bahasa dengan mudah. Dalam artikel ini, kami menunjukkan cara untuk membangunkan menggunakan gRPC di Golang melalui kod sampel tertentu. Anda boleh mentakrifkan mesej dan perkhidmatan berdasarkan keperluan anda, dan menulis kod sisi pelayan dan sisi klien untuk membolehkan komunikasi merentas bahasa. Saya harap artikel ini dapat membantu anda memahami dan menggunakan rangka kerja gRPC.

Atas ialah kandungan terperinci Pembangunan Golang: Cara menggunakan gRPC untuk mencapai komunikasi merentas bahasa. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!