1.proto

syntax = "proto3";
option go_package = ".;proto";
service Greeter {
rpc SayHello (HelloRequest) returns (HelloReply);
}
//将session放入 放入cookie中 http协议
message HelloRequest {
string name = 1;
}
message HelloReply {
string message = 1;
}

2.server

package main
import (
    "OldPackageTest/grpc_test/proto"
    "context"
    "fmt"
    "google.golang.org/grpc"
    "google.golang.org/grpc/codes"
    "google.golang.org/grpc/metadata"
    "google.golang.org/grpc/status"
    "net"
)
type Server struct {
}
func (s *Server) SayHello(ctx context.Context, request *proto.HelloRequest) (*proto.HelloReply, error) {
    return &proto.HelloReply{
        Message: "hello " + request.Name,
    }, nil
}
func main() {
    interceptor := func(ctx context.Context, req interface{}, info *grpc.UnaryServerInfo, handler grpc.UnaryHandler) (resp interface{}, err error) {
        fmt.Println("接收到了一个新的请求")
        md, ok := metadata.FromIncomingContext(ctx)
        fmt.Println(md)
        if !ok {
            //已经开始接触到grpc的错误处理了
            return resp, status.Error(codes.Unauthenticated, "无token认证信息")
        }
        var (
            appid  string
            appkey string
        )
        if va1, ok := md["appid"]; ok {
            appid = va1[0]
        }
        if va1, ok := md["appkey"]; ok {
            appkey = va1[0]
        }
        if appid != "101010" || appkey != "I am key" {
            return resp, status.Error(codes.Unauthenticated, "无token认证信息")
        }
        res, err := handler(ctx, req)
        fmt.Println("请求已经完成")
        return res, err
    }
    opt := grpc.UnaryInterceptor(interceptor)
    g := grpc.NewServer(opt)
    proto.RegisterGreeterServer(g, &Server{})
    lis, err := net.Listen("tcp", "0.0.0.0:8080")
    if err != nil {
        panic("failed to listen" + err.Error())
    }
    err = g.Serve(lis)
    if err != nil {
        panic("failed to start" + err.Error())
    }
}

3.client

package main
import (
    "OldPackageTest/grpc_test/proto"
    "context"
    "fmt"
    "google.golang.org/grpc"
)
type customCredential struct {
}
func (c customCredential) GetRequestMetadata(ctx context.Context, uri ...string) (map[string]string, error) {
    return map[string]string{
        "appid":  "101010",
        "appkey": "I am key",
    },nil
}
func (c customCredential) RequireTransportSecurity() bool {
    return false
}
func main() {
    //stream
    //interceptor := func(ctx context.Context, method string, req, reply interface{}, cc *grpc.ClientConn, invoker grpc.UnaryInvoker, opts ...grpc.CallOption) error{
    //    start := time.Now()
    //    md :=metadata.New(map[string]string{
    //        "appid":"101010",
    //        "appkey":"I am key",
    //    })
    //    ctx = metadata.NewOutgoingContext(context.Background(), md)
    //    err := invoker(ctx, method, req, reply, cc, opts...)
    //    if err != nil {
    //        return err
    //    }
    //    fmt.Printf("耗时: %s\n",time.Since(start))
    //    return err
    //}
    grpc.WithPerRPCCredentials(customCredential{})
    var opts []grpc.DialOption
    opts = append(opts, grpc.WithInsecure())
    opts = append(opts, grpc.WithPerRPCCredentials(customCredential{}))
    //opt := grpc.WithUnaryInterceptor(interceptor)
    //conn, err := grpc.Dial("127.0.0.1:8080", grpc.WithInsecure(),opt)
    conn, err := grpc.Dial("127.0.0.1:8080", opts...)
    if err != nil {
        panic(err)
    }
    defer conn.Close()
    c := proto.NewGreeterClient(conn)
    r, err := c.SayHello(context.Background(), &proto.HelloRequest{Name: "Anwma"})
    if err != nil {
        panic(err)
    }
    fmt.Println(r.Message)
}