Table of Contents

1. 前言

gRPC除了1:1的请求应答模式之外,还支持流式的请求响应模式,而在JS语法下的使用语句也有点意思,这里做一个简单整理。

首先给出使用的proto定义文件,下文所有的代码都以这个定义为准:

2. 单请求 单响应

2.1 说明

请求模式:单请求,单响应

服务端:

客户端:

  • 客户端比较简单,自行构造请求,然后使用回调得到返回值即可。

2.2 例子

Proto定义的请求:

rpc GetBook (GetBookRequest) returns (Book) {}

Server:

const getBook = (call: grpc.ServerUnaryCall<GetBookRequest>, callback: grpc.sendUnaryData<Book>) => {
  const book = new Book();

  book.setTitle("DefaultBook");
  book.setAuthor("DefaultAuthor");

  log(`[getBook] Done: ${JSON.stringify(book.toObject())}`);
  callback(null, book);
};

client:

const getBook = async (isbn: number) => {
  return new Promise((resolve, reject) => {
    const request = new GetBookRequest();
    request.setIsbn(isbn);

    log(`[getBook] Request: ${JSON.stringify(request.toObject())}`);

    client.getBook(request, (err, book: Book) => {
      if (err != null) {
        debug(`[getBook] err:\nerr.message: ${err.message}\nerr.stack:\n${err.stack}`);
        reject(err); return;
      }
      log(`[getBook] Book: ${JSON.stringify(book.toObject())}`);
      resolve(book);
    });
  });
};

3. 单请求 流响应

3.1 说明

请求模式:单请求,流式响应(多响应)

服务端:

  • 收到的请求是一个grpc.ServerWriteableStream<RequestType>类型,和单请求单响应的情况不同,作为可写入流该对象还要负责返回数据,但作为请求对象处理的时候,主要职责仍旧是承载request: RequestType
  • 返回响应需要使用请求给到的这个可写入流来write返回ResponseType,全部结束之后需要主动关闭可写入流,即end

客户端:

  • 请求仍旧是自行构造即可。
  • 响应是一个grpc.ClientReadableStream<ResponseType>类型,是一个可读取流,客户端需要监听data事件,得到返回的ResponseType数据,并监听end事件,标识响应流的结束。

3.2 范例

Proto定义的请求:

rpc GetBooksViaAuthor (GetBookViaAuthor) returns (stream Book) {}

Server:

const getBooksViaAuthor = (call: grpc.ServerWriteableStream<GetBookViaAuthor>) => {
  const request = call.request as GetBookViaAuthor;

  log(`[getBooksViaAuthor] Request: ${JSON.stringify(request.toObject())}`);
  for (let i = 1; i <= 10; i++) {
    const reply = new Book();
    reply.setTitle(`Book${i}`);
    reply.setAuthor(request.getAuthor());
    reply.setIsbn(i);
    log(`[getBooksViaAuthor] Write: ${JSON.stringify(reply.toObject())}`);
    call.write(reply);
  }
  log("[getBooksViaAuthor] Done.");
  call.end();
};

Client:

const getBooksViaAuthor = (author: string) => {
  return new Promise((resolve) => {
    const request = new GetBookViaAuthor();
    request.setAuthor(author);

    log(`[getBooksViaAuthor] Request: ${JSON.stringify(request.toObject())}`);

    const stream: grpc.ClientReadableStream<GetBookViaAuthor> = client.getBooksViaAuthor(request);
    stream.on("data", (data: Book) => {
      log(`[getBooksViaAuthor] Book: ${JSON.stringify(data.toObject())}`);
    });
    stream.on("end", () => {
      log("[getBooksViaAuthor] Done.");
      resolve();
    });
  });
};

4. 流请求 单响应

4.1 说明

请求模式:流式请求(多请求),单响应

服务端:

  • 收到的请求是一个grpc.ServerReadableStream<RequestType>类型,是一个可读取流,需要监听data事件获得RequestType,并监听end事件得到所有请求获得结束的通知,然后开始处理服务端业务。
  • 返回的响应仍旧是一个grpc.sendUnaryData<ResponseType>,回调函数,用于处理结束后返回结果。

客户端:

  • 和上面几个模式稍稍有点不同,客户端直接发起请求,得到一个可写入流的返回值grpc.ClientWritableStream<RequestType>,并得到一个回调函数。
  • 在可写入流里使用write方法,向服务端发出RequestType的请求,并使用end方法通知服务端请求发送结束。
  • 在回调函数里处理服务端返回回来的ResponseType结果。

4.2 范例

Proto定义的请求:

rpc GetGreatestBook (stream GetBookRequest) returns (Book) {}

Server:

const getGreatestBook = (call: grpc.ServerReadableStream<GetBookRequest>, callback: grpc.sendUnaryData<Book>) => {
  let lastOne: GetBookRequest;
  call.on("data", (request: GetBookRequest) => {
    log(`[getGreatestBook] Request: ${JSON.stringify(request.toObject())}`);
    lastOne = request;
  });
  call.on("end", () => {
    const reply = new Book();
    reply.setIsbn(lastOne.getIsbn());
    reply.setTitle("LastOne");
    reply.setAuthor("LastOne");
    log(`[getGreatestBook] Done: ${JSON.stringify(reply.toObject())}`);
    callback(null, reply);
  });
};

Client:

const getGreatestBook = () => {
  return new Promise((resolve) => {
    const stream: grpc.ClientWritableStream<GetBookRequest> = client.getGreatestBook((err, data: Book) => {
      if (err != null) {
        log(`[getGreatestBook] err:\nerr.message: ${err.message}\nerr.stack:\n${err.stack}`);
      }
      log(`[getGreatestBook] Book: ${JSON.stringify(data.toObject())}`);
      resolve();
    });

    for (let i = 0; i < 10; i++) {
      const req = new GetBookRequest();
      req.setIsbn(i);
      log(`[getGreatestBook] Request: ${JSON.stringify(req.toObject())}`);
      stream.write(req);
    }
    stream.end();
  });
};

5. 流请求 流响应

5.1 说明

请求模式:流式请求(多请求),流式响应(多响应),实质上的请求和响应还是一对一关系

服务端:

  • 得到的参数只有一个,是一个grpc.ServerDuplexStream<RequestType, ResponseType>的双向流。
  • 需要程序员监听data事件,获取RequestType的请求,并使用write方法,返回ResponseType的结果,这里基本上是1:1的应答关系。
  • 然后在监听到end事件并处理完服务端逻辑之后,使用end方法,告知客户端处理完成。

客户端:

5.2 范例

Proto定义的请求:

rpc GetBooks (stream GetBookRequest) returns (stream Book) {}

Server:

const getBooks = (call: grpc.ServerDuplexStream<GetBookRequest, Book>) => {
  call.on("data", (request: GetBookRequest) => {
    const reply = new Book();
    reply.setTitle(`Book${request.getIsbn()}`);
    reply.setAuthor(`Author${request.getIsbn()}`);
    reply.setIsbn(request.getIsbn());
    log(`[getBooks] Write: ${JSON.stringify(reply.toObject())}`);
    call.write(reply);
  });
  call.on("end", () => {
    log("[getBooks] Done.");
    call.end();
  });
};

Client:

const getBooks = () => {
  return new Promise((resolve) => {
    const stream: grpc.ClientDuplexStream<GetBookRequest, Book> = client.getBooks();

    stream.on("data", (data: Book) => {
      log(`[getBooks] Book: ${JSON.stringify(data.toObject())}`);
    });
    stream.on("end", () => {
      log("[getBooks] Done.");
      resolve();
    });

    for (let i = 0; i < 10; i++) {
      const req = new GetBookRequest();
      req.setIsbn(i);
      log(`[getBooks] Request: ${JSON.stringify(req.toObject())}`);
      stream.write(req);
    }
    stream.end();
  });
};

6. 完整可运行的范例

完整的代码请参见:v2.2.2/examples/src

EOF