栏目分类:
子分类:
返回
名师互学网用户登录
快速导航关闭
当前搜索
当前分类
子分类
实用工具
热门搜索
名师互学网 > IT > 软件开发 > 后端开发 > Java

Go语言使用GRPC由浅入深

Java 更新时间: 发布时间: IT归档 最新发布 模块sitemap 名妆网 法律咨询 聚返吧 英语巴士网 伯小乐 网商动力

Go语言使用GRPC由浅入深

Golang中grpc入门

注意:阅读开始前,请确保有grpc相关基础,新手向,使用各种实战方式来学习grpc

文章目录
  • Golang中grpc入门
    • 一、grpc的四种调用模式
      • 1.1、准备工作
        • 编写proto文件
        • 生成grpc-go文件
      • 1.2、单向调用
        • 服务端实现单向调用
        • 客户端实现单向调用
      • 1.3、客户端流模式
        • 服务端实现单向客户端流模式调用
        • 客户端实现单向客户端流模式调用
      • 1.4、服务端流模式
        • 服务端实现单向服务端流模式调用
        • 客户端实现单向服务端流模式调用
      • 1.5、双向流模式
        • 服务端实现双向流模式调用
        • 客户端实现双向流模式调用
    • 二、grpc中的metadata
      • 客户端
      • 服务端

一、grpc的四种调用模式 1.1、准备工作 编写proto文件
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.proto
1.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
}
转载请注明:文章转载自 www.mshxw.com
本文地址:https://www.mshxw.com/it/939363.html
我们一直用心在做
关于我们 文章归档 网站地图 联系我们

版权所有 (c)2021-2022 MSHXW.COM

ICP备案号:晋ICP备2021003244-6号