grpc是google开发的一款rpc框架，非常好用而且流行。grpc使用proto buffer来进行接口定义，也使用proto buffer作为底层的编码格式（gRPC can use protocol buffers as both its Interface Definition Language (IDL) and as its underlying message interchange format）。
hello world
首先要安装proto buffer的编译器，这里省略。为了生成go的文件，还需要安装两个go的插件，如下：
$ go install google.golang.org/protobuf/cmd/protoc-gen-go@v1.28
$ go install google.golang.org/grpc/cmd/protoc-gen-go-grpc@v1.2并且设置PATH环境变量：
$ export PATH="$PATH:$(go env GOPATH)/bin"在项目下面创建一个proto文件夹，如图：
proto文件夹下面放的是相关结构体和rpc的定义，pkg文件夹下面放的是之后protoc自动生成的框架代码。
hello.proto的文件内容：
syntax = "proto3";
option go_package = "./hellopb";
// The greeting service definition.
service Greeter {
// Sends a greeting
rpc SayHello (HelloRequest) returns (HelloReply) {}
}
// The request message containing the user's name.
message HelloRequest {
string name = 1;
}
// The response message containing the greetings
message HelloReply {
string message = 1;
}option go_package 表示的是go的import path，待会生成文件之后我们会看到有什么用。
使用以下命令生成go文件：
protoc --go_out=./pkg/ --go-grpc_out=./pkg/ proto/hello.protogo_out和go-grpc_out参数都表示生成的文件存放的位置。
生成文件的结果：
pkg下面多了一个文件夹hellopb，里面是生成好的文件，这个hellopb就来源于我们在proto文件里面定义的option go_package = “./hellopb”;
然后分别简单地实现server和client。
server端实现了具体的rpc的处理逻辑。
package main
import (
"context"
"flag"
"fmt"
pb "learngrpc/proto/pkg/hellopb"
"log"
"net"
"google.golang.org/grpc"
)
var (
port = flag.Int("port", 8080, "The server port")
)
type server struct {
pb.UnimplementedGreeterServer
}
func (*server) SayHello(ctx context.Context, req *pb.HelloRequest) (*pb.HelloReply, error) {
return &pb.HelloReply{Message: "hello " + req.GetName()}, nil
}
func main() {
flag.Parse()
lis, err := net.Listen("tcp", fmt.Sprintf("0.0.0.0:%d", *port))
if err != nil {
log.Fatalf("failed to listen: %v", err)
}
s := grpc.NewServer()
pb.RegisterGreeterServer(s, &server{})
log.Printf("server listening at %v", lis.Addr())
if err := s.Serve(lis); err != nil {
log.Fatalf("failed to serve: %v", err)
}
}client:
package main
import (
"context"
"flag"
"log"
"time"
pb "learngrpc/proto/pkg/hellopb"
"google.golang.org/grpc"
"google.golang.org/grpc/credentials/insecure"
)
const (
defaultName = "world"
)
var (
addr = flag.String("addr", "localhost:8080", "the address to connect to")
name = flag.String("name", defaultName, "Name to greet")
)
func main() {
flag.Parse()
// Set up a connection to the server.
conn, err := grpc.Dial(*addr, grpc.WithTransportCredentials(insecure.NewCredentials()))
if err != nil {
log.Fatalf("did not connect: %v", err)
}
defer conn.Close()
c := pb.NewGreeterClient(conn)
// Contact the server and print out its response.
ctx, cancel := context.WithTimeout(context.Background(), time.Second)
defer cancel()
r, err := c.SayHello(ctx, &pb.HelloRequest{Name: *name})
if err != nil {
log.Fatalf("could not greet: %v", err)
}
log.Printf("Greeting: %s", r.GetMessage())
}启动server:
启动client：
到此我们就成功完成了grpc的hello world的demo。
流式rpc (streaming rpc)
上面的hello world是一种基本的rpc用法，对于客户端来说，就像调用普通函数一样进行了rpc调用。grpc还提供了streaming RPC，可以让服务端或者客户端持续发送消息。
客户端流式 (client-side streaming RPC)
IDL：
// Accepts a stream of Points on a route being traversed, returning
// RouteSummary when traversal is completed.
rpc RecordRoute(stream Point) returns (RouteSummary) {}要使用客户端流式rpc，只需要在定义时在参数前面加一个 stream。这个例子中，客户端会发送多个Point的信息，服务端汇总后再把结果返回给客户端。
客户端的实现：
// Create a random number of random points
r := rand.New(rand.NewSource(time.Now().UnixNano()))
pointCount := int(r.Int31n(100)) + 2 // Traverse at least two points
var points []*pb.Point
for i := 0; i < pointCount; i++ {
points = append(points, randomPoint(r))
}
log.Printf("Traversing %d points.", len(points))
stream, err := client.RecordRoute(context.Background())
if err != nil {
log.Fatalf("%v.RecordRoute(_) = _, %v", client, err)
}
for _, point := range points {
if err := stream.Send(point); err != nil {
log.Fatalf("%v.Send(%v) = %v", stream, point, err)
}
}
reply, err := stream.CloseAndRecv()
if err != nil {
log.Fatalf("%v.CloseAndRecv() got error %v, want %v", stream, err, nil)
}
log.Printf("Route summary: %v", reply)在调用client.RecordRoute（）方法时，并不是直接进行rpc调用，而是返回一个RecordRouteClient。后面可以使用这个结构体调用Send()和CloseAndRecv()等方法。
服务端的实现：
func (s *routeGuideServer) RecordRoute(stream pb.RouteGuide_RecordRouteServer) error {
var pointCount, featureCount, distance int32
var lastPoint *pb.Point
startTime := time.Now()
for {
point, err := stream.Recv()
if err == io.EOF {
endTime := time.Now()
return stream.SendAndClose(&pb.RouteSummary{
PointCount: pointCount,
FeatureCount: featureCount,
Distance: distance,
ElapsedTime: int32(endTime.Sub(startTime).Seconds()),
})
}
if err != nil {
return err
}
pointCount++
for _, feature := range s.savedFeatures {
if proto.Equal(feature.Location, point) {
featureCount++
}
}
if lastPoint != nil {
distance += calcDistance(lastPoint, point)
}
lastPoint = point
}
}客户端在实现时，函数的参数也不是普通的参数，而是一个RecordRouteServer，它可以调用Recv()和SendAndClose()方法。
服务端流式 (Server-side streaming RPC)
IDl:
rpc ListFeatures(Rectangle) returns (stream Feature) {}客户端的实现：
rect := &pb.Rectangle{ ... } // initialize a pb.Rectangle
stream, err := client.ListFeatures(context.Background(), rect)
if err != nil {
...
}
for {
feature, err := stream.Recv()
if err == io.EOF {
break
}
if err != nil {
log.Fatalf("%v.ListFeatures(_) = _, %v", client, err)
}
log.Println(feature)
}服务端的实现：
func (s *routeGuideServer) ListFeatures(rect *pb.Rectangle, stream pb.RouteGuide_ListFeaturesServer) error {
for _, feature := range s.savedFeatures {
if inRange(feature.Location, rect) {
if err := stream.Send(feature); err != nil {
return err
}
}
}
return nil
}双向流式 (Bidirectional streaming RPC)
IDl:
rpc RouteChat(stream RouteNote) returns (stream RouteNote) {}客户端：
stream, err := client.RouteChat(context.Background())
waitc := make(chan struct{})
go func() {
for {
in, err := stream.Recv()
if err == io.EOF {
// read done.
close(waitc)
return
}
if err != nil {
log.Fatalf("Failed to receive a note : %v", err)
}
log.Printf("Got message %s at point(%d, %d)", in.Message, in.Location.Latitude, in.Location.Longitude)
}
}()
for _, note := range notes {
if err := stream.Send(note); err != nil {
log.Fatalf("Failed to send a note: %v", err)
}
}
stream.CloseSend()
<-waitc服务端：
func (s *routeGuideServer) RouteChat(stream pb.RouteGuide_RouteChatServer) error {
for {
in, err := stream.Recv()
if err == io.EOF {
return nil
}
if err != nil {
return err
}
key := serialize(in.Location)
... // look for notes to be sent to client
for _, note := range s.routeNotes[key] {
if err := stream.Send(note); err != nil {
return err
}
}
}
}
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
