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

最新推荐文章于 2024-08-15 02:31:19 发布
最新推荐文章于 2024-08-15 02:31:19 发布
阅读量774 收藏 1
点赞数
分类专栏： go 文章标签： protobuf go
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lctmei/article/details/117987670
版权

 

 

 

1、安装protobuf库文件

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文件夹下

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

a、protoc --go_out=. *.proto

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

示例 test.proto

syntax = "proto3";

package jlb;

message Request{
    string req_id=1;
    repeated int64 a_ids=2;
    string platform=3;
    int64 ts=4;
}

 

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

// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: test.proto

package jlb

import (
   fmt "fmt"
   proto "github.com/golang/protobuf/proto"
   io "io"
   math "math"
   math_bits "math/bits"
)

// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf

// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package

type Request struct {
   ReqId                string   `protobuf:"bytes,1,opt,name=req_id,json=reqId,proto3" json:"req_id,omitempty"`
   AIds                 []int64  `protobuf:"varint,2,rep,packed,name=a_ids,json=aIds,proto3" json:"a_ids,omitempty"`
   Platform             string   `protobuf:"bytes,3,opt,name=platform,proto3" json:"platform,omitempty"`
   Ts                   int64    `protobuf:"varint,4,opt,name=ts,proto3" json:"ts,omitempty"`
   XXX_NoUnkeyedLiteral struct{} `json:"-"`
   XXX_unrecognized     []byte   `json:"-"`
   XXX_sizecache        int32    `json:"-"`
}

func (m *Request) Reset()         { *m = Request{} }
func (m *Request) String() string { return proto.CompactTextString(m) }
func (*Request) ProtoMessage()    {}
func (*Request) Descriptor() ([]byte, []int) {
   return fileDescriptor_c161fcfdc0c3ff1e, []int{0}
}
func (m *Request) XXX_Unmarshal(b []byte) error {
   return m.Unmarshal(b)
}
func (m *Request) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
   if deterministic {
      return xxx_messageInfo_Request.Marshal(b, m, deterministic)
   } else {
      b = b[:cap(b)]
      n, err := m.MarshalToSizedBuffer(b)
      if err != nil {
         return nil, err
      }
      return b[:n], nil
   }
}
func (m *Request) XXX_Merge(src proto.Message) {
   xxx_messageInfo_Request.Merge(m, src)
}
func (m *Request) XXX_Size() int {
   return m.Size()
}
func (m *Request) XXX_DiscardUnknown() {
   xxx_messageInfo_Request.DiscardUnknown(m)
}

var xxx_messageInfo_Request proto.InternalMessageInfo

func (m *Request) GetReqId() string {
   if m != nil {
      return m.ReqId
   }
   return ""
}

func (m *Request) GetAIds() []int64 {
   if m != nil {
      return m.AIds
   }
   return nil
}

func (m *Request) GetPlatform() string {
   if m != nil {
      return m.Platform
   }
   return ""
}

func (m *Request) GetTs() int64 {
   if m != nil {
      return m.Ts
   }
   return 0
}

func init() {
   proto.RegisterType((*Request)(nil), "jlb.Request")
}

func init() { proto.RegisterFile("test.proto", fileDescriptor_c161fcfdc0c3ff1e) }

var fileDescriptor_c161fcfdc0c3ff1e = []byte{
   // 154 bytes of a gzipped FileDescriptorProto
   0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0xe2, 0x2a, 0x49, 0x2d, 0x2e,
   0xd1, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0x62, 0xce, 0xca, 0x49, 0x52, 0x4a, 0xe4, 0x62, 0x0f,
   0x4a, 0x2d, 0x2c, 0x4d, 0x2d, 0x2e, 0x11, 0x12, 0xe5, 0x62, 0x2b, 0x4a, 0x2d, 0x8c, 0xcf, 0x4c,
   0x91, 0x60, 0x54, 0x60, 0xd4, 0xe0, 0x0c, 0x62, 0x2d, 0x4a, 0x2d, 0xf4, 0x4c, 0x11, 0x12, 0xe6,
   0x62, 0x4d, 0x8c, 0xcf, 0x4c, 0x29, 0x96, 0x60, 0x52, 0x60, 0xd6, 0x60, 0x0e, 0x62, 0x49, 0xf4,
   0x4c, 0x29, 0x16, 0x92, 0xe2, 0xe2, 0x28, 0xc8, 0x49, 0x2c, 0x49, 0xcb, 0x2f, 0xca, 0x95, 0x60,
   0x06, 0xab, 0x86, 0xf3, 0x85, 0xf8, 0xb8, 0x98, 0x4a, 0x8a, 0x25, 0x58, 0x14, 0x18, 0x35, 0x98,
   0x83, 0x98, 0x4a, 0x8a, 0x9d, 0x04, 0x4e, 0x3c, 0x92, 0x63, 0xbc, 0xf0, 0x48, 0x8e, 0xf1, 0xc1,
   0x23, 0x39, 0xc6, 0x19, 0x8f, 0xe5, 0x18, 0x92, 0xd8, 0xc0, 0x0e, 0x30, 0x06, 0x04, 0x00, 0x00,
   0xff, 0xff, 0x73, 0x6a, 0x49, 0x0d, 0x8e, 0x00, 0x00, 0x00,
}

func (m *Request) Marshal() (dAtA []byte, err error) {
   size := m.Size()
   dAtA = make([]byte, size)
   n, err := m.MarshalToSizedBuffer(dAtA[:size])
   if err != nil {
      return nil, err
   }
   return dAtA[:n], nil
}

func (m *Request) MarshalTo(dAtA []byte) (int, error) {
   size := m.Size()
   return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Request) MarshalToSizedBuffer(dAtA []byte) (int, error) {
   i := len(dAtA)
   _ = i
   var l int
   _ = l
   if m.XXX_unrecognized != nil {
      i -= len(m.XXX_unrecognized)
      copy(dAtA[i:], m.XXX_unrecognized)
   }
   if m.Ts != 0 {
      i = encodeVarintTest(dAtA, i, uint64(m.Ts))
      i--
      dAtA[i] = 0x20
   }
   if len(m.Platform) > 0 {
      i -= len(m.Platform)
      copy(dAtA[i:], m.Platform)
      i = encodeVarintTest(dAtA, i, uint64(len(m.Platform)))
      i--
      dAtA[i] = 0x1a
   }
   if len(m.AIds) > 0 {
      dAtA2 := make([]byte, len(m.AIds)*10)
      var j1 int
      for _, num1 := range m.AIds {
         num := uint64(num1)
         for num >= 1<<7 {
            dAtA2[j1] = uint8(uint64(num)&0x7f | 0x80)
            num >>= 7
            j1++
         }
         dAtA2[j1] = uint8(num)
         j1++
      }
      i -= j1
      copy(dAtA[i:], dAtA2[:j1])
      i = encodeVarintTest(dAtA, i, uint64(j1))
      i--
      dAtA[i] = 0x12
   }
   if len(m.ReqId) > 0 {
      i -= len(m.ReqId)
      copy(dAtA[i:], m.ReqId)
      i = encodeVarintTest(dAtA, i, uint64(len(m.ReqId)))
      i--
      dAtA[i] = 0xa
   }
   return len(dAtA) - i, nil
}

func encodeVarintTest(dAtA []byte, offset int, v uint64) int {
   offset -= sovTest(v)
   base := offset
   for v >= 1<<7 {
      dAtA[offset] = uint8(v&0x7f | 0x80)
      v >>= 7
      offset++
   }
   dAtA[offset] = uint8(v)
   return base
}
func (m *Request) Size() (n int) {
   if m == nil {
      return 0
   }
   var l int
   _ = l
   l = len(m.ReqId)
   if l > 0 {
      n += 1 + l + sovTest(uint64(l))
   }
   if len(m.AIds) > 0 {
      l = 0
      for _, e := range m.AIds {
         l += sovTest(uint64(e))
      }
      n += 1 + sovTest(uint64(l)) + l
   }
   l = len(m.Platform)
   if l > 0 {
      n += 1 + l + sovTest(uint64(l))
   }
   if m.Ts != 0 {
      n += 1 + sovTest(uint64(m.Ts))
   }
   if m.XXX_unrecognized != nil {
      n += len(m.XXX_unrecognized)
   }
   return n
}

func sovTest(x uint64) (n int) {
   return (math_bits.Len64(x|1) + 6) / 7
}
func sozTest(x uint64) (n int) {
   return sovTest(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *Request) Unmarshal(dAtA []byte) error {
   l := len(dAtA)
   iNdEx := 0
   for iNdEx < l {
      preIndex := iNdEx
      var wire uint64
      for shift := uint(0); ; shift += 7 {
         if shift >= 64 {
            return ErrIntOverflowTest
         }
         if iNdEx >= l {
            return io.ErrUnexpectedEOF
         }
         b := dAtA[iNdEx]
         iNdEx++
         wire |= uint64(b&0x7F) << shift
         if b < 0x80 {
            break
         }
      }
      fieldNum := int32(wire >> 3)
      wireType := int(wire & 0x7)
      if wireType == 4 {
         return fmt.Errorf("proto: Request: wiretype end group for non-group")
      }
      if fieldNum <= 0 {
         return fmt.Errorf("proto: Request: illegal tag %d (wire type %d)", fieldNum, wire)
      }
      switch fieldNum {
      case 1:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field ReqId", wireType)
         }
         var stringLen uint64
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowTest
            }
            if iNdEx >= l {
               return io.ErrUnexpectedEOF
            }
            b := dAtA[iNdEx]
            iNdEx++
            stringLen |= uint64(b&0x7F) << shift
            if b < 0x80 {
               break
            }
         }
         intStringLen := int(stringLen)
         if intStringLen < 0 {
            return ErrInvalidLengthTest
         }
         postIndex := iNdEx + intStringLen
         if postIndex < 0 {
            return ErrInvalidLengthTest
         }
         if postIndex > l {
            return io.ErrUnexpectedEOF
         }
         m.ReqId = string(dAtA[iNdEx:postIndex])
         iNdEx = postIndex
      case 2:
         if wireType == 0 {
            var v int64
            for shift := uint(0); ; shift += 7 {
               if shift >= 64 {
                  return ErrIntOverflowTest
               }
               if iNdEx >= l {
                  return io.ErrUnexpectedEOF
               }
               b := dAtA[iNdEx]
               iNdEx++
               v |= int64(b&0x7F) << shift
               if b < 0x80 {
                  break
               }
            }
            m.AIds = append(m.AIds, v)
         } else if wireType == 2 {
            var packedLen int
            for shift := uint(0); ; shift += 7 {
               if shift >= 64 {
                  return ErrIntOverflowTest
               }
               if iNdEx >= l {
                  return io.ErrUnexpectedEOF
               }
               b := dAtA[iNdEx]
               iNdEx++
               packedLen |= int(b&0x7F) << shift
               if b < 0x80 {
                  break
               }
            }
            if packedLen < 0 {
               return ErrInvalidLengthTest
            }
            postIndex := iNdEx + packedLen
            if postIndex < 0 {
               return ErrInvalidLengthTest
            }
            if postIndex > l {
               return io.ErrUnexpectedEOF
            }
            var elementCount int
            var count int
            for _, integer := range dAtA[iNdEx:postIndex] {
               if integer < 128 {
                  count++
               }
            }
            elementCount = count
            if elementCount != 0 && len(m.AIds) == 0 {
               m.AIds = make([]int64, 0, elementCount)
            }
            for iNdEx < postIndex {
               var v int64
               for shift := uint(0); ; shift += 7 {
                  if shift >= 64 {
                     return ErrIntOverflowTest
                  }
                  if iNdEx >= l {
                     return io.ErrUnexpectedEOF
                  }
                  b := dAtA[iNdEx]
                  iNdEx++
                  v |= int64(b&0x7F) << shift
                  if b < 0x80 {
                     break
                  }
               }
               m.AIds = append(m.AIds, v)
            }
         } else {
            return fmt.Errorf("proto: wrong wireType = %d for field AIds", wireType)
         }
      case 3:
         if wireType != 2 {
            return fmt.Errorf("proto: wrong wireType = %d for field Platform", wireType)
         }
         var stringLen uint64
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowTest
            }
            if iNdEx >= l {
               return io.ErrUnexpectedEOF
            }
            b := dAtA[iNdEx]
            iNdEx++
            stringLen |= uint64(b&0x7F) << shift
            if b < 0x80 {
               break
            }
         }
         intStringLen := int(stringLen)
         if intStringLen < 0 {
            return ErrInvalidLengthTest
         }
         postIndex := iNdEx + intStringLen
         if postIndex < 0 {
            return ErrInvalidLengthTest
         }
         if postIndex > l {
            return io.ErrUnexpectedEOF
         }
         m.Platform = string(dAtA[iNdEx:postIndex])
         iNdEx = postIndex
      case 4:
         if wireType != 0 {
            return fmt.Errorf("proto: wrong wireType = %d for field Ts", wireType)
         }
         m.Ts = 0
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return ErrIntOverflowTest
            }
            if iNdEx >= l {
               return io.ErrUnexpectedEOF
            }
            b := dAtA[iNdEx]
            iNdEx++
            m.Ts |= int64(b&0x7F) << shift
            if b < 0x80 {
               break
            }
         }
      default:
         iNdEx = preIndex
         skippy, err := skipTest(dAtA[iNdEx:])
         if err != nil {
            return err
         }
         if (skippy < 0) || (iNdEx+skippy) < 0 {
            return ErrInvalidLengthTest
         }
         if (iNdEx + skippy) > l {
            return io.ErrUnexpectedEOF
         }
         m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
         iNdEx += skippy
      }
   }

   if iNdEx > l {
      return io.ErrUnexpectedEOF
   }
   return nil
}
func skipTest(dAtA []byte) (n int, err error) {
   l := len(dAtA)
   iNdEx := 0
   depth := 0
   for iNdEx < l {
      var wire uint64
      for shift := uint(0); ; shift += 7 {
         if shift >= 64 {
            return 0, ErrIntOverflowTest
         }
         if iNdEx >= l {
            return 0, io.ErrUnexpectedEOF
         }
         b := dAtA[iNdEx]
         iNdEx++
         wire |= (uint64(b) & 0x7F) << shift
         if b < 0x80 {
            break
         }
      }
      wireType := int(wire & 0x7)
      switch wireType {
      case 0:
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return 0, ErrIntOverflowTest
            }
            if iNdEx >= l {
               return 0, io.ErrUnexpectedEOF
            }
            iNdEx++
            if dAtA[iNdEx-1] < 0x80 {
               break
            }
         }
      case 1:
         iNdEx += 8
      case 2:
         var length int
         for shift := uint(0); ; shift += 7 {
            if shift >= 64 {
               return 0, ErrIntOverflowTest
            }
            if iNdEx >= l {
               return 0, io.ErrUnexpectedEOF
            }
            b := dAtA[iNdEx]
            iNdEx++
            length |= (int(b) & 0x7F) << shift
            if b < 0x80 {
               break
            }
         }
         if length < 0 {
            return 0, ErrInvalidLengthTest
         }
         iNdEx += length
      case 3:
         depth++
      case 4:
         if depth == 0 {
            return 0, ErrUnexpectedEndOfGroupTest
         }
         depth--
      case 5:
         iNdEx += 4
      default:
         return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
      }
      if iNdEx < 0 {
         return 0, ErrInvalidLengthTest
      }
      if depth == 0 {
         return iNdEx, nil
      }
   }
   return 0, io.ErrUnexpectedEOF
}

var (
   ErrInvalidLengthTest        = fmt.Errorf("proto: negative length found during unmarshaling")
   ErrIntOverflowTest          = fmt.Errorf("proto: integer overflow")
   ErrUnexpectedEndOfGroupTest = fmt.Errorf("proto: unexpected end of group")
)

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

 

 

十二月未完
关注
专栏目录
golang 微服务之gRPC与Protobuf的使用
09-17
在Golang中，安装Protobuf需要根据不同的操作系统执行相应的命令，如在Mac上使用`brew install protobuf`，Windows上下载并配置环境变量，而在Linux上则需要安装依赖并编译源码。 总结来说，gRPC和Protobuf结合为...
k8s 部署外部etcd集群（v3.4.13）etcd状态cannot unmarshal event: proto: wrong wireType = 0 for field Key异常处理
hedao0515的专栏
08-09 719
k8s 部署外部etcd集群（v3.4.13）etcd状态cannot unmarshal event: proto: wrong wireType = 0 for field Key异常处理
【GO】go安装protobuf、proto、grpc、报错（go get: module github.com/golang/protobuf/proto: Get ）
红尘道，红尘练心
08-02 1128
放到D\ProgramFiles(x86)\Protobuf\bin目录protoc-gen-go.exe。在go.mod添加requiregithub.com/golang/protobufv1.3.2。通过各种尝试，执行以下两条命令后，再次执行goget可顺利安装。获得protoc-gen-go.exe。
Golang使用Protobuf
最新发布
weixin_30800249的博客
08-15 241
1、 概述Protocol buffers 是语言中立、平台中立、可扩展的结构化数据序列化机制，就像 XML，但是它更小、更快、更简单。你只需定义一次数据的结构化方式，然后就可以使用特殊生成的源代码轻松地将结构化数据写入和读取各种数据流，支持各种语言。因为profobuf是二进制数据格式，需要编码和解码。数据本身不具有可读...
golang 使用 protobuf 的教程
taoerchun的专栏
11-23 4362
1、下载protobuf的编译器protoc 地址：https://github.com/google/protobuf/releases window： 下载: protoc-3.3.0-win32.zip 解压，把bin目录下的protoc.exe复制到GOPATH/bin下，GOPATH/bin加入环境变量。（不加也行） 当然也可放在其他目录，需加入环境变量，能让...
golang proto3的message中奇怪字段XXX_NoUnkeyedLiteral
u010100466的专栏
05-19 3819
Protocol Buffers中，通过syntax设置语法类型，有proto2和proto3两种语法。当使用proto3时，会自动生成奇怪的字段，如XXX_NoUnkeyedLiteral、XXX_unrecognized、XXX_sizecache等。 # 生成命令：protoc --go_out=. pf.proto type Person struct { Name ...
Golang（Go语言）中Protobuf的使用
热门推荐
weixin_42117918的博客
03-30 2万+
什么是protobuf protobuf也叫protocol buffer是google 的一种数据交换的格式，它独立于语言，独立于平台。google 提供了多种语言的实现：java、c#、c++、go 和 python，每一种实现都包含了相应语言的编译器以及库文件。 由于它是一种二进制的格式，比使用 xml 、json进行数据交换快许多。可以把它用于分布式应用之间的数据通信或者异构环境下的数...
golang在windows平台使用zmq所需lib和dll
05-07
放在gopath目录下，通过go get下载的资源包中，我本地目录C:\Users\wyy\go\pkg\mod\github.com\pebbe\zmq4@v1.2.7
protobuf3封装工具 c# golang windows.rar
07-13
在本压缩包中，提供了支持C#和Golang的实现，并且是在Windows环境下使用的。 1. **protobuf**: protobuf是Google开源的一种轻量级的数据交换格式，它比XML更小、更快、更简单。通过定义消息格式，protobuf可以将...
Golang 1.18.10 Windows安装包
07-14
Golang 1.18.10 Windows安装包。Golang 1.18.10 Windows安装包。Golang 1.18.10 Windows安装包。Golang 1.18.10 Windows安装包。Golang 1.18.10 Windows安装包。Golang 1.18.10 Windows安装包。Golang 1.18.10 ...
go get github.com/golang/protobuf/protoc-gen-go的问题
wwqcherry的博客
05-10 9083
需要go的protoc-gen-go，但是因为golang被墙，go getgithub.com/golang/protobuf/protoc-gen-go的时候总是timeout。（但是如果你锲而不舍一遍一遍试，也是有可能能下下来的） 一次失败的尝试 我的上一篇博客写了先通过github下载源码，然后go install的方式。我的这次没有成功的尝试正是用的这个方法。 在$GOPATH/src/golang.org/下 git clone https://github.com/golang/pro.
K8S-解决报错--总结日记
mingqing的博客
06-02 3510
排错思路
golang/protobuf 学习
yevvzi的博客
11-22 702
看到k8s源码里面用到这个东西，感觉和json很相似 学习一下 protobuf 和json差不多 用于 encoding/decoding 数据  github 地址是github.com/golang/protobuf 开始不知道protoc这个二进制执行文件是干啥的，摸索了好一会儿才明白，原来是用于将proto文件编译为对应的程序文件 按照github的例子 1.创建proto文
golang：截取器
朱金拖的专栏
07-07 201
《GO语言高级编程》设计中案例，仅作为笔记进行收藏。gRPC中的grpc.UnaryInterceptor和grpc.StreamInterceptor分别对普通⽅法和流⽅法提供了截取器的⽀持。不过gRPC框架中只能为每个服务设置⼀个截取器，因此所有的截取⼯作只能在⼀个函数中完成。开源的grpc-ecosystem项⽬中的go-grpc-middleware包已经基于gRPC对截取器实现了链式截取器的⽀持。 这⾥简单介绍普通⽅法的截取器⽤法。 1.helloworld.proto syntax =
[golang 微服务] 3. ProtoBuf认识，安装以及golang 中ProtoBuf使用
zhoupenghui168的博客
05-30 5204
ProtoBuf认识与使用,protoBuf的安装,protoBuf语句以及高级用法,protoBuf基本编译,protoBuf的序列化和反序列化,message关键字,repeated关键字,enum关键字,以及protoBuf golang案例讲解,golang 中ProtoBuf使用
golang使用protobuf简易教程
weixin_34080951的博客
08-16 561
2019独角兽企业重金招聘Python工程师标准>>> ...
K8s 异常问题处理
Jerry00713的博客
12-01 9072
问题1：etcd、apiserver启动异常 现象： [root@hdss7-22 supervisord.d]# supervisorctl status etcd-server-22 FATAL Exited too quickly (process log may have details) kube-apiserver-7-22 FATAL Exited too quickly (proce...
protoc-gen-go 安装踩坑记录
m0_67402096的博客
06-10 1430
尝试安装protobuf，并生成golang代码。记录一下安装过程中的踩坑。 事后感觉全都是不看提示的错 wwwww。按照教程，指令如下 但执行后会有如下错误 报了两个错误所以拉取命令如下 编译.proto文件 创建一个文件夹，创建文件 文件如下 此时目录结构如下 按照教程，执行以下命令 报以下错误 原因是因为当前路径没有在环境变量中，便进行如下设置 并在文件下方添加 注意保存并生效 这里保存之后还需要关闭命令行或者新开一个命令行，我一直在原来的命令行操作好像一直没有生效。。换了个命令行就可以了 生效后再次
2024年最新 golang语言windows下 protobuf3 安装使用（避免采坑）
咸甜适中
03-25 919
下载网址：https://github.com/protocolbuffers/protobuf/releases。Any 可以表示不在 .proto 中定义任意的内置类型。
golang 与c# protobuf使用
06-06
无论是在 Golang 还是在 C# 中，使用 Protobuf 的方式都是类似的。 对于 Golang，你需要使用 Protobuf 的 Golang 版本库，可以通过以下命令进行安装： ``` go get -u github.com/golang/protobuf/protoc-gen-go ``...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值