gRPC让我们可以像本地调用一样实现远程调用，对于每一次的RPC调用中，都可能会有一些有用的数据，而这些数据就可以通过metadata来传递。metadata是以key-value的形式存储数据的，其中key是string类型，而value是[]string，即一个字符串数组类型。metadata使得client和server能够为对方提供关于本次调用的一些信息，就像一次http请求的RequestHeader和ResponseHeader一样。http中header的生命周周期是一次http请求，那么metadata的生命周期就是一次RPC调用。

1. go中使用metadata

源码：源码
项目文档：文档

1. 新建metadata

MD 类型实际上是map，key是string，value是string类型的slice。

  1. type MD map[string][]string

创建的时候可以像创建普通的map类型一样使用new关键字进行创建：

  1. //第一种方式
  2. md := metadata.New(map[string]string{"key1": "val1", "key2": "val2"})
  3. //第二种方式 key不区分大小写，会被统一转成小写。
  4. md := metadata.Pairs(
  5.     "key1", "val1",
  6.     "key1", "val1-2", // "key1" will have map value []string{"val1", "val1-2"}
  7.     "key2", "val2",
  8. )

2. 发送metadata

  1. md := metadata.Pairs("key", "val")
  3. // 新建一个有 metadata 的 context
  4. ctx := metadata.NewOutgoingContext(context.Background(), md)
  6. // 单向 RPC
  7. response, err := client.SomeRPC(ctx, someRequest)

3. 接收metadata

  1. func (s *server) SomeRPC(ctx context.Context, in *pb.SomeRequest) (*pb.SomeResponse, err) {
  2.     md, ok := metadata.FromIncomingContext(ctx)
  3.     // do something with metadata
  4. }

2. grpc中使用metadata

1. proto

  1. syntax = "proto3";
  2. option go_package=".;proto";
  4. // The greeting service definition.
  5. service Greeter {
  6.     //   Sends a greeting
  7.     rpc SayHello (HelloRequest) returns (HelloReply) {
  8.     }
  9. }
  11. // The request message containing the user's name.
  12. message HelloRequest {
  13.     string name = 1;
  14. }
  16. // The response message containing the greetings
  17. message HelloReply {
  18.     string message = 1;
  19. }

2. client

  1. package main
  3. import (
  4.     "OldPackageTest/grpc_test/proto"
  5.     "context"
  6.     "fmt"
  7.     "google.golang.org/grpc"
  8.     "google.golang.org/grpc/metadata"
  9. )
  11. func main(){
  12.     //stream
  13.     conn, err := grpc.Dial("127.0.0.1:50051", grpc.WithInsecure())
  14.     if err != nil {
  15.         panic(err)
  16.     }
  17.     defer conn.Close()
  19.     c := proto.NewGreeterClient(conn)
  21.     //md := metadata.Pairs("timestamp", time.Now().Format(timestampFormat))
  22.     md := metadata.New(map[string]string{
  23.         "name":"yeliangchen",
  24.         "pasword":"123456",
  25.     })
  26.     ctx := metadata.NewOutgoingContext(context.Background(), md)
  27.     r, err := c.SayHello(ctx, &proto.HelloRequest{Name:"yeliangchen"})
  28.     if err != nil {
  29.         panic(err)
  30.     }
  31.     fmt.Println(r.Message)
  32. }

3. server

  1. package main
  3. import (
  4.     "context"
  5.     "fmt"
  6.     "google.golang.org/grpc/metadata"
  7.     "net"
  9.     "google.golang.org/grpc"
  11.     "OldPackageTest/grpc_test/proto"
  12. )
  14. type Server struct{}
  16. func (s *Server) SayHello(ctx context.Context, request *proto.HelloRequest) (*proto.HelloReply,
  17.     error) {
  19.     md, ok := metadata.FromIncomingContext(ctx)
  20.     if ok {
  21.         fmt.Println("get metadata error")
  22.     }
  23.     if nameSlice, ok := md["name"]; ok {
  24.         fmt.Println(nameSlice)
  25.         for i, e := range nameSlice {
  26.             fmt.Println(i, e)
  27.         }
  28.     }
  29.     return &proto.HelloReply{
  30.         Message: "hello " + request.Name,
  31.     }, nil
  32. }
  34. func main() {
  35.     g := grpc.NewServer()
  36.     proto.RegisterGreeterServer(g, &Server{})
  37.     lis, err := net.Listen("tcp", "0.0.0.0:50051")
  38.     if err != nil {
  39.         panic("failed to listen:" + err.Error())
  40.     }
  41.     err = g.Serve(lis)
  42.     if err != nil {
  43.         panic("failed to start grpc:" + err.Error())
  44.     }
  45. }