golang grpc初体验

Source

grpc 是一个高性能、开源和通用的 RPC 框架,面向服务端和移动端,基于 HTTP/2 设计。目前支持c、java和go,分别是grpc、grpc-java、grpc-go,目前c版本支持c、c++、node.js、ruby、python、objective-c、php和c#。grpc官网 grpc-go
在这里插入图片描述
ProtoBuf(全称Protocol Buffer)是数据结构序列化和反序列化框架,ProtoBuf是Google推出的一款轻量高效的数据化数据存储格式,性能比json、xml强,ProtoBuf经历了ProtoBuf2和ProtoBuf3,ProtoBuf3比ProtoBuf简化了很多,目前主流的是ProtoBuf3.
优点:
1.性能:压缩性好、序列化和反序列化快(比xml和json快2-100倍)、传输速度快
2.便捷性:使用简单(自动生成序列化和反序列化代码)、维护成本低(只支持proto文件)、向后兼容(不必破坏旧格式)、加密型号
3.跨语言:跨平台、支持各种主流语言
缺点:
1.通用性差:json可以任何语言都支持,但是protobuf需要专门的解析库
2.自解释性差:只有通过proto文件才能了解数据结构
protoBuf安装并配置环境变量官网
1.编辑环境变量文件‌:vim ~/.zshrc
‌2.添加环境变量‌:

export PATH="$PATH:/usr/local/go/src/GolangStudy/protoc-28.2-osx-x86_64/bin"

3.使配置生效‌:保存并关闭编辑器后,在终端中输入source ~/.zshrc
命令,使更改生效。
4.验证

 protoc --version

安装protoBuf的go依赖包

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

helloworld.proto

syntax = "proto3";

// 生成 proto 文件所在包路径
package protos;
// 影响go文件生成位置和包名
option go_package = "GolangStudy/Introduction/grpc/protos";
message HelloRquest{
    
      
    string name=1;//1是编号不是值
}

项目目录结构
在这里插入图片描述
转换命令(第一种命令使用grpc,会比第二种多很多)

protoc --go_out=. --go_opt=paths=source_relative --go-grpc_out=. --go-grpc_opt=paths=source_relative helloworld.proto 
protoc --go_out=/usr/local/go/src/GolangStudy/GolangStudy --proto_path=/usr/local/go/src/GolangStudy/GolangStudy/Introduction/grpc/protos --go_opt=module=GolangStudy helloworld.proto

调用并比较跟json格式的区别

package main

import (
	"GolangStudy/Introduction/grpc/protos"
	"encoding/json"
	"fmt"

	"github.com/golang/protobuf/proto"
)

type Hello struct {
    
      
	Name string `json:"name"`
}

func main() {
    
      
	req := protos.HelloRquest{
    
      
		Name: "bobby",
	}
	jsonStruct := Hello{
    
      Name: "bobby"}
	jsonRsp, _ := json.Marshal(jsonStruct)
	fmt.Println(len(string(jsonRsp)))
	rsp, _ := proto.Marshal(&req)
	fmt.Println(len(string(rsp)))
}

json长度是15,而protobuf长度是7

grpc四种数据流

简单模式(simple rpc):客户端发起一次请求,服务端响应一个数据
服务端数据流模式(server-side streaming rpc):客户端发起一次请求,服务端返回一段连续的数据流。(客户端向服务端发送一个股票代码,服务端就把该股票的实时数据源源不断的返回给客户端)
客户端数据流模式(client-side streaming rpc):客户端源源不断的项向服务端发送数据流,而在发送结束后,由服务器返回一个响应(物流网终端向服务器报送数据)
双向数据流模式(bidirectional streaming rpc):客户端和服务端都可以向双方发送数据流,双方的数据可以同时互相发送,可以实现实时交互(聊天机器人)

grpc简单模式

目录结构
在这里插入图片描述

proto代码

syntax = "proto3";

// 生成proto文件所在包路径
package protos;
option go_package = ".;proto";
// 影响go文件生成位置和包名
service Greeter{
    
      
    rpc SayHello(HelloRquest)returns(HelloReply);//hello接口
}
message HelloRquest{
    
      
    string name=1;//1是编号不是值
}
message HelloReply{
    
      
    string message=1;
}

生成go文件

protoc --go_out=. --go_opt=paths=source_relative --go-grpc_out=. --go-grpc_opt=paths=source_relative helloworld.proto

使用接口删除这一行(可能是生成方式的问题)
在这里插入图片描述
server端

package main

import (
	"GolangStudy/Introduction/grpc/example2/proto"
	"context"
	"net"

	"google.golang.org/grpc"
)

type Server struct {
    
      
}

func (s *Server) SayHello(ctx context.Context, request *proto.HelloRquest) (*proto.HelloReply, error) {
    
      
	return &proto.HelloReply{
    
      
		Message: "helo" + request.Name,
	}, nil
}
func main() {
    
      
	g := grpc.NewServer()
	proto.RegisterGreeterServer(g, &Server{
    
      })
	lis, err := net.Listen("tcp", "0.0.0.0:8080")
	if err != nil {
    
      
		panic("failed to listen:" + err.Error())
	}
	err = g.Serve(lis)
	if err != nil {
    
      
		panic("failed to start ")
	}
}

client端

package main

import (
	"GolangStudy/Introduction/grpc/example2/proto"
	"context"
	"fmt"

	"google.golang.org/grpc"
)

func main() {
    
      
	conn, err := grpc.Dial("127.0.0.1:8080", grpc.WithInsecure())
	if err != nil {
    
      
		panic(err)
	}
	defer conn.Close()
	c := proto.NewGreeterClient(conn)
	r, err := c.SayHello(context.Background(), &proto.HelloRquest{
    
      
		Name: "bobby",
	})
	if err != nil {
    
      
		panic(err)
	}
	fmt.Println(r.Message)
}

grpc流模式

proto

syntax = "proto3";

// 生成proto文件所在包路径
package protos;
option go_package = ".;proto";
// 影响go文件生成位置和包名
service Greeter{
    
      
    rpc GetStream(StreamReqData)returns(stream SteramResData);//服务端流模式
    rpc PostStream(stream StreamReqData)returns(stream SteramResData);//客户端流模式
    rpc AllStream(stream StreamReqData)returns(stream SteramResData);//双向流模式
}
message StreamReqData{
    
      
    string data=1;
}
message SteramResData{
    
      
    string data=1;
}

生成go文件

 protoc --go_out=. --go_opt=paths=source_relative --go-grpc_out=. --go-grpc_opt=paths=source_relative stream.proto

删除
在这里插入图片描述
server

package main

import (
	"GolangStudy/Introduction/grpc/stream_grpc_test/proto"
	"fmt"
	"net"
	"sync"
	"time"

	"google.golang.org/grpc"
)

const PORT = ":50052"

type server struct {
    
      
}

func (s *server) GetStream(req *proto.StreamReqData, res proto.Greeter_GetStreamServer) error {
    
      
	i := 0
	for {
    
      
		i++
		_ = res.Send(&proto.SteramResData{
    
      
			Data: fmt.Sprintf("%v", time.Now().Unix()),
		})
		time.Sleep(time.Second)
		if i > 10 {
    
      
			break
		}
	}
	return nil
}
func (s *server) PostStream(cliStr proto.Greeter_PostStreamServer) error {
    
      
	for {
    
      
		if a, err := cliStr.Recv(); err != nil {
    
      
			fmt.Println(err)
			break
		} else {
    
      
			fmt.Println(a.Data)
		}
	}
	return nil
}
func (s *server) AllStream(allStr proto.Greeter_AllStreamServer) error {
    
      
	wg := sync.WaitGroup{
    
      }
	wg.Add(2)
	go func() {
    
      
		defer wg.Done()
		for {
    
      
			data, _ := allStr.Recv()
			fmt.Println("收到客户端消息:" + data.Data)
		}
	}()
	go func() {
    
      
		defer wg.Done()
		for {
    
      
			allStr.Send(&proto.SteramResData{
    
      
				Data: "我是服务器",
			})
			time.Sleep(time.Second)
		}
	}()
	wg.Wait()
	return nil
}
func main() {
    
      
	lis, err := net.Listen("tcp", PORT)
	if err != nil {
    
      
		panic(err)
	}
	s := grpc.NewServer()
	proto.RegisterGreeterServer(s, &server{
    
      })
	err = s.Serve(lis)
	if err != nil {
    
      
		panic("failed to start ")
	}
}

client

package main

import (
	"GolangStudy/Introduction/grpc/stream_grpc_test/proto"
	"context"
	"fmt"
	"sync"
	"time"

	"google.golang.org/grpc"
)

func main() {
    
      
	conn, err := grpc.Dial("127.0.0.1:50052", grpc.WithInsecure())
	if err != nil {
    
      
		panic(err)
	}
	defer conn.Close()
	//服务端流模式
	// c := proto.NewGreeterClient(conn)
	// res, _ := c.GetStream(context.Background(), &proto.StreamReqData{Data: "mooc"})
	// for {
    
      
	// 	a, err := res.Recv() //socket编程send recv
	// 	if err != nil {
    
      
	// 		fmt.Println(err)
	// 		break
	// 	}
	// 	fmt.Println(a)

	// }

	// //客户端流模式
	// c := proto.NewGreeterClient(conn)
	// putS, _ := c.PostStream(context.Background())
	// i := 0
	// for {
    
      
	// 	i++
	// 	_ = putS.Send(&proto.StreamReqData{
    
      
	// 		Data: fmt.Sprintf("mooc%d", i),
	// 	})
	// 	time.Sleep(time.Second)
	// 	if i > 10 {
    
      
	// 		break
	// 	}
	// }

	//双向流模式
	c := proto.NewGreeterClient(conn)
	allStr, _ := c.AllStream(context.Background())
	wg := sync.WaitGroup{
    
      }
	wg.Add(2)
	go func() {
    
      
		defer wg.Done()
		for {
    
      
			data, _ := allStr.Recv()
			fmt.Println("收到服务器消息:" + data.Data)
		}
	}()
	go func() {
    
      
		defer wg.Done()
		for {
    
      
			allStr.Send(&proto.StreamReqData{
    
      
				Data: "我是客户端",
			})
			time.Sleep(time.Second)
		}
	}()
	wg.Wait()
}