Gunakan go-zero untuk melaksanakan panggilan RPC merentas bahasa yang diedarkan

Dengan pertumbuhan skala perniagaan, kewujudan aplikasi tunggal tidak lagi dapat memenuhi keperluan sistem, dan seni bina yang diedarkan secara beransur-ansur menjadi arus perdana. Dalam sistem teragih, RPC telah menjadi bahagian yang amat diperlukan Ia menyediakan cara yang mudah, cekap dan boleh dipercayai untuk memanggil perkhidmatan dari jauh, membolehkan interaksi data dan panggilan yang cepat dan stabil antara pelbagai perkhidmatan.

Untuk panggilan RPC merentas bahasa, kedua-dua protokol komunikasi dan protokol bersiri perlu serasi dengan berbilang bahasa pengaturcaraan, jadi ia agak sukar untuk dilaksanakan. Artikel ini akan memperkenalkan cara menggunakan rangka kerja go-zero untuk melaksanakan panggilan RPC teragih merentas bahasa, bertujuan untuk menyediakan penyelesaian praktikal kepada pembaca.

1. Pengenalan kepada rangka kerja go-zero

go-zero ialah rangka kerja Web ringan yang menggunakan modul net/http asli bahasa go dan menyediakan set A kaedah pembangunan API yang ringkas, mudah digunakan dan berprestasi tinggi yang boleh menggabungkan perkhidmatan HTTP dengan perkhidmatan mikro dengan mudah. go-zero boleh membantu kami membina aplikasi pelayan berkonkurensi tinggi dengan cepat dan kod serta dokumentasi boleh diperoleh secara percuma di GitHub.

2. Melaksanakan panggilan RPC merentas bahasa

2.1 Menentukan perkhidmatan

Apabila kami mentakrifkan perkhidmatan dalam go-zero, kami perlu menulis fail proto terlebih dahulu dan tentukan antara muka Komunikasi antara pelayan dan klien. Katakan kita mentakrifkan perkhidmatan bernama Contoh, yang mengandungi dua kaedah:

syntax = "proto3";

package rpc;

service Example {
    rpc SayHello (Request) returns (Response);
    rpc GetUser (UserRequest) returns (UserResponse);
}

message Request {
    string name = 1;
}

message Response {
    string message = 1;
}

message UserRequest {
    string id = 1;
}

message UserResponse {
    string name = 1;
    string email = 2;
}

Selepas mentakrifkan fail proto, kita perlu menggunakan pengkompil protobuf untuk menyusunnya ke dalam fail sumber bahasa go dan laksanakan arahan berikut:

protoc --go_out=. --go-grpc_out=. rpc.proto

Ini akan menghasilkan dua fail, rpc.pb.go dan rpc_grpc.pb.go.

2.2 Melaksanakan pelayan

Dalam rangka kerja go-zero, kita boleh menggunakan modul go-grpc untuk melaksanakan perkhidmatan grpc. Apabila melaksanakan pelayan, anda perlu melaksanakan antara muka yang ditakrifkan dalam fail proto, gunakan pelayan.NewServer yang disediakan oleh go-zero dan panggil kaedah AddService untuk menambah perkhidmatan, dan kemudian mulakan perkhidmatan grpc dalam kaedah Init.

package server

import (
    "context"
    "rpc"

    "github.com/tal-tech/go-zero/core/logx"
    "github.com/tal-tech/go-zero/core/stores/sqlx"
    "github.com/tal-tech/go-zero/core/syncx"
    "github.com/tal-tech/go-zero/zrpc"
    "google.golang.org/grpc"
)

type ExampleContext struct {
    Logx      logx.Logger
    SqlConn   sqlx.SqlConn
    CacheConn syncx.SharedCalls
}

type ExampleServer struct {
    Example rpc.ExampleServer
}

func NewExampleServer(ctx ExampleContext) *ExampleServer {
    return &ExampleServer{
        Example: &exampleService{
            ctx: ctx,
        },
    }
}

func (s *ExampleServer) Init() {
    server := zrpc.MustNewServer(zrpc.RpcServerConf{
        BindAddress: "localhost:7777",
    })
    rpc.RegisterExampleServer(server, s.Example)
    server.Start()
}

type exampleService struct {
    ctx ExampleContext
}

func (s *exampleService) SayHello(ctx context.Context, req *rpc.Request) (*rpc.Response, error) {
    return &rpc.Response{
        Message: "Hello, " + req.Name,
    }, nil
}

func (s *exampleService) GetUser(ctx context.Context, req *rpc.UserRequest) (*rpc.UserResponse, error) {
    // 查询数据库
    return &rpc.UserResponse{
        Name:  "name",
        Email: "email",
    }, nil
}

Pada pelayan, kita boleh menggunakan kaedah Init untuk memulakan pelayan RPC dan menggunakan MustNewServer untuk mencipta pelayan RPC Kita mesti lulus dalam struktur RpcServerConf yang mengandungi alamat yang ingin kita ikat.

2.3 Melaksanakan klien

Dalam rangka kerja go-zero, kita boleh menggunakan modul zrpc untuk melaksanakan klien grpc. Gunakan zrpc.Dial untuk membuat sambungan dan membuat instantiate klien rpc.

package client

import (
    "context"
    "rpc"

    "google.golang.org/grpc"
)

type ExampleClient struct {
    client rpc.ExampleClient
}

func NewExampleClient(conn *grpc.ClientConn) *ExampleClient {
    return &ExampleClient{
        client: rpc.NewExampleClient(conn),
    }
}

func (c *ExampleClient) SayHello(name string) (string, error) {
    resp, err := c.client.SayHello(context.Background(), &rpc.Request{
        Name: name,
    })
    if err != nil {
        return "", err
    }
    return resp.Message, nil
}

func (c *ExampleClient) GetUser(id string) (*rpc.UserResponse, error) {
    return c.client.GetUser(context.Background(), &rpc.UserRequest{
        Id: id,
    })
}

Pada klien, kami hanya perlu menggunakan fungsi NewExampleClient untuk mencipta klien RPC. Fungsi kaedah SayHello adalah untuk mendapatkan respons daripada pelayan dan mengembalikannya. Kaedah GetUser mendapatkan respons maklumat pengguna daripada pelayan dan mengembalikannya dalam bentuk UserResponse.

2.4 Pengujian

Sekarang kami telah melaksanakan kod pelayan dan klien, kami boleh mengujinya dengan kod berikut:

package main

import (
    "fmt"
    "log"
    "rpc_example/client"
    "rpc_example/server"

    "google.golang.org/grpc"
)

func main() {
    ctx := server.ExampleContext{}
    conn, err := grpc.Dial("localhost:7777", grpc.WithInsecure())
    if err != nil {
        log.Fatalf("grpc.Dial err :%v", err)
    }

    defer conn.Close()

    client := client.NewExampleClient(conn)
    resp, err := client.SayHello("Alice")
    if err != nil {
        log.Fatalf("client.SayHello err : %v", err)
    }

    fmt.Println(resp)

    user, err := client.GetUser("123")
    if err != nil {
        log.Fatalf("client.GetUser err : %v", err)
    }

    fmt.Println(user)
}

Dalam kod di atas, kami mencipta Open a grpc dan hubungi kaedah SayHello dan GetUser untuk menguji perkhidmatan RPC kami. Kami berjaya membalas dengan data yang betul dan mengesahkan bahawa perkhidmatan RPC berfungsi seperti biasa.

3. Ringkasan

Dalam artikel ini, kami memperkenalkan cara menggunakan rangka kerja go-zero untuk melaksanakan panggilan RPC merentas bahasa teragih, yang melibatkan modul Def go-zero , grpc, protobuf dan zrpc serta teknologi lain. Apabila melaksanakan perkhidmatan RPC, kami mula-mula menentukan antara muka RPC, dan kemudian menulis kod pelayan dan klien berdasarkan antara muka. Akhir sekali tambah kaedah Init untuk memulakan perkhidmatan RPC. Jika anda sedang mencari rangka kerja sistem teragih yang ringan dan mudah digunakan, go-zero sememangnya pilihan yang baik.

Atas ialah kandungan terperinci Gunakan go-zero untuk melaksanakan panggilan RPC merentas bahasa yang diedarkan. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!