Comment implémenter RPC dans Golang

Ces dernières années, avec le développement rapide d'Internet, les systèmes distribués attirent de plus en plus l'attention. La technologie RPC (Remote Procedure Call) est une technologie clé dans les systèmes distribués, qui permet à différents systèmes de communiquer et de collaborer entre eux. Parmi les différents langages, la plupart des langages ont leur propre framework RPC. Dans cet article, nous présenterons comment utiliser Golang pour implémenter RPC afin que les systèmes puissent collaborer harmonieusement.

1. Le concept de base du RPC

1.1. Qu'est-ce que

RPC est un appel de procédure à distance (Remote Procedure Call), ce qui signifie que le client Appeler un service distant localement, c'est comme appeler du code local, et vous pouvez transmettre des paramètres et obtenir des valeurs de retour tout comme appeler du code local. En fait, il résume le processus de communication réseau selon un modèle similaire aux appels locaux.

1.2. Pourquoi

Dans un système distribué, chaque nœud est dispersé et chacun entreprend des tâches ou des services métiers différents. Pour que ces nœuds fonctionnent ensemble, ils doivent communiquer sur le réseau. RPC permet à ces nœuds d'échanger des données via le réseau pour mettre en œuvre l'exécution de la logique métier.

1.3. Caractéristiques

Le principe de base de RPC est d'abstraire le processus de communication réseau en un processus d'appel local. Le client transmet les paramètres localement au service distant. le serveur envoie les paramètres Après traitement, les résultats du traitement sont renvoyés au client. Cela permet à différents nœuds du système distribué de coopérer les uns avec les autres pour accomplir diverses tâches du système distribué. Les caractéristiques de RPC sont les suivantes :

• Abstraction : Le processus de communication réseau est résumé dans un processus d'appel local, afin que les développeurs utilisant le framework RPC puissent utiliser des services distants comme des services locaux.
• Transparence : RPC protège la plupart des détails liés à la communication pour les utilisateurs, permettant aux développeurs de se concentrer davantage sur la logique métier.
• Efficace : RPC utilise le binaire pour transmettre des données, avec une efficacité de sérialisation et de désérialisation élevée et une vitesse de transmission rapide. Il peut transmettre une grande quantité de données lorsque la bande passante du réseau est petite.

2. Étapes de base pour implémenter RPC dans Golang

2.1 Définir l'interface

Dans Golang, vous devez d'abord définir. l'interface à exposer Interface, cette interface est équivalente au prototype de fonction d'appel à distance.

type Server struct {}

type Args struct {
    A, B int
}

func (s *Server) Multiply(args *Args, reply *int) error {
    *reply = args.A * args.B
    return nil
}

Dans le code, une structure Serveur et une structure Args sont définies. La structure Serveur définit une fonction Multiply. La fonction Multiply est utilisée pour calculer le produit de deux entiers. Il est à noter que les paramètres et la valeur de retour de la fonction Multiply doivent répondre aux spécifications RPC.

2.2. Enregistrez le service RPC

Après avoir défini l'interface, vous devez enregistrer l'interface dans le service RPC afin que le client puisse appeler le service RPC. Pour enregistrer le service sur le serveur RPC, nous devons utiliser la fonction rpc.Serve() dans Golang.

func main() {
    server := new(Server)
    rpc.Register(server)
    rpc.HandleHTTP()

    listener, err := net.Listen("tcp", ":8080")
    if err != nil {
        log.Fatal("listen error:", err)
    }

    http.Serve(listener, nil)
}

Dans le code ci-dessus, nous créons d'abord une structure de serveur, puis enregistrons l'interface définie dans la structure de serveur sur le serveur RPC via la fonction rpc.Register, puis utilisons rpc.HandleHTTP( ) Liez le serveur RPC au multiplexeur par défaut dans le package http, et enfin liez le serveur RPC à l'adresse d'écoute TCP via http.Serve.

2.3. Écrivez le code client

Une fois l'enregistrement du service RPC terminé, nous devons écrire le code client pour appeler le service RPC. Le package rpc de Golang fournit la fonction rpc.DialHTTP, qui peut être utilisée pour établir une connexion client RPC. Ce qui suit est une implémentation simple du client RPC :

func main() {
    client, err := rpc.DialHTTP("tcp", "localhost:8080")
    if err != nil {
        log.Fatal("dialing:", err)
    }

    args := &Args{7, 8}
    var reply int
    err = client.Call("Server.Multiply", args, &reply)
    if err != nil {
        log.Fatal("Server error:", err)
    }

    fmt.Printf("Multiply: %d*%d=%d", args.A, args.B, reply)
}

Le client établit une connexion avec le serveur RPC via la fonction rpc.DialHTTP, puis appelle la méthode client.Call pour exécuter la fonction du serveur RPC. Le premier paramètre de Call est le nom de la fonction à appeler, le deuxième paramètre est le paramètre de la fonction et le troisième paramètre est la valeur de retour de la fonction.

3. Exemple de code Golang RPC

Ce qui suit est un exemple complet d'implémentation de RPC basé sur Golang :

package main

import (
    "fmt"
    "log"
    "net"
    "net/http"
    "net/rpc"
)

type Server struct{}

type Args struct {
    A, B int
}

func (s *Server) Multiply(args *Args, reply *int) error {
    *reply = args.A * args.B
    return nil
}

func main() {
    server := new(Server)
    rpc.Register(server)
    rpc.HandleHTTP()

    listener, err := net.Listen("tcp", ":8080")
    if err != nil {
        log.Fatal("listen error:", err)
    }

    go http.Serve(listener, nil)

    client, err := rpc.DialHTTP("tcp", "localhost:8080")
    if err != nil {
        log.Fatal("dialing:", err)
    }

    args := &Args{7, 8}
    var reply int
    err = client.Call("Server.Multiply", args, &reply)
    if err != nil {
        log.Fatal("Server error:", err)
    }

    fmt.Printf("Multiply: %d*%d=%d", args.A, args.B, reply)
}

Grâce au code ci-dessus, nous Je peux voir qu'en Golang, l'implémentation de RPC est simple. Il vous suffit de définir l'interface, d'enregistrer le service RPC et d'écrire le code client. Bien entendu, les clients et les serveurs RPC peuvent être hétérogènes, ce qui est très utile lors de la mise à l'échelle de systèmes distribués.

4. Résumé

Cet article présente ce qu'est RPC, pourquoi RPC est nécessaire et comment utiliser Golang pour implémenter RPC. En lisant cet article, on comprend que le RPC est largement utilisé et constitue une technologie de base dans les systèmes distribués. En tant que langage de programmation efficace, Golang dispose d'un excellent framework RPC qui peut aider les développeurs à mieux implémenter des systèmes distribués. Si vous avez besoin de développer un système distribué, vous pouvez aussi bien essayer d'utiliser Golang pour implémenter RPC.

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!