GRPC prend-il uniquement en charge le langage Go ? Explorer et analyser

GRPC ne prend-il en charge que le langage Go ? Exploration et analyse

GRPC (gRPC Remote Procedure Call) est un framework d'appel de procédure à distance multilingue hautes performances, développé à l'origine par Google et largement utilisé dans la communauté open source. En raison de sa méthode de sérialisation efficace et de ses performances de transmission basées sur le protocole HTTP/2, GRPC est largement utilisé dans l'architecture des microservices. Cependant, certaines personnes comprennent à tort que GRPC ne prend en charge que le langage Go. Nous allons ici explorer ce problème en profondeur et donner des exemples de code spécifiques.

Tout d'abord, il doit être clair que GRPC ne limite pas le langage de programmation utilisé par les développeurs. Il prend en charge une variété de langages de programmation, notamment Go, Java, Python, C++, etc. Avec le développement rapide de GRPC, la communauté continue de s'étendre, prenant en charge davantage de langages de programmation.

Lors de l'utilisation de GRPC, vous devez définir un fichier .proto, qui contient la définition de l'interface et le format de message du service. Ci-dessous, nous prenons le langage Go et le langage Python comme exemples pour montrer comment définir un service GRPC simple.

Premier exemple du langage Go :

syntax = "proto3";

package helloworld;

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

message HelloRequest {
  string name = 1;
}

message HelloReply {
  string message = 1;
}

Ensuite, générez le code du langage Go via l'outil de protocole :

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

Ensuite, écrivez le code du serveur et du client GRPC :

package main

import (
    "context"
    "log"
    "net"

    "google.golang.org/grpc"
    pb "path/to/proto"
)

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

Ensuite, l'exemple du langage Python :

syntax = "proto3";

package helloworld;

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

message HelloRequest {
  string name = 1;
}

message HelloReply {
  string message = 1;
}

De même, générez du code Python via le protocole :

python3 -m grpc_tools.protoc -I. --python_out=. --grpc_python_out=. helloworld.proto

Ensuite, écrivez le code serveur et client GRPC de Python :

from concurrent import futures
import grpc
import helloworld_pb2_grpc as pb2_grpc
import helloworld_pb2 as pb2

class Greeter(pb2_grpc.GreeterServicer):

    def SayHello(self, request, context):
        return pb2.HelloReply(message='Hello, %s' % request.name)

def serve():
    server = grpc.server(futures.ThreadPoolExecutor(max_workers=10))
    pb2_grpc.add_GreeterServicer_to_server(Greeter(), server)
    server.add_insecure_port('[::]:50051')
    server.start()
    server.wait_for_termination()

if __name__ == '__main__':
    serve()

Comme vous pouvez le voir dans l'exemple ci-dessus, GRPC prend non seulement en charge le langage Go, mais prend également en charge une variété d'autres langages de programmation. Définissez simplement le fichier .proto, puis utilisez le plug-in de langue correspondant pour générer le code correspondant et implémentez le serveur et le client GRPC dans chaque langue.

En résumé, GRPC prend non seulement en charge le langage Go, mais également un cadre d'appel de procédure à distance multilingue qui peut fournir des services RPC hautes performances pour les applications dans différentes langues. Nous encourageons les développeurs à essayer d'utiliser GRPC dans différents projets et à faire bon usage de ses fonctionnalités multilingues pour mieux créer des systèmes distribués et des architectures de microservices.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!