golang menghantar permintaan rpc

Golang, sebagai bahasa pengaturcaraan yang cekap dan ringan, telah menjadi semakin popular di kalangan pembangun sejak beberapa tahun kebelakangan ini. Antaranya, RPC (Remote Procedure Call) merupakan teknologi komunikasi rangkaian yang penting di Golang, yang dapat merealisasikan penghantaran data dan komunikasi merentasi rangkaian. Dalam artikel ini, kami akan memperkenalkan cara Golang menghantar permintaan RPC.

Apakah itu RPC?

RPC adalah singkatan kepada Remote Procedure Call, yang merujuk kepada proses memanggil proses komputer lain daripada satu proses komputer melalui rangkaian. RPC membuat panggilan program antara komputer yang berbeza semudah panggilan fungsi dalam program asli. Sebagai contoh, dalam beberapa kes kita perlu memanggil fungsi pada satu pelayan pada pelayan lain. Menggunakan teknologi RPC, kami boleh melaksanakan proses ini dengan mudah.

RPC di Golang

Di Golang, kami boleh menggunakan RPC untuk mencapai komunikasi merentas rangkaian dan penghantaran data. Di Golang, apabila berkomunikasi melalui RPC, kita perlu menentukan antara muka, yang mengandungi kaedah yang ingin kita dedahkan kepada proses lain untuk dipanggil.

Ambil contoh mudah Kami mentakrifkan antara muka pada bahagian pelayan seperti berikut:

type Arithmetic int

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

Seterusnya, kami perlu melaksanakan kod pelayan 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)
    }
}

Seterusnya, Kami perlu menghantar permintaan RPC pada klien:

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

Dalam kod klien, kita perlu menyambung ke pelayan RPC terlebih dahulu melalui fungsi rpc.Dial. Seterusnya, kami mentakrifkan struktur jenis Args untuk menghantar dua nombor yang perlu dikira. Apabila menghantar permintaan RPC, kami memanggil kaedah client.Call, lulus nama fungsi yang ingin kami panggil dan parameter yang perlu dihantar, dan akhirnya menyimpan hasilnya dalam reply.

Ringkasan

Di Golang, RPC ialah teknologi penting untuk merealisasikan penghantaran dan komunikasi merentas rangkaian. Dengan mentakrifkan antara muka dan kaedah tersuai, kami boleh melaksanakan pelayan dan klien RPC. Dalam aplikasi praktikal, kita perlu memilih protokol rangkaian dan kaedah penghantaran yang sesuai berdasarkan keperluan sebenar supaya aplikasi kita boleh berjalan dengan lebih cekap dan stabil.

Atas ialah kandungan terperinci golang menghantar permintaan rpc. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!