前言

上篇文章《Go - 如何编写 ProtoBuf 插件 (一) 》，分享了使用 proto3 的 自定义选项 可以实现插件的编写，说到基于 MethodOptions 和 ServiceOptions 选项去实现 method 和 service 自定义设置拦截器。

接上篇文章，继续分享。

定义插件

  1. // plugin/interceptor/options/interceptor.proto
  3. syntax = "proto3";
  5. package interceptor;
  7. option go_package = "./;interceptor/options";
  9. import "google/protobuf/descriptor.proto";
  11. extend google.protobuf.MethodOptions {
  12.   optional MethodHandler method_handler = 63500;
  13. }
  15. extend google.protobuf.ServiceOptions {
  16.   optional ServiceHandler service_handler = 63501;
  17. }
  19. message MethodHandler {
  20.   optional string authorization = 1; // login token
  21.   optional string whitelist = 2;     // ip whitelist
  22.   optional bool logger = 3;          // logger      
  23. }
  25. message ServiceHandler {
  26.   optional string authorization = 1; // login token
  27.   optional string whitelist = 2;     // ip whitelist
  28.   optional bool logger = 3;          // logger
  29. }

接下来根据 interceptor.proto 生成 interceptor.pb.go

  1. // 生成 interceptor.pb.go
  2. // 使用的 protoc --version 为 libprotoc 3.18.1
  3. // 使用的 protoc-gen-go --version 为 protoc-gen-go v1.27.1
  4. // 在 plugin/interceptor/options 目录下执行 protoc 命令
  6. protoc --go_out=. interceptor.proto

使用插件

  1. // helloworld/helloworld.proto
  3. syntax = "proto3";
  5. package helloworld;
  7. option go_package = "./;helloworld";
  9. import "plugin/interceptor/options/interceptor.proto";
  11. service Greeter {
  12.   option (interceptor.service_handler) = {
  13.     authorization : "login_token",
  14.   };
  16.   rpc SayHello1 (HelloRequest) returns (HelloReply) {
  17.     option (interceptor.method_handler) = {
  18.       whitelist : "ip_whitelist",
  19.       logger: true,
  20.     };
  21.   }
  23.   rpc SayHello2 (HelloRequest) returns (HelloReply) {
  24.     option (interceptor.method_handler) = {
  25.       logger: false,
  26.     };
  27.   }
  28. }
  30. message HelloRequest {
  31.   string name = 1;
  32. }
  34. message HelloReply {
  35.   string message = 1;
  36. }

接下来根据 helloworld.proto 生成 helloworld.pb.go

  1. // 生成 helloworld.pb.go
  2. // 使用的 protoc --version 为 libprotoc 3.18.1
  3. // 使用的 protoc-gen-go --version 为 protoc-gen-go v1.27.1
  4. // 在根目录下执行 protoc 命令
  6. protoc --go_out=helloworld/gen helloworld/helloworld.proto

获取自定义选项

  1. // main.go
  2. // 演示代码
  4. package main
  6. import (
  7.     "fmt"
  8.     "strconv"
  10.     _ "github.com/xinliangnote/protobuf/helloworld/gen"
  11.     "github.com/xinliangnote/protobuf/plugin/interceptor/options"
  13.     "google.golang.org/protobuf/proto"
  14.     "google.golang.org/protobuf/reflect/protoreflect"
  15.     "google.golang.org/protobuf/reflect/protoregistry"
  16. )
  18. func main() {
  19.     protoregistry.GlobalFiles.RangeFiles(func(fd protoreflect.FileDescriptor) bool {
  20.         services := fd.Services()
  21.         for i := 0; i < services.Len(); i++ {
  22.             service := services.Get(i)
  23.             if serviceHandler, _ := proto.GetExtension(service.Options(), options.E_ServiceHandler).(*options.ServiceHandler); serviceHandler != nil {
  24.                 fmt.Println()
  25.                 fmt.Println("--- service ---")
  26.                 fmt.Println("service name: " + string(service.FullName()))
  28.                 if serviceHandler.Authorization != nil && *serviceHandler.Authorization != "" {
  29.                     fmt.Println("use interceptor authorization: " + *serviceHandler.Authorization)
  30.                 }
  31.                 fmt.Println("--- service ---")
  32.             }
  34.             methods := service.Methods()
  35.             for k := 0; k < methods.Len(); k++ {
  36.                 method := methods.Get(k)
  37.                 if methodHandler, _ := proto.GetExtension(method.Options(), options.E_MethodHandler).(*options.MethodHandler); methodHandler != nil {
  38.                     fmt.Println()
  39.                     fmt.Println("--- method ---")
  40.                     fmt.Println("method name: " + string(method.FullName()))
  41.                     if methodHandler.Whitelist != nil && *methodHandler.Whitelist != "" {
  42.                         fmt.Println("use interceptor whitelist: " + *methodHandler.Whitelist)
  43.                     }
  45.                     if methodHandler.Logger != nil {
  46.                         fmt.Println("use interceptor logger: " + strconv.FormatBool(*methodHandler.Logger))
  47.                     }
  49.                     fmt.Println("--- method ---")
  50.                 }
  51.             }
  52.         }
  54.         return true
  55.     })
  56. }

输出：

  1. --- service ---
  2. service name: helloworld.Greeter
  3. use interceptor authorization: login_token
  4. --- service ---
  6. --- method ---
  7. method name: helloworld.Greeter.SayHello1
  8. use interceptor whitelist: ip_whitelist
  9. use interceptor logger: true
  10. --- method ---
  12. --- method ---
  13. method name: helloworld.Greeter.SayHello2
  14. use interceptor logger: false
  15. --- method ---

小结

本文主要内容是基于 自定义选项 定义了 interceptor 插件，然后在 helloworld.proto 中使用了插件，最后在 golang 代码中获取到使用的插件信息。

接下来，要对获取到的插件信息进行使用，主要用在 grpc.ServerOption 中，例如在 grpc.UnaryInterceptor 和 grpc.StreamInterceptor 中使用。

推荐阅读