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()
}
