关于go语言中protobuf高级使用

最新推荐文章于 2024-03-06 08:00:00 发布
最新推荐文章于 2024-03-06 08:00:00 发布
阅读量440 收藏 1
点赞数
分类专栏： go 文章标签： 1024程序员节 golang
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/kuangshp128/article/details/120939081
版权

如果你仅仅是想玩玩go-web单机开发可以参考gin项目框架

一、微服务之间传递数据

  • 1、在微服务中不仅仅是可以通过入参和返回参数来进行数据交互，另外还可以通过metadata的方式传递参数

  • 2、定义一个简单的proto文件

    syntax = "proto3";

option go_package = ".;proto";

service HelloWorld {
  rpc SayHello(HelloRequest) returns(HelloResponse);
}

message HelloRequest {
  string name = 1;
}

message HelloResponse {
  string message = 1;
}

  • 3、服务器端定义接口客户端传递过来的metadata的数据

    type server struct {
}

func (s *server) SayHello(ctx context.Context, in *proto.HelloRequest) (*proto.HelloResponse, error) {
	md, ok := metadata.FromIncomingContext(ctx)
	if !ok {
		log.Fatalf("获取metadata数据失败")
	}
	if nameSlice, ok := md["name"]; ok {
		fmt.Println("获取到的数据", nameSlice[0])
	}
	return &proto.HelloResponse{
		Message: "hello" + in.Name,
	}, nil
}
func main() {
	listen, err := net.Listen("tcp", ":9000")
	if err != nil {
		log.Fatalf("监听端口错误:" + err.Error())
	}
	service := grpc.NewServer()
	proto.RegisterHelloWorldServer(service, &server{})
	err = service.Serve(listen)
	if err != nil {
		fmt.Println(err.Error())
	}
}

  • 4、客户端定义metadata传递参数给服务器端

    func main() {
	conn, err := grpc.Dial("localhost:9000", grpc.WithInsecure())
	if err != nil {
		fmt.Println(err.Error())
		return
	}
	defer conn.Close()

	c := proto.NewHelloWorldClient(conn)
	// 自定义传递的metadata参数
	md := metadata.New(map[string]string{
		"name":     "admin",
		"password": "123456",
	})
	ctx := metadata.NewOutgoingContext(context.Background(), md)
	response, err := c.SayHello(ctx, &proto.HelloRequest{
		Name: "admin",
	})
	if err != nil {
		fmt.Println(err.Error())
		return
	}
	fmt.Println("服务器端返回的数据" + response.Message)
}

二、拦截器的使用interceptor

  • 1、所谓的拦截器是在网络请求的过程中，拦截请求和响应的，以下先配置一个简单的protobuf的网络请求，然后在这个基础上添加拦截器，来拦截客户端发送的数据到服务器端，也可以用来统计接口访问时长

    • 1、proto文件
    syntax = "proto3";

option go_package = ".;proto";

service HelloWorld {
  rpc SayHello(HelloRequest) returns(HelloResponse);
}

message HelloRequest {
  string name = 1;
}

message HelloResponse {
  string message = 1;
}
    • 2、使用命令生成go文件
    protoc -I=. --go_out=plugins=grpc,paths=source_relative:. helloWorld.proto

    • 3、服务器端的代码

      type server struct {
}

func (s *server) SayHello(ctx context.Context, in *proto.HelloRequest) (*proto.HelloResponse, error) {
	return &proto.HelloResponse{
		Message: "hello" + in.Name,
	}, nil
}

func main() {
	listen, err := net.Listen("tcp", ":9000")
	if err != nil {
		log.Fatalf("监听端口错误:" + err.Error())
	}
	service := grpc.NewServer()
	proto.RegisterHelloWorldServer(service, &server{})
	err = service.Serve(listen)
	if err != nil {
		fmt.Println(err.Error())
	}
}

    • 4、客户端

      func main() {
	conn, err := grpc.Dial("localhost:9000", grpc.WithInsecure())
	if err != nil {
		fmt.Println(err.Error())
		return
	}
	defer conn.Close()

	c := proto.NewHelloWorldClient(conn)
	response, err := c.SayHello(context.Background(), &proto.HelloRequest{
		Name: "admin",
	})
	if err != nil {
		fmt.Println(err.Error())
		return
	}
	fmt.Println("服务器端返回的数据" + response.Message)
}

  • 2、在服务器端定义拦截器来拦截请求，客户端的不变，启动客户端和服务器端，观察服务器端

    func main() {
	listen, err := net.Listen("tcp", ":9000")
	if err != nil {
		log.Fatalf("监听端口错误:" + err.Error())
	}
	// 定义拦截器
	interceptor := func(ctx context.Context, req interface{}, info *grpc.UnaryServerInfo, handler grpc.UnaryHandler) (resp interface{}, err error) {
		fmt.Println("接收到一个新的请求")
		return handler(ctx, req)
	}
	// 使用拦截器
	opt := grpc.UnaryInterceptor(interceptor)
	service := grpc.NewServer(opt)
	
	proto.RegisterHelloWorldServer(service, &server{})
	err = service.Serve(listen)
	if err != nil {
		fmt.Println(err.Error())
	}
}

  • 3、拦截在请求前和请求后都打印信息出来

    ...
// 定义拦截器
interceptor := func(ctx context.Context, req interface{}, info *grpc.UnaryServerInfo, handler grpc.UnaryHandler) (resp interface{}, err error) {
  fmt.Println("请求前打印")
  res, err := handler(ctx, req)
  fmt.Println("请求完成打印")
  return res, err
}
// 使用拦截器
opt := grpc.UnaryInterceptor(interceptor)
service := grpc.NewServer(opt)
...

  • 4、客户端拦截器的使用

    func main() {
	// 定义拦截器
	interceptor := func(ctx context.Context, method string, req, reply interface{}, cc *grpc.ClientConn, invoker grpc.UnaryInvoker, opts ...grpc.CallOption) error {
		start := time.Now()
		err := invoker(ctx, method, req, reply, cc, opts...)
		fmt.Printf("耗时:%s\n", time.Since(start))
		return err
	}
	// 使用拦截器
	opt := grpc.WithUnaryInterceptor(interceptor)
	conn, err := grpc.Dial("localhost:9000", grpc.WithInsecure(), opt)
	if err != nil {
		fmt.Println(err.Error())
		return
	}
	defer conn.Close()

	c := proto.NewHelloWorldClient(conn)
	response, err := c.SayHello(context.Background(), &proto.HelloRequest{
		Name: "admin",
	})
	if err != nil {
		fmt.Println(err.Error())
		return
	}
	fmt.Println("服务器端返回的数据" + response.Message)
}

三、使用拦截器和metadata来做微服务之间的授权

  • 1、这里授权我们可以简单的做一个类似用户登录后才能访问的功能，把客户端想象成浏览器，把服务器端想象成之前我们熟悉的gin-web开发

  • 2、简单的demo和上面的一样的，只是在基础上添加拦截器和metadata的操作

  • 3、在客户端的拦截器中传递用户名和密码到服务器端

    func main() {
	// 定义拦截器
	interceptor := func(ctx context.Context, method string, req, reply interface{}, cc *grpc.ClientConn, invoker grpc.UnaryInvoker, opts ...grpc.CallOption) error {
		start := time.Now()
		fmt.Printf("耗时:%s\n", time.Since(start))
		// 使用metadata传递数据
		md := metadata.New(map[string]string{
			"username": "admin",
			"password": "123456",
		})
		ctx = metadata.NewOutgoingContext(context.Background(), md)
		err := invoker(ctx, method, req, reply, cc, opts...)
		return err
	}
	// 使用拦截器
	opt := grpc.WithUnaryInterceptor(interceptor)
	conn, err := grpc.Dial("localhost:9000", grpc.WithInsecure(), opt)
	if err != nil {
		fmt.Println(err.Error())
		return
	}
	defer conn.Close()

	c := proto.NewHelloWorldClient(conn)
	response, err := c.SayHello(context.Background(), &proto.HelloRequest{
		Name: "admin",
	})
	if err != nil {
		fmt.Println(err.Error())
		return
	}
	fmt.Println("服务器端返回的数据" + response.Message)
}

  • 4、服务器端在拦截中获取到metadata中的数据并且判断用户名和密码

    func main() {
	listen, err := net.Listen("tcp", ":9000")
	if err != nil {
		log.Fatalf("监听端口错误:" + err.Error())
	}
	// 定义拦截器
	interceptor := func(ctx context.Context, req interface{}, info *grpc.UnaryServerInfo, handler grpc.UnaryHandler) (resp interface{}, err error) {
		fmt.Println("请求前打印")
		// 解析metadata中的数据验证
		md, ok := metadata.FromIncomingContext(ctx)
		if !ok {
			return resp, status.Error(codes.Unauthenticated, "无效的参数")
		}
		var (
			username string
			password string
		)
		if val, ok := md["username"]; ok {
			username = val[0]
		}
		if val, ok := md["password"]; ok {
			password = val[0]
		}
		fmt.Println(username, password, "接收到的参数")
		if username != "admin" || password != "123456" {
			return resp, status.Error(codes.Unauthenticated, "用户名和密码错误")
		}
		res, err := handler(ctx, req)
		fmt.Println("请求完成打印")
		return res, err
	}
	// 使用拦截器
	opt := grpc.UnaryInterceptor(interceptor)
	service := grpc.NewServer(opt)

	proto.RegisterHelloWorldServer(service, &server{})
	err = service.Serve(listen)
	if err != nil {
		fmt.Println(err.Error())
	}
}

四、参数校验

五、返回状态吗

  • 1、我们在http请求的时候有状态吗，自然在grpc的时候也有状态码，来标注当前请求成功与失败

  • 2、github参考文档

  • 3、服务器端使用状态码返回给客户端端

    import (
	...
	"google.golang.org/grpc"
	"google.golang.org/grpc/codes"
	"google.golang.org/grpc/status"
	"log"
	"net"
)

type server struct {
}

func (s *server) SayHello(ctx context.Context, in *proto.HelloRequest) (*proto.HelloResponse, error) {
	//return &proto.HelloResponse{
	//	Message: "hello" + in.Name,
	//}, nil
	// 返回错误
	return nil, status.Error(codes.NotFound, "记录没有找到")
}

func main() {
	listen, err := net.Listen("tcp", ":9000")
	if err != nil {
		log.Fatalf("监听端口错误:" + err.Error())
	}

	service := grpc.NewServer()

	proto.RegisterHelloWorldServer(service, &server{})
	err = service.Serve(listen)
	if err != nil {
		fmt.Println(err.Error())
	}
}

  • 4、客户端接收错误，根据错误中的状态码提示

    func main() {

	conn, err := grpc.Dial("localhost:9000", grpc.WithInsecure())
	if err != nil {
		fmt.Println(err.Error())
		return
	}
	defer conn.Close()

	c := proto.NewHelloWorldClient(conn)
	response, err := c.SayHello(context.Background(), &proto.HelloRequest{
		Name: "admin",
	})
	if err != nil {
		str, ok := status.FromError(err)
		if !ok {
			panic("解析错误信息失败")
		}
		fmt.Println(str.Message(), "获取到的错误信息")
		fmt.Println(str.Code(), "获取到的错误code")
		fmt.Println(err.Error())
		return
	}
	fmt.Println("服务器端返回的数据" + response.Message)
}

六、超时处理

  • 1、在客户端设置一个最大时间限制

    // 设置时间
ctx, _ := context.WithTimeout(context.Background(), time.Second*3)
response, err := c.SayHello(ctx, &proto.HelloRequest{
  Name: "admin",
})

  • 2、服务器端休眠下返回数据

水痕01
关注
专栏目录
【Gin⭐010】Go语言Gin框架-返回protobuf
玉
09-07 5502
下面是gin返回protobuf对象，在client端获取出来后，用protobuf在解析出来的过程。 go语言文件 syntax = "proto3"; option go_package = "./;proto"; message Teacher{ string name = 1; repeated string course = 2; } package main import ( "net/http" "github.com/gin-gonic/gin" "awesomePro/
protobuf3 自定义option_protobuf3基础语法
weixin_39922151的博客
12-22 3311
简介ProtoBuf (Google Protocol Buffer)是由google公司用于数据交换的序列结构化数据格式，具有跨平台、跨语言、可扩展特性，同类型有常用的XML及JSON，但具有更小的传输体积、更高的编码、解码能力，特别适合于数据存储、网络数据传输等对存储体积、实时性要求高的领域，目前已经发展到protoc3 版本。优点：空间效率高，时间效率要高，对于数据大小敏感，传输效率高的缺点...
【从零开始学Skynet】高级篇（一）：Protobuf数据传输
我是一条寻水的鱼
05-13 1920
Protobuf是谷歌发布的一套协议格式，它规定了一系列的编码和解 码方法，比如对于数字，它要求根据数字的大小选择存储空间，小于等于15的数字只用1个字节来表示，大于15的数用2个字节表示，以此类推，这样要求可以尽可能地节省空间。Protobuf协议的一大特点是编码后的数据量很小，可以节省网络带宽。上图展示了用pbc模块处理Protobuf协议的流程。我们需要先编写描述文件，描述文件有它特定的格式，再用名为protoc的软件将它转换成.pb格式的文件；最后使用pbc库提供的方法实现编码解码。
转换protobuf_ProtoBuf试用与JSON的比较，高级程序员都应该看
weixin_32581787的博客
01-21 203
介绍ProtoBuf 是google团队开发的用于高效存储和读取结构化数据的工具。什么是结构化数据呢，正如字面上表达的，就是带有一定结构的数据。比如电话簿上有很多记录数据，每条记录包含姓名、ID、邮件、电话等，这种结构重复出现。同类XML、JSON 也可以用来存储此类结构化数据，但是使用ProtoBuf表示的数据能更加高效，并且将数据压缩得更小。原理Protobuf是一个网络通信协议，提供了高效率...
Protocol Buffers 1入门
xyc1211的博客
11-10 341
文章目录protocol buffers使用流程1.定义.proto文件2.proto编译器编译 实践：https://github.com/xu1211/goFrame/tree/main/protoBuf protocol buffers 谷歌官方介绍: protocol buffers 是一种语言无关、平台无关、可扩展的序列化结构数据的方法，它可用于（数据）通信协议、数据存储等。 Protocol Buffers 是一种灵活，高效，自动化机制的结构数据序列化方法－可类比 XML，但是比 XM
books-《Go语言高级编程》开源图书，涵盖CGO、Go汇编语言、RPC实现、Protobuf-advanced-go
最新发布
08-29
books_《Go语言高级编程》开源图书，涵盖CGO、Go汇编语言、RPC实现、Protobuf_advanced-go-programming-book.zip books_《Go语言高级编程》开源图书，涵盖CGO、Go汇编语言、RPC实现、Protobuf_advanced-go-...
掌握Go语言高级技巧：CGO、汇编、RPC与Protobuf
资源摘要信息:"《Go语言高级编程》是一本开源图书，涵盖了CGO、Go汇编语言、RPC实现、Protobuf等多个高级主题。CGO是Go语言的一个特性，允许开发者在Go代码中调用C语言库。Go汇编语言则是Go语言的底层语言，提供了更...
高级编程手册：《 Go语言高级编程》开源图书，涵盖CGO，Go汇编语言，RPC实现，Protobuf插件实现，Web框架实现，分布式系统等高阶主题（完稿）
02-04
Go语言高级编程（高级Go编程） Go语言QQ群：102319854，1055927514 光谷码农课堂： ://study.163.com/provider/480000001914454/index.htm 凹语言（凹读音“ Wa”）（Wa编程语言）： : 蚂蚁金服招聘云原生方向和...
Go语言RPC实践与Protobuf深度解析
本文档是一本关于计算机组成原理和Go语言编程的书籍的一部分，主要涵盖了Go语言的基础、CGO编程、汇编语言、RPC与Protobuf以及Web开发和分布式系统等主题。以下是各个章节的主要知识点： 1. **Go语言基础** - **...
Go语言RPC与Protobuf深度解析
Protobuf提供了定义数据结构的语法，然后可以生成能在各种语言中使用的代码，以便于在不同系统间交换这些结构化数据。 #### 2.1 Protobuf基本概念 理解Protobuf的.proto文件，以及如何定义消息类型和服务。 #### ...
“Protobuf入门指南：高效数据序列化的艺术与实践“
Eason_jun的博客
03-06 965
Protobuf是由Google开发的一种语言无关、平台无关、可扩展的序列化结构数据表示方法，旨在实现数据的高效序列化。这种方法不仅能确保数据包的大小尽可能小，还能保证序列化和反序列化的速度非常快。对于需要高速数据交换的应用程序来说，这一点非常关键。定义Protobuf模型的第一步是创建一个.proto文件，该文件包含了所有需要序列化的数据结构的定义。这些定义采用Protobuf特有的语法，指定了数据类型、字段名和字段编号。
Protobuf3语言指南
热门推荐
千念飞羽的专栏
01-25 12万+
定义一个消息类型 指定字段类型 分配标识号 指定字段规则 添加更多消息类型 添加注释 保留标识符（Reserved） 从.proto文件生成了什么？ 标量数值类型 默认值 枚举 使用其他消息类型 导入定义 使用proto2消息类型 嵌套类型 更新一个消息类型 Any Oneof 使用Oneof Oneof 特性 向后兼容性问题 映射（Maps） 向后兼容性问题 包（Packages） 包及
Protobuf 完整解析 - 公司最常用的数据交互协议
u013085496的博客
05-20 1175
Protobuf 完整解析 - 公司最常用的数据交互协议 Google Protocol Buffer(简称 Protobuf)是一种轻便高效的结构化数据存储格式，平台无关、语言无关、可扩展，可用于通讯协议和数据存储等领域。 数据交互xml、json、protobuf格式比较 1、json: 一般的web项目中，最流行的主要还是json。因...
笔记：关于protobuf协议传输repeated(即表/数组)类型数据出错问题。
Fanrncho的博客
09-11 1万+
err 1：假设协议是这样定义的: message protoMsg { repeated string content = 1; } 我用lua这样定义数据： local tab = {} tab[1] = "content 1" tab[2] = "content 2" tab[3] = "content 3" 服务器数据包{content = tab}通过pr
protobuf精讲
09-21
主要讲解了google protocol buffer（以下简称protobuf）在windows平台和linux平台下的编译及使用。其中涉及跨平台编译管理工具cmake的安装及使用，protobuf的使用例子及原理，以及protobuf的高级使用方法等。
Protobuf 介绍与实战34：protobuf FileOptions 文件级别 选项介绍
码二哥的技术池
03-07 2498
1  go grpc-go 相关技术专栏 总入口 2  Protobuf介绍与实战 图文专栏 文章目录 1、文件级别选项的作用 主要是对xxx.proto文件生成的不同类型的语言库文件的相关设置， 如 go语言生成的库文件类似于xxx.pb.go，文件级别选项主要作用于xxx.pb.go的相关设置 Java语言生成的库文件类似于xxx.java，文件级别选项主要作用于xxx.java的相关设置，如 设置Java类的包名， 文件名称， 默认文件的路径， proto文件里一个message类型的消息生成一个
protoBuf-go学习笔记
weixin_44627989的博客
05-13 4438
protoc-go学习笔记下载protoBuf编译器安装go专属plugin编译proto到go代码proto包名syntax声明定义message 下载protoBuf编译器 根据不同系统下载不同protoc编译器，在windows下下载windows后缀的 protoc-3.12.0-rc-1-winxxx.zip 解压后得到的目录中，bin目录中的protoc.exe就是编译protoc代码命令 Mode LastWriteTime Length Nam
protobuf入门到高手教程
targetcloud
03-28 1万+
protobuf入门教程 全称Protocol Buffers ，简称GPB、PB  ，是QQ等IM采用的协议，比XML、XMPP（环信）、JSON、结构体等所有传输效果都高的一种传输协议，由谷歌发明，其效率一般是XML XMPP的20倍以上，JSON的10倍以上，是一种游戏中普遍采用的IM消息协议，所以你非常有必要认真读一下本博文的入门教程，并运行作
Golang gRPC实践 连载三 Protobuf语法
weixin_33788244的博客
12-26 439
Protobuf语法 gRPC推荐使用proto3，本节只介绍常用语法，更多高级使用姿势请参考官方文档 Message定义 一个message类型定义描述了一个请求或相应的消息格式，可以包含多种类型字段。例如定义一个搜索请求的消息格式，每个请求包含查询字符串、页码、每页数目。 syntax = "proto3"; message Sea...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

水痕01

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值