项目地址

https://github.com/envoyproxy/protoc-gen-validate

前置条件

需要安装protoc、protoc-gen-go、protoc-gen-validate, protoc和protoc-gen-go已经安装过了, 不懂的可以看之前的笔记, 传送门, 下面介绍一下protoc-gen-validate的安装和配置
1.先试用go get -d github.com/envoyproxy/protoc-gen-validate
2.然后我们需要cd到envoyproxy目录下, 我的是这样的, 然后我们在cd到protoc-gen-validate@v0.1.0目录下
image.png
3.执行make build命令, 这样我们就可以使用protoc-gen-validate插件了
3.可以通过protoc-gen-validate命令检查, 如果不报错, 说明安装成功了
image.png

快速体验

protocol文件的编写

  1. syntax = "proto3";
  2. import "validate.proto";
  3. option go_package=".;bark";
  5. service Bark {
  6.   rpc SayHello (Person) returns (Person);
  7. }
  9. message Person {
  10.   uint64 id = 1 [(validate.rules).uint64.gt = 999];
  11.   string email = 2 [(validate.rules).string.email = true];
  12.   string mobile = 3 [(validate.rules).string = {
  13.     pattern: "^1\\d{10}$"}];
  14. }

在proto文件同级目录下创建一个名为validate.proto的文件, 贴入以下内容

  1. syntax = "proto2";
  2. package validate;
  3. option go_package = "github.com/envoyproxy/protoc-gen-validate/validate";
  5. import "google/protobuf/descriptor.proto";
  6. import "google/protobuf/duration.proto";
  7. import "google/protobuf/timestamp.proto";
  9. // Validation rules applied at the message level
  10. extend google.protobuf.MessageOptions {
  11.   // Disabled nullifies any validation rules for this message, including any
  12.   // message fields associated with it that do support validation.
  13.   optional bool disabled = 1071;
  14.   // Ignore skips generation of validation methods for this message.
  15.   optional bool ignored = 1072;
  16. }
  18. // Validation rules applied at the oneof level
  19. extend google.protobuf.OneofOptions {
  20.   // Required ensures that exactly one the field options in a oneof is set;
  21.   // validation fails if no fields in the oneof are set.
  22.   optional bool required = 1071;
  23. }
  25. // Validation rules applied at the field level
  26. extend google.protobuf.FieldOptions {
  27.   // Rules specify the validations to be performed on this field. By default,
  28.   // no validation is performed against a field.
  29.   optional FieldRules rules = 1071;
  30. }
  32. // FieldRules encapsulates the rules for each type of field. Depending on the
  33. // field, the correct set should be used to ensure proper validations.
  34. message FieldRules {
  35.   optional MessageRules message = 17;
  36.   oneof type {
  37.     // Scalar Field Types
  38.     FloatRules    float    = 1;
  39.     DoubleRules   double   = 2;
  40.     Int32Rules    int32    = 3;
  41.     Int64Rules    int64    = 4;
  42.     UInt32Rules   uint32   = 5;
  43.     UInt64Rules   uint64   = 6;
  44.     SInt32Rules   sint32   = 7;
  45.     SInt64Rules   sint64   = 8;
  46.     Fixed32Rules  fixed32  = 9;
  47.     Fixed64Rules  fixed64  = 10;
  48.     SFixed32Rules sfixed32 = 11;
  49.     SFixed64Rules sfixed64 = 12;
  50.     BoolRules     bool     = 13;
  51.     StringRules   string   = 14;
  52.     BytesRules    bytes    = 15;
  54.     // Complex Field Types
  55.     EnumRules     enum     = 16;
  56.     RepeatedRules repeated = 18;
  57.     MapRules      map      = 19;
  59.     // Well-Known Field Types
  60.     AnyRules       any       = 20;
  61.     DurationRules  duration  = 21;
  62.     TimestampRules timestamp = 22;
  63.   }
  64. }
  66. // FloatRules describes the constraints applied to `float` values
  67. message FloatRules {
  68.   // Const specifies that this field must be exactly the specified value
  69.   optional float const = 1;
  71.   // Lt specifies that this field must be less than the specified value,
  72.   // exclusive
  73.   optional float lt = 2;
  75.   // Lte specifies that this field must be less than or equal to the
  76.   // specified value, inclusive
  77.   optional float lte = 3;
  79.   // Gt specifies that this field must be greater than the specified value,
  80.   // exclusive. If the value of Gt is larger than a specified Lt or Lte, the
  81.   // range is reversed.
  82.   optional float gt = 4;
  84.   // Gte specifies that this field must be greater than or equal to the
  85.   // specified value, inclusive. If the value of Gte is larger than a
  86.   // specified Lt or Lte, the range is reversed.
  87.   optional float gte = 5;
  89.   // In specifies that this field must be equal to one of the specified
  90.   // values
  91.   repeated float in = 6;
  93.   // NotIn specifies that this field cannot be equal to one of the specified
  94.   // values
  95.   repeated float not_in = 7;
  97.   // IgnoreEmpty specifies that the validation rules of this field should be
  98.   // evaluated only if the field is not empty
  99.   optional bool ignore_empty = 8;
  100. }
  102. // DoubleRules describes the constraints applied to `double` values
  103. message DoubleRules {
  104.   // Const specifies that this field must be exactly the specified value
  105.   optional double const = 1;
  107.   // Lt specifies that this field must be less than the specified value,
  108.   // exclusive
  109.   optional double lt = 2;
  111.   // Lte specifies that this field must be less than or equal to the
  112.   // specified value, inclusive
  113.   optional double lte = 3;
  115.   // Gt specifies that this field must be greater than the specified value,
  116.   // exclusive. If the value of Gt is larger than a specified Lt or Lte, the
  117.   // range is reversed.
  118.   optional double gt = 4;
  120.   // Gte specifies that this field must be greater than or equal to the
  121.   // specified value, inclusive. If the value of Gte is larger than a
  122.   // specified Lt or Lte, the range is reversed.
  123.   optional double gte = 5;
  125.   // In specifies that this field must be equal to one of the specified
  126.   // values
  127.   repeated double in = 6;
  129.   // NotIn specifies that this field cannot be equal to one of the specified
  130.   // values
  131.   repeated double not_in = 7;
  133.   // IgnoreEmpty specifies that the validation rules of this field should be
  134.   // evaluated only if the field is not empty
  135.   optional bool ignore_empty = 8;
  136. }
  138. // Int32Rules describes the constraints applied to `int32` values
  139. message Int32Rules {
  140.   // Const specifies that this field must be exactly the specified value
  141.   optional int32 const = 1;
  143.   // Lt specifies that this field must be less than the specified value,
  144.   // exclusive
  145.   optional int32 lt = 2;
  147.   // Lte specifies that this field must be less than or equal to the
  148.   // specified value, inclusive
  149.   optional int32 lte = 3;
  151.   // Gt specifies that this field must be greater than the specified value,
  152.   // exclusive. If the value of Gt is larger than a specified Lt or Lte, the
  153.   // range is reversed.
  154.   optional int32 gt = 4;
  156.   // Gte specifies that this field must be greater than or equal to the
  157.   // specified value, inclusive. If the value of Gte is larger than a
  158.   // specified Lt or Lte, the range is reversed.
  159.   optional int32 gte = 5;
  161.   // In specifies that this field must be equal to one of the specified
  162.   // values
  163.   repeated int32 in = 6;
  165.   // NotIn specifies that this field cannot be equal to one of the specified
  166.   // values
  167.   repeated int32 not_in = 7;
  169.   // IgnoreEmpty specifies that the validation rules of this field should be
  170.   // evaluated only if the field is not empty
  171.   optional bool ignore_empty = 8;
  172. }
  174. // Int64Rules describes the constraints applied to `int64` values
  175. message Int64Rules {
  176.   // Const specifies that this field must be exactly the specified value
  177.   optional int64 const = 1;
  179.   // Lt specifies that this field must be less than the specified value,
  180.   // exclusive
  181.   optional int64 lt = 2;
  183.   // Lte specifies that this field must be less than or equal to the
  184.   // specified value, inclusive
  185.   optional int64 lte = 3;
  187.   // Gt specifies that this field must be greater than the specified value,
  188.   // exclusive. If the value of Gt is larger than a specified Lt or Lte, the
  189.   // range is reversed.
  190.   optional int64 gt = 4;
  192.   // Gte specifies that this field must be greater than or equal to the
  193.   // specified value, inclusive. If the value of Gte is larger than a
  194.   // specified Lt or Lte, the range is reversed.
  195.   optional int64 gte = 5;
  197.   // In specifies that this field must be equal to one of the specified
  198.   // values
  199.   repeated int64 in = 6;
  201.   // NotIn specifies that this field cannot be equal to one of the specified
  202.   // values
  203.   repeated int64 not_in = 7;
  205.   // IgnoreEmpty specifies that the validation rules of this field should be
  206.   // evaluated only if the field is not empty
  207.   optional bool ignore_empty = 8;
  208. }
  210. // UInt32Rules describes the constraints applied to `uint32` values
  211. message UInt32Rules {
  212.   // Const specifies that this field must be exactly the specified value
  213.   optional uint32 const = 1;
  215.   // Lt specifies that this field must be less than the specified value,
  216.   // exclusive
  217.   optional uint32 lt = 2;
  219.   // Lte specifies that this field must be less than or equal to the
  220.   // specified value, inclusive
  221.   optional uint32 lte = 3;
  223.   // Gt specifies that this field must be greater than the specified value,
  224.   // exclusive. If the value of Gt is larger than a specified Lt or Lte, the
  225.   // range is reversed.
  226.   optional uint32 gt = 4;
  228.   // Gte specifies that this field must be greater than or equal to the
  229.   // specified value, inclusive. If the value of Gte is larger than a
  230.   // specified Lt or Lte, the range is reversed.
  231.   optional uint32 gte = 5;
  233.   // In specifies that this field must be equal to one of the specified
  234.   // values
  235.   repeated uint32 in = 6;
  237.   // NotIn specifies that this field cannot be equal to one of the specified
  238.   // values
  239.   repeated uint32 not_in = 7;
  241.   // IgnoreEmpty specifies that the validation rules of this field should be
  242.   // evaluated only if the field is not empty
  243.   optional bool ignore_empty = 8;
  244. }
  246. // UInt64Rules describes the constraints applied to `uint64` values
  247. message UInt64Rules {
  248.   // Const specifies that this field must be exactly the specified value
  249.   optional uint64 const = 1;
  251.   // Lt specifies that this field must be less than the specified value,
  252.   // exclusive
  253.   optional uint64 lt = 2;
  255.   // Lte specifies that this field must be less than or equal to the
  256.   // specified value, inclusive
  257.   optional uint64 lte = 3;
  259.   // Gt specifies that this field must be greater than the specified value,
  260.   // exclusive. If the value of Gt is larger than a specified Lt or Lte, the
  261.   // range is reversed.
  262.   optional uint64 gt = 4;
  264.   // Gte specifies that this field must be greater than or equal to the
  265.   // specified value, inclusive. If the value of Gte is larger than a
  266.   // specified Lt or Lte, the range is reversed.
  267.   optional uint64 gte = 5;
  269.   // In specifies that this field must be equal to one of the specified
  270.   // values
  271.   repeated uint64 in = 6;
  273.   // NotIn specifies that this field cannot be equal to one of the specified
  274.   // values
  275.   repeated uint64 not_in = 7;
  277.   // IgnoreEmpty specifies that the validation rules of this field should be
  278.   // evaluated only if the field is not empty
  279.   optional bool ignore_empty = 8;
  280. }
  282. // SInt32Rules describes the constraints applied to `sint32` values
  283. message SInt32Rules {
  284.   // Const specifies that this field must be exactly the specified value
  285.   optional sint32 const = 1;
  287.   // Lt specifies that this field must be less than the specified value,
  288.   // exclusive
  289.   optional sint32 lt = 2;
  291.   // Lte specifies that this field must be less than or equal to the
  292.   // specified value, inclusive
  293.   optional sint32 lte = 3;
  295.   // Gt specifies that this field must be greater than the specified value,
  296.   // exclusive. If the value of Gt is larger than a specified Lt or Lte, the
  297.   // range is reversed.
  298.   optional sint32 gt = 4;
  300.   // Gte specifies that this field must be greater than or equal to the
  301.   // specified value, inclusive. If the value of Gte is larger than a
  302.   // specified Lt or Lte, the range is reversed.
  303.   optional sint32 gte = 5;
  305.   // In specifies that this field must be equal to one of the specified
  306.   // values
  307.   repeated sint32 in = 6;
  309.   // NotIn specifies that this field cannot be equal to one of the specified
  310.   // values
  311.   repeated sint32 not_in = 7;
  313.   // IgnoreEmpty specifies that the validation rules of this field should be
  314.   // evaluated only if the field is not empty
  315.   optional bool ignore_empty = 8;
  316. }
  318. // SInt64Rules describes the constraints applied to `sint64` values
  319. message SInt64Rules {
  320.   // Const specifies that this field must be exactly the specified value
  321.   optional sint64 const = 1;
  323.   // Lt specifies that this field must be less than the specified value,
  324.   // exclusive
  325.   optional sint64 lt = 2;
  327.   // Lte specifies that this field must be less than or equal to the
  328.   // specified value, inclusive
  329.   optional sint64 lte = 3;
  331.   // Gt specifies that this field must be greater than the specified value,
  332.   // exclusive. If the value of Gt is larger than a specified Lt or Lte, the
  333.   // range is reversed.
  334.   optional sint64 gt = 4;
  336.   // Gte specifies that this field must be greater than or equal to the
  337.   // specified value, inclusive. If the value of Gte is larger than a
  338.   // specified Lt or Lte, the range is reversed.
  339.   optional sint64 gte = 5;
  341.   // In specifies that this field must be equal to one of the specified
  342.   // values
  343.   repeated sint64 in = 6;
  345.   // NotIn specifies that this field cannot be equal to one of the specified
  346.   // values
  347.   repeated sint64 not_in = 7;
  349.   // IgnoreEmpty specifies that the validation rules of this field should be
  350.   // evaluated only if the field is not empty
  351.   optional bool ignore_empty = 8;
  352. }
  354. // Fixed32Rules describes the constraints applied to `fixed32` values
  355. message Fixed32Rules {
  356.   // Const specifies that this field must be exactly the specified value
  357.   optional fixed32 const = 1;
  359.   // Lt specifies that this field must be less than the specified value,
  360.   // exclusive
  361.   optional fixed32 lt = 2;
  363.   // Lte specifies that this field must be less than or equal to the
  364.   // specified value, inclusive
  365.   optional fixed32 lte = 3;
  367.   // Gt specifies that this field must be greater than the specified value,
  368.   // exclusive. If the value of Gt is larger than a specified Lt or Lte, the
  369.   // range is reversed.
  370.   optional fixed32 gt = 4;
  372.   // Gte specifies that this field must be greater than or equal to the
  373.   // specified value, inclusive. If the value of Gte is larger than a
  374.   // specified Lt or Lte, the range is reversed.
  375.   optional fixed32 gte = 5;
  377.   // In specifies that this field must be equal to one of the specified
  378.   // values
  379.   repeated fixed32 in = 6;
  381.   // NotIn specifies that this field cannot be equal to one of the specified
  382.   // values
  383.   repeated fixed32 not_in = 7;
  385.   // IgnoreEmpty specifies that the validation rules of this field should be
  386.   // evaluated only if the field is not empty
  387.   optional bool ignore_empty = 8;
  388. }
  390. // Fixed64Rules describes the constraints applied to `fixed64` values
  391. message Fixed64Rules {
  392.   // Const specifies that this field must be exactly the specified value
  393.   optional fixed64 const = 1;
  395.   // Lt specifies that this field must be less than the specified value,
  396.   // exclusive
  397.   optional fixed64 lt = 2;
  399.   // Lte specifies that this field must be less than or equal to the
  400.   // specified value, inclusive
  401.   optional fixed64 lte = 3;
  403.   // Gt specifies that this field must be greater than the specified value,
  404.   // exclusive. If the value of Gt is larger than a specified Lt or Lte, the
  405.   // range is reversed.
  406.   optional fixed64 gt = 4;
  408.   // Gte specifies that this field must be greater than or equal to the
  409.   // specified value, inclusive. If the value of Gte is larger than a
  410.   // specified Lt or Lte, the range is reversed.
  411.   optional fixed64 gte = 5;
  413.   // In specifies that this field must be equal to one of the specified
  414.   // values
  415.   repeated fixed64 in = 6;
  417.   // NotIn specifies that this field cannot be equal to one of the specified
  418.   // values
  419.   repeated fixed64 not_in = 7;
  421.   // IgnoreEmpty specifies that the validation rules of this field should be
  422.   // evaluated only if the field is not empty
  423.   optional bool ignore_empty = 8;
  424. }
  426. // SFixed32Rules describes the constraints applied to `sfixed32` values
  427. message SFixed32Rules {
  428.   // Const specifies that this field must be exactly the specified value
  429.   optional sfixed32 const = 1;
  431.   // Lt specifies that this field must be less than the specified value,
  432.   // exclusive
  433.   optional sfixed32 lt = 2;
  435.   // Lte specifies that this field must be less than or equal to the
  436.   // specified value, inclusive
  437.   optional sfixed32 lte = 3;
  439.   // Gt specifies that this field must be greater than the specified value,
  440.   // exclusive. If the value of Gt is larger than a specified Lt or Lte, the
  441.   // range is reversed.
  442.   optional sfixed32 gt = 4;
  444.   // Gte specifies that this field must be greater than or equal to the
  445.   // specified value, inclusive. If the value of Gte is larger than a
  446.   // specified Lt or Lte, the range is reversed.
  447.   optional sfixed32 gte = 5;
  449.   // In specifies that this field must be equal to one of the specified
  450.   // values
  451.   repeated sfixed32 in = 6;
  453.   // NotIn specifies that this field cannot be equal to one of the specified
  454.   // values
  455.   repeated sfixed32 not_in = 7;
  457.   // IgnoreEmpty specifies that the validation rules of this field should be
  458.   // evaluated only if the field is not empty
  459.   optional bool ignore_empty = 8;
  460. }
  462. // SFixed64Rules describes the constraints applied to `sfixed64` values
  463. message SFixed64Rules {
  464.   // Const specifies that this field must be exactly the specified value
  465.   optional sfixed64 const = 1;
  467.   // Lt specifies that this field must be less than the specified value,
  468.   // exclusive
  469.   optional sfixed64 lt = 2;
  471.   // Lte specifies that this field must be less than or equal to the
  472.   // specified value, inclusive
  473.   optional sfixed64 lte = 3;
  475.   // Gt specifies that this field must be greater than the specified value,
  476.   // exclusive. If the value of Gt is larger than a specified Lt or Lte, the
  477.   // range is reversed.
  478.   optional sfixed64 gt = 4;
  480.   // Gte specifies that this field must be greater than or equal to the
  481.   // specified value, inclusive. If the value of Gte is larger than a
  482.   // specified Lt or Lte, the range is reversed.
  483.   optional sfixed64 gte = 5;
  485.   // In specifies that this field must be equal to one of the specified
  486.   // values
  487.   repeated sfixed64 in = 6;
  489.   // NotIn specifies that this field cannot be equal to one of the specified
  490.   // values
  491.   repeated sfixed64 not_in = 7;
  493.   // IgnoreEmpty specifies that the validation rules of this field should be
  494.   // evaluated only if the field is not empty
  495.   optional bool ignore_empty = 8;
  496. }
  498. // BoolRules describes the constraints applied to `bool` values
  499. message BoolRules {
  500.   // Const specifies that this field must be exactly the specified value
  501.   optional bool const = 1;
  502. }
  504. // StringRules describe the constraints applied to `string` values
  505. message StringRules {
  506.   // Const specifies that this field must be exactly the specified value
  507.   optional string const = 1;
  509.   // Len specifies that this field must be the specified number of
  510.   // characters (Unicode code points). Note that the number of
  511.   // characters may differ from the number of bytes in the string.
  512.   optional uint64 len = 19;
  514.   // MinLen specifies that this field must be the specified number of
  515.   // characters (Unicode code points) at a minimum. Note that the number of
  516.   // characters may differ from the number of bytes in the string.
  517.   optional uint64 min_len = 2;
  519.   // MaxLen specifies that this field must be the specified number of
  520.   // characters (Unicode code points) at a maximum. Note that the number of
  521.   // characters may differ from the number of bytes in the string.
  522.   optional uint64 max_len = 3;
  524.   // LenBytes specifies that this field must be the specified number of bytes
  525.   // at a minimum
  526.   optional uint64 len_bytes = 20;
  528.   // MinBytes specifies that this field must be the specified number of bytes
  529.   // at a minimum
  530.   optional uint64 min_bytes = 4;
  532.   // MaxBytes specifies that this field must be the specified number of bytes
  533.   // at a maximum
  534.   optional uint64 max_bytes = 5;
  536.   // Pattern specifes that this field must match against the specified
  537.   // regular expression (RE2 syntax). The included expression should elide
  538.   // any delimiters.
  539.   optional string pattern  = 6;
  541.   // Prefix specifies that this field must have the specified substring at
  542.   // the beginning of the string.
  543.   optional string prefix   = 7;
  545.   // Suffix specifies that this field must have the specified substring at
  546.   // the end of the string.
  547.   optional string suffix   = 8;
  549.   // Contains specifies that this field must have the specified substring
  550.   // anywhere in the string.
  551.   optional string contains = 9;
  553.   // NotContains specifies that this field cannot have the specified substring
  554.   // anywhere in the string.
  555.   optional string not_contains = 23;
  557.   // In specifies that this field must be equal to one of the specified
  558.   // values
  559.   repeated string in     = 10;
  561.   // NotIn specifies that this field cannot be equal to one of the specified
  562.   // values
  563.   repeated string not_in = 11;
  565.   // WellKnown rules provide advanced constraints against common string
  566.   // patterns
  567.   oneof well_known {
  568.     // Email specifies that the field must be a valid email address as
  569.     // defined by RFC 5322
  570.     bool email    = 12;
  572.     // Hostname specifies that the field must be a valid hostname as
  573.     // defined by RFC 1034. This constraint does not support
  574.     // internationalized domain names (IDNs).
  575.     bool hostname = 13;
  577.     // Ip specifies that the field must be a valid IP (v4 or v6) address.
  578.     // Valid IPv6 addresses should not include surrounding square brackets.
  579.     bool ip       = 14;
  581.     // Ipv4 specifies that the field must be a valid IPv4 address.
  582.     bool ipv4     = 15;
  584.     // Ipv6 specifies that the field must be a valid IPv6 address. Valid
  585.     // IPv6 addresses should not include surrounding square brackets.
  586.     bool ipv6     = 16;
  588.     // Uri specifies that the field must be a valid, absolute URI as defined
  589.     // by RFC 3986
  590.     bool uri      = 17;
  592.     // UriRef specifies that the field must be a valid URI as defined by RFC
  593.     // 3986 and may be relative or absolute.
  594.     bool uri_ref  = 18;
  596.     // Address specifies that the field must be either a valid hostname as
  597.     // defined by RFC 1034 (which does not support internationalized domain
  598.     // names or IDNs), or it can be a valid IP (v4 or v6).
  599.     bool address  = 21;
  601.     // Uuid specifies that the field must be a valid UUID as defined by
  602.     // RFC 4122
  603.     bool uuid     = 22;
  605.     // WellKnownRegex specifies a common well known pattern defined as a regex.
  606.     KnownRegex well_known_regex = 24;
  607.   }
  609.   // This applies to regexes HTTP_HEADER_NAME and HTTP_HEADER_VALUE to enable
  610.   // strict header validation.
  611.   // By default, this is true, and HTTP header validations are RFC-compliant.
  612.   // Setting to false will enable a looser validations that only disallows
  613.   // \r\n\0 characters, which can be used to bypass header matching rules.
  614.   optional bool strict = 25 [default = true];
  616.   // IgnoreEmpty specifies that the validation rules of this field should be
  617.   // evaluated only if the field is not empty
  618.   optional bool ignore_empty = 26;
  619. }
  621. // WellKnownRegex contain some well-known patterns.
  622. enum KnownRegex {
  623.   UNKNOWN = 0;
  625.   // HTTP header name as defined by RFC 7230.
  626.   HTTP_HEADER_NAME = 1;
  628.   // HTTP header value as defined by RFC 7230.
  629.   HTTP_HEADER_VALUE = 2;
  630. }
  632. // BytesRules describe the constraints applied to `bytes` values
  633. message BytesRules {
  634.   // Const specifies that this field must be exactly the specified value
  635.   optional bytes const = 1;
  637.   // Len specifies that this field must be the specified number of bytes
  638.   optional uint64 len = 13;
  640.   // MinLen specifies that this field must be the specified number of bytes
  641.   // at a minimum
  642.   optional uint64 min_len = 2;
  644.   // MaxLen specifies that this field must be the specified number of bytes
  645.   // at a maximum
  646.   optional uint64 max_len = 3;
  648.   // Pattern specifes that this field must match against the specified
  649.   // regular expression (RE2 syntax). The included expression should elide
  650.   // any delimiters.
  651.   optional string pattern  = 4;
  653.   // Prefix specifies that this field must have the specified bytes at the
  654.   // beginning of the string.
  655.   optional bytes  prefix   = 5;
  657.   // Suffix specifies that this field must have the specified bytes at the
  658.   // end of the string.
  659.   optional bytes  suffix   = 6;
  661.   // Contains specifies that this field must have the specified bytes
  662.   // anywhere in the string.
  663.   optional bytes  contains = 7;
  665.   // In specifies that this field must be equal to one of the specified
  666.   // values
  667.   repeated bytes in     = 8;
  669.   // NotIn specifies that this field cannot be equal to one of the specified
  670.   // values
  671.   repeated bytes not_in = 9;
  673.   // WellKnown rules provide advanced constraints against common byte
  674.   // patterns
  675.   oneof well_known {
  676.     // Ip specifies that the field must be a valid IP (v4 or v6) address in
  677.     // byte format
  678.     bool ip   = 10;
  680.     // Ipv4 specifies that the field must be a valid IPv4 address in byte
  681.     // format
  682.     bool ipv4 = 11;
  684.     // Ipv6 specifies that the field must be a valid IPv6 address in byte
  685.     // format
  686.     bool ipv6 = 12;
  687.   }
  689.   // IgnoreEmpty specifies that the validation rules of this field should be
  690.   // evaluated only if the field is not empty
  691.   optional bool ignore_empty = 14;
  692. }
  694. // EnumRules describe the constraints applied to enum values
  695. message EnumRules {
  696.   // Const specifies that this field must be exactly the specified value
  697.   optional int32 const        = 1;
  699.   // DefinedOnly specifies that this field must be only one of the defined
  700.   // values for this enum, failing on any undefined value.
  701.   optional bool  defined_only = 2;
  703.   // In specifies that this field must be equal to one of the specified
  704.   // values
  705.   repeated int32 in           = 3;
  707.   // NotIn specifies that this field cannot be equal to one of the specified
  708.   // values
  709.   repeated int32 not_in       = 4;
  710. }
  712. // MessageRules describe the constraints applied to embedded message values.
  713. // For message-type fields, validation is performed recursively.
  714. message MessageRules {
  715.   // Skip specifies that the validation rules of this field should not be
  716.   // evaluated
  717.   optional bool skip     = 1;
  719.   // Required specifies that this field must be set
  720.   optional bool required = 2;
  721. }
  723. // RepeatedRules describe the constraints applied to `repeated` values
  724. message RepeatedRules {
  725.   // MinItems specifies that this field must have the specified number of
  726.   // items at a minimum
  727.   optional uint64 min_items = 1;
  729.   // MaxItems specifies that this field must have the specified number of
  730.   // items at a maximum
  731.   optional uint64 max_items = 2;
  733.   // Unique specifies that all elements in this field must be unique. This
  734.   // contraint is only applicable to scalar and enum types (messages are not
  735.   // supported).
  736.   optional bool   unique    = 3;
  738.   // Items specifies the contraints to be applied to each item in the field.
  739.   // Repeated message fields will still execute validation against each item
  740.   // unless skip is specified here.
  741.   optional FieldRules items = 4;
  743.   // IgnoreEmpty specifies that the validation rules of this field should be
  744.   // evaluated only if the field is not empty
  745.   optional bool ignore_empty = 5;
  746. }
  748. // MapRules describe the constraints applied to `map` values
  749. message MapRules {
  750.   // MinPairs specifies that this field must have the specified number of
  751.   // KVs at a minimum
  752.   optional uint64 min_pairs = 1;
  754.   // MaxPairs specifies that this field must have the specified number of
  755.   // KVs at a maximum
  756.   optional uint64 max_pairs = 2;
  758.   // NoSparse specifies values in this field cannot be unset. This only
  759.   // applies to map's with message value types.
  760.   optional bool no_sparse = 3;
  762.   // Keys specifies the constraints to be applied to each key in the field.
  763.   optional FieldRules keys   = 4;
  765.   // Values specifies the constraints to be applied to the value of each key
  766.   // in the field. Message values will still have their validations evaluated
  767.   // unless skip is specified here.
  768.   optional FieldRules values = 5;
  770.   // IgnoreEmpty specifies that the validation rules of this field should be
  771.   // evaluated only if the field is not empty
  772.   optional bool ignore_empty = 6;
  773. }
  775. // AnyRules describe constraints applied exclusively to the
  776. // `google.protobuf.Any` well-known type
  777. message AnyRules {
  778.   // Required specifies that this field must be set
  779.   optional bool required = 1;
  781.   // In specifies that this field's `type_url` must be equal to one of the
  782.   // specified values.
  783.   repeated string in     = 2;
  785.   // NotIn specifies that this field's `type_url` must not be equal to any of
  786.   // the specified values.
  787.   repeated string not_in = 3;
  788. }
  790. // DurationRules describe the constraints applied exclusively to the
  791. // `google.protobuf.Duration` well-known type
  792. message DurationRules {
  793.   // Required specifies that this field must be set
  794.   optional bool required = 1;
  796.   // Const specifies that this field must be exactly the specified value
  797.   optional google.protobuf.Duration const = 2;
  799.   // Lt specifies that this field must be less than the specified value,
  800.   // exclusive
  801.   optional google.protobuf.Duration lt = 3;
  803.   // Lt specifies that this field must be less than the specified value,
  804.   // inclusive
  805.   optional google.protobuf.Duration lte = 4;
  807.   // Gt specifies that this field must be greater than the specified value,
  808.   // exclusive
  809.   optional google.protobuf.Duration gt = 5;
  811.   // Gte specifies that this field must be greater than the specified value,
  812.   // inclusive
  813.   optional google.protobuf.Duration gte = 6;
  815.   // In specifies that this field must be equal to one of the specified
  816.   // values
  817.   repeated google.protobuf.Duration in = 7;
  819.   // NotIn specifies that this field cannot be equal to one of the specified
  820.   // values
  821.   repeated google.protobuf.Duration not_in = 8;
  822. }
  824. // TimestampRules describe the constraints applied exclusively to the
  825. // `google.protobuf.Timestamp` well-known type
  826. message TimestampRules {
  827.   // Required specifies that this field must be set
  828.   optional bool required = 1;
  830.   // Const specifies that this field must be exactly the specified value
  831.   optional google.protobuf.Timestamp const = 2;
  833.   // Lt specifies that this field must be less than the specified value,
  834.   // exclusive
  835.   optional google.protobuf.Timestamp lt = 3;
  837.   // Lte specifies that this field must be less than the specified value,
  838.   // inclusive
  839.   optional google.protobuf.Timestamp lte = 4;
  841.   // Gt specifies that this field must be greater than the specified value,
  842.   // exclusive
  843.   optional google.protobuf.Timestamp gt = 5;
  845.   // Gte specifies that this field must be greater than the specified value,
  846.   // inclusive
  847.   optional google.protobuf.Timestamp gte = 6;
  849.   // LtNow specifies that this must be less than the current time. LtNow
  850.   // can only be used with the Within rule.
  851.   optional bool lt_now  = 7;
  853.   // GtNow specifies that this must be greater than the current time. GtNow
  854.   // can only be used with the Within rule.
  855.   optional bool gt_now  = 8;
  857.   // Within specifies that this field must be within this duration of the
  858.   // current time. This constraint can be used alone or with the LtNow and
  859.   // GtNow rules.
  860.   optional google.protobuf.Duration within = 9;
  861. }

层级目录如下
image.png

在proto文件目录下执行以下命令生成validate文件

protoc -I . --go_out=plugins=grpc:. --validate_out="lang=go:." greeter.proto

server端代码

  1. type Greeter struct{}
  3. func (g Greeter) SayHello(ctx context.Context, person *bark.Person) (*bark.Person, error) {
  4.     return &bark.Person{
  5.         Id: 32,
  6.     }, nil
  7. }
  9. type Validator interface {
  10.     Validate() error
  11. }
  13. func main() {
  14.     /** 测试validate的调用
  15.     p := new(bark.Person)
  16.     p.Id = 1000
  17.     err := p.Validate()
  18.     if err != nil {
  19.         panic(err)
  20.     }
  21.     */
  23.     interceptor := func(ctx context.Context, req interface{}, info *grpc.UnaryServerInfo,
  24.         handler grpc.UnaryHandler) (resp interface{}, err error) {
  25.         if r, ok := req.(Validator); ok {
  26.             if err := r.Validate(); err != nil {
  27.                 return nil, status.Error(codes.InvalidArgument, err.Error())
  28.             }
  29.         }
  30.         return handler(ctx, req)
  31.     }
  32.     opt := grpc.UnaryInterceptor(interceptor)
  34.     s := grpc.NewServer(opt)
  36.     bark.RegisterBarkServer(s, &Greeter{})
  37.     lis, err := net.Listen("tcp", ":8080")
  38.     if err != nil {
  39.         panic(err)
  40.     }
  41.     s.Serve(lis)
  42. }

client端代

  1. func main() {
  2.     conn, err := grpc.Dial(":8080", grpc.WithInsecure())
  3.     if err != nil {
  4.         panic(err)
  5.     }
  6.     defer conn.Close()
  8.     c := bark.NewBarkClient(conn)
  10.     res, err := c.SayHello(context.Background(), &bark.Person{
  11.         Id:     1000,
  12.         Email:  "741883227@qq.com",
  13.         Mobile: "18978057553",
  14.     })
  15.     if err != nil {
  16.         fmt.Println("err", err)
  17.         return
  18.     }
  19.     fmt.Println("res", res)
  20. }

启动server端然后使用client端发送请求, 如果数据没有通过校验, 则会在服务端的拦截器里拦截并且返回

image.png
更多规则请参考文档
bingo！