golang工程——grpc一元请求与流请求

最新推荐文章于 2024-05-13 06:22:03 发布
最新推荐文章于 2024-05-13 06:22:03 发布
阅读量295 收藏
点赞数
文章标签： golang 开发语言 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43058348/article/details/133341410
版权

唉，难顶，像块砖一样到处搬。又跑去golang技术栈的项目俩月
本篇博客多有参考，记录一下近期学习

rpc、grpc原理

grpc 是一项进程间通信技术，可以用来连接、调用、操作和调试构建分布式程序，调用过程如同调用函数一样，整个过程操作起来很简单，就像调用本地方法一样。与许多rpc 系统一样，grpc 是定义服务的思想，服务器需要实现此接口并运行grpc 来处理客户端调用。

在这里插入图片描述

grpc 默认使用 Protocol Buffers 作为 IDL 定义服务接口。 Protocol Buffers 是中立的、与平台无关、实现结构化数据序列化的可扩展机制，虽然也可以使用json，但是 Protocol Buffers 是二进制编解码，所以编解码性能比Json好。服务接口定义在 proto 文件中指定，也就是在扩展名为 “. proto” 的普通文本文件中。我们要按照普通的 Protocol Buffers 范式来定义grpc服务，并将方法参数和返回类型指定为 Protocol buffers 的格式，也因为服务定义是Protocol Buffers 规范的扩展，所以可以借助特殊的 gRPC 插件来根据 proto 文件生成代码。

grpc常用通信模式

一元rpc模式

类似http 协议一问一答

服务端数据流模式

这种流模式可以理解为，服务器向客户端源源不断的发送数据流，应用场景很多，比如游戏中定时任务或者其他事件造成玩家数据变化需要将数据推送给客户端。

一元rpc模式下，grpc服务器端和 grpc 客户端在通信时始终只有 一个请求和 一个响应。在服务器端流rpc 模式下，服务端接收到一个请求后发送多个响应组成的序列，在服务器发送所有响应消息完毕后，发送trailer 元数据给客户端，标识流结束。

客户端接收流数据需要循环接收，直到出现io.EOF,代表服务器发送流数据已经完毕，后面会写grpc实现这个功能的原理

客户端数据流模式

客户端可以将数据源源不断发送给服务器，跟服务端流相反，客户端会发送多条响应，服务器发送一条响应，但是服务器不必等到发送完所有消息才响应。可以发送一条或几条消息就开始响应。

下面来看一个例子：物联网硬件将本地的缓存信息上传到服务器

  • 服务器需要以流的方式去接收数据，当客户端关闭流的时候会返回io.EOF，这时候我们可以做响应。
双向数据流模式

双方都可以将数据源源不断发给对方。简单来说就是上面客户端流和服务器流的一个整合。

下面来看一个例子：玩家连续进行了多次战斗请求，服务器将操作结果响应给玩家

  • 服务器读到客户端流关闭时返回nil，标记服务器流结束。

  • 与之前客户端流模式不一样，客户端流模式是直接sendAndClose()。下面这样读到一半数据返回nil，也标识服务器流数据结束，只是可能会丢数据

  • 启动一个协程异步接收数据，官方有说明，一个goroutine 读，一个goroutine 写是不会有并发问题的。

  • stream.CloseSend()代表关闭客户端流，标记客户端流已经结束

  • 客户端需要通过定义rpc方法c.DataUpload(ctx)打开流，然后通过send 发送请求，发送完后调用CloseAndRecv关闭流等待消息响应，并处理错误，这里为了demo 演示 ,err就直接panic，实际情况可能更加复杂，对错误处理也很多种方式。

四种通信模式例子

例子

echo.proto

syntax = "proto3";
option go_package = "grpc/echo";
import  "google/protobuf/timestamp.proto";
package grpc.echo;

message EchoRequest {
  string message = 1;
  bytes bytes = 2;
  int32 length = 3;
  google.protobuf.Timestamp time = 4;

}
message EchoResponse {
  string message = 1;
  bytes bytes = 2;
  int32 length = 3;
  google.protobuf.Timestamp time = 4;
}

service Echo {
  //一元请求
  rpc UnaryEcho(EchoRequest) returns(EchoResponse) {}
  //服务端流
  rpc ServerStreamingEcho(EchoRequest) returns(stream EchoResponse){}
  //客户端流
  rpc ClientStreamingEcho(stream EchoRequest) returns( EchoResponse){}
  //双向流
  rpc BidirectionalStreamingEcho(stream EchoRequest) returns(stream EchoResponse){}
}

服务端
server.go

package server

import (
    "context"
    "fmt"
    "google.golang.org/protobuf/types/known/timestamppb"
    "grpc/echo"
    "io"
    "log"
    "os"
    "strconv"
    "sync"
    "time"
)


type EchoServer struct {
    echo.UnimplementedEchoServer
}
func (EchoServer) UnaryEcho(ctx context.Context, in *echo.EchoRequest) (*echo.EchoResponse, error) {
    fmt.Printf("server recv :%v\n", in.Message)

    return &echo.EchoResponse{
        Message: "server send message",
    }, nil
}
//服务端流，发送文件
func (EchoServer) ServerStreamingEcho(in *echo.EchoRequest, stream echo.Echo_ServerStreamingEchoServer) error {
    fmt.Printf("server recv :%v\n", in.Message)
    filePath := "echo-server-practice/files/server.jpg"

    file, err := os.Open(filePath)
    if err != nil {
        log.Fatal(err.Error())
    }
    defer file.Close()

    buf := make([]byte, 1024)

    for {
        n, err := file.Read(buf)
        if err == io.EOF {
            break
        }
        if err != nil {
            return err
        }

        stream.Send(&echo.EchoResponse{
            Message: "server sending files",
            Bytes: buf[:n],
            Time: timestamppb.New(time.Now()),
            Length: int32(n),
        })
    }
    //服务端流结束 return nil
    return nil
}
//客户端流，接收文件
func (EchoServer) ClientStreamingEcho(stream echo.Echo_ClientStreamingEchoServer) error {

    filePath := "echo-server-practice/files/" + strconv.FormatInt(time.Now().UnixMilli(), 10) + ".jpg"

    file, err := os.OpenFile(filePath, os.O_CREATE|os.O_APPEND|os.O_WRONLY, 0644)

    if err != nil {
        log.Fatal(err)
        return err
    }
    defer file.Close()

    for {
        res, err := stream.Recv()
        if err == io.EOF {
            break
        }

        if err != nil {
            log.Println(err)
            return err
        }
        file.Write(res.Bytes[:res.Length])
        fmt.Printf("server recv :%v\n", res.Message)

    }
    err = stream.SendAndClose(
        &echo.EchoResponse{
            Message: "server send complete",
        })
    return err
}
//双向流，互发文件
func (EchoServer) BidirectionalStreamingEcho(stream echo.Echo_BidirectionalStreamingEchoServer) error {

    wg := &sync.WaitGroup{}

    wg.Add(1)
    go func () {
        defer wg.Done()
        //接收客户端文件

        filePath := "echo-server-practice/files/" + strconv.FormatInt(time.Now().UnixMilli(), 10) + ".jpg"

        file, err := os.OpenFile(filePath, os.O_CREATE|os.O_APPEND|os.O_WRONLY, 0644)

        if err != nil {
            log.Fatal(err)
        }
        defer file.Close()

        for {
            res, err := stream.Recv()
            if err == io.EOF {
                break
            }

            if err != nil {
                log.Println(err)
                return
            }
            file.Write(res.Bytes[:res.Length])
            fmt.Printf("server recv :%v\n", res.Message)

        }
    }()

    wg.Add(1)

    go func() {
        defer wg.Done()
        // 发文件
        filePath := "echo-server-practice/files/server.jpg"

        file, err := os.Open(filePath)
        if err != nil {
            log.Fatal(err.Error())
        }
        defer file.Close()

        buf := make([]byte, 1024)

        for {
            n, err := file.Read(buf)
            if err == io.EOF {
                break
            }
            if err != nil {
                log.Fatal(err)
                return
            }

            stream.Send(&echo.EchoResponse{
                Message: "server sending files",
                Bytes: buf[:n],
                Time: timestamppb.New(time.Now()),
                Length: int32(n),
            })
        }
    } ()
    wg.Wait()
    // 服务端流关闭
    return nil
}

main.go

package main

import (
    "flag"
    "fmt"
    "google.golang.org/grpc"
    "grpc/echo"
    "grpc/echo-server-practice/server"
    "log"
    "net"
)

var (
    port = flag.Int("port", 50053, "port")
)

func main() {
    flag.Parse()

    lis, err := net.Listen("tcp", fmt.Sprintf(":%d", *port))

    if err != nil {
        log.Fatal(err)
    }

    // grpc server
    s := grpc.NewServer()
    echo.RegisterEchoServer(s, &server.EchoServer{})

    log.Printf("server listening at : %v\n", lis.Addr())

    if err := s.Serve(lis); err !=nil {
        log.Fatal(err)
    }

}

客户端
client.go

package client

import (
    "fmt"
    "golang.org/x/net/context"
    "google.golang.org/protobuf/types/known/timestamppb"
    "grpc/echo"
    "io"
    "log"
    "os"
    "strconv"
    "sync"
    "time"
)
//一元请求
func CallUnary(client echo.EchoClient) {
    ctx, cancel := context.WithTimeout(context.Background(), time.Second)

    defer cancel()
    in := &echo.EchoRequest{
        Message: "client send message",
        Time: timestamppb.New(time.Now()),
    }

    res, err := client.UnaryEcho(ctx, in)
    if err != nil {
        log.Fatal(err)
    }

    fmt.Printf("client recv: %v", res.Message)

}
//服务端流
func CallServerStream(client echo.EchoClient) {
    ctx, cancel := context.WithTimeout(context.Background(), time.Second)

    defer cancel()
    in := &echo.EchoRequest{
        Message: "client send message",
        Time: timestamppb.New(time.Now()),
    }

    stream, err := client.ServerStreamingEcho(ctx, in)

    if err != nil {
        log.Fatal(err)
    }

    filename := "echo-client-practice/files/" + strconv.FormatInt(time.Now().UnixMilli(), 10) + ".jpg"

    file, err := os.OpenFile(filename, os.O_CREATE|os.O_APPEND|os.O_WRONLY, 0644)

    if err != nil {
        log.Fatal(err)
        return
    }
    defer file.Close()

    for {
        res, err := stream.Recv()
        if err == io.EOF {
            break
        }

        if err != nil {
            log.Println(err)
            break
        }

        file.Write(res.Bytes[:res.Length])
        fmt.Printf("client recv %v\n", res.Message)
    }
    stream.CloseSend()
}
//客户端流
func CallClientSteam(client echo.EchoClient) {
    // 客户端流
    filePath := "echo-client-practice/files/client.jpg"

    file, err := os.Open(filePath)
    if err != nil {
        log.Fatal(err)
    }

    defer file.Close()

    ctx, cancel := context.WithTimeout(context.Background(), time.Second)

    defer cancel()

    stream, err := client.ClientStreamingEcho(ctx)

    if err != nil {
        log.Fatal(err)
    }

    buf := make([]byte, 1024)

    for {
        n, err := file.Read(buf)

        if err == io.EOF {break}
        if err != nil {
            log.Fatal(err)
        }

        stream.Send(&echo.EchoRequest{
            Message: "client sending file",
            Bytes: buf,
            Length: int32(n),
            Time: timestamppb.New(time.Now()),
        })

    }

    res, err := stream.CloseAndRecv()
    if err != nil {
        log.Fatal(err)
    }

    fmt.Printf("client recv : %v\n", res.Message)
}
// 双向流发文件
func CallBidirectional(client echo.EchoClient) {

    // 发送文件
    ctx, cancel := context.WithTimeout(context.Background(), 10 * time.Second)

    defer cancel()

    stream, err := client.BidirectionalStreamingEcho(ctx)
    if err != nil {
        log.Fatal(err)
    }

    wg := &sync.WaitGroup{}
    wg.Add(1)

    go func() {
        defer wg.Done()
        filePath := "echo-client-practice/files/client.jpg"

        file, err := os.Open(filePath)
        if err != nil {
            log.Fatal(err)
        }

        defer file.Close()

        buf := make([]byte, 1024)

        for {
            n, err := file.Read(buf)

            if err == io.EOF {break}
            if err != nil {
                log.Fatal(err)
            }

            stream.Send(&echo.EchoRequest{
                Message: "client sending file",
                Bytes: buf,
                Length: int32(n),
                Time: timestamppb.New(time.Now()),
            })
        }
        stream.CloseSend()
    }()

    wg.Add(1)

    go func() {
        //接收文件
        defer wg.Done()
        filename := "echo-client-practice/files/" + strconv.FormatInt(time.Now().UnixMilli(), 10) + ".jpg"

        file, err := os.OpenFile(filename, os.O_CREATE|os.O_APPEND|os.O_WRONLY, 0644)

        if err != nil {
            log.Fatal(err)
            return
        }
        defer file.Close()

        for {
            res, err := stream.Recv()
            if err == io.EOF {
                break
            }

            if err != nil {
                log.Println(err)
                break
            }

            file.Write(res.Bytes[:res.Length])
            fmt.Printf("client recv %v\n", res.Message)
        }
    }()
    wg.Wait()
}

main.go

package main

import (
    "flag"
    "google.golang.org/grpc"
    "google.golang.org/grpc/credentials/insecure"
    "grpc/echo"
    "grpc/echo-client-practice/client"
    "log"
)

var (
    addr = flag.String("host", "localhost:50053", "")
)




func main() {
    flag.Parse()

    conn, err := grpc.Dial(*addr, grpc.WithTransportCredentials(insecure.NewCredentials()))

    if err != nil {
        log.Fatal(err)
    }

    defer conn.Close()
    c := echo.NewEchoClient(conn)

    //client.CallUnary(c)

   // client.CallServerStream(c)
  //client.CallClientSteam(c)
  client.CallBidirectional(c)
}
咚伢
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
15. 【gRPC系列学习】gRPC四种通信模式：一元RPC、客户端流RPC、服务端流RPC、双向流RPC
菜鸟的博客
12-22 1084
gRPC四种通信模式
详解golang consul-grpc 服务注册与发现
09-20
总的来说，golang consul-grpc服务注册与发现通过整合Golang语言特性、Consul服务治理能力以及GRPC高效通信机制，提供了一套适用于分布式系统的高效、透明的服务管理解决方案。通过这种机制，可以大大简化服务维护的...
智能高效的Go IDE——GoLand v2023.1全新发布，引入gRPC 导航
需要界面开发、IDE工具研发中文教程资料的小伙伴，记得私信我~
05-15 875
智能高效的IDE——GoLand v2023.1全新发布，引入了漏洞检查器、gRPC 代码中更好的导航，以及针对泛型接收器的 Rename（重命名）重构，欢迎下载最新版体验~
Golang:一个服务同时处理普通http请求和gRPC请求
Nice To Come Here
07-06 818
【代码】Golang:一个服务同时处理普通http请求和gRPC请求。
最全1，2024年最新实现原理分析
最新发布
2401_84904308的博客
05-13 657
RPC是的简称，中文叫远程过程调用，简单的说，就是调用远程方法和调用本地方法一样那么grpc就是由google开发的一个高性能、通用的开源RPC框架gRPC是一种现代开源高性能远程过程调用(RPC)框架，可在任何环境中运行。它可以高效地连接数据中心内的服务，并支持负载平衡、跟踪、健康检查和身份验证等插件功能。它适用于分布式计算的最后一英里，以连接设备、移动应用程序和浏览器到后端服务。公司已使用gRPC连接其环境中的多个服务，从连接少数服务到跨多种语言的数据中心内数百种服务。
golang工程组件篇:高性能RPC框架gRPC之一元请求和流式请求
SMILY12138的博客
05-23 375
gRPC 支持一元请求和流式请求两种方式来实现远程过程调用。一元请求是指客户端发送一个请求，并且服务器返回一个响应；流式请求是指客户端发送多个请求，并且服务器通过一系列响应进行回应。在实现 gRPC 客户端时，我们可以通过调用自动生成的代码中的方法来发送一元请求或者流式请求并接收响应。
golang 微服务之gRPC与Protobuf的使用
09-17
gRPC与Protobuf是现代微服务架构中常用的技术栈，尤其在Golang开发中占据着重要地位。本文将深入探讨这两个概念以及它们在实际应用中的优势。 首先，RPC（Remote Procedure Call）是一种让程序可以在分布式环境中像...
golang写的grpc实例demo
10-25
在本文中，我们将深入探讨如何使用Golang实现gRPC服务的实例。gRPC是一个由Google开发的现代开源RPC（远程过程调用）框架，它基于HTTP/2协议，支持多种编程语言，包括Golang。其设计目标是提供高性能、安全、可扩展...
Golang实现请求限流的几种办法(小结)
09-18
在Golang中，请求限流是一种关键的技术，用于保护系统免受过高的并发请求压力，防止资源耗尽，保证服务的稳定性和可用性。本文将深入探讨几种实现请求限流的方法，并通过示例代码进行详细解释。 1. 利用Channel的...
2. 【gRPC系列学习】 创建一元gRPC的客户端与服务端
菜鸟的博客
12-21 686
编写proto文件，安装protoc，编译为pb文件，编写客户端代码，服务端代码，解析pb文件中ServiceDesc字段含义及用法
第五节——实现一元GRPC
分享简单的安全技术
04-05 395
第五章——使用一元GRPC传递pcbook 5.1、定义一个 proto 服务和一个一元 RPC 创建新文件——proto/laptop_service.proto 定义一条CreateLaptopRequest消息，它只包含一个字段：我们要创建的笔记本电脑 message CreateLaptopRequest { Laptop laptop = 1; } 定义CreateLaptopResponse消息也只有 1 个字段：创建的笔记本电脑的 ID message CreateLaptopR
gRPC（四）基础：gRPC流
林钟一的博客
11-03 2032
这章的内容需要安装好插件和protoc，建议阅读我的上一篇grpc使用篇点击跳转点击跳转我们先把基础的模板和空定义写出来在进行完善，不太懂的看我上一篇文章。
golang 调用php,grpc套路（四）php通过grpc调用golang的grpc接口服务
weixin_39840153的博客
03-09 518
如果看到这篇文章你还搞不明白为什么不直接使用 http, 而要搞 rpc?那么请看我的另一篇博客：什么是rpc?你会彻底搞明白为啥这个？为啥那个？如果还不懂那我也没办法了！我们开发过程当中可能不仅涉及到一门语言，比如php java golang 在同一个项目当中都运用了，当然这可能是个非常大的项目，但是考虑到项目的可维护性三者同时出现的可能性还是比较低的，但是涉及到大型项目比如涉及到微服务架...
golang中使用grpc服务Demo
SHELLCODE_8BIT的博客
02-17 4816
1、安装protobuf grpc使用protobuf作为IDL(interface descriton language)，且要求protobuf 3.0以上，这里我们直接选用当前最新版本 3.8，git下载地址。 选择操作系统对应的版本下载，这里我们直接使用已经编译好的protoc可执行文件（或者下载安装包编译安装）。 1 2 3 4 5 6 wget https://github.com/protocolbuffers/pro
golang grpc使用
qq_29295329的博客
10-05 718
golang grpc使用
gRPC的四种调用方式 go-demo
weixin_35691937的博客
11-30 821
gRPC的四种调用方式 一元调用 普通的rpc调用，客户端传递对象，服务器返回对象 服务器发送流调用 客户端发送请求对象，服务器返回流式对象 客户端流式调用 客户端发送流式对象，服务器返回一个对象 双向流式调用 客户端发送流式对象，服务器返回流式对象 demo proto syntax = "proto3"; package objectStorageService; service ObjectStorageService{ rpc GetData(ReqData) returns(RepDa
.net core gRPC 一元，流通信 --- （单工 双工）
iml6yu的博客
11-07 1256
文章目录一元调用客户端流模式双向流模式服务端流模式 #.NET 客户端调用 gRPC 服务的四种通信方式 一元调用 客户端流模式 双向流模式 服务端流模式 一元调用 一元调用从客户端发送请求消息开始。 服务完成后，将返回响应消息。 客户端流模式 客户端流式处理调用在客户端发送消息的情况下启动。 客户端可以选择发送发送消息RequestStream.WriteAsync。 当客户端已经完成发送消...
gRPC 的 4 种基础通信模式
图灵教育
02-18 1271
题图 |from freepik本文将讨论 gRPC 应用程序的 4 种基础通信模式：一元 RPC、服务器端流 RPC、客户端流 RPC 以及双向流 RPC。在这个过程中，我们会使用一...
gRPC的四种调用方式
江浙沪柯蓝
10-10 4794
RPC的四种调用方式一元调用服务端流式调用客户端流式调用双向流式调用附 在 上一篇 介绍了gRPC的使用场景及基本使用，本文将介绍gRPC的四种调用方式。 一元调用 普通RPC调用，客户端带一个请求对象进行调用，服务端返回一个响应对象。 proto syntax = "proto3"; option csharp_namespace = "GrpcDemoServices"; pa...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值