gRPC.md · 六二一/OOAD

# gRPC

## Why gRPC?

[gRPC](https://grpc.io/)

让我们从一个简单的问题开始：gRPC的动机是什么？或是gRPC试图解决的问题是什么？好吧，答案是通信。

应用程序是使用不同的编程语言编写的。例如，后端可以用Go编写，而前端（例如android app用Java编写，iOS app用Swift编写）。

那么他们如何互相通信，当今的趋势是使用微服务架构。因此，即使在后端，根据业务需求和技术约束，我们可能还会有许多用不同语言（例如Go，Python或Rust）编写的服务。

### 使用gRPC的动机：不同语言之间通信

![n2.png](gRPC.assets/bVbFJUQ)

- 前后端采用了不同的语言
- 微服务架构，采用了不同的语言
- 通过遵守一致的约定去交互信息
  - 通信通道：REST，SOAP，消息队列
  - 身份验证机制：Basic，OAuth，JWT
  - 负载类型：JSON，XML，binary
  - 数据模型
  - 错误处理

因此，为了彼此通信，他们必须都遵守一组API约定。例如：通信通道，身份验证机制，有效载荷格式，数据模型以及如何处理错误。

有太多事情需要考虑，这就是为什么构建API真的很困难。

### 使用gRPC的动机：简单而高效的通信

![n1.png](gRPC.assets/bVbFJTL)

更重要的是，我们希望通信高效，快速且轻巧。您知道，微服务之间的交换消息数量巨大。因此，通信越快越好。

另外，在某些环境（例如移动应用）中，网络速度和带宽受到限制，拥有轻量级的通信协议与服务器进行交互非常重要。

最后但并非最不重要的一点是，我们希望沟通很简单。假设我们正在构建一个包含数百个甚至数千个微服务的系统。我们绝对不希望将大部分时间花在编写代码上只是为了让他们彼此通信，对吗？

我们想要的是某种框架，允许开发人员专注于实现其服务的核心逻辑。并将其他所有内容留给框架处理。

该框架就是gRPC。

## gRPC vs REST

gRPC+Protobuf的方案应该会越来越多，尤其在某些内存受限的情况下，性能优势和部署需要的内存都有优势。利用HTTP/2具有双向连接能力。

gRPC上搭建一个Nginx Proxy可以转换为REST Web Service。

现在，我们对 gRPC 和 REST 有了一个初步认识，下面我们来看看它们的主要区别。

### HTTP 1.1 vs HTTP 2

REST API 遵循一个通常基于 HTTP 1.1 构建的**请求-响应通信模型**。不幸的是，这意味着如果一个微服务收到来自多个客户端的多个请求，该模型必须每次只处理一个请求，拖慢了整个系统的速度。REST API 也可以构建在 HTTP 2 上，但通信的请求-响应模型保持不变，这使得 REST API 无法充分利用 HTTP 2 的优势，例如**流式通信**和**双向支持**。

gRPC 没有面临类似的障碍。它建立在 HTTP 2 之上，且遵循客户端-响应通信模型。这让它支持双向通信和流式通信，因为 gRPC 能接收来自多个客户端的多个请求，并通过不断地流式传输信息来同时处理这些请求。此外，gRPC 还可以处理“一元”交互，例如构建在 HTTP 1.1 上的交互。

总之，gRPC 能处理一元交互和多种类型的流：

- 一元：客户端发出单个请求并接收单个响应。
- 服务器流：服务器对客户端的请求响应一个消息流。当全部数据发送完毕后，服务器会再发送一条状态消息来完成流程。
- 客户端流：客户端向服务器发送一个消息流，并接收单个响应消息。
- 双向流：客户端和服务器的两个流互相独立，也就是说它们都能以任何顺序传输消息。客户端负责发起并结束双向流。

![流类型](gRPC.assets/155a193c6cbba97475ed4bb8c4304093.png)

### 浏览器支持

这可能是 REST 相对于 gRPC 的主要优势之一。一方面，所有浏览器都完全支持 REST。另一方面，gRPC 获得的浏览器支持仍然非常有限。

不幸的是，它需要 gRPC-web 和一个代理层来执行 HTTP 1.1 和 HTTP 2 之间的转换。因此，gRPC 主要用于内部/私有系统（特定组织的后端数据和应用程序功能中的 API 程序）。

### 负载数据结构

如前所述，gRPC 默认使用 Protocol Buffers 来序列化负载数据。这个方案更轻便，因为它支持高度压缩的格式并减少了消息的大小。此外，Protobuf（或 Protocol Buffer）是二进制的；它对结构化数据进行序列化和反序列化，以便通信和传输。换句话说，强类型消息可以自动从 Protobuf 转换为客户端和服务器的编程语言。

相比之下，REST 主要依靠 JSON 或 XML 格式来发送和接收数据。事实上，即使它不强制要求任何结构，JSON 也是最流行的格式，因为它具有灵活性和发送动态数据的能力，而不必遵循严格的结构。使用 JSON 的另一显著优势是其人类可读水平，这方面 Protobuf 尚无法与之竞争。

尽管如此，JSON 在数据传输方面并不够轻量或快速。其原因在于，在使用 REST 时，必须将 JSON（或其他格式）序列化并转换为客户端和服务器端使用的编程语言。这在传输数据的过程中增加了一个额外步骤，从而可能会损害性能并增加出现错误的可能性。

### 代码生成功能

与 gRPC 不同，REST API 不提供内置代码生成功能，这意味着开发人员必须使用 Swagger 或 Postman 等第三方工具为 API 请求生成代码。

相比之下，gRPC 由于其 protoc 编译器而具有原生代码生成功能，该编译器与多种编程语言兼容。这对于集成了以不同语言和平台开发的各种服务的微服务系统来说尤其方便。此外，内置的代码生成器还有助于创建 SDK（软件开发工具包）。

### gRPC 与 REST：对比表

![gRPC 与 REST：对比表](gRPC.assets/2a885d8675c884668da19cafd345b487.jpeg)

### 何时使用 gRPC，何时使用 REST？

如前所述，尽管 gRPC 提供了许多优势，但它有一个主要障碍：浏览器兼容性低。因此，gRPC 的用例一般局限在内部/私有系统。

相比之下，正如我们所讨论的那样，REST API 可能有其缺点，但它们仍然是连接基于微服务的系统的最流行的 API。此外，REST 遵循 HTTP 协议标准化并提供通用支持，使这种 API 架构风格成为 Web 服务开发以及应用程序和微服务集成的首选。然而，这并不意味着我们应该忽视 gRPC 的应用场景。

gRPC 架构风格具有很多值得（并且应该）探索的有前途的特性。它是处理多语言系统和实时流的绝佳选择，例如，当运营需要轻量级消息传输（可以由序列化 Protobuf 消息支持）的 IoT 系统时，gRPC 就很合适。此外，gRPC 也可以考虑用于移动应用程序，因为它们不需要浏览器，且消息体积更小，不会拖慢移动设备的速度。

### 结论

gRPC 提供了很多优势。与 REST 不同，它可以充分利用 HTTP 2，使用多路复用流并遵循二进制协议。此外，由于 Protobuf 消息结构，它还具备性能优势，支持多语言环境的内置代码生成功能也是一大好处。这些因素使 gRPC 成为了一种很有前途的 API 架构风格。

尽管如此，浏览器支持不足使 gRPC 很难匹敌 REST 的通用支持能力。REST 仍然是微服务系统中的粘合剂，是最流行的解决方案。因此它很可能会存在很长时间，而且说实话，它是一个非常成熟和成功的架构。

## What is gRPC? How it works?

gRPC是最初由Google开发的高性能，开源，功能丰富的RPC框架，现在与Kubernetes或Prometheus一样，它是云原生计算基础（或CNCF）的一部分。

RPC是什么？ RPC代表远程过程调用。它是允许程序执行位于其他计算机上的另一个程序的过程的协议。

令人敬畏的是，开发人员不必明确编码网络交互的细节。它由基础框架自动处理。

因此，在客户端代码中，看起来我们只是在直接调用服务器代码的功能。即使客户端和服务器上的代码是用不同的编程语言编写的，它也可以工作。像本示例一样，客户端代码用Go编写，服务器代码用Rust编写。

![n4.jpg](gRPC.assets/bVbFJWG)

那么gRPC如何做到这一点？基本上，客户端具有一个存根，该存根提供与服务器相同的方法（或功能）。该存根由gRPC自动为您生成。

存根将在后台调用gRPC框架，以通过网络与服务器交换信息。

瞧，神奇的是一切正常。由于存根，客户端和服务器现在只需要关心实现其核心服务逻辑。

![Concept Diagram](gRPC.assets/landing-2.svg)

接下来，我们将看到如何在protocol buffer的帮助下生成gRPC存根。

## gRPC如何生成代码？

代码生成是gRPC的最重要功能之一。

为了为服务器和客户端生成存根，我们首先需要编写API协定，该协定包括在protocol buffer文件中的服务及其有效载荷消息的描述，如下所示：

```protobuf
syntax = "proto3"

message HelloRequest {
  string name = 1;
}

message HelloResponse {
  string greet = 1;
}

service HelloService {
  rpc Hello(HelloRequest) return (HelloResponse);
}
```

在此文件中，定义了一个Hello方法，该方法将HelloRequest作为输入并返回HelloResponse。 HelloRequest仅包含一个字符串名称，而HelloResponse具有一个字符串。

protocol buffer编译器从此proto文件生成服务器和客户端存根代码。根据编程语言，我们将不得不告诉编译器为其使用正确的gRPC插件。

为Rust和Go生成的代码将如下所示：

![n6.jpg](gRPC.assets/bVbFJYM)

OK，所以您可能想知道为什么gRPC使用protocol buffer？好吧，有很多原因。

* 首先，它非常易于阅读和理解。
* 其次，它的语言可与多种语言自动生成代码互操作
* 第三，它表示二进制格式的数据，与某些基于文本的格式（如JSON或XML）相比，它的大小更小，传输速度更快，序列化的效率更高。

它在客户端和服务器之间提供了一种强类型的API契约，使用它非常安全, 而且确保向后和向前的兼容性。

听起来很棒，对吗？但是，使用gRPC一定需要protocol buffer吗？

答案是不。您可以改用Google Flatbuffers或Microsoft Bond。但是我认为protocol buffer已经是一个不错的选择。

它支持许多流行的编程语言，其中10种已正式支持，其中纯实现了Go，Java，NodeJS，另外7种是gRPC核心C的包装，即C ++，C＃，Objective-C，Python，Ruby，Dart和PHP。

此外，还有许多其他语言的非官方库，例如Swift，Rust，TypeScript，Haskell等。

![n7.jpg](gRPC.assets/bVbFJ2n)

## gRPC与HTTP2

gRPC使用HTTP/2作为其传输协议，因此它继承了HTTP/2提供的一些出色功能，例如二进制帧，与其他基于文本的协议相比，它具有高性能，强健性，更轻便的传输和更安全的解码能力。而且因为它是二进制文件，所以它与protocol buffer完美结合。

HTTP/2还使用HPACK压缩报头，这将减少开销成本并提高性能。

在HTTP/2中可以进行多路复用，这意味着客户端和服务器可以通过单个TCP连接并行发送多个请求和响应。这将有助于减少延迟并提高网络利用率。

![n8.jpg](gRPC.assets/bVbFJ3A)

最后，HTTP/2允许服务器推送，其中来自客户端的1个单个请求使服务器可以发回多个响应。在许多情况下，当服务器确切知道客户端需要什么资源并在请求之前将其发送时，这对于减少客户端和服务器之间的往返延迟非常有价值。

## 如何在NodeJS中有效使用gRPC流

![g10.png](gRPC.assets/bVbhpnU)

### 什么是gRPC中的流

gRPC中的流可帮助我们在单个RPC调用中发送消息流。

![g11.png](gRPC.assets/bVbFI2K)

gRPC 的流式，分为三种类型：

- server-side streaming RPC：服务器端流式 RPC
- Client-side streaming RPC：客户端流式 RPC
- Bidirectional streaming RPC：双向流式 RPC

### gRPC中的流使用场景

- 大规模数据包
- 实时场景

在本文中，我们将重点关注以下流：

- **Server Streaming GRPC**：在这种情况下，客户端向服务器发出单个请求，服务器将消息流发送回客户端。
- **Client Streaming GRPC**：在这种情况下，客户端将消息流发送到服务器。然后，服务器处理流并将单个响应发送回客户端。

### Server Streaming gRPC

现在让我们为服务器流gRPC创建服务器和客户端代码。

#### 创建 .proto 文件

创建一个名为**proto**的文件夹。在该文件夹中创建一个名为**employee.proto**的文件。将以下内容复制到**employee.proto**中:

```protobuf
syntax = "proto3";

package employee;

service Employee {
  rpc paySalary (EmployeeRequest) returns (stream EmployeeResponse) {}
}

message EmployeeRequest {
  repeated int32 employeeIdList = 1;
}

message EmployeeResponse{
  string message = 1;
}
```

在这里，我们创建一个名为**paySalary**的rpc，它接受**EmployeeRequest**作为请求并发送**EmployeeResponse**流作为响应。我们使用关键字流来指示服务器将发送消息流。

上面也定义了**EmployeeRequest**和**EmployeeResponse**。 repeate关键字表示将发送数据列表。

在此示例中，paySalary的请求将是员工ID的列表。服务器将通过一条消息流做出响应，告知是否已向员工支付薪水。

#### 为服务器创建虚拟数据

创建一个名为data.js的文件，并将以下代码复制到其中。

```javascript
//Hardcode some data for employees
let employees = [
    {
        id: 1,
        email: 'abcd@abcd.com',
        firstName: 'First1',
        lastName: 'Last1'
    },
    {
        id: 2,
        email: 'xyz@xyz.com',
        firstName: 'First2',
        lastName: 'Last2'
    },
    {
        id: 3,
        email: 'temp@temp.com',
        firstName: 'First3',
        lastName: 'Last3'
    }
]

exports.employees = employees
```

我们将其用作服务器的数据源。

#### 创建Server

创建一个名为server.js的文件。将以下代码复制到server.js中

```javascript
const PROTO_PATH = __dirname + '/proto/employee.proto'

const grpc = require('grpc')
const protoLoader = require('@grpc/proto-loader')

let packageDefinition = protoLoader.loadSync(PROTO_PATH, {
  keepCase: true,
  longs: String,
  enums: String,
  defaults: true,
  oneofs: true
})
let employee_proto = grpc.loadPackageDefinition(packageDefinition).employee
```

接下来，将以下代码片段添加到server.js中

```javascript
let { paySalary } = require('./pay_salary.js')

function main() {
  let server = new grpc.Server()
  server.addService(employee_proto.Employee.service, { paySalary: paySalary })
  server.bind('0.0.0.0:4500', grpc.ServerCredentials.createInsecure())
  server.start()
}

main()
```

在上面的脚本中，我们将启动GRPC Server并将**Employee** Service和**paySalary**实现一起添加到其中。

但是**paySalary**函数在**pay_salary.js**文件中定义。

让我们创建一个**pay_salary.js**文件。

将以下脚本添加到**pay_salary.js**文件中

```javascript
let { employees } = require('./data.js')
const _ = require('lodash')

function paySalary(call) {
  let employeeIdList = call.request.employeeIdList

_.each(employeeIdList, function (employeeId) {
    let employee = _.find(employees, { id: employeeId })
    if (employee != null) {
      let responseMessage = 'Salary paid for '.concat(employee.firstName, ', ', employee.lastName)
      call.write({ message: responseMessage })
    } else {
      call.write({ message: 'Employee with Id ' + employeeId + ' not found in record' })
    }
  })
  call.end()
}
exports.paySalary = paySalary
```

**paySalary**函数将调用作为输入。 **call.request**将包含客户端发送的请求。

**call.request.employeeIdList**将包含客户端发送的员工ID的列表。

然后，我们遍历EmployeeId，并为每个员工ID进行一些处理。

对于每个员工ID，我们最后都调用**call.write**函数。 **call.write**将在流中将单个消息写回到客户端。

在这种情况下，对于每位员工，**call.write**都会发回工资是否已经支付。

处理完所有员工编号后，我们将调用**call.end**函数。 **call.end**指示流已完成。

这是最终的**server.js**文件

```javascript
const PROTO_PATH = __dirname + '/proto/employee.proto'

const grpc = require('grpc')
const protoLoader = require('@grpc/proto-loader')

let { paySalary } = require('./pay_salary.js')

main()
```

#### 创建Client

创建一个名为**client_grpc_server_stream.js**的文件。将以下代码复制到文件中。

```javascript
const PROTO_PATH = __dirname + '/proto/employee.proto'

const grpc = require('grpc')
const protoLoader = require('@grpc/proto-loader')

let packageDefinition = protoLoader.loadSync(PROTO_PATH, {
    keepCase: true,
    longs: String,
    enums: String,
    defaults: true,
    oneofs: true
})
let employee_proto = grpc.loadPackageDefinition(packageDefinition).employee
```

接下来，将以下脚本片段添加到客户端。

```javascript
function main() {
    let client = new employee_proto.Employee('localhost:4500', grpc.credentials.createInsecure())

let employeeIdList = [1, 10, 2]
    let call = client.paySalary({ employeeIdList: employeeIdList })

call.on('data', function (response) {
        console.log(response.message)
    })

call.on('end', function () {
        console.log('All Salaries have been paid')
    })
}

main()
```

**client**变量将具有存根，这将有助于我们在服务器中调用该函数。

**employeeIdList**是提供给服务器的输入。

`let call = client.paySalary({employeeIdList: employeeIdList});` 脚本调用服务器中的paySalary函数，并将employeeIdList作为请求传递。由于服务器将要发送消息流，因此调用对象将帮助我们侦听流事件。

我们会侦听呼叫对象中的“数据”事件，以查看流中来自服务器的任何消息。如下面的脚本所示。

```javascript
call.on('data', function (response) {
    console.log(response.message)
})
```

在这里，只要我们从服务器收到任何消息，我们就只打印响应消息。

我们在调用对象中侦听“结束”事件，以了解服务器流何时结束。如下面的脚本所示。

```javascript
call.on('end', function () {
    console.log('All Salaries have been paid')
})
```

在此流结束时，我们正在打印“已支付所有薪水”。

这是**client_gprc_server_stream.js**的完整代码。

```javascript
const PROTO_PATH = __dirname + '/proto/employee.proto'

const grpc = require('grpc')
const protoLoader = require('@grpc/proto-loader')

let packageDefinition = protoLoader.loadSync(PROTO_PATH, {
    keepCase: true,
    longs: String,
    enums: String,
    defaults: true,
    oneofs: true
})
let employee_proto = grpc.loadPackageDefinition(packageDefinition).employee

function main() {
    let client = new employee_proto.Employee('localhost:4500', grpc.credentials.createInsecure())

let employeeIdList = [1, 10, 2]
    let call = client.paySalary({ employeeIdList: employeeIdList })

call.on('data', function (response) {
        console.log(response.message)
    })

call.on('end', function () {
        console.log('All Salaries have been paid')
    })
}

main()
```

#### 运行代码

打开命令提示符，然后使用以下脚本启动服务器。

```sh
npm i grpc
npm i @grpc/proto-loader
npm i lodash
node server.js
```

打开一个新的命令提示符，并使用以下脚本运行客户端。

```sh
node client_grpc_server_stream.js
```

在运行客户端时，我们将获得以下输出。

```text
Salary paid for First1, Last1
Employee with Id 10 not found in record
Salary paid for First2, Last2
All Salaries have been paid
```

在这种情况下，客户端已向服务器发送了3个Id的1,10,2。服务器一一处理ID，然后将消息流发送给客户端。流中的所有消息完成后，将显示消息“已支付所有薪水”。

### Client Streaming GRPC

现在，让我们为客户端流GRPC创建服务器和客户端代码。

#### 创建.proto文件

在先前创建的employee.proto文件中，添加以下内容

```protobuf
service Employee {
  rpc paySalary (EmployeeRequest) returns (stream EmployeeResponse) {}
  rpc generateReport (stream ReportEmployeeRequest) returns (ReportEmployeeResponse) {}
}

message ReportEmployeeRequest {
  int32 id = 1;
}

message ReportEmployeeResponse{
  string successfulReports = 1;
  string failedReports = 2;
}
```

在这里，我们添加了一个名为**generateReport**的新rpc，它接受**ReportEmployeeRequest**流作为请求并返回**ReportEmployeeResponse**作为响应。

因此，向rpc输入的内容是员工ID的流，服务器的响应将是单个响应，其中指出生成了多少报告以及有多少报告失败。

这是我们更改后的完整的**employee.proto**文件：

```protobuf
syntax = "proto3";

package employee;

service Employee {

rpc paySalary (EmployeeRequest) returns (stream EmployeeResponse) {}

rpc generateReport (stream ReportEmployeeRequest) returns (ReportEmployeeResponse) {}
}

message EmployeeRequest {
  repeated int32 employeeIdList = 1;
}

message EmployeeResponse{
  string message = 1;
}

message ReportEmployeeRequest {
  int32 id = 1;
}

message ReportEmployeeResponse{
  string successfulReports = 1;
  string failedReports = 2;
}
```

#### 创建Server

这是添加了新rpc的完整server.js代码：

```javascript
const PROTO_PATH = __dirname + '/proto/employee.proto'

const grpc = require('grpc')
const protoLoader = require('@grpc/proto-loader')

let { paySalary } = require('./pay_salary.js')
let { generateReport } = require('./generate_report.js')

function main() {
  let server = new grpc.Server()
  server.addService(employee_proto.Employee.service, { paySalary: paySalary, generateReport: generateReport })
  server.bind('0.0.0.0:4500', grpc.ServerCredentials.createInsecure())
  server.start()
}

main()
```

在上面的脚本中，我们可以看到我们还向grpc服务器添加了**generateReport**函数。我们还可以看到**generateReport**函数来自**generate_report.js**文件。

创建一个名为**generate_report.js**的文件。

将以下脚本添加到文件中：

```javascript
let { employees } = require('./data.js')
const _ = require('lodash')

function generateReport(call, callback) {
    let successfulReports = []
    let failedReports = []
    call.on('data', function (employeeStream) {
        let employeeId = employeeStream.id
        let employee = _.find(employees, { id: employeeId })
        if (employee != null) {
            successfulReports.push(employee.firstName)
        } else {
            failedReports.push(employeeId)
        }
    })
    call.on('end', function () {
        callback(null, {
            successfulReports: successfulReports.join(),
            failedReports: failedReports.join()
        })
    })
}

exports.generateReport = generateReport
```

**generateReport**函数接受两个输入，即调用和回调

为了从客户端获取消息流，我们需要在调用对象中监听数据事件。这是在以下脚本中完成的。

```text
call.on('data',function(employeeStream){
        let employeeId = employeeStream.id;
        let employee = _.find(employees, { id: employeeId });
        if (employee != null) {
          successfulReports.push(employee.firstName);
        }
      else{
          failedReports.push(employeeId);
      }

});
```

来自客户端的每条消息都会调用**data**事件。该消息存在于**employeeStream**变量中。收到消息后，我们尝试生成报告，并确定报告是成功还是失败。

调用对象上的结束事件表示客户端流已结束。以下代码显示了如何监听结束事件。

```text
call.on('end',function(){
        callback(null,{
            successfulReports: successfulReports.join(),
            failedReports: failedReports.join()
        })
    })
```

在这种情况下，当结束事件发生时，我们将所有成功和失败报告组合到一个响应对象中，并使用回调对象将其发送回客户端。

#### 创建Client

创建一个名为**client_grpc_client_stream.js**的文件。将以下脚本添加到其中。

```javascript
const PROTO_PATH = __dirname + '/proto/employee.proto'

const grpc = require('grpc')
const protoLoader = require('@grpc/proto-loader')
const _ = require('lodash')

上面的脚本具有与服务器代码相同的功能。

将以下脚本也添加到**client_grpc_client_stream.js**。

```javascript
function main() {
  let client = new employee_proto.Employee('localhost:4500', grpc.credentials.createInsecure())

let call = client.generateReport(function (error, response) {
    console.log('Reports successfully generated for: ', response.successfulReports)
    console.log("Reports failed since Following Employee Id's do not exist: ", response.failedReports)
  })

let employeeIdList = [1, 10, 2]
  _.each(employeeIdList, function (employeeId) {
    call.write({ id: employeeId })
  })

call.end()
}

main()
```

让我们看看上面的脚本在做什么。

```javascript
let call = client.generateReport(function (error, response) {
    console.log('Reports successfully generated for: ', response.successfulReports)
    console.log("Reports failed since Following Employee Id's do not exist: ", response.failedReports)
})
```

在脚本的这一部分中，我们正在创建一个调用对象并调用**generateReport**函数。同样在**generateReport**函数内部，我们指示客户端一旦收到服务器的响应，应该怎么做。在这种情况下，我们将打印服务器发送回的成功和失败报告。

```javascript
let employeeIdList = [1, 10, 2]
_.each(employeeIdList, function (employeeId) {
    call.write({ id: employeeId })
})
```

在脚本的以上部分中，我们遍历了员工ID，并将消息流发送到服务器。我们使用**call.write**将消息以流的形式发送到服务器。

最后，一旦我们在流中发送了所有消息，就可以使用**call.end**函数指示流已完成，如下所示：

```javascript
call.end();
```

下面给出了**client_grpc_client_stream**的完整代码。

```javascript
const PROTO_PATH = __dirname + '/proto/employee.proto'

const grpc = require('grpc')
const protoLoader = require('@grpc/proto-loader')
const _ = require('lodash')

function main() {
  let client = new employee_proto.Employee('localhost:4500', grpc.credentials.createInsecure())

let employeeIdList = [1, 10, 2]
  _.each(employeeIdList, function (employeeId) {
    call.write({ id: employeeId })
  })

call.end()
}

main()
```

#### 运行代码

打开命令提示符，然后使用以下脚本启动服务器。

```sh
node server.js
```

打开一个新的命令提示符，并使用以下脚本运行客户端。

```sh
node client_grpc_client_stream.js
```

在运行客户端时，我们将获得以下输出。

```text
Reports successfully generated for:  First1,First2
Reports failed since Following Employee Id\'s do not exist:  10
```

在这种情况下，客户端已向服务器发送了3个Id的1,10,2作为消息流。然后，服务器处理流中的消息，并将单个响应发送回客户端，以显示成功的报告数量和失败的报告数量。

六二一/OOAD

简介

发行版

贡献者

近期动态

六二一/OOAD .gitee-modal { width: 500px !important; }

简介

发行版

贡献者

近期动态

搜索帮助

六二一/OOAD