Golang envoie une requête RPC

Golang, en tant que langage de programmation efficace et léger, est devenu de plus en plus populaire parmi les développeurs ces dernières années. Parmi eux, RPC (Remote Procedure Call) est une technologie de communication réseau importante à Golang, qui peut réaliser la transmission de données et la communication à travers le réseau. Dans cet article, nous présenterons comment Golang envoie des requêtes RPC.

Qu'est-ce que le RPC ?

RPC signifie Remote Procedure Call, qui fait référence au processus d'appel d'un autre processus informatique à partir d'un processus informatique via le réseau. RPC rend les appels de programmes entre différents ordinateurs aussi pratiques que les appels de fonctions dans les programmes natifs. Par exemple, dans certains cas, nous devons appeler une fonction sur un serveur sur un autre serveur. Grâce à la technologie RPC, nous pouvons facilement mettre en œuvre ce processus.

RPC à Golang

À Golang, nous pouvons utiliser RPC pour réaliser une communication inter-réseau et une transmission de données. Dans Golang, lors de la communication via RPC, nous devons définir une interface qui contient les méthodes que nous souhaitons exposer aux autres processus à appeler.

Prenons un exemple simple. Nous définissons une interface sur le serveur comme suit :

type Arithmetic int

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

Ensuite, nous devons implémenter le code du serveur RPC :

import (
    "net"
    "net/rpc"
)

func main() {
    // 1.注册服务
    arith := new(Arithmetic)
    rpc.Register(arith)

    // 2.网络监听
    listener, err := net.Listen("tcp", ":1234")
    if err != nil {
        fmt.Println("ListenTCP error:", err)
        return
    }

    // 3.启动监听
    for {
        conn, err := listener.Accept()
        if err != nil {
            fmt.Println("Accept error:", err)
            continue
        }
        // 4.服务端处理请求
        go rpc.ServeConn(conn)
    }
}

Ensuite, nous devons envoyer une requête RPC sur le client :

import (
    "fmt"
    "net/rpc"
)

type Args struct {
    A, B int
}

func main() {
    // 1.连接rpc服务端
    client, err := rpc.Dial("tcp", "127.0.0.1:1234")
    if err != nil {
        fmt.Println("Dial error:", err)
        return
    }

    args := &Args{7, 8}
    var reply int

    // 2.客户端发送请求
    err = client.Call("Arithmetic.Multiply", args, &reply)
    if err != nil {
        fmt.Println("Call error:", err)
        return
    }

    fmt.Println("7*8=", reply)
}

Dans le code client, nous devons d'abord passer rpc.Dial函数来连接RPC服务端。接着，我们定义了一个Args类型的结构体，用于传输需要计算的两个数。在发送RPC请求时，我们调用client.Call方法，并传递我们想调用的函数名以及需要传输的参数，最后将结果保存在reply.

Résumé

À Golang, RPC est une technologie importante pour réaliser la transmission et la communication entre réseaux. En définissant des interfaces et des méthodes personnalisées, nous pouvons implémenter le serveur et le client RPC. Dans les applications pratiques, nous devons choisir des protocoles réseau et des méthodes de transmission appropriés en fonction des besoins réels afin que nos applications puissent fonctionner de manière plus efficace et plus stable.

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!