Golang中的RPC和gRPC

一、RPC编程

• 参考资料

  <<Go语言编程>> --许式伟
  gRPC介绍与安装
  gRPC官方文档
  gRPC中文文档
  protocol-buffers

• 介绍

RPC(Remote Procedure Call,远程过程调用)是一种通过网络从远程计算机程序上请求服务,而不需要了解底层网络细节的应用程序通信协议。RPC协议构建于TCP或UDP,或者是HTTP上。允许开发者直接调用另一台服务器上的程序,而开发者无需另外的为这个调用过程编写网络通信相关代码,使得开发网络分布式程序在内的应用程序更加容易

RPC采用客户端-服务器端的工作模式,请求程序就是一个客户端,而服务提供程序就是一个服务器端。当执行一个远程过程调用时,客户端程序首先先发送一个带有参数的调用信息到服务端,然后等待服务端响应。在服务端,服务进程保持睡眠状态直到客户端的调用信息到达。当一个调用信息到达时,服务端获得进程参数,计算出结果,并向客户端发送应答信息。然后等待下一个调用。

• Go语言中的RPC支持与处理

在Go中,标准库提供的net/rpc包实现了RPC协议需要的相关细节,开发者可以很方便的使用该包编写RPC的服务端和客户端程序。这使得用Go语言开发的多个进程之间的通信变得非常简单
net/rpc包允许PRC客户端程序通过网络或者其他IO连接调用一个远程对象的公开方法(该方法必须是外部可访问即首字母大写)。在PRC服务端,可将一个对象注册为可访问的服务,之后该对象的公开方法就能够以远程的方式提供访问。一个RPC服务端可以注册多个不通类型的对象,但<font color="Brown">不允许注册同一类型的多个对象。</font>

• 一个对象中只有满足如下条件的方法,才能被PRC服务端设置为可供远程访问
  1.<font color="Brown">必须是在对象外部可公开调用的方法(首字母大写)</font>
  2.<font color="Brown">必须有两个参数,且参数的类型都必须是包外部可以访问的类型或者是Go內建支持的类型</font>
  3.<font color="Brown">第二个参数必须是一个指针</font>
  4.<font color="Brown">方法必须返回一个error类型的值</font>
  用代码表示

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

  在上面这行代码中,类型 T T1 T2 默认会使用Go内置的encoding/gob包进行编码和解码
  改方法的第一个参数表示由PRC客户端传入的参数,第二个参数表示要返回给PRC客户端的结果。改方法最后返回一个error类型

• RPC客户端和服务器端的使用

RPC服务端可以通过调用 ```rpc.ServerConn```处理单个连接请求。多数情况下,通过tcp或是http在某个网络地址上监听然后再创建该服务是个不错的选择 
在RPC客户端,Go的net/rpc包提供了便利的```rpc.Dial()```和```rpc.DialHTTP()```方法来与指定的RPC服务建立连接。在建立连接之后,Go的net/rpc包允许我们使用通过或者异步的方式接受RPC服务端的结果。调用RPC客户端的```Call()```方法则进行同步处理。这个时候客户端程序按照顺序执行。当调用RPC客户端的```Go()```方法时,则进行异步处理。客户端无需等待服务端的结果即可执行后面的程序,当接收到服务端响应时,再对其进行相应的处理。 无论是哪个方法,都必须要指定要调用的服务及其方法名称,以及一个客户端传入参数的引用,还有一个用于接收处理结果参数的指针 
如果没有指定RPC传输过程中使用何种编码解码器,默认使用Go标准库提供的eccoding/gob包进行数据传输 

• 代码示例

服务器端代码

package main
import (
 "errors"
 "log"
 "net"
 "net/http"
 "net/rpc"
 "os"
 "time"
)
type Args struct {
 A, B int
}
type Quotient struct {
 Quo, Rem int
}
type Arith int
//计算乘积
func (t *Arith) Multiply(args *Args, reply *int) error {
 time.Sleep(time.Second * 3) //睡三秒,同步调用会等待,异步会先往下执行
 *reply = args.A * args.B
 return nil
}
//计算商和余数
func (t *Arith) Divide(args *Args, quo *Quotient) error {
 time.Sleep(time.Second * 3)
 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服务注册了一个arith对象 公开方法供客户端调用
 rpc.Register(arith)
 //指定rpc的传输协议 这里采用http协议作为rpc调用的载体 也可以用rpc.ServeConn处理单个连接请求
 rpc.HandleHTTP()
 l, e := net.Listen("tcp", ":1234")
 if e != nil {
 log.Fatal("listen error", e)
 }
 go http.Serve(l, nil)
 os.Stdin.Read(make([]byte, 1))
}

客户端代码

package main
import (
 "fmt"
 "log"
 "net/rpc"
 "time"
)
type Args struct {
 A, B int
}
type Quotient struct {
 Quo, Rem int
}
func main() {
 //调用rpc服务端提供的方法之前,先与rpc服务端建立连接
 client, err := rpc.DialHTTP("tcp", "127.0.0.1:1234")
 if err != nil {
 log.Fatal("dialHttp error", err)
 return
 }
 //同步调用服务端提供的方法
 args := &Args{7, 8}
 var reply int
 //可以查看源码 其实Call同步调用是用异步调用实现的。后续再详细学习
 err = client.Call("Arith.Multiply", args, &reply) //这里会阻塞三秒
 if err != nil {
 log.Fatal("call arith.Multiply error", err)
 }
 fmt.Printf("Arith:%d*%d=%d\n", args.A, args.B, reply)
 //异步调用
 quo := Quotient{}
 divCall := client.Go("Arith.Divide", args, &quo, nil)
 //使用select模型监听通道有数据时执行,否则执行后续程序
 for {
 select {
 case <-divCall.Done:
 fmt.Printf("商是%d,余数是%d\n", quo.Quo, quo.Rem)
 default:
 fmt.Println("继续向下执行....")
 time.Sleep(time.Second * 1)
 }
 }
}

说明

//Go函数的原型,注意其最后一个参数是一个channel 也就是调用结果存到了这个channel里 里面的类型数据是*Call类型
//如果你不传递这个channel这个参数,Go函数内部会默认创建一个*Call类型的10个长度的channel来缓存结果数据。channel的名字叫做
//Done也就是返回值*Calll俩面的最后一个值 
//好吧,其实我就是想说,cient.Go的返回值包含了最后一个参数(channel),想获取调用结果,可以从参数管道中直接获取,也可以从返回值
//Done中获取
// Call represents an active RPC.
type Call struct {
 ServiceMethod string // The name of the service and method to call.
 Args interface{} // The argument to the function (*struct).
 Reply interface{} // The reply from the function (*struct).
 Error error // After completion, the error status.
 Done chan *Call // Strobes when call is complete.
}
func (client *Client) Go(serviceMethod string, args interface{}, reply interface{}, done chan *Call) *Call {

二 gRpc

• gRPC是什么

gRPC中文文档

gRPC是一个高性能、开源、通用的RPC框架。基于HTTP/2协议标准设计开发,默认采用Protocol Buffers数据序列化协议([Protocol Buffers基本语法]()),支持多种开发语言。gRPC提供了一种简单的方法来精确的定义服务,并且为客户端和服务端自动生成可靠的功能库

• gRPC应用场景

在gRPC客户端可以直接调用不通服务器上的远程程序,就想调用本地程序一样,很容易构建分布式应用和服务。和很多RPC系统一样,服务负责实现定义好的接口并处理客户端请求,客户端根据接口描述直接调用需要的服务。客户端和服务器可以分别使用gRPC支持的不同语言实现

图片

• 安装

protobuf Golang插件

执行完成后会在GOPATH/bin目录下生成 protoc-gen-go工具,在编译.proto文件时,protoc命令需要用到此插件

[关于protobuf语法和基本使用]()

go get -u github.com/golang/protobuf/{proto,protoc-gen-go}

grpc-go golang第三方库下载(需要翻墙 用ss配置http代理完成终端翻墙))

go get -u google.golang.org/grpc

• gPRC列子 hello gRPC

流程

1.编写.proto描述文件 
2.编译生成.pb.go文件 
3.客户端实现约定的接口并提供服务 
4.客户端按照约定调用方法请求服务 

目录结构

$GOPATH/src/go_demo/
23gPRC/
|—— hello/
 |—— client/
 |—— main.go // 客户端
 |—— server/
 |—— main.go // 服务端
|—— proto/
 |—— hello.proto // proto描述文件
 |—— hello.pb.go // proto编译后文件

• 代码示例

proto rpc服务描述文件

syntax = "proto3"; //指定proto版本
package proto;
//定义请求结构
message HelloRequest{
 string name=1;
}
//定义响应结构
message HelloReply{
 string message=1;
}
//定义Hello服务
service Hello{
 //定义服务中的方法
 rpc SayHello(HelloRequest)returns (HelloReply){}
}

protoc -I . --go_out=plugins=grpc:. ./hello.proto
hello.proto文件中定义了一个Hello Service 该服务包含了一个SayHello方法 同时声明了HelloRequest和HelloReply消息结构
用于请求和响应。客户端使用HelloRequest参数调用SayHello方法请求服务端 服务端响应HelloReply消息
根据hello.proto文件编译生成Golang源文件 hello.pb.go
源文件中包含消息传递的请求和响应结构。服务端注册对象的方法 创建客户端 以及调用服务端方法

服务器端代码

package main
import (
 "fmt"
 pb "go_demo/23gRPC/proto"
 "net"
 "golang.org/x/net/context"
 "google.golang.org/grpc"
)
const (
 //gRPC服务地址
 Address = "127.0.0.1:50052"
)
//定义一个helloServer并实现约定的接口
type helloService struct{}
func (h helloService) SayHello(ctx context.Context, in *pb.HelloRequest) (*pb.HelloReply, error) {
 resp := new(pb.HelloReply)
 resp.Message = "hello" + in.Name + "."
 return resp, nil
}
var HelloServer = helloService{}
func main() {
 listen, err := net.Listen("tcp", Address)
 if err != nil {
 fmt.Printf("failed to listen:%v", err)
 }
 //实现gRPC Server
 s := grpc.NewServer()
 //注册helloServer为客户端提供服务
 pb.RegisterHelloServer(s, HelloServer) //内部调用了s.RegisterServer()
 fmt.Println("Listen on" + Address)
 s.Serve(listen)
}

go run main.go
Listen on127.0.0.1:50052

客户端代码

package main
import (
 "fmt"
 pb "go_demo/23gRPC/proto"
 "golang.org/x/net/context"
 "google.golang.org/grpc"
)
const (
 Address = "127.0.0.1:50052"
)
func main() {
 //连接gRPC服务器
 conn, err := grpc.Dial(Address, grpc.WithInsecure())
 if err != nil {
 fmt.Println(err)
 }
 defer conn.Close()
 //初始化客户端
 c := pb.NewHelloClient(conn)
 //调用方法
 reqBody := new(pb.HelloRequest)
 reqBody.Name = "gRPC"
 r, err := c.SayHello(context.Background(), reqBody)
 if err != nil {
 fmt.Println(err)
 }
 fmt.Println(r.Message)
}

go run main.go
hello gRpc

本文来自:Segmentfault

感谢作者:xiaodulala

查看原文:Golang中的RPC和gRPC

• 编辑
• 预览