Go RPC

已于 2023-06-26 10:12:53 修改
阅读量1.1k 收藏
点赞数
分类专栏： Go 文章标签： golang rpc
于 2023-05-11 10:23:04 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Klaus_S/article/details/130616113
版权
目录

文章目录

Go RPC

Go 标准包中已经提供了对 RPC 的支持，而且支持三个级别的 RPC：TCP、HTTP、JSONRPC。但 Go 的 RPC 包是独一无二的 RPC，它和传统的 RPC 系统不同，它只支持 Go 开发的服务器与客户端之间的交互，因为在内部，它们采用了 Gob 来编码。

Go RPC 的函数只有符合下面的条件才能被远程访问，不然会被忽略，详细的要求如下：

  • 函数必须是导出的 (首字母大写)
  • 必须有两个导出类型的参数，
  • 第一个参数是接收的参数，第二个参数是返回给客户端的参数，第二个参数必须是指针类型的
  • 函数还要有一个返回值 error

举个例子，正确的 RPC 函数格式如下：

func (t *T) MethodName(argType T1, replyType *T2) error

T、T1 和 T2 类型必须能被 encoding/gob 包编解码。

任何的 RPC 都需要通过网络来传递数据，Go RPC 可以利用 HTTP 和 TCP 来传递数据，利用 HTTP 的好处是可以直接复用 net/http 里面的一些函数。详细的例子请看下面的实现

HTTP RPC

http 的服务端代码实现如下：


package main

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

type Args struct {
    A, B int
}

type Quotient struct {
    Quo, Rem int
}

type Arith int

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

func (t *Arith) Divide(args *Args, quo *Quotient) error {
    if args.B == 0 {
        return errors.New("divide by zero")
    }
    quo.Quo = args.A / args.B
    quo.Rem = args.A % args.B
    return nil
}

func main() {

    arith := new(Arith)
    rpc.Register(arith)
    rpc.HandleHTTP()

    err := http.ListenAndServe(":1234", nil)
    if err != nil {
        fmt.Println(err.Error())
    }
}

通过上面的例子可以看到，我们注册了一个 Arith 的 RPC 服务，然后通过 rpc.HandleHTTP 函数把该服务注册到了 HTTP 协议上，然后我们就可以利用 http 的方式来传递数据了。

请看下面的客户端代码：


package main

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

type Args struct {
    A, B int
}

type Quotient struct {
    Quo, Rem int
}

func main() {
    if len(os.Args) != 2 {
        fmt.Println("Usage: ", os.Args[0], "server")
        os.Exit(1)
    }
    serverAddress := os.Args[1]

    client, err := rpc.DialHTTP("tcp", serverAddress+":1234")
    if err != nil {
        log.Fatal("dialing:", err)
    }
    // Synchronous call
    args := Args{17, 8}
    var reply int
    err = client.Call("Arith.Multiply", args, &reply)
    if err != nil {
        log.Fatal("arith error:", err)
    }
    fmt.Printf("Arith: %d*%d=%d\n", args.A, args.B, reply)

    var quot Quotient
    err = client.Call("Arith.Divide", args, &quot)
    if err != nil {
        log.Fatal("arith error:", err)
    }
    fmt.Printf("Arith: %d/%d=%d remainder %d\n", args.A, args.B, quot.Quo, quot.Rem)

}

我们把上面的服务端和客户端的代码分别编译，然后先把服务端开启，然后开启客户端，输入代码，就会输出如下信息：


$ ./http_c localhost
Arith: 17*8=136
Arith: 17/8=2 remainder 1

通过上面的调用可以看到参数和返回值是我们定义的 struct 类型，在服务端我们把它们当做调用函数的参数的类型，在客户端作为 client.Call 的第 2，3 两个参数的类型。客户端最重要的就是这个 Call 函数，它有 3 个参数，第 1 个要调用的函数的名字，第 2 个是要传递的参数，第 3 个要返回的参数 (注意是指针类型)，通过上面的代码例子我们可以发现，使用 Go 的 RPC 实现相当的简单，方便。

TCP RPC

上面我们实现了基于 HTTP 协议的 RPC，接下来我们要实现基于 TCP 协议的 RPC，服务端的实现代码如下所示：


package main

import (
    "errors"
    "fmt"
    "net"
    "net/rpc"
    "os"
)

type Args struct {
    A, B int
}

type Quotient struct {
    Quo, Rem int
}

type Arith int

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

func (t *Arith) Divide(args *Args, quo *Quotient) error {
    if args.B == 0 {
        return errors.New("divide by zero")
    }
    quo.Quo = args.A / args.B
    quo.Rem = args.A % args.B
    return nil
}

func main() {

    arith := new(Arith)
    rpc.Register(arith)

    tcpAddr, err := net.ResolveTCPAddr("tcp", ":1234")
    checkError(err)

    listener, err := net.ListenTCP("tcp", tcpAddr)
    checkError(err)

    for {
        conn, err := listener.Accept()
        if err != nil {
            continue
        }
        rpc.ServeConn(conn)
    }

}

func checkError(err error) {
    if err != nil {
        fmt.Println("Fatal error ", err.Error())
        os.Exit(1)
    }
}

上面这个代码和 http 的服务器相比，不同在于：在此处我们采用了 TCP 协议，然后需要自己控制连接，当有客户端连接上来后，我们需要把这个连接交给 rpc 来处理。

如果你留心了，你会发现这它是一个阻塞型的单用户的程序，如果想要实现多并发，那么可以使用 goroutine 来实现，我们前面在 socket 小节的时候已经介绍过如何处理 goroutine。
下面展现了 TCP 实现的 RPC 客户端：


package main

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

type Args struct {
    A, B int
}

type Quotient struct {
    Quo, Rem int
}

func main() {
    if len(os.Args) != 2 {
        fmt.Println("Usage: ", os.Args[0], "server:port")
        os.Exit(1)
    }
    service := os.Args[1]

    client, err := rpc.Dial("tcp", service)
    if err != nil {
        log.Fatal("dialing:", err)
    }
    // Synchronous call
    args := Args{17, 8}
    var reply int
    err = client.Call("Arith.Multiply", args, &reply)
    if err != nil {
        log.Fatal("arith error:", err)
    }
    fmt.Printf("Arith: %d*%d=%d\n", args.A, args.B, reply)

    var quot Quotient
    err = client.Call("Arith.Divide", args, &quot)
    if err != nil {
        log.Fatal("arith error:", err)
    }
    fmt.Printf("Arith: %d/%d=%d remainder %d\n", args.A, args.B, quot.Quo, quot.Rem)

}

这个客户端代码和 http 的客户端代码对比，唯一的区别一个是 DialHTTP，一个是 Dial (tcp)，其他处理一模一样。

JSON RPC

JSON RPC 是数据编码采用了 JSON，而不是 gob 编码，其他和上面介绍的 RPC 概念一模一样，下面我们来演示一下，如何使用 Go 提供的 json-rpc 标准包，请看服务端代码的实现：


package main

import (
    "errors"
    "fmt"
    "net"
    "net/rpc"
    "net/rpc/jsonrpc"
    "os"
)

type Args struct {
    A, B int
}

type Quotient struct {
    Quo, Rem int
}

type Arith int

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

func (t *Arith) Divide(args *Args, quo *Quotient) error {
    if args.B == 0 {
        return errors.New("divide by zero")
    }
    quo.Quo = args.A / args.B
    quo.Rem = args.A % args.B
    return nil
}

func main() {

    arith := new(Arith)
    rpc.Register(arith)

    tcpAddr, err := net.ResolveTCPAddr("tcp", ":1234")
    checkError(err)

    listener, err := net.ListenTCP("tcp", tcpAddr)
    checkError(err)

    for {
        conn, err := listener.Accept()
        if err != nil {
            continue
        }
        jsonrpc.ServeConn(conn)
    }

}

func checkError(err error) {
    if err != nil {
        fmt.Println("Fatal error ", err.Error())
        os.Exit(1)
    }
}

通过示例我们可以看出 json-rpc 是基于 TCP 协议实现的，目前它还不支持 HTTP 方式。

请看客户端的实现代码：


package main

import (
    "fmt"
    "log"
    "net/rpc/jsonrpc"
    "os"
)

type Args struct {
    A, B int
}

type Quotient struct {
    Quo, Rem int
}

func main() {
    if len(os.Args) != 2 {
        fmt.Println("Usage: ", os.Args[0], "server:port")
        log.Fatal(1)
    }
    service := os.Args[1]

    client, err := jsonrpc.Dial("tcp", service)
    if err != nil {
        log.Fatal("dialing:", err)
    }
    // Synchronous call
    args := Args{17, 8}
    var reply int
    err = client.Call("Arith.Multiply", args, &reply)
    if err != nil {
        log.Fatal("arith error:", err)
    }
    fmt.Printf("Arith: %d*%d=%d\n", args.A, args.B, reply)

    var quot Quotient
    err = client.Call("Arith.Divide", args, &quot)
    if err != nil {
        log.Fatal("arith error:", err)
    }
    fmt.Printf("Arith: %d/%d=%d remainder %d\n", args.A, args.B, quot.Quo, quot.Rem)

}
Klaus_S
关注
专栏目录
基于go语言的rpc框架【万字拆解】
weixin_44545838的博客
05-11 1545
rpc（远程过程调用）是计算机通信协议，允许在不同进程空间的程序之间进行调用。其客户端和服务器可以在同一台机器上，也可以在不同的机器上，并且使用时就像调用本地程序一样，无需关注实现细节，因此相比其他通信方式具有更高的灵活性与易扩展性。相较于传输层以 http 为基础的 restful api，rpc 更接近直接调用，且自定义协议格式减少了冗余报文，提供更高效的序列化协议并使得扩展与集成例如注册中心、负载均衡等功能更加容易。Header。
Go Rpc
weixin_38982838的博客
03-18 247
Go Rpc rpc_server.go package main import ( "errors" "fmt" "net/http" "net/rpc" ) type Args struct { A, B int } type Quotient struct { Quo, Rem int } type Arith int fu...
Go微服务（一）——RPC详细入门
脑袋装水的博客
06-19 4131
RPC是远程过程调⽤的简称，是分布式系统中不同节点间流⾏的通信⽅式。在互联⽹时代，RPC已经 和 IPC⼀样成为⼀个不可或缺的基础构件。因此Go语⾔的标准库也提供了⼀个简单的RPC实现，我们 将以此为⼊⼝学习RPC的各种⽤法。Go语⾔的RPC包的路径为net/rpc，也就是放在了net包⽬录下⾯。因此我们可以猜测该RPC包是建⽴ 在net包基础之上的。在第⼀章“Hello, World”⾰命⼀节最后，我们基于http实现了⼀个打印例⼦。下⾯ 我们尝试基于rpc实现⼀个类似的例⼦。 其中Hello⽅法必须满⾜
go语言rpc,grpc介绍
General_zy的博客
02-10 1439
微服务架构中，由于每个服务对应的代码库是独立运行的，无法直接调用，彼此间的通信就是个大问题。gRPC可以实现微服务，将大的项目拆分为多个小且独立的业务模块，也就是服务，各服务间使用高效的protobuf协议进行RPC调用，gRPC默认使用protocol buffers，这是google开源的一套成熟的结构数据序列化机制（当然也可以使用其他数据格式如JSON）可以用proto files创建gRPC服务，用message类型来定义方法参数和返回类型。
2024年Go最新字节跳动 Go RPC 框架 KiteX 性能优化实践，真香系列
最新发布
2401_84925977的博客
05-11 418
我们再做思考：msec=0 仅单次调用耗时减少 50ns，影响太小，如果想要进一步优化，必须要在调度逻辑上做出调整。进一步思考：上述伪代码中，当无事件触发，调整 msec=-1 时，直接 continue 会立即再次执行 EpollWait，而由于无事件，msec=-1，当前 goroutine 会 block 并被 P 切换。但是被动切换效率较低，如果我们在 continue 前主动为 P 切换 goroutine，则可以节约时间。因此我们将上述伪代码改为如下：for {msec = -1。
【Go语言RPC实战】深入理解Go语言中的RPC规则与实现流程
mundo.wang的个人博客
07-25 1229
RPC（远程过程调用）是一种在分布式系统中进行通信的方式，它允许一个计算机程序调用另一个计算机上的子程序，而无需了解底层网络细节。在涉及RPC的应用中，通常有三个角色：服务端开发人员、客户端调用人员和设计RPC接口规范的人员。以上代码演示了一个简单的RPC示例，服务端实现了一个Multiply方法用于乘法运算，客户端通过RPC调用该方法并获取结果。下面是一个简单的示例代码，演示了如何使用Go语言的net/rpc包实现基本的RPC通信。
RPC
QuinnNorris的博客
07-10 332
RPC是一种概念，用以让远程连接的多台服务器可以像调用本地方法一样互相调用。 RPC 的全称是 Remote Procedure Call 是一种进程间通信方式。 它允许程序调用另一个地址空间（通常是共享网络的另一台机器上）的过程或函数，而不用程序员显式编码这个远程调用的细节。 即程序员无论是调用本地的还是远程的，本质上编写的调用代码基本相同。由于计算能力需要横向扩展，需要在多台机器组成的集群上部...
Go RPC开发指南.pdf
06-15
"Go RPC开发指南.pdf" ...Go RPC开发指南.pdf是Go语言中的一种RPC开发指南，涵盖了RPC的基本概念、RPC库的选择、RPC服务的实现、客户端调用、序列化、Fail Mode、路由选择、统计与限流等多个方面。
gorpc:一个为大型分布式系统设计的golang rpc框架
03-11
戈尔普一个为大型分布式系统设计的golang rpc框架运行gorpc测试go test -v github.com/johntech-o/gorpc 上面的命令将在测试输出的末尾显示性能信息client conn status: {"Result":{"127.0.0.1:6668":{"creating":0,...
Go语言RPC（模拟远程过程调用）
01-07
 服务器开发中会使用RPC(Remote Procedure Call，远程过程调用)简化进程间通信的过程。RPC能有效地封装通信过程。RPC能有效地封装通信过程，让远程的数据收发通信过程看起来就像本地的函数调用一样。  本例中，...
Go语言RPC Authorization进行简单ip安全验证的方法
09-22
主要介绍了Go语言RPC Authorization进行简单ip安全验证的方法,实例分析了Go语言进行ip验证的技巧,需要的朋友可以参考下
Go之rpc入门
屈帅波的技术博客
11-29 3837
参考资料 GO高级编程 一 Rpc入门 RPC是远程过程调用的简称，是分布式系统中不同节点间流行的通信方式。在互联网时代，RPC已经和IPC一样成为一个不可或缺的基础构件。因此Go语言的标准库也提供了一个简单的RPC实现，我们将以此为入口学习RPC的各种用法。 1.简单示例 Go语言的RPC包的路径为net/rpc，也就是放在了net包目录下面。因此我们可以猜测该RPC包是建立在net包基础之上的。在第一章“Hello, World”革命一节最后，我们基于http实现了一个打印例子。下面我们尝试基于rp.
go 原生rpc使用详解
qq_41149621的博客
01-26 479
【代码】go 原生rpc使用详解。
【Golang】Golang的RPC（Remote Procedure Call）
linjiuxiansheng的博客
04-16 384
Golang 的 RPC（Remote Procedure Call）是一种用于不同计算机之间通信的技术。它允许在不同的计算机之间调用函数，就像本地调用一样。
RPC原理与Go RPC详解
m0_63230155的博客
08-04 1797
RPC（Remote Procedure Call），即远程过程调用。它允许像调用本地服务一样调用远程服务。RPC是一种服务器-客户端（Client/Server）模式，经典实现是一个通过发送请求-接受回应进行信息交互的系统。首先与RPC（远程过程调用）相对应的是本地调用。
go语言学习-RPC的简单使用
len_yue_mo_fu的博客
07-19 1285
什么是RPC？ RPC（Remote Procedure Call）—远程过程调用，它是一种通过网络从远程计算机程序上请求服务，而不需要了解底层网络技术的协议。RPC协议假定某些传输协议的存在，如TCP或UDP，为通信程序之间携带信息数据。在OSI网络通信模型中，RPC跨越了传输层和应用层。RPC使得开发包括网络分布式多程序在内的应用程序更加容易。 RPC采用客户机/服务器模式。请求程序就是一...
go微服务系列(十)：Go RPC实现服务间通信
阿白，
06-21 1239
Go 语言原生的 RPC 过程调用实现起来非常简单。服务端只需实现对外提供的远程过程方法和结构体，然后将其注册到 RPC 服务中，客户端就可以通过其服务名称和方法名称进行 RPC 方法调用。 使用字符串操作的服务来展示如何使用 Go 语言原生的 RPC 来进行过程调用。 第一步，定义远程过程调用相关接口传入参数和返回参数的数据结构。如下代码所示，调用字符串操作的请求包括两个参数：字符串 A 和字符串 B。 第二步，定义一个服务对象。这个服务对象可以很简单，比如类型是 int 或者是 interface{}，
Go RPC开发与实践指南
Go RPC开发指南是一份深入探讨Go语言中RPC（Remote Procedure Call）技术的文档，旨在帮助开发者了解并掌握如何使用Go进行RPC服务的开发。文档分为四个主要部分，全面涵盖了RPC的基础知识、编程实践、特性和插件开发...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值