一、什么是rpc
RPC（Remote Procedure Call），即远程过程调用。它允许像调用本地服务一样调用远程服务。在分布式计算，远程过程调用（Remote Procedure Call，缩写为 RPC）是一个计算机通信协议。该协议允许运行于一台计算机的程序调用另一个地址空间（通常为一个开放网络的一台计算机）的子程序，而程序员就像调用本地程序一样，无需额外地为这个交互作用编程（无需关注细节）。 RPC是一种服务器-客户端（Client/Server）模式，经典实现是一个通过发送请求-接受回应进行信息交互的系统。 接口定义语言 (IDL) - 用于描述软件组件的应用程序编程接口 (API) 的规范语言 - 常用于远程过程调用软件。在这种情况下，IDL 在链路两端的机器之间提供了一座桥梁，这些机器可能使用不同的操作系统 (OS) 和计算机语言。
1.1本地调用
package main
import "fmt"
func add(x, y int) int {
return x + y
}
func main() {
a := 10
b := 20
ret := add(a, b)
fmt.Println(ret)
}
本地调用add函数的执行流程，可以理解为以下四个步骤。
- 将变量 a 和 b 的值分别压入堆栈上
- 执行 add 函数，从堆栈中获取 a 和 b 的值，并将它们分配给 x 和 y
- 计算 x + y 的值并将其保存到堆栈中
- 退出 add 函数并将 x + y 的值赋给 ret
1.2RPC调用
本地过程调用发生在同一进程中，共享同一个内存空间，但 RPC 通信需要跨不同的机器和不同的进程，因此需要解决以下三个问题。
- 如何确定函数？ 在本地调用中，函数主体通过函数指针函数指定，然后调用 add 函数，编译器通过函数指针函数自动确定 add 函数在内存中的位置。但是在 RPC 中，调用不能通过函数指针完成，因为它们的内存地址可能完全不同。因此，调用方和被调用方都需要维护一个{ function <-> ID }映射表，以确保调用正确的函数。
- 如何表达参数？ 本地过程调用中传递的参数是通过堆栈内存结构实现的，但 RPC 不能直接使用内存传递参数，因此参数或返回值需要在传输期间序列化并转换成字节流，反之亦然。
- 如何进行网络传输？ 函数的调用方和被调用方通常是通过网络连接的，也就是说，function ID 和序列化字节流需要通过网络传输，因此，只要能够完成传输，调用方和被调用方就不受某个网络协议的限制。.例如，一些 RPC 框架使用 TCP 协议，一些使用 HTTP。
1.3HTTP调用RESTful API
首先，我们编写一个基于HTTP的server服务，它将接收其他程序发来的HTTP请求，执行特定的程序并将结果返回。
package main
import (
"encoding/json"
"io/ioutil"
"log"
"net/http"
)
type addParam struct {
X int `json:"x"`
Y int `json:"y"`
}
type addResult struct {
Code int `json:"code"`
Data int `json:"data"`
}
func add(x, y int) int {
return x + y
}
func addHandler(w http.ResponseWriter, r *http.Request) {
b, _ := ioutil.ReadAll(r.Body)
var param addParam
json.Unmarshal(b, ¶m)
ret := add(param.X, param.Y)
respBytes, _ := json.Marshal(addResult{Code: 0, Data: ret})
w.Write(respBytes)
}
func main() {
http.HandleFunc("/add", addHandler)
log.Fatal(http.ListenAndServe(":9090", nil))
}
我们编写一个客户端来请求上述HTTP服务，传递x和y两个整数，等待返回结果。
package main
import (
"bytes"
"encoding/json"
"fmt"
"io/ioutil"
"net/http"
)
type addParam struct {
X int `json:"x"`
Y int `json:"y"`
}
type addResult struct {
Code int `json:"code"`
Data int `json:"data"`
}
func main() {
url := "http://127.0.0.1:9090/add"
param := addParam{
X: 10,
Y: 20,
}
paramBytes, _ := json.Marshal(param)
resp, _ := http.Post(url, "application/json", bytes.NewReader(paramBytes))
defer resp.Body.Close()
respBytes, _ := ioutil.ReadAll(resp.Body)
var respData addResult
json.Unmarshal(respBytes, &respData)
fmt.Println(respData.Data)
}
这种模式是我们目前比较常见的跨服务或跨语言之间基于RESTful API的服务调用模式。
RESTful API通常是基于HTTP协议，传输数据采用JSON等文本协议，相较于RPC 直接使用TCP协议，传输数据多采用二进制协议来说，RPC通常相比RESTful API性能会更好。
RESTful API多用于前后端之间的数据传输，而目前微服务架构下各个微服务之间多采用RPC调用。
二、net/rpc
2.1基础RPC示例
Go语言的 rpc 包提供对通过网络或其他 i/o 连接导出的对象方法的访问，服务器注册一个对象，并把它作为服务对外可见（服务名称就是类型名称）。注册后，对象的导出方法将支持远程访问。服务器可以注册不同类型的多个对象(服务) ，但是不支持注册同一类型的多个对象。
在下面的代码中我们定义一个ServiceA类型，并为其定义了一个可导出的Add方法。
package main
type Args struct {
X, Y int
}
type ServiceA struct{}
func (s *ServiceA) Add(args *Args, reply *int) error {
*reply = args.X + args.Y
return nil
}
通过下面的代码将上面定义的ServiceA类型注册为一个服务，其Add方法就支持RPC调用了。
package main
import (
"log"
"net"
"net/http"
"net/rpc"
)
func main() {
service := new(ServiceA)
rpc.Register(service)
rpc.HandleHTTP()
l, e := net.Listen("tcp", ":9091")
if e != nil {
log.Fatal("listen error:", e)
}
http.Serve(l, nil)
}
此时，client 端便能看到一个拥有“Add”方法的“ServiceA”服务，想要调用这个服务需要使用下面的代码先连接到server端再执行远程调用。
package main
import (
"fmt"
"log"
"net/rpc"
)
type Args struct {
X, Y int
}
func main() {
client, err := rpc.DialHTTP("tcp", "127.0.0.1:9091")
if err != nil {
log.Fatal("dialing:", err)
}
args := &Args{10, 20}
var reply int
err = client.Call("ServiceA.Add", args, &reply)
if err != nil {
log.Fatal("ServiceA.Add error:", err)
}
fmt.Printf("ServiceA.Add: %d+%d=%d\n", args.X, args.Y, reply)
var reply2 int
divCall := client.Go("ServiceA.Add", args, &reply2, nil)
replyCall := <-divCall.Done
fmt.Println(replyCall.Error)
fmt.Println(reply2)
}
执行上述程序，查看 RPC 调用的结果。
先启动 server 端。
go run server.go service.go
再启动 client 端。
go run client.go
会看到如下输出结果。
ServiceA.Add: 10+20=30 <nil> 30
2.2基于TCP协议的RPC
当然 rpc 包也支持直接使用 TCP 协议而不使用HTTP协议。
server 端代码修改如下。
package main
import (
"log"
"net"
"net/rpc"
)
func main() {
service := new(ServiceA)
rpc.Register(service)
l, e := net.Listen("tcp", ":9091")
if e != nil {
log.Fatal("listen error:", e)
}
for {
conn, _ := l.Accept()
rpc.ServeConn(conn)
}
}
client 端代码修改如下。
package main
import (
"fmt"
"log"
"net/rpc"
)
type Args struct {
X, Y int
}
func main() {
client, err := rpc.Dial("tcp", "127.0.0.1:9091")
if err != nil {
log.Fatal("dialing:", err)
}
args := &Args{10, 20}
var reply int
err = client.Call("ServiceA.Add", args, &reply)
if err != nil {
log.Fatal("ServiceA.Add error:", err)
}
fmt.Printf("ServiceA.Add: %d+%d=%d\n", args.X, args.Y, reply)
var reply2 int
divCall := client.Go("ServiceA.Add", args, &reply2, nil)
replyCall := <-divCall.Done
fmt.Println(replyCall.Error)
fmt.Println(reply2)
}
2.3使用JSON协议的RPC
rpc 包默认使用的是 gob 协议对传输数据进行序列化/反序列化，比较有局限性。下面的代码将尝试使用 JSON 协议对传输数据进行序列化与反序列化。
server 端代码修改如下。
package main
import (
"log"
"net"
"net/rpc"
"net/rpc/jsonrpc"
)
func main() {
service := new(ServiceA)
rpc.Register(service)
l, e := net.Listen("tcp", ":9091")
if e != nil {
log.Fatal("listen error:", e)
}
for {
conn, _ := l.Accept()
rpc.ServeCodec(jsonrpc.NewServerCodec(conn))
}
}
client 端代码修改如下。
package main
import (
"fmt"
"log"
"net"
"net/rpc"
"net/rpc/jsonrpc"
)
type Args struct {
X, Y int
}
func main() {
conn, err := net.Dial("tcp", "127.0.0.1:9091")
if err != nil {
log.Fatal("dialing:", err)
}
client := rpc.NewClientWithCodec(jsonrpc.NewClientCodec(conn))
args := &Args{10, 20}
var reply int
err = client.Call("ServiceA.Add", args, &reply)
if err != nil {
log.Fatal("ServiceA.Add error:", err)
}
fmt.Printf("ServiceA.Add: %d+%d=%d\n", args.X, args.Y, reply)
var reply2 int
divCall := client.Go("ServiceA.Add", args, &reply2, nil)
replyCall := <-divCall.Done
fmt.Println(replyCall.Error)
fmt.Println(reply2)
}
2.4Python调用RPC
下面的代码演示了如何使用 python client 远程调用上面 Go server中 serviceA的Add方法。
import socket
import json
request = {
"id": 0,
"params": [{"x":10, "y":20}],
"method": "ServiceA.Add"
}
client = socket.create_connection(("127.0.0.1", 9091),5)
client.sendall(json.dumps(request).encode())
rsp = client.recv(1024)
rsp = json.loads(rsp.decode())
print(rsp)
|