golang 在windows下使用protobuf的一次完整记录

雨点打透心脏的1/2处 2022-10-07 09:50 284阅读 0赞

1、安装protobuf库文件

  1. go get github.com/golang/protobuf/proto

2、安装protobuf的编译器

2.1、go get github.com/golang/protobuf/protoc-gen-go

2.2 使用 gogoprotobuf完全兼容google protobuf，它生成的代码质量和编解码性能均比goprotobuf高一些。以下a、b二选一即可

a、gogo

go get github.com/gogo/protobuf/protoc-gen-gogo

b、gofast

go get github.com/gogo/protobuf/protoc-gen-gofast

成功后会在GOPATH的第一个目录的bin文件夹下生成protoc-gen-go可执行文件（如果该路径没在系统的环境变量中，则需要将改路径也加入到环境变量的path中去）。

注：如果是手动下载的gofast、gogo等文件包，需要切换到响应的目录go build 生成可执行文件，并移动到你的bin文件夹下

2021061711451731.png

watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xjdG1laQ_size_16_color_FFFFFF_t_70

3、使用protoc编译.proto文件成.pd.go文件

a、protoc —go_out=. *.proto

b、protoc —gofast_out=plugins=grpc:. test.proto

示例 test.proto

  1. syntax = "proto3";
  3. package jlb;
  5. message Request{
  6.     string req_id=1;
  7.     repeated int64 a_ids=2;
  8.     string platform=3;
  9.     int64 ts=4;
  10. }

watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xjdG1laQ_size_16_color_FFFFFF_t_70 1

编译后的go文件test.pb.go

  1. // Code generated by protoc-gen-gogo. DO NOT EDIT.
  2. // source: test.proto
  4. package jlb
  6. import (
  7.    fmt "fmt"
  8.    proto "github.com/golang/protobuf/proto"
  9.    io "io"
  10.    math "math"
  11.    math_bits "math/bits"
  12. )
  14. // Reference imports to suppress errors if they are not otherwise used.
  15. var _ = proto.Marshal
  16. var _ = fmt.Errorf
  17. var _ = math.Inf
  19. // This is a compile-time assertion to ensure that this generated file
  20. // is compatible with the proto package it is being compiled against.
  21. // A compilation error at this line likely means your copy of the
  22. // proto package needs to be updated.
  23. const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package
  25. type Request struct {
  26.    ReqId                string   `protobuf:"bytes,1,opt,name=req_id,json=reqId,proto3" json:"req_id,omitempty"`
  27.    AIds                 []int64  `protobuf:"varint,2,rep,packed,name=a_ids,json=aIds,proto3" json:"a_ids,omitempty"`
  28.    Platform             string   `protobuf:"bytes,3,opt,name=platform,proto3" json:"platform,omitempty"`
  29.    Ts                   int64    `protobuf:"varint,4,opt,name=ts,proto3" json:"ts,omitempty"`
  30.    XXX_NoUnkeyedLiteral struct{} `json:"-"`
  31.    XXX_unrecognized     []byte   `json:"-"`
  32.    XXX_sizecache        int32    `json:"-"`
  33. }
  35. func (m *Request) Reset()         { *m = Request{} }
  36. func (m *Request) String() string { return proto.CompactTextString(m) }
  37. func (*Request) ProtoMessage()    {}
  38. func (*Request) Descriptor() ([]byte, []int) {
  39.    return fileDescriptor_c161fcfdc0c3ff1e, []int{0}
  40. }
  41. func (m *Request) XXX_Unmarshal(b []byte) error {
  42.    return m.Unmarshal(b)
  43. }
  44. func (m *Request) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
  45.    if deterministic {
  46.       return xxx_messageInfo_Request.Marshal(b, m, deterministic)
  47.    } else {
  48.       b = b[:cap(b)]
  49.       n, err := m.MarshalToSizedBuffer(b)
  50.       if err != nil {
  51.          return nil, err
  52.       }
  53.       return b[:n], nil
  54.    }
  55. }
  56. func (m *Request) XXX_Merge(src proto.Message) {
  57.    xxx_messageInfo_Request.Merge(m, src)
  58. }
  59. func (m *Request) XXX_Size() int {
  60.    return m.Size()
  61. }
  62. func (m *Request) XXX_DiscardUnknown() {
  63.    xxx_messageInfo_Request.DiscardUnknown(m)
  64. }
  66. var xxx_messageInfo_Request proto.InternalMessageInfo
  68. func (m *Request) GetReqId() string {
  69.    if m != nil {
  70.       return m.ReqId
  71.    }
  72.    return ""
  73. }
  75. func (m *Request) GetAIds() []int64 {
  76.    if m != nil {
  77.       return m.AIds
  78.    }
  79.    return nil
  80. }
  82. func (m *Request) GetPlatform() string {
  83.    if m != nil {
  84.       return m.Platform
  85.    }
  86.    return ""
  87. }
  89. func (m *Request) GetTs() int64 {
  90.    if m != nil {
  91.       return m.Ts
  92.    }
  93.    return 0
  94. }
  96. func init() {
  97.    proto.RegisterType((*Request)(nil), "jlb.Request")
  98. }
  100. func init() { proto.RegisterFile("test.proto", fileDescriptor_c161fcfdc0c3ff1e) }
  102. var fileDescriptor_c161fcfdc0c3ff1e = []byte{
  103.    // 154 bytes of a gzipped FileDescriptorProto
  104.    0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0xe2, 0x2a, 0x49, 0x2d, 0x2e,
  105.    0xd1, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0x62, 0xce, 0xca, 0x49, 0x52, 0x4a, 0xe4, 0x62, 0x0f,
  106.    0x4a, 0x2d, 0x2c, 0x4d, 0x2d, 0x2e, 0x11, 0x12, 0xe5, 0x62, 0x2b, 0x4a, 0x2d, 0x8c, 0xcf, 0x4c,
  107.    0x91, 0x60, 0x54, 0x60, 0xd4, 0xe0, 0x0c, 0x62, 0x2d, 0x4a, 0x2d, 0xf4, 0x4c, 0x11, 0x12, 0xe6,
  108.    0x62, 0x4d, 0x8c, 0xcf, 0x4c, 0x29, 0x96, 0x60, 0x52, 0x60, 0xd6, 0x60, 0x0e, 0x62, 0x49, 0xf4,
  109.    0x4c, 0x29, 0x16, 0x92, 0xe2, 0xe2, 0x28, 0xc8, 0x49, 0x2c, 0x49, 0xcb, 0x2f, 0xca, 0x95, 0x60,
  110.    0x06, 0xab, 0x86, 0xf3, 0x85, 0xf8, 0xb8, 0x98, 0x4a, 0x8a, 0x25, 0x58, 0x14, 0x18, 0x35, 0x98,
  111.    0x83, 0x98, 0x4a, 0x8a, 0x9d, 0x04, 0x4e, 0x3c, 0x92, 0x63, 0xbc, 0xf0, 0x48, 0x8e, 0xf1, 0xc1,
  112.    0x23, 0x39, 0xc6, 0x19, 0x8f, 0xe5, 0x18, 0x92, 0xd8, 0xc0, 0x0e, 0x30, 0x06, 0x04, 0x00, 0x00,
  113.    0xff, 0xff, 0x73, 0x6a, 0x49, 0x0d, 0x8e, 0x00, 0x00, 0x00,
  114. }
  116. func (m *Request) Marshal() (dAtA []byte, err error) {
  117.    size := m.Size()
  118.    dAtA = make([]byte, size)
  119.    n, err := m.MarshalToSizedBuffer(dAtA[:size])
  120.    if err != nil {
  121.       return nil, err
  122.    }
  123.    return dAtA[:n], nil
  124. }
  126. func (m *Request) MarshalTo(dAtA []byte) (int, error) {
  127.    size := m.Size()
  128.    return m.MarshalToSizedBuffer(dAtA[:size])
  129. }
  131. func (m *Request) MarshalToSizedBuffer(dAtA []byte) (int, error) {
  132.    i := len(dAtA)
  133.    _ = i
  134.    var l int
  135.    _ = l
  136.    if m.XXX_unrecognized != nil {
  137.       i -= len(m.XXX_unrecognized)
  138.       copy(dAtA[i:], m.XXX_unrecognized)
  139.    }
  140.    if m.Ts != 0 {
  141.       i = encodeVarintTest(dAtA, i, uint64(m.Ts))
  142.       i--
  143.       dAtA[i] = 0x20
  144.    }
  145.    if len(m.Platform) > 0 {
  146.       i -= len(m.Platform)
  147.       copy(dAtA[i:], m.Platform)
  148.       i = encodeVarintTest(dAtA, i, uint64(len(m.Platform)))
  149.       i--
  150.       dAtA[i] = 0x1a
  151.    }
  152.    if len(m.AIds) > 0 {
  153.       dAtA2 := make([]byte, len(m.AIds)*10)
  154.       var j1 int
  155.       for _, num1 := range m.AIds {
  156.          num := uint64(num1)
  157.          for num >= 1<<7 {
  158.             dAtA2[j1] = uint8(uint64(num)&0x7f | 0x80)
  159.             num >>= 7
  160.             j1++
  161.          }
  162.          dAtA2[j1] = uint8(num)
  163.          j1++
  164.       }
  165.       i -= j1
  166.       copy(dAtA[i:], dAtA2[:j1])
  167.       i = encodeVarintTest(dAtA, i, uint64(j1))
  168.       i--
  169.       dAtA[i] = 0x12
  170.    }
  171.    if len(m.ReqId) > 0 {
  172.       i -= len(m.ReqId)
  173.       copy(dAtA[i:], m.ReqId)
  174.       i = encodeVarintTest(dAtA, i, uint64(len(m.ReqId)))
  175.       i--
  176.       dAtA[i] = 0xa
  177.    }
  178.    return len(dAtA) - i, nil
  179. }
  181. func encodeVarintTest(dAtA []byte, offset int, v uint64) int {
  182.    offset -= sovTest(v)
  183.    base := offset
  184.    for v >= 1<<7 {
  185.       dAtA[offset] = uint8(v&0x7f | 0x80)
  186.       v >>= 7
  187.       offset++
  188.    }
  189.    dAtA[offset] = uint8(v)
  190.    return base
  191. }
  192. func (m *Request) Size() (n int) {
  193.    if m == nil {
  194.       return 0
  195.    }
  196.    var l int
  197.    _ = l
  198.    l = len(m.ReqId)
  199.    if l > 0 {
  200.       n += 1 + l + sovTest(uint64(l))
  201.    }
  202.    if len(m.AIds) > 0 {
  203.       l = 0
  204.       for _, e := range m.AIds {
  205.          l += sovTest(uint64(e))
  206.       }
  207.       n += 1 + sovTest(uint64(l)) + l
  208.    }
  209.    l = len(m.Platform)
  210.    if l > 0 {
  211.       n += 1 + l + sovTest(uint64(l))
  212.    }
  213.    if m.Ts != 0 {
  214.       n += 1 + sovTest(uint64(m.Ts))
  215.    }
  216.    if m.XXX_unrecognized != nil {
  217.       n += len(m.XXX_unrecognized)
  218.    }
  219.    return n
  220. }
  222. func sovTest(x uint64) (n int) {
  223.    return (math_bits.Len64(x|1) + 6) / 7
  224. }
  225. func sozTest(x uint64) (n int) {
  226.    return sovTest(uint64((x << 1) ^ uint64((int64(x) >> 63))))
  227. }
  228. func (m *Request) Unmarshal(dAtA []byte) error {
  229.    l := len(dAtA)
  230.    iNdEx := 0
  231.    for iNdEx < l {
  232.       preIndex := iNdEx
  233.       var wire uint64
  234.       for shift := uint(0); ; shift += 7 {
  235.          if shift >= 64 {
  236.             return ErrIntOverflowTest
  237.          }
  238.          if iNdEx >= l {
  239.             return io.ErrUnexpectedEOF
  240.          }
  241.          b := dAtA[iNdEx]
  242.          iNdEx++
  243.          wire |= uint64(b&0x7F) << shift
  244.          if b < 0x80 {
  245.             break
  246.          }
  247.       }
  248.       fieldNum := int32(wire >> 3)
  249.       wireType := int(wire & 0x7)
  250.       if wireType == 4 {
  251.          return fmt.Errorf("proto: Request: wiretype end group for non-group")
  252.       }
  253.       if fieldNum <= 0 {
  254.          return fmt.Errorf("proto: Request: illegal tag %d (wire type %d)", fieldNum, wire)
  255.       }
  256.       switch fieldNum {
  257.       case 1:
  258.          if wireType != 2 {
  259.             return fmt.Errorf("proto: wrong wireType = %d for field ReqId", wireType)
  260.          }
  261.          var stringLen uint64
  262.          for shift := uint(0); ; shift += 7 {
  263.             if shift >= 64 {
  264.                return ErrIntOverflowTest
  265.             }
  266.             if iNdEx >= l {
  267.                return io.ErrUnexpectedEOF
  268.             }
  269.             b := dAtA[iNdEx]
  270.             iNdEx++
  271.             stringLen |= uint64(b&0x7F) << shift
  272.             if b < 0x80 {
  273.                break
  274.             }
  275.          }
  276.          intStringLen := int(stringLen)
  277.          if intStringLen < 0 {
  278.             return ErrInvalidLengthTest
  279.          }
  280.          postIndex := iNdEx + intStringLen
  281.          if postIndex < 0 {
  282.             return ErrInvalidLengthTest
  283.          }
  284.          if postIndex > l {
  285.             return io.ErrUnexpectedEOF
  286.          }
  287.          m.ReqId = string(dAtA[iNdEx:postIndex])
  288.          iNdEx = postIndex
  289.       case 2:
  290.          if wireType == 0 {
  291.             var v int64
  292.             for shift := uint(0); ; shift += 7 {
  293.                if shift >= 64 {
  294.                   return ErrIntOverflowTest
  295.                }
  296.                if iNdEx >= l {
  297.                   return io.ErrUnexpectedEOF
  298.                }
  299.                b := dAtA[iNdEx]
  300.                iNdEx++
  301.                v |= int64(b&0x7F) << shift
  302.                if b < 0x80 {
  303.                   break
  304.                }
  305.             }
  306.             m.AIds = append(m.AIds, v)
  307.          } else if wireType == 2 {
  308.             var packedLen int
  309.             for shift := uint(0); ; shift += 7 {
  310.                if shift >= 64 {
  311.                   return ErrIntOverflowTest
  312.                }
  313.                if iNdEx >= l {
  314.                   return io.ErrUnexpectedEOF
  315.                }
  316.                b := dAtA[iNdEx]
  317.                iNdEx++
  318.                packedLen |= int(b&0x7F) << shift
  319.                if b < 0x80 {
  320.                   break
  321.                }
  322.             }
  323.             if packedLen < 0 {
  324.                return ErrInvalidLengthTest
  325.             }
  326.             postIndex := iNdEx + packedLen
  327.             if postIndex < 0 {
  328.                return ErrInvalidLengthTest
  329.             }
  330.             if postIndex > l {
  331.                return io.ErrUnexpectedEOF
  332.             }
  333.             var elementCount int
  334.             var count int
  335.             for _, integer := range dAtA[iNdEx:postIndex] {
  336.                if integer < 128 {
  337.                   count++
  338.                }
  339.             }
  340.             elementCount = count
  341.             if elementCount != 0 && len(m.AIds) == 0 {
  342.                m.AIds = make([]int64, 0, elementCount)
  343.             }
  344.             for iNdEx < postIndex {
  345.                var v int64
  346.                for shift := uint(0); ; shift += 7 {
  347.                   if shift >= 64 {
  348.                      return ErrIntOverflowTest
  349.                   }
  350.                   if iNdEx >= l {
  351.                      return io.ErrUnexpectedEOF
  352.                   }
  353.                   b := dAtA[iNdEx]
  354.                   iNdEx++
  355.                   v |= int64(b&0x7F) << shift
  356.                   if b < 0x80 {
  357.                      break
  358.                   }
  359.                }
  360.                m.AIds = append(m.AIds, v)
  361.             }
  362.          } else {
  363.             return fmt.Errorf("proto: wrong wireType = %d for field AIds", wireType)
  364.          }
  365.       case 3:
  366.          if wireType != 2 {
  367.             return fmt.Errorf("proto: wrong wireType = %d for field Platform", wireType)
  368.          }
  369.          var stringLen uint64
  370.          for shift := uint(0); ; shift += 7 {
  371.             if shift >= 64 {
  372.                return ErrIntOverflowTest
  373.             }
  374.             if iNdEx >= l {
  375.                return io.ErrUnexpectedEOF
  376.             }
  377.             b := dAtA[iNdEx]
  378.             iNdEx++
  379.             stringLen |= uint64(b&0x7F) << shift
  380.             if b < 0x80 {
  381.                break
  382.             }
  383.          }
  384.          intStringLen := int(stringLen)
  385.          if intStringLen < 0 {
  386.             return ErrInvalidLengthTest
  387.          }
  388.          postIndex := iNdEx + intStringLen
  389.          if postIndex < 0 {
  390.             return ErrInvalidLengthTest
  391.          }
  392.          if postIndex > l {
  393.             return io.ErrUnexpectedEOF
  394.          }
  395.          m.Platform = string(dAtA[iNdEx:postIndex])
  396.          iNdEx = postIndex
  397.       case 4:
  398.          if wireType != 0 {
  399.             return fmt.Errorf("proto: wrong wireType = %d for field Ts", wireType)
  400.          }
  401.          m.Ts = 0
  402.          for shift := uint(0); ; shift += 7 {
  403.             if shift >= 64 {
  404.                return ErrIntOverflowTest
  405.             }
  406.             if iNdEx >= l {
  407.                return io.ErrUnexpectedEOF
  408.             }
  409.             b := dAtA[iNdEx]
  410.             iNdEx++
  411.             m.Ts |= int64(b&0x7F) << shift
  412.             if b < 0x80 {
  413.                break
  414.             }
  415.          }
  416.       default:
  417.          iNdEx = preIndex
  418.          skippy, err := skipTest(dAtA[iNdEx:])
  419.          if err != nil {
  420.             return err
  421.          }
  422.          if (skippy < 0) || (iNdEx+skippy) < 0 {
  423.             return ErrInvalidLengthTest
  424.          }
  425.          if (iNdEx + skippy) > l {
  426.             return io.ErrUnexpectedEOF
  427.          }
  428.          m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
  429.          iNdEx += skippy
  430.       }
  431.    }
  433.    if iNdEx > l {
  434.       return io.ErrUnexpectedEOF
  435.    }
  436.    return nil
  437. }
  438. func skipTest(dAtA []byte) (n int, err error) {
  439.    l := len(dAtA)
  440.    iNdEx := 0
  441.    depth := 0
  442.    for iNdEx < l {
  443.       var wire uint64
  444.       for shift := uint(0); ; shift += 7 {
  445.          if shift >= 64 {
  446.             return 0, ErrIntOverflowTest
  447.          }
  448.          if iNdEx >= l {
  449.             return 0, io.ErrUnexpectedEOF
  450.          }
  451.          b := dAtA[iNdEx]
  452.          iNdEx++
  453.          wire |= (uint64(b) & 0x7F) << shift
  454.          if b < 0x80 {
  455.             break
  456.          }
  457.       }
  458.       wireType := int(wire & 0x7)
  459.       switch wireType {
  460.       case 0:
  461.          for shift := uint(0); ; shift += 7 {
  462.             if shift >= 64 {
  463.                return 0, ErrIntOverflowTest
  464.             }
  465.             if iNdEx >= l {
  466.                return 0, io.ErrUnexpectedEOF
  467.             }
  468.             iNdEx++
  469.             if dAtA[iNdEx-1] < 0x80 {
  470.                break
  471.             }
  472.          }
  473.       case 1:
  474.          iNdEx += 8
  475.       case 2:
  476.          var length int
  477.          for shift := uint(0); ; shift += 7 {
  478.             if shift >= 64 {
  479.                return 0, ErrIntOverflowTest
  480.             }
  481.             if iNdEx >= l {
  482.                return 0, io.ErrUnexpectedEOF
  483.             }
  484.             b := dAtA[iNdEx]
  485.             iNdEx++
  486.             length |= (int(b) & 0x7F) << shift
  487.             if b < 0x80 {
  488.                break
  489.             }
  490.          }
  491.          if length < 0 {
  492.             return 0, ErrInvalidLengthTest
  493.          }
  494.          iNdEx += length
  495.       case 3:
  496.          depth++
  497.       case 4:
  498.          if depth == 0 {
  499.             return 0, ErrUnexpectedEndOfGroupTest
  500.          }
  501.          depth--
  502.       case 5:
  503.          iNdEx += 4
  504.       default:
  505.          return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
  506.       }
  507.       if iNdEx < 0 {
  508.          return 0, ErrInvalidLengthTest
  509.       }
  510.       if depth == 0 {
  511.          return iNdEx, nil
  512.       }
  513.    }
  514.    return 0, io.ErrUnexpectedEOF
  515. }
  517. var (
  518.    ErrInvalidLengthTest        = fmt.Errorf("proto: negative length found during unmarshaling")
  519.    ErrIntOverflowTest          = fmt.Errorf("proto: integer overflow")
  520.    ErrUnexpectedEndOfGroupTest = fmt.Errorf("proto: unexpected end of group")
  521. )

注意：生成的pb.go中结构体json转换忽略零值，如果不忽略，需要手动删除 omitempty；

watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xjdG1laQ_size_16_color_FFFFFF_t_70 2

发表评论

表情：
评论列表 （有 0 条评论，284人围观）

还没有评论，来说两句吧...

相关阅读

    相关 golang使用protobuf简易教程

    golang使用protobuf简易教程 google公司发布的一套开源编码规则，基于二进制流的序列化传输，可以转换成多种编程语言，几乎涵盖了市面上所有的主流编程语言，当

    Bertha 。Bertha 。/ 0 赞/ 303 阅读