网站首页 返回列表 像“草根”一样，紧贴着地面，低调的存在，冬去春来，枯荣无恙。

go 语言中 RPC

2020-06-10 02:46:12 admin 770

golang_real.jpg

微服务已经 hot 了一段时间，自己作为 web
开发人员当然也不由自主想研究研究微服务，不过微服务的整个知识体系过于庞大，要掌握的概念和技术太多，一时有点吃不消。个人为了生计又没有大块时间去搞。不过还是难舍微服务，最近学习了
go 语言，想一块一块地吃掉微服务，先从 go 和容器入手。

我们知道微服务之间是需要相互调用和通讯的，一般会采用 RPC 来实现不同语言不用服务间的调用和通讯。那么我就先从 RPC 入手来学习微服务。

RPC 框架的特点

所谓的特点就是他能够满足那些需求，RPC 框架要实现以上目的需要满足以下需求

  • 序列化（GOB）语言单一

  • 上下文管理（超时控制）

  • 拦截器（鉴权、统计和限流）

  • 跨语言

  • 服务注册

  • Call ID：由于客户端和服务端运行在不同进程，为了让客户端和服务端都了解调用了哪个函数，需要在两端维护一个函数到Call ID 的映射表，客户端根据表获取函数的 Call ID，发起请求，服务端根据 Call ID 来执行对应的函数，返回值给客户端。

  • 序列化和反序列化：在本地调用时候函数是从栈中获取参数运行函数。而远程调用时候，如果需要在不同语言间相互调用函数，需要将参数进行序列化然后以字节流方式传递给服务端，服务端在反序列化来得到参数

  • 网络传输：客户端和服务端间的调用往往是通过网络完成。只要能传递数据就行，与协议无关，可以使用 TCP 或 UDP。gRcp 使用的 HTTP2 。

什么是 RPC

RPC是指 远程过程
调用，也就是说两台服务器A，B，一个应用部署在A服务器上，想要调用B服务器上应用提供的函数/方法，由于不在一个内存空间，不能直接调用，需要通过网络来表达调用的语义和传达调用的数据。

为什么需要 RPC 呢

因为 RPC 是分布式系统中不同节点间流行的通讯方式，在互联网时代，RPC 和 IPC 一样成为不可或缺的基础构建。在 Go 语言的标准库也提供了简单的
RPC 的实现。

RPC 在服务间调用流程

屏幕快照 2019-04-24 下午8.21.15.png

我们通过上面图来看，这个流程比较清晰，也不难理解。

  1. 调用客户端句柄，执行传送参数
  2. 调用本地系统内核发送网络消息
  3. 消息传送至远程机器
  4. 服务器句柄得到消息并取得参数
  5. 执行远程过程
  6. 执行过程将结果返回给服务器句柄
  7. 服务器句柄返回结果，调用远程系统内核
  8. 消息传回本地主机
  9. 客户句柄由内核接收消息
  10. 客户接收句柄返回的数据

有了上面理论基础，我们基于理论来实现。

__

  1. type RPCService struct{}

创建一个RPCService服务，随后将其进行注册

__

  1. func (s *RPCService) Hello(request string, reply *string) error{
  2.     *reply = "Hello " + request
  3.     return nil
  4. }
  • 函数必须是外部可以访问函数，函数名需要首字母大写
  • 函数需要有两个参数
    1. 第一个参数接收的参数
    2. 第二个参数是返回给客户端的参数，而且需要是指针类型
  • 函数还需要有一个 error 返回值

__

  1. rpc.RegisterName("RPCService",new(RPCService))

注册rpc服务

__

  1. listener , err := net.Listen("tcp",":1234")

创建 tcp 服务端口号为 1234 用于 rpc 服务。

__

  1. conn , err := listener.Accept()
  3.     if err != nil{
  4.         log.Fatal("Accept error:", err)
  5.     }
  7.     rpc.ServeConn(conn)

服务端完整代码

__

  1. package main
  3. import(
  4.     // "fmt"
  5.     "log"
  6.     "net"
  7.     "net/rpc"
  8. )
  10. type RPCService struct{}
  12. func (s *RPCService) Hello(request string, reply *string) error{
  13.     *reply = "Hello " + request
  14.     return nil
  15. }
  17. func main() {
  18.     rpc.RegisterName("RPCService",new(RPCService))
  20.     listener, err := net.Listen("tcp",":1234")
  21.     if err != nil{
  22.         log.Fatal("ListenTCP error:",err)
  23.     }
  25.     conn, err := listener.Accept()
  27.     if err != nil{
  28.         log.Fatal("Accept error:", err)
  29.     }
  31.     rpc.ServeConn(conn)
  32. }

客户端代码

__

  1. client , err := rpc.Dial("tcp","localhost:1234")

客户端调用 RPC 服务，然后通过client.Call调用具体的RPC方法。

__

  1. err = client.Call("RPCService.Hello","World",&reply)

在调用client.Call时，第一个参数是用点号链接的RPC服务名字和方法名字，第二和第三个参数分别我们定义RPC方法的两个参数。

__

  1.  package main
  3. import(
  4.     "fmt"
  5.     "log"
  6.     "net/rpc"
  7. )
  9. func main() {
  10.     client, err := rpc.Dial("tcp","localhost:1234")
  12.     if err != nil{
  13.         log.Fatal("dialing:", err)
  14.     }
  16.     var reply string
  17.     err = client.Call("RPCService.Hello","World",&reply)
  19.     if err != nil{
  20.         log.Fatal("call Hello method of RPCService:",err)
  21.     }
  23.     fmt.Println(reply)
  24. }

我们先后启动服务端和客户端就可以看到下面效果

__

  1. Hello World

下面更加贴近实际来写一个基于 HTTP 的 RPC 服务，服务提供两个数四则运算。

__

  1. rpcService := new(RPCService)
  2.     rpc.Register(rpcService)
  3.     rpc.HandleHTTP()

这里的注册方式略有不同，但是大同小异相信大家一看就懂。
服务端完整代码

__

  1. package main
  3. import(
  4.     "errors"
  5.     "fmt"
  6.     "net/http"
  7.     "net/rpc"
  8. )
  10. type Args struct{
  11.     A, B int
  12. }
  14. type Quotient struct{
  15.     Quo, Rem int
  16. }
  18. type RPCService int
  20. func (t *RPCService) Add(args *Args, reply *int) error{
  21.     *reply = args.A - args.B
  22.     return nil
  23. }
  25. func (t *RPCService) Multiply(args *Args, reply *int) error{
  26.     *reply = args.A * args.B
  27.     return nil
  28. }
  30. func (t *RPCService) Divide(args *Args, quo *Quotient) error{
  31.     if args.B == 0{
  32.         return errors.New("divide by zero")
  33.     }
  34.     quo.Quo = args.A / args.B
  35.     quo.Rem = args.A % args.B
  36.     return nil
  37. }
  40. func main() {
  41.     rpcService := new(RPCService)
  42.     rpc.Register(rpcService)
  43.     rpc.HandleHTTP()
  45.     err := http.ListenAndServe(":1234",nil)
  46.     if err != nil{
  47.         fmt.Println(err.Error())
  48.     }
  49. }

__

  1. package main
  3. import(
  4.     "fmt"
  5.     "log"
  6.     "net/rpc"
  7.     "os"
  8. )
  10. type Args struct{
  11.     A, B int
  12. }
  14. type Quotient struct{
  15.     Quo, Rem int
  16. }
  18. func main()  {
  19.     if len(os.Args) != 2{
  20.         fmt.Println("Usage: ", os.Args[0],"server")
  21.         os.Exit(1)
  22.     }
  23.     serverAddress := os.Args[1]
  25.     client, err := rpc.DialHTTP("tcp",serverAddress + ":1234")
  26.     if err != nil {
  27.         log.Fatal("dialing: ", err)
  28.     }
  30.     args := Args{17, 8}
  31.     var reply int
  32.     err = client.Call("RPCService.Add",args, &reply)
  33.     if err != nil{
  34.         log.Fatal("RPCService error: ", err)
  35.     }
  36.     fmt.Printf("RPCService: %d + %d = %d\n", args.A, args.B, &reply)
  38.     var quot Quotient
  39.     err = client.Call("RPCService.Divide",args, &quot)
  40.     if err != nil{
  41.         log.Fatal("RPCService error: ",err)
  42.     }
  44.     fmt.Printf("RPCService: %d/%d=%d remainder %d\n",args.A, args.B, quot.Quo,quot.Rem)
  45. }

__

  1. RPCService: 17 + 8 = 824634312296
  2. RPCService: 17/8=2 remainder 1

其实在实际开发中我们还需要对其进行改造，例如让 rpc 请求可以获得一个 context 对象，其中包含用户信息等，然后可以对 rpc 进行超时处理。

JSONRPC

Go语言内置的 RPC 框架已经支持在 Http 协议上提供 RPC 服务。但是 Http 服务内置采用了 GOB 协议。编码不是 JSON
编码，不方便其他语言调用。不过 go 提供 JsonRPC 的 RPC 服务支持，我们来看一看怎么用代码实现。

服务端代码

__

  1. package main
  3. import(
  4.     "errors"
  5.     "fmt"
  6.     "net"
  7.     "net/rpc"
  8.     "net/rpc/jsonrpc"
  9.     // "os"
  10. )
  12. type Args struct{
  13.     A, B int
  14. }
  16. type Quotient struct{
  17.     Quo, Rem int
  18. }
  20. type RPCService int
  21. func (t *RPCService) Multiply(args *Args, reply *int) error{
  22.     *reply = args.A * args.B
  23.     return nil
  24. }
  26. func (t *RPCService) Divide(args *Args, quo *Quotient) error{
  27.     if args.B == 0{
  28.         return errors.New("divide by zero")
  29.     }
  30.     quo.Quo = args.A / args.B
  31.     quo.Rem = args.A % args.B
  32.     return nil
  33. }
  35. func main() {
  36.     rpcService := new(RPCService)
  37.     rpc.Register(rpcService)
  39.     tcpAddr, err := net.ResolveTCPAddr("tcp",":1234")
  40.     checkError(err)
  43.     listener, err := net.ListenTCP("tcp",tcpAddr)
  44.     checkError(err)
  46.     for{
  47.         conn, err := listener.Accept()
  48.         if err != nil{
  49.             continue
  50.         }
  51.         jsonrpc.ServeConn(conn)
  52.     }
  55. }
  57. func checkError(err error){
  58.     if err != nil{
  59.         fmt.Println("Fatal error ", err.Error())
  60.     }
  61. }

客户端代码

__

  1. package main
  3. import(
  4.     "fmt"
  5.     "log"
  6.     "net/rpc/jsonrpc"
  7.     "os"
  8. )
  10. type Args struct{
  11.     A, B int
  12. }
  14. type Quotient struct{
  15.     Quo, Rem int
  16. }
  18. func main()  {
  19.     if len(os.Args) != 2{
  20.         fmt.Println("Usage: ", os.Args[0],"server")
  21.         log.Fatal(1)
  22.     }
  23.     serverAddress := os.Args[1]
  25.     client, err := jsonrpc.Dial("tcp",serverAddress + ":1234")
  26.     if err != nil {
  27.         log.Fatal("dialing: ", err)
  28.     }
  30.     args := Args{17, 8}
  32.     var quot Quotient
  33.     err = client.Call("RPCService.Divide",args, &quot)
  34.     if err != nil{
  35.         log.Fatal("RPCService error: ",err)
  36.     }
  38.     fmt.Printf("RPCService: %d/%d=%d remainder %d\n",args.A, args.B, quot.Quo,quot.Rem)
  39. }

grpc_square_reverse_4x.png

转载文章，原文链接： go 语言中 RPC

关键字词goRPC

分享到：

上一篇：golang 网络编程（3）

下一篇：golang 网络编程（6）中间件

如需留言，请 登录，没有账号？请 注册

0 条评论 0 人参与

顶部 底部