类似Google这种大公司产出的产品，一般就两种情况，一种是面向小白用户的，如此让G粉簇拥而来找Bug优化产品思路，等到时机成熟再推出正式版或者取消产品，AngularJS就是这一类。还有一种就是Google自己的需求而总结出来的产品，优点什么的我就不吹了，gRPC就是这一类的。

序言

今年年初的时候我就一直想做一款基于RPC实现组件化搭建网站的一款产品。目的就是为了让各种语言的程序员能以最低沟通、学习代价来进行快速、稳定开发产品。而当初做的时候为了速度摸坑，用了Nodejs来进行开发，做出了GQ这款产品，自己边用边总结，说真的坑是真的多，JSON是不够用的，还有bytes、流数据等等问题。几个月下来，发现这个东西是个史诗大坑，因为要考虑到各种语言的兼容、使用难易、不同类型组件（数据库组件、流文件处理组件等）通用接口等等问题，迟迟没有拿出一套跨语言的规范来。几乎要放弃。这项目被我搁置。不巧，gRPC出来了。当初心想有搞头，但是当时文档不够健全，让那些爱折腾的人先去探探路吧。现在我作为第二批吃螃蟹的人，上手一试，心中暗叹：厉害了我的Goggle

案例简介

一套基于路由注册的分发服务。这里使用Nodejs来快速上手。服务端：注册HTTP端口，以及gRPC基础服务，通过基础服务，可以注册HTTP请求的处理权。子服务：注册基础服务，实现对HTTP请求的处理。流程如下：

HTTP请求--->服务端--/a/b-->子服务1
　　　　　　　　　|--/a/c-->子服务2
　　　　　　　　　+--/a/d-->子服务3

实现流程

PS:我这里不赘述XX为什么要这以做之类的话语，直接上代码，并简单解释代码中的重点。这个案例没有难点。 gRPC的安装省略。使用Nodejs版本v6.9.1。用到一些ES6的语法，不完全兼容v4.*

proto文件

syntax = "proto3";

option objc_class_prefix = "Gaubee";

package httpserver;

// HttpServer服务的定义
service HttpServer {
    rpc BindRoute(RouteInfo) returns(RequestInfo) {}
    rpc ReturnResponse(ResponInfo) returns(ResponReply) {}
}

message RouteInfo {
    enum Method {
        GET = 0;
        POST = 1;
        PUT = 2;
        DELETE = 3;
    }
    // 注册的路由pathname
    string path = 1;
    Method method = 2;
    // 是否直接解析query到query中
    bool is_parse_query = 3;
    // 是否解析带有Body的请求
    bool is_parse_body = 4;
}
message RequestInfo {
    // 请求的ID，在做响应的时候需要带上
    string require_id = 1;
    // 请求链接中的数据
    map<string, string> query = 2;
    // 请求数据包中的数据
    map<string, string> body = 3;
}
message ResponInfo{
    string require_id = 1;
    map<string, string> response_head = 2;
    string response_data = 3;
    int32 statusCode = 4;
}
// 返回整个请求的时间信息
message ResponReply{
    // 收到请求，解析请求query、body花费的时间
    float route_parsed_time = 1;
    // 传输请求数据花费的时间
    float route_send_time = 2;
    // 处理请求至服务端收到数据花费的时间
    float responsed_time = 3;
    // 返回请求结果给客户花费的时间
    float responsed_send_time = 4;
}

以上的proto文件描述了两个接口：

BindRoute：实现路由绑定把要绑定的路由写道path中，这里为了简单，我只是进行了字符串相等匹配。BindRoute的回调函数不会马上触发。要等到服务端有HTTP请求的时候，匹配到对应的路由，最后再执行返回。
ReturnResponse：BindRoute收到回调后，意味着子服务开始处理HTTP请求，在处理完成后，需要调用此函数来返回处理结果。

require_id是注册基础服务后生成的一次性编号，每一次注册都会生成一个，在收到HTTP请求是，匹配到对应的路由，就要通过这个require_id来发送请求、接受处理结果。

服务端

"use strict";
// PROTO文件路径，按需换成自己的文件路径
const PROTO_PATH = __dirname + "/../pingpong/http-server.proto";
const grpc = require("grpc");
const http = require("http");
const url = require("url");
const querystring = require("querystring");

// 动态加载PROTO文件，生成接口
const httpserver = grpc.load(PROTO_PATH).httpserver;

/** 路由映射表
 *  结构为：{ [METHOD:GET|POST|PUT|DELETE] : { [PATHNAME] : Array<String>[require_id,...] } }
 */
const route_res_list = {};

/** require_id对应的路由注册信息与回调函数
 *  结构为：{ args : 路由注册信息, callback: 回调函数，用于通知子服务来处理HTTP请求 }
 */
const handleCache = new Map();
/** require_id对应的HTTP请求
 *  结构为：{ req : HTTP.Request, res: HTTP.Response }
 */
const reqresCache = new Map();
// 初始化路由映射表的结构
for (let method in httpserver.RouteInfo.Method) {
  route_res_list[method] = {};
}

/** rgRPC服务：绑定路由
 *
 */
function BindRoute(call, callback) {
  const args = call.request;
  const routes = route_res_list[args.method];
  var handles = routes[args.path];
  if (!handles) {
    handles = routes[args.path] = new Set();
  }
  // 生成require_id
  const require_id = Math.random().toString(36).substr(2);

  // 加入路由映射表
  handles.add(require_id);

  // 这里不调用callback，而是等待到收到HTTP请求的时候再执行
  handleCache.set(require_id, {
    args: args,
    callback,
  });
}

/** rgRPC服务：响应HTTP请求
 *
 */
function ReturnResponse(call, callback) {
  const args = call.request;
  const require_id = args.require_id;
  // 取出缓存中的req、res对象
  const { req, res } = reqresCache.get(require_id);
  if (!res) {
    return callback(`Ref Error:require_id:${require_id} no ref.`);
  }
  // 返回数据
  res.writeHead(args.statusCode, args.response_head);
  res.end(args.response_data);
  // 清除缓存
  reqresCache.delete(require_id);

  // 返回整个流程的消耗时间，这里为了简化代码没有加统计时间的代码
  callback(null, {
    route_parsed_time: 0,
    route_send_time: 0,
    responsed_time: 0,
    responsed_send_time: 0,
  });
}

function main() {
  const grpc_server = new grpc.Server();
  grpc_server.addProtoService(httpserver.HttpServer.service, {
    bindRoute: BindRoute,
    returnResponse: ReturnResponse,
  });
  // 注册gRPC服务
  grpc_server.bind("0.0.0.0:50051", grpc.ServerCredentials.createInsecure());
  grpc_server.start();
}

main();
// 注册HTTP服务
const server = http.createServer((req, res) => {
  const routes = route_res_list[req.method];
  if (routes) {
    const url_info = url.parse(req.url);
    const handles = routes[url_info.pathname];
    if (handles && handles.size) {
      const { value: require_id, has_key } = handles.values().next();
      if (has_key) {
        console.log("no handle");
        return;
      }
      const handle = handleCache.get(require_id);
      // 通知客户端处理HTTP请求，并带上HTTP请求的一些数据
      handle.callback(null, {
        require_id,
        // TODO：headers
        query: handle.args.is_parse_query
          ? Object.assign({}, querystring.parse(url_info.query))
          : {},
        // TODO：body应该改用流数据传输
        body:
          handle.args.method !== "GET" && handle.args.is_parse_body ? {} : {},
      });
      // 缓存req、res
      reqresCache.set(require_id, {
        req,
        res,
      });
      // 清除缓存，此require_id已经报废，只用于最后的响应res的处理
      handleCache.delete(require_id);
      handles.delete(require_id);
    }
  }
});
server.listen(1337, "0.0.0.0", () => {});

子服务

const PROTO_PATH = __dirname + "/../pingpong/http-server.proto";
const grpc = require("grpc");
const http = require("http");
const httpserver = grpc.load(PROTO_PATH).httpserver;
const address = "localhost:50051";

function main() {
  var client = new httpserver.HttpServer(
    address,
    grpc.credentials.createInsecure(),
  );
  // 注册路由
  client.bindRoute(
    {
      path: "/QAQ",
      method: httpserver.RouteInfo.Method.GET,
      is_parse_query: true,
      is_parse_body: false,
    },
    function (err, response) {
      // 收到路由请求
      console.log(err, response);
      // 返回路由处理结果
      client.returnResponse(
        {
          require_id: response.require_id,
          statusCode: 200,
          response_head: {},
          response_data: JSON.stringify(response.query),
        },
        function (err, response) {
          // 收到性能统计
          console.log(err, response);
        },
      );
    },
  );

  // 模拟发起请求
  setTimeout(function () {
    var req = http.get("http://localhost:1337/QAQ?a=a", (res, socket, head) => {
      var datas = [];
      res.on("data", (chunk) => {
        datas.push(chunk);
      });
      res.on("end", () => {
        // 打印结果
        console.log("request res:", Buffer.concat(datas).toString());
      });
    });
  }, 200);
}

main();

总结

以上代码流程只是简单的示例，有一点不好的就是路由的注册变成了一次性，这不能说完全不对。但更优的做法应该改为流数据，这就不需要调用callback来结束服务，而是可以通过流不停地发起请求，流的实践参考官方代码：route_guide。