文章目录注意:阅读开始前,请确保有grpc相关基础,新手向,使用各种实战方式来学习grpc
- Golang中grpc入门
- 一、grpc的四种调用模式
- 1.1、准备工作
- 编写proto文件
- 生成grpc-go文件
- 1.2、单向调用
- 服务端实现单向调用
- 客户端实现单向调用
- 1.3、客户端流模式
- 服务端实现单向客户端流模式调用
- 客户端实现单向客户端流模式调用
- 1.4、服务端流模式
- 服务端实现单向服务端流模式调用
- 客户端实现单向服务端流模式调用
- 1.5、双向流模式
- 服务端实现双向流模式调用
- 客户端实现双向流模式调用
- 二、grpc中的metadata
- 客户端
- 服务端
syntax = "proto3";
// 服务端流模式
option go_package = "./;streamprotodemo";
service Greeter {
rpc Single(StreamReqData) returns (StreamResData); //单向调用
rpc GetStream(StreamReqData) returns (stream StreamResData); // 服务端流模式
rpc PutStream(stream StreamReqData) returns (StreamResData); // 客户端流模式
rpc AllStream(stream StreamReqData) returns (stream StreamResData); // 双向流模式
}
message StreamReqData {
string data =1 ;
}
message StreamResData {
string data =1 ;
}
生成grpc-go文件
命令如下:
protoc -I . --go_out=. stream.proto --go-grpc_out=. stream.proto1.2、单向调用
首先我们初始化一个client对象,以及请求体对象
client := streamprotodemo.NewGreeterClient(conn)
StreamReqData := streamprotodemo.StreamReqData{
Data: "chenteng",
}
服务端实现单向调用
func (s * server)Single(ctx context.Context,req *streamprotodemo.StreamReqData) (*streamprotodemo.StreamResData,error){
fmt.Println("server Single 被调用")
return &streamprotodemo.StreamResData{
Data: req.Data +"from server",
},nil
}
客户端实现单向调用
func Single(client streamprotodemo.GreeterClient,StreamReqData *streamprotodemo.StreamReqData){
StreamReqData.Data = "client single func "
res ,err := client.Single(context.Background(),StreamReqData)
if err != nil {
log.Fatalln("single call fail ",err)
}
fmt.Println("Single call res :",res)
}
1.3、客户端流模式
服务端实现单向客户端流模式调用
func (s *server) PutStream(clientdata streamprotodemo.Greeter_PutStreamServer) error {
fmt.Println("server PutStream 被调用")
for {
a, err := clientdata.Recv()
if err != nil {
log.Println(err)
break
}
fmt.Println(a)
}
return nil
}
客户端实现单向客户端流模式调用
func PutStream(client streamprotodemo.GreeterClient,StreamReqData *streamprotodemo.StreamReqData){
putres ,_ := client.PutStream(context.Background())
for i:=0;i<10;i++ {
StreamReqData.Data = fmt.Sprintf("NO:%d, 客户端流模式",i)
fmt.Println("向服务端发送",StreamReqData.Data)
err := putres.Send(StreamReqData)
if err != nil {
log.Fatalln("向服务端发送数据失败",err)
}
}
}
1.4、服务端流模式
服务端实现单向服务端流模式调用
func (s *server) GetStream(req *streamprotodemo.StreamReqData, res streamprotodemo.Greeter_GetStreamServer) error {
fmt.Println("server GetStream 被调用")
for i:=0;i<10;i++{
err := res.Send(&streamprotodemo.StreamResData{
Data: fmt.Sprintf("%v", time.Now().Unix()),
})
if err != nil {
log.Fatalln("send err", err)
}
time.Sleep(time.Second)
}
return nil
}
客户端实现单向服务端流模式调用
func GetStream(client streamprotodemo.GreeterClient,StreamReqData *streamprotodemo.StreamReqData){
//服务端流模式
res,_ := client.GetStream(context.TODO(),StreamReqData)
for {
data ,err := res.Recv()
if err != nil {
if err == io.EOF {
fmt.Println("服务端传输结束")
break
}
log.Fatalln(err)
}
fmt.Println(data)
}
}
1.5、双向流模式
服务端实现双向流模式调用
func (s *server) AllStream(alldata streamprotodemo.Greeter_AllStreamServer) error {
fmt.Println("server AllStream 被调用")
wg := sync.WaitGroup{}
wg.Add(2)
defer wg.Wait()
go func() {
defer wg.Done()
for i:=0;i<10;i++ {
data,_ := alldata.Recv()
fmt.Println("AllStream收到客户端消息",data)
}
}()
go func() {
defer wg.Done()
for i:=0;i<10;i++ {
_ = alldata.Send(&streamprotodemo.StreamResData{
Data: "我是服务器",
})
time.Sleep(time.Second)
}
}()
return nil
}
客户端实现双向流模式调用
func AllStream(client streamprotodemo.GreeterClient,StreamReqData *streamprotodemo.StreamReqData){
//双向流模式
allstream , _ := client.AllStream(context.Background())
wg := sync.WaitGroup{}
wg.Add(2)
defer wg.Wait()
go func() {
defer wg.Done()
for i:=0;i<10;i++ {
StreamResData,_ := allstream.Recv()
fmt.Println("AllStream收到服务端消息",StreamResData.Data)
}
}()
go func() {
defer wg.Done()
StreamReqData.Data = "AllStream:我是客户端"
for i:=0;i<10;i++ {
_ = allstream.Send(StreamReqData)
time.Sleep(time.Second)
}
}()
}
二、grpc中的metadata
客户端
func main(){
//md := metadata.Pairs("timestamp",time.Now().Format(timeformat))
lis ,_ := grpc.Dial("127.0.0.1:8081",grpc.WithInsecure())
client := metadatademo.NewHelloServiceClient(lis)
req := metadatademo.HelloRequest{Name: "chenteng"}
md := metadata.New(map[string]string{
"name":"chenteng",
})
ctx := metadata.NewOutgoingContext(context.Background(),md)
res,_ := client.SayHello(ctx,&req)
fmt.Println(res.Message)
}
服务端
func (h *HelloServer)SayHello(ctx context.Context,req *metadatademo.HelloRequest) (*metadatademo.HelloReply,error){
md , ok := metadata.FromIncomingContext(ctx)
if !ok {
fmt.Println("获取md失败")
}
if name,ok := md["name"];ok {
fmt.Println(name[0])
}
//for key,val := range md {
// fmt.Println(key,val)
//}
return &metadatademo.HelloReply{
Message: "Hello " + req.Name,
},nil
}



