上一章我们简单介绍了一下grpc 概念方面的信息，这一章我们具体学习grpc 在golang的知识。

源码地址：

https://github.com/grpc/grpc-go/tree/master/examples/route_guide

关于protocol buffers 的相关信息我们这里暂不赘述，如果有读者对这部分的知识不熟悉可以参看以下链接学习。

http://doc.oschina.net/grpc?t=60133

先上我们的route_guide.proto 文件

// Interface exported by the server.
service RouteGuide {// A simple RPC. 最基本的不含流式信息的rpc 接口//// Obtains the feature at a given position.//// A feature with an empty name is returned if there's no feature at the given// position.rpc GetFeature(Point) returns (Feature) {}// A server-to-client streaming RPC. 服务器端是流式信息的接口//// Obtains the Features available within the given Rectangle.  Results are// streamed rather than returned at once (e.g. in a response message with a// repeated field), as the rectangle may cover a large area and contain a// huge number of features.rpc ListFeatures(Rectangle) returns (stream Feature) {}// A client-to-server streaming RPC.  客户端是流式信息的接口//// Accepts a stream of Points on a route being traversed, returning a// RouteSummary when traversal is completed.rpc RecordRoute(stream Point) returns (RouteSummary) {}// A Bidirectional streaming RPC. //双端流式信息的接口//// Accepts a stream of RouteNotes sent while a route is being traversed,// while receiving other RouteNotes (e.g. from other users).rpc RouteChat(stream RouteNote) returns (stream RouteNote) {}
}

相信读者已经看出来了在我们定义的服务中，普通的rpc 与流式rpc是使用stream 进行标识。

当我们完成route_guide.proto 服务的定义后，接下来我们需要从 .proto 的服务定义中生成 gRPC 客户端和服务器端的接口。我们通过 protocol buffer 的编译器 protoc 以及一个特殊的 gRPC Go 插件来完成。

具体生成步骤我们可以参考关于protocol buffers 的链接进行学习，这部分暂时只介绍代码结构的内容。

我们会生成  route_guide.pb.go 这个文件，

文件内容包括：

• 所有用于填充，序列化和获取我们请求和响应消息类型的 protocol buffer 代码
• 一个为客户端调用定义在RouteGuide服务的方法的接口类型（或者 存根 ）
• 一个为服务器使用定义在RouteGuide服务的方法去实现的接口类型（或者 存根 ）

package routeguideimport (...)/*这部分是所有用于填充，序列化和获取我们请求和响应消息类型的 protocol buffer 代码，我们不用特别关注这些代码，所以由于篇幅的原因就不记录
如果有读者对着部分代码充满好奇可以 通过 https://github.com/grpc/grpc-go/blob/master/examples/route_guide/routeguide/route_guide.pb.go 查看
*/
// Reference imports to suppress errors if they are not otherwise used.
var _ context.Context
var _ grpc.ClientConn// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
const _ = grpc.SupportPackageIsVersion4// RouteGuideClient is the client API for RouteGuide service.
//
// 生成的RouteGuide 客户端接口代码
type RouteGuideClient interface {// A simple RPC.//GetFeature(ctx context.Context, in *Point, opts ...grpc.CallOption) (*Feature, error)// A server-to-client streaming RPC.//ListFeatures(ctx context.Context, in *Rectangle, opts ...grpc.CallOption) (RouteGuide_ListFeaturesClient, error)// A client-to-server streaming RPC.//RecordRoute(ctx context.Context, opts ...grpc.CallOption) (RouteGuide_RecordRouteClient, error)// A Bidirectional streaming RPC.RouteChat(ctx context.Context, opts ...grpc.CallOption) (RouteGuide_RouteChatClient, error)
}type routeGuideClient struct {cc *grpc.ClientConn
}func NewRouteGuideClient(cc *grpc.ClientConn) RouteGuideClient {return &routeGuideClient{cc}
}func (c *routeGuideClient) GetFeature(ctx context.Context, in *Point, opts ...grpc.CallOption) (*Feature, error) {out := new(Feature)err := c.cc.Invoke(ctx, "/routeguide.RouteGuide/GetFeature", in, out, opts...)if err != nil {return nil, err}return out, nil
}func (c *routeGuideClient) ListFeatures(ctx context.Context, in *Rectangle, opts ...grpc.CallOption) (RouteGuide_ListFeaturesClient, error) {stream, err := c.cc.NewStream(ctx, &_RouteGuide_serviceDesc.Streams[0], "/routeguide.RouteGuide/ListFeatures", opts...)if err != nil {return nil, err}x := &routeGuideListFeaturesClient{stream}if err := x.ClientStream.SendMsg(in); err != nil {return nil, err}if err := x.ClientStream.CloseSend(); err != nil {return nil, err}return x, nil
}type RouteGuide_ListFeaturesClient interface {Recv() (*Feature, error)grpc.ClientStream
}type routeGuideListFeaturesClient struct {grpc.ClientStream
}func (x *routeGuideListFeaturesClient) Recv() (*Feature, error) {m := new(Feature)if err := x.ClientStream.RecvMsg(m); err != nil {return nil, err}return m, nil
}func (c *routeGuideClient) RecordRoute(ctx context.Context, opts ...grpc.CallOption) (RouteGuide_RecordRouteClient, error) {stream, err := c.cc.NewStream(ctx, &_RouteGuide_serviceDesc.Streams[1], "/routeguide.RouteGuide/RecordRoute", opts...)if err != nil {return nil, err}x := &routeGuideRecordRouteClient{stream}return x, nil
}type RouteGuide_RecordRouteClient interface {Send(*Point) errorCloseAndRecv() (*RouteSummary, error)grpc.ClientStream
}type routeGuideRecordRouteClient struct {grpc.ClientStream
}func (x *routeGuideRecordRouteClient) Send(m *Point) error {return x.ClientStream.SendMsg(m)
}func (x *routeGuideRecordRouteClient) CloseAndRecv() (*RouteSummary, error) {if err := x.ClientStream.CloseSend(); err != nil {return nil, err}m := new(RouteSummary)if err := x.ClientStream.RecvMsg(m); err != nil {return nil, err}return m, nil
}func (c *routeGuideClient) RouteChat(ctx context.Context, opts ...grpc.CallOption) (RouteGuide_RouteChatClient, error) {stream, err := c.cc.NewStream(ctx, &_RouteGuide_serviceDesc.Streams[2], "/routeguide.RouteGuide/RouteChat", opts...)if err != nil {return nil, err}x := &routeGuideRouteChatClient{stream}return x, nil
}type RouteGuide_RouteChatClient interface {Send(*RouteNote) errorRecv() (*RouteNote, error)grpc.ClientStream
}type routeGuideRouteChatClient struct {grpc.ClientStream
}func (x *routeGuideRouteChatClient) Send(m *RouteNote) error {return x.ClientStream.SendMsg(m)
}func (x *routeGuideRouteChatClient) Recv() (*RouteNote, error) {m := new(RouteNote)if err := x.ClientStream.RecvMsg(m); err != nil {return nil, err}return m, nil
}// RouteGuideServer is the server API for RouteGuide service.
type RouteGuideServer interface {// A simple RPC.//// Obtains the feature at a given position.//// A feature with an empty name is returned if there's no feature at the given// position.GetFeature(context.Context, *Point) (*Feature, error)// A server-to-client streaming RPC.//// Obtains the Features available within the given Rectangle.  Results are// streamed rather than returned at once (e.g. in a response message with a// repeated field), as the rectangle may cover a large area and contain a// huge number of features.ListFeatures(*Rectangle, RouteGuide_ListFeaturesServer) error// A client-to-server streaming RPC.//// Accepts a stream of Points on a route being traversed, returning a// RouteSummary when traversal is completed.RecordRoute(RouteGuide_RecordRouteServer) error// A Bidirectional streaming RPC.//// Accepts a stream of RouteNotes sent while a route is being traversed,// while receiving other RouteNotes (e.g. from other users).RouteChat(RouteGuide_RouteChatServer) error
}// UnimplementedRouteGuideServer can be embedded to have forward compatible implementations.
type UnimplementedRouteGuideServer struct {
}func (*UnimplementedRouteGuideServer) GetFeature(ctx context.Context, req *Point) (*Feature, error) {return nil, status.Errorf(codes.Unimplemented, "method GetFeature not implemented")
}
func (*UnimplementedRouteGuideServer) ListFeatures(req *Rectangle, srv RouteGuide_ListFeaturesServer) error {return status.Errorf(codes.Unimplemented, "method ListFeatures not implemented")
}
func (*UnimplementedRouteGuideServer) RecordRoute(srv RouteGuide_RecordRouteServer) error {return status.Errorf(codes.Unimplemented, "method RecordRoute not implemented")
}
func (*UnimplementedRouteGuideServer) RouteChat(srv RouteGuide_RouteChatServer) error {return status.Errorf(codes.Unimplemented, "method RouteChat not implemented")
}func RegisterRouteGuideServer(s *grpc.Server, srv RouteGuideServer) {s.RegisterService(&_RouteGuide_serviceDesc, srv)
}func _RouteGuide_GetFeature_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {in := new(Point)if err := dec(in); err != nil {return nil, err}if interceptor == nil {return srv.(RouteGuideServer).GetFeature(ctx, in)}info := &grpc.UnaryServerInfo{Server:     srv,FullMethod: "/routeguide.RouteGuide/GetFeature",}handler := func(ctx context.Context, req interface{}) (interface{}, error) {return srv.(RouteGuideServer).GetFeature(ctx, req.(*Point))}return interceptor(ctx, in, info, handler)
}func _RouteGuide_ListFeatures_Handler(srv interface{}, stream grpc.ServerStream) error {m := new(Rectangle)if err := stream.RecvMsg(m); err != nil {return err}return srv.(RouteGuideServer).ListFeatures(m, &routeGuideListFeaturesServer{stream})
}type RouteGuide_ListFeaturesServer interface {Send(*Feature) errorgrpc.ServerStream
}type routeGuideListFeaturesServer struct {grpc.ServerStream
}func (x *routeGuideListFeaturesServer) Send(m *Feature) error {return x.ServerStream.SendMsg(m)
}func _RouteGuide_RecordRoute_Handler(srv interface{}, stream grpc.ServerStream) error {return srv.(RouteGuideServer).RecordRoute(&routeGuideRecordRouteServer{stream})
}type RouteGuide_RecordRouteServer interface {SendAndClose(*RouteSummary) errorRecv() (*Point, error)grpc.ServerStream
}type routeGuideRecordRouteServer struct {grpc.ServerStream
}func (x *routeGuideRecordRouteServer) SendAndClose(m *RouteSummary) error {return x.ServerStream.SendMsg(m)
}func (x *routeGuideRecordRouteServer) Recv() (*Point, error) {m := new(Point)if err := x.ServerStream.RecvMsg(m); err != nil {return nil, err}return m, nil
}func _RouteGuide_RouteChat_Handler(srv interface{}, stream grpc.ServerStream) error {return srv.(RouteGuideServer).RouteChat(&routeGuideRouteChatServer{stream})
}type RouteGuide_RouteChatServer interface {Send(*RouteNote) errorRecv() (*RouteNote, error)grpc.ServerStream
}type routeGuideRouteChatServer struct {grpc.ServerStream
}func (x *routeGuideRouteChatServer) Send(m *RouteNote) error {return x.ServerStream.SendMsg(m)
}func (x *routeGuideRouteChatServer) Recv() (*RouteNote, error) {m := new(RouteNote)if err := x.ServerStream.RecvMsg(m); err != nil {return nil, err}return m, nil
}var _RouteGuide_serviceDesc = grpc.ServiceDesc{ServiceName: "routeguide.RouteGuide",HandlerType: (*RouteGuideServer)(nil),Methods: []grpc.MethodDesc{{MethodName: "GetFeature",Handler:    _RouteGuide_GetFeature_Handler,},},Streams: []grpc.StreamDesc{{StreamName:    "ListFeatures",Handler:       _RouteGuide_ListFeatures_Handler,ServerStreams: true,},{StreamName:    "RecordRoute",Handler:       _RouteGuide_RecordRoute_Handler,ClientStreams: true,},{StreamName:    "RouteChat",Handler:       _RouteGuide_RouteChat_Handler,ServerStreams: true,ClientStreams: true,},},Metadata: "route_guide.proto",
}

不知道大家有没有从上面的部分看出来普通rpc 接口与流式rpc接口的区别。

关于流式的说明。

1：在什么情况下会在*.pb.go 文件产生Send() 和 Recv()，以及CloseAndRecv(),SendAndClose 方法

首先我们需要了解到，只有在流式处理的情况才会自动生成Send()Recv() 方法。

Recv() 方法是用来接受流式信息的，就如同在ListFeatures（）方法中cient 端需要一个Recv() 方法。

Send() 方法是用来发起流式信息的，就如同在ListFeatures（）方法中server端需要一个Send() 方法。但是不会有CloseAndRecv()。

在RecordRoute()方法中,在client 端就会有Send（）和 CloseAndRecv() 方法，在server 端会存在SendAndClose（）和Recv() 方法。

在RouteChat() 方法中无论是client端还是server 端，都只存在Send（）和Recv() 方法。

其实route_guide.pb.go 中的代码信息我们不用特别的关注，只需要知道相应的接口的作用就ok了。

介绍完了相应的配置工作，下面我们将详细学习关于服务器代码与客户端代码的编写工作。

服务端源码地址:   https://github.com/grpc/grpc-go/blob/master/examples/route_guide/server/server.go

客户端源码地址：https://github.com/grpc/grpc-go/blob/master/examples/route_guide/client/client.go

实现RouteGuide

服务器端我们需要实现 RouteGuideServer 接口的routeGuideServer 结构类型，并且实现RouteGuideServer 的所有接口。

简单 RPC

routeGuideServer 实现了我们所有的服务方法。首先让我们看看最简单的类型 GetFeature，它从客户端拿到一个 Point 对象，然后从返回包含从数据库拿到的feature信息的 Feature.

// GetFeature returns the feature at the given point.
func (s *routeGuideServer) GetFeature(ctx context.Context, point *pb.Point) (*pb.Feature, error) {for _, feature := range s.savedFeatures {if proto.Equal(feature.Location, point) {return feature, nil}}// No feature was found, return an unnamed featurereturn &pb.Feature{Location: point}, nil
}

该方法传入了 RPC 的上下文对象，以及客户端的 Point protocol buffer请求。它返回了一个包含响应信息和error 的 Feature protocol buffer对象。在方法中我们用适当的信息填充 Feature，然后将其和一个nil错误一起返回，告诉 gRPC 我们完成了对 RPC 的处理，并且 Feature 可以返回给客户端。

服务器端流式 RPC

现在让我们来看看我们的一种流式 RPC。 ListFeatures 是一个服务器端的流式 RPC，所以我们需要将多个 Feature 发回给客户端。

// ListFeatures lists all features contained within the given bounding Rectangle.
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
}

如你所见，这里的请求对象是一个 Rectangle，客户端期望从中找到 Feature，这次我们得到了一个请求对象和一个特殊的RouteGuide_ListFeaturesServer来写入我们的响应，而不是得到方法参数中的简单请求和响应对象。

在这个方法中，我们填充了尽可能多的 Feature 对象去返回，用它们的 Send() 方法把它们写入 RouteGuide_ListFeaturesServer。最后，在我们的简单 RPC中，我们返回了一个 nil 错误告诉 gRPC 响应的写入已经完成。如果在调用过程中发生任何错误，我们会返回一个非 nil 的错误；gRPC 层会将其转化为合适的 RPC 状态通过线路发送。

客户端流式 RPC

现在让我们看看稍微复杂点的东西：客户端流方法 RecordRoute，我们通过它可以从客户端拿到一个 Point 的流，其中包括它们路径的信息。如你所见，这次这个方法没有请求参数。相反的，它拿到了一个 RouteGuide_RecordRouteServer 流，服务器可以用它来同时读 和 写消息——它可以用自己的 Recv() 方法接收客户端消息并且用 SendAndClose() 方法返回它的单个响应。

// RecordRoute records a route composited of a sequence of points.
//
// It gets a stream of points, and responds with statistics about the "trip":
// number of points,  number of known features visited, total distance traveled, and
// total time spent.
func (s *routeGuideServer) RecordRoute(stream pb.RouteGuide_RecordRouteServer) error {var pointCount, featureCount, distance int32var lastPoint *pb.PointstartTime := 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}
}

在方法体中，我们使用 RouteGuide_RecordRouteServer 的 Recv() 方法去反复读取客户端的请求到一个请求对象（在这个场景下是 Point），直到没有更多的消息：服务器需要在每次调用后检查 Read() 返回的错误。如果返回值为 nil，流依然完好，可以继续读取；如果返回值为 io.EOF，消息流结束，服务器可以返回它的 RouteSummary。如果它还有其它值，我们原样返回错误，gRPC 层会把它转换为 RPC 状态。

双向流式 RPC

最后，让我们看看双向流式 RPC RouteChat()。

// RouteChat receives a stream of message/location pairs, and responds with a stream of all
// previous messages at each of those locations.
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)s.mu.Lock()s.routeNotes[key] = append(s.routeNotes[key], in)// Note: this copy prevents blocking other clients while serving this one.// We don't need to do a deep copy, because elements in the slice are// insert-only and never modified.rn := make([]*pb.RouteNote, len(s.routeNotes[key]))copy(rn, s.routeNotes[key])s.mu.Unlock()for _, note := range rn {if err := stream.Send(note); err != nil {return err}}}
}

这次我们得到了一个 RouteGuide_RouteChatServer 流，和我们的客户端流的例子一样，它可以用来读写消息。但是，这次当客户端还在往 它们 的消息流中写入消息时，我们通过方法的流返回值。

这里读写的语法和客户端流方法相似，除了服务器会使用流的 Send() 方法而不是 SendAndClose()，因为它需要写多个响应。虽然客户端和服务器端总是会拿到对方写入时顺序的消息，它们可以以任意顺序读写——流的操作是完全独立的。

启动服务器

一旦我们实现了所有的方法，我们还需要启动一个gRPC服务器，这样客户端才可以使用服务。下面这段代码展示了在我们RouteGuide服务中实现的过程：

func main() {flag.Parse()lis, err := net.Listen("tcp", fmt.Sprintf("localhost:%d", *port))if err != nil {log.Fatalf("failed to listen: %v", err)}var opts []grpc.ServerOptionif *tls {if *certFile == "" {*certFile = testdata.Path("server1.pem")}if *keyFile == "" {*keyFile = testdata.Path("server1.key")}creds, err := credentials.NewServerTLSFromFile(*certFile, *keyFile)if err != nil {log.Fatalf("Failed to generate credentials %v", err)}opts = []grpc.ServerOption{grpc.Creds(creds)}}grpcServer := grpc.NewServer(opts...)//newServer() new routeGuideServer structpb.RegisterRouteGuideServer(grpcServer, newServer())grpcServer.Serve(lis)
}

为了构建和启动服务器，我们需要：

1. 使用 lis, err := net.Listen("tcp", fmt.Sprintf(":%d", *port)) 指定我们期望客户端请求的监听端口。
2. 使用grpc.NewServer()创建 gRPC 服务器的一个实例。
3. 在 gRPC 服务器注册我们的服务实现。
4. 用服务器 Serve() 方法以及我们的端口信息区实现阻塞等待，直到进程被杀死或者 Stop() 被调用

创建客户端

下面部分，我们将介绍为 RouteGuide 服务创建一个 Go 客户端。

为了调用服务方法，我们首先创建一个 gRPC channel 和服务器交互。我们通过给 grpc.Dial() 传入服务器地址和端口号做到这点，如下：

func main() {flag.Parse()var opts []grpc.DialOptionif *tls {if *caFile == "" {*caFile = testdata.Path("ca.pem")}creds, err := credentials.NewClientTLSFromFile(*caFile, *serverHostOverride)if err != nil {log.Fatalf("Failed to create TLS credentials %v", err)}opts = append(opts, grpc.WithTransportCredentials(creds))} else {opts = append(opts, grpc.WithInsecure())}opts = append(opts, grpc.WithBlock())conn, err := grpc.Dial(*serverAddr, opts...)if err != nil {log.Fatalf("fail to dial: %v", err)}defer conn.Close()client := pb.NewRouteGuideClient(conn)// Looking for a valid featureprintFeature(client, &pb.Point{Latitude: 409146138, Longitude: -746188906})// Feature missing.printFeature(client, &pb.Point{Latitude: 0, Longitude: 0})// Looking for features between 40, -75 and 42, -73.printFeatures(client, &pb.Rectangle{Lo: &pb.Point{Latitude: 400000000, Longitude: -750000000},Hi: &pb.Point{Latitude: 420000000, Longitude: -730000000},})// RecordRouterunRecordRoute(client)// RouteChatrunRouteChat(client)
}

调用服务方法

现在让我们看看如何调用服务方法。注意，在 gRPC-Go 中，RPC以阻塞/同步模式操作，这意味着 RPC 调用等待服务器响应，同时要么返回响应，要么返回错误。

简单 RPC

调用简单 RPC GetFeature 几乎是和调用一个本地方法一样直观。

feature, err := client.GetFeature(context.Background(), &pb.Point{409146138, -746188906})
if err != nil {...
}

如你所见，我们调用了前面创建的存根上的方法。在我们的方法参数中，我们创建并且填充了一个请求的 protocol buffer 对象（例子中为 Point）。我们同时传入了一个 context.Context ，在有需要时可以让我们改变 RPC 的行为，比如超时/取消一个正在运行的 RPC。 如果调用没有返回错误，那么我们就可以从服务器返回的第一个返回值中读到响应信息。

log.Println(feature)

服务器端流式 RPC

ListFeatures 就是我们说的服务器端流方法，它会返回地理的Feature 流。 如果你已经读过创建服务器，本节的一些内容也许看上去会很熟悉——流式 RPC 是在客户端和服务器两端以一种类似的方式实现的。

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)
}

在简单 RPC 的例子中，我们给方法传入一个上下文和请求。然而，我们得到返回的是一个 RouteGuide_ListFeaturesClient 实例，而不是一个应答对象。客户端可以使用 RouteGuide_ListFeaturesClient 流去读取服务器的响应。

我们使用 RouteGuide_ListFeaturesClient 的 Recv() 方法去反复读取服务器的响应到一个响应 protocol buffer 对象（在这个场景下是Feature）直到消息读取完毕：每次调用完成时，客户端都要检查从 Recv() 返回的错误 err。如果返回为 nil，流依然完好并且可以继续读取；如果返回为 io.EOF，则说明消息流已经结束；否则就一定是一个通过 err 传过来的 RPC 错误。

客户端流式 RPC

除了我们需要给方法传入一个上下文而后返回 RouteGuide_RecordRouteClient 流以外，客户端流方法 RecordRoute 和服务器端方法类似，它可以用来读 和 写消息。

// 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)

RouteGuide_RecordRouteClient 有一个 Send() 方法，我们可以用它来给服务器发送请求。一旦我们完成使用 Send() 方法将客户端请求写入流，就需要调用流的 CloseAndRecv()方法，让 gRPC 知道我们已经完成了写入同时期待返回应答。我们从 CloseAndRecv() 返回的 err 中获得 RPC 的状态。如果状态为nil，那么CloseAndRecv()的第一个返回值将会是合法的服务器应答。

双向流式 RPC

最后，让我们看看双向流式 RPC RouteChat()。 和 RecordRoute 的场景类似，我们只给函数传 入一个上下文对象，拿到可以用来读写的流。但是，当服务器依然在往 他们 的消息流写入消息时，我们 通过方法流返回值。

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

这里读写的语法和我们的客户端流方法很像，除了在完成调用时，我们会使用流的 CloseSend() 方法。 虽然每一端获取对方信息的顺序和信息被写入的顺序一致，客户端和服务器都可以以任意顺序读写——流的操作是完全独立的。

到这里我们grpc 的介绍就完成了。