在NodeJS中玩转Protocol Buffer

  • Protocol Buffer入门教程

    • Protocol Buffer是个什么鬼
    • NodeJS开发者为何要跟Protocol Buffer打交道
    • 在NodeJS中实践Protocol Buffer协议
      • 选择支持protobuf的NodeJS第三方模块
      • 一个栗子
        • 书写proto文件
        • 编译 proto 文件
        • 编写 Writer
        • 编写Reader
        • 运行结果
      • 再举一个栗子
        • 编写proto
        • 编写client
        • 书写server
        • 运行结果
      • 其他高级特性
        • 嵌套Message
        • Import Message
    • 总结一下
      • 优点

        • 简洁
      • 缺点
    • 参考文档

Protocol Buffer入门教程

Protocol Buffer是个什么鬼?

Protocol Buffer(下文简称protobuf)是Google提供的一种数据序列化协议,下面是我从网上找到的Google官方对protobuf的定义:

Protocol Buffers 是一种轻便高效的结构化数据存储格式,可以用于结构化数据序列化,很适合做数据存储或 RPC 数据交换格式。它可用于通讯协议、数据存储等领域的语言无关、平台无关、可扩展的序列化结构数据格式。目前提供了 C++、Java、Python 三种语言的 API。

道理我们都懂,然后并没有什么卵用,看完上面这段定义,对于protobuf是什么我还是一脸懵逼~

NodeJS开发者为何要跟Protocol Buffer打交道

作为JavaScript开发者,对我们最友好的数据序列化协议当然是大名鼎鼎的JSON啦!我们本能的会想protobuf是什么鬼?还我JSON!

这就要说到protobuf的历史了。

Protobuf由Google出品,08年的时候Google把这个项目开源了,官方支持C++,Java,C#,Go和Python五种语言,但是由于其设计得很简单,所以衍生出很多第三方的支持,基本上常用的PHP,C,Actoin Script,Javascript,Perl等多种语言都已有第三方的库。

由于protobuf协议相较于之前流行的XML更加的简洁高效(后面会提到这是为什么),因此许多后台接口都是基于protobuf定制的数据序列化协议。而作为NodeJS开发者,跟C++或JAVA编写的后台服务接口打交道那是家常便饭的事儿,因此我们很有必要掌握protobuf协议。

下面举两个简单的例子,应该有助于我们理解protobuf。

在NodeJS中实践Protocol Buffer协议

选择支持protobuf的NodeJS第三方模块

一个栗子

我打算使用 Protobuf 和NodeJS开发一个十分简单的例子程序。

该程序由两部分组成。第一部分被称为 Writer,第二部分叫做 Reader。

Writer 负责将一些结构化的数据写入一个磁盘文件,Reader 则负责从该磁盘文件中读取结构化数据并打印到屏幕上。

准备用于演示的结构化数据是 HelloWorld,它包含两个基本数据:

  • ID,为一个整数类型的数据
  • Str,这是一个字符串

书写.proto文件

首先我们需要编写一个 proto 文件,定义我们程序中需要处理的结构化数据,在 protobuf 的术语中,结构化数据被称为 Message。proto 文件非常类似 java 或者 C 语言的数据定义。代码清单 1 显示了例子应用中的 proto 文件内容。

清单 1. proto 文件

package lm;
message helloworld
{
   required int32     id = 1;  // ID
   required string    str = 2;  // str
   optional int32     opt = 3;  //optional field
}

一个比较好的习惯是认真对待 proto 文件的文件名。比如将命名规则定于如下:

packageName.MessageName.proto

在上例中,package 名字叫做 lm,定义了一个消息 helloworld,该消息有三个成员,类型为 int32 的 id,另一个为类型为 string 的成员 str。opt 是一个可选的成员,即消息中可以不包含该成员。1、2、3这几个数字是这三个字段的唯一标识符,这些标识符是用来在消息的二进制格式中识别各个字段的,一旦开始使用就不能够再改变。

编译 .proto 文件

我们可以使用protobuf.js提供的命令行工具来编译 .proto 文件

用法:

# pbjs <filename> [options] [> outFile]

我们来看看options:

  --help, -h        Show help  [boolean] 查看帮助
  --version, -v     Show version number  [boolean] 查看版本号
  --source, -s      Specifies the source format. Valid formats are:

                       json       Plain JSON descriptor
                       proto      Plain .proto descriptor
指定来源文件格式,可以是json或proto文件

  --target, -t      Specifies the target format. Valid formats are:

                       amd        Runtime structures as AMD module
                       commonjs   Runtime structures as CommonJS module
                       js         Runtime structures
                       json       Plain JSON descriptor
                       proto      Plain .proto descriptor
指定生成文件格式,可以是符合amd或者commonjs规范的js文件,或者是单纯的js/json/proto文件。

  --using, -u       Specifies an option to apply to the volatile builder
                    loading the source, e.g. convertFieldsToCamelCase.
  --min, -m         Minifies the output.  [default: false] 压缩生成文件
  --path, -p        Adds a directory to the include path.
  --legacy, -l      Includes legacy descriptors from google/protobuf/ if
                    explicitly referenced.  [default: false]
  --quiet, -q       Suppresses any informatory output to stderr.  [default: false]
  --use, -i         Specifies an option to apply to the emitted builder
                    utilized by your program, e.g. populateAccessors.
  --exports, -e     Specifies the namespace to export. Defaults to export
                    the root namespace.
  --dependency, -d  Library dependency to use when generating classes.
                    Defaults to ‘protobufjs‘ for CommonJS, ‘ProtoBuf‘ for
                    AMD modules and ‘dcodeIO.ProtoBuf‘ for classes.

重点关注- -target就好,由于我们是在Node环境中使用,因此选择生成符合commonjs规范的文件,命令如下:

# ./pbjs ../../lm.message.proto  -t commonjs > ../../lm.message.js

得到编译后的符合commonjs规范的js文件:

module.exports = require("protobufjs").newBuilder({})[‘import‘]({
    "package": "lm",
    "messages": [
        {
            "name": "helloworld",
            "fields": [
                {
                    "rule": "required",
                    "type": "int32",
                    "name": "id",
                    "id": 1
                },
                {
                    "rule": "required",
                    "type": "string",
                    "name": "str",
                    "id": 2
                },
                {
                    "rule": "optional",
                    "type": "int32",
                    "name": "opt",
                    "id": 3
                }
            ]
        }
    ]
}).build();

编写 Writer

var HelloWorld = require(‘./lm.helloworld.js‘)[‘lm‘][‘helloworld‘];
var fs = require(‘fs‘);

// 除了这种传入一个对象的方式, 你也可以使用get/set 函数用来修改和读取结构化数据中的数据成员
var hw = new HelloWorld({
    ‘id‘: 101,
    ‘str‘: ‘Hello‘
})

var buffer = hw.encode();

fs.writeFile(‘./test.log‘, buffer.toBuffer(), function(err) {
    if(!err) {
        console.log(‘done!‘);
    }
});

编写Reader

var HelloWorld = require(‘./lm.helloworld.js‘)[‘lm‘][‘helloworld‘];
var fs = require(‘fs‘);

var buffer = fs.readFile(‘./test.log‘, function(err, data) {
    if(!err) {
        console.log(data); // 来看看Node里的Buffer对象长什么样子。
        var message = HelloWorld.decode(data);
        console.log(message);
    }
})

运行结果

由于我们没有在Writer中给可选字段opt字段赋值,因此Reader读出来的opt字段值为null

这个例子本身并无意义,但只要您稍加修改就可以将它变成更加有用的程序。比如将磁盘替换为网络 socket,那么就可以实现基于网络的数据交换任务。而存储和交换正是 Protobuf 最有效的应用领域。

再举一个栗子

俗话说得好:“世界上没有什么技术问题是不能用一个helloworld的栗子解释清楚的,如果不行,那就用两个!”

在这个栗子中,我们来实现基于网络的数据交换任务。

编写.proto

cover.helloworld.proto文件:

package cover;

message helloworld {

    message helloCoverReq {
        required string name = 1;
    }

    message helloCoverRsp {
        required int32 retcode = 1;
        optional string reply = 2;
    }
}

编写client

一般情况下,使用 Protobuf 的人们都会先写好 .proto 文件,再用 Protobuf 编译器生成目标语言所需要的源代码文件。将这些生成的代码和应用程序一起编译。

可是在某些情况下,人们无法预先知道 .proto 文件,他们需要动态处理一些未知的 .proto 文件。比如一个通用的消息转发中间件,它不可能预知需要处理怎样的消息。这需要动态编译 .proto 文件,并使用其中的 Message。

我们这里决定利用protobuf文件可以动态编译的特性,在代码中直接读取proto文件,动态生成我们需要的commonjs模块。

client.js

var dgram = require(‘dgram‘);
var ProtoBuf = require("protobufjs");
var PORT = 33333;
var HOST = ‘127.0.0.1‘;

var builder = ProtoBuf.loadProtoFile("./cover.helloworld.proto"),
    Cover = builder.build("cover"),
    HelloCoverReq = Cover.helloworld.helloCoverReq;
    HelloCoverRsp = Cover.helloworld.helloCoverRsp;

var hCReq = new HelloCoverReq({
    name: ‘R U coverguo?‘
})

var buffer = hCReq.encode();

var socket = dgram.createSocket({
    type: ‘udp4‘,
    fd: 8080
}, function(err, message) {
    if(err) {
        console.log(err);
    }

    console.log(message);
});

var message = buffer.toBuffer();

socket.send(message, 0, message.length, PORT, HOST, function(err, bytes) {
    if(err) {
        throw err;
    }

    console.log(‘UDP message sent to ‘ + HOST +‘:‘+ PORT);
});

socket.on("message", function (msg, rinfo) {
    console.log("[UDP-CLIENT] Received message: " + HelloCoverRsp.decode(msg).reply + " from " + rinfo.address + ":" + rinfo.port);
    console.log(HelloCoverRsp.decode(msg));

    socket.close();

    //udpSocket = null;
});

socket.on(‘close‘, function(){
    console.log(‘socket closed.‘);

});

socket.on(‘error‘, function(err){
    socket.close();

    console.log(‘socket err‘);
    console.log(err);
});

书写server

server.js

var PORT = 33333;
var HOST = ‘127.0.0.1‘;
var ProtoBuf = require("protobufjs");
var dgram = require(‘dgram‘);
var server = dgram.createSocket(‘udp4‘);

var builder = ProtoBuf.loadProtoFile("./cover.helloworld.proto"),
    Cover = builder.build("cover"),
    HelloCoverReq = Cover.helloworld.helloCoverReq;
    HelloCoverRsp = Cover.helloworld.helloCoverRsp;

server.on(‘listening‘, function () {
    var address = server.address();
    console.log(‘UDP Server listening on ‘ + address.address + ":" + address.port);
});

server.on(‘message‘, function (message, remote) {
    console.log(remote.address + ‘:‘ + remote.port +‘ - ‘ + message);
    console.log(HelloCoverReq.decode(message) + ‘from client!‘);
    var hCRsp = new HelloCoverRsp({
        retcode: 0,
        reply: ‘Yeah!I\‘m handsome cover!‘
    })

    var buffer = hCRsp.encode();
    var message = buffer.toBuffer();
    server.send(message, 0, message.length, remote.port, remote.address, function(err, bytes) {
        if(err) {
            throw err;
        }

        console.log(‘UDP message reply to ‘ + remote.address +‘:‘+ remote.port);
    })

});

server.bind(PORT, HOST);

运行结果

其他高级特性

嵌套Message

message Person {
  required string name = 1;
  required int32 id = 2;        // Unique ID number for this person.
  optional string email = 3; 

  enum PhoneType {
    MOBILE = 0;
    HOME = 1;
    WORK = 2;
  } 

  message PhoneNumber {
    required string number = 1;
    optional PhoneType type = 2 [default = HOME];
  }
  repeated PhoneNumber phone = 4;
 }

在 Message Person 中,定义了嵌套消息 PhoneNumber,并用来定义 Person 消息中的 phone 域。这使得人们可以定义更加复杂的数据结构。

Import Message

在一个 .proto 文件中,还可以用 Import 关键字引入在其他 .proto 文件中定义的消息,这可以称做 Import Message,或者 Dependency Message。

比如下例:

import common.header; 

 message youMsg{
  required common.info_header header = 1;
  required string youPrivateData = 2;
 }

其中 ,common.info_header定义在common.header包内。

Import Message 的用处主要在于提供了方便的代码管理机制,类似 C 语言中的头文件。您可以将一些公用的 Message 定义在一个 package 中,然后在别的 .proto 文件中引入该 package,进而使用其中的消息定义。

Google Protocol Buffer 可以很好地支持嵌套 Message 和引入 Message,从而让定义复杂的数据结构的工作变得非常轻松愉快。

总结一下

优点

简单说来 Protobuf 的主要优点就是:简洁,快。

为什么这么说呢?

简洁

因为Protocol Buffer 信息的表示非常紧凑,这意味着消息的体积减少,自然需要更少的资源。比如网络上传输的字节数更少,需要的 IO 更少等,从而提高性能。

对于代码清单 1 中的消息,用 Protobuf 序列化后的字节序列为:

08 65 12 06 48 65 6C 6C 6F 77

而如果用 XML,则类似这样:

31 30 31 3C 2F 69 64 3E 3C 6E 61 6D 65 3E 68 65
 6C 6C 6F 3C 2F 6E 61 6D 65 3E 3C 2F 68 65 6C 6C
 6F 77 6F 72 6C 64 3E 

一共 55 个字节,这些奇怪的数字需要稍微解释一下,其含义用 ASCII 表示如下:
 <helloworld>
    <id>101</id>
    <name>hello</name>
 </helloworld>

我相信与XML一样同为文本序列化协议的JSON也不会好到哪里去。

首先我们来了解一下 XML 的封解包过程。XML 需要从文件中读取出字符串,再转换为 XML 文档对象结构模型。之后,再从 XML 文档对象结构模型中读取指定节点的字符串,最后再将这个字符串转换成指定类型的变量。这个过程非常复杂,其中将 XML 文件转换为文档对象结构模型的过程通常需要完成词法文法分析等大量消耗 CPU 的复杂计算。

反观 Protobuf,它只需要简单地将一个二进制序列,按照指定的格式读取到编程语言对应的结构类型中就可以了。而消息的 decoding 过程也可以通过几个位移操作组成的表达式计算即可完成。速度非常快。

缺点

作为二进制的序列化协议,人眼不可读!

参考文档

Google Protocol Buffer 的使用和原理

Protobuf 语法指南

时间: 04-03

在NodeJS中玩转Protocol Buffer的相关文章

在 go/golang语言中使用 google Protocol Buffer

怎么在go语言中实用google protocol Buffer呢? 现在的潮流趋势就是一键搞定,跟ubuntu安装软件一样 go get code.google.com/p/goprotobuf/{proto,protoc-gen-go} go install  code.google.com/p/goprotobuf/proto 搞定,可以在 $GO_PATH/bin下找到 protoc-gen-go 这个程序,那么就可以实用protoc-gen-go 进行go语言的proto文件的自动生成

golang环境protocol buffer的安装

怎么在go语言中使用google protocol Buffer呢? 1.下载相应的proto版本:https://github.com/google/protobuf/releases 2.把bin下的protoc文件 copy到GOPATH目录和/usr/local/bin目录里 3.下载protoc-gen-go插件:https://github.com/golang/protobuf/ 4.把上述文件拷贝到GOPATH路径下 5.cd到protobuf下执行make 6.到GOPATH目

Android:手把手带你分析 Protocol Buffer使用 源码

前言 习惯用 Json.XML 数据存储格式的你们,相信大多都没听过Protocol Buffer Protocol Buffer 其实 是 Google出品的一种轻量 & 高效的结构化数据存储格式,性能比 Json.XML 真的强!太!多! 由于 Google出品,我相信Protocol Buffer已经具备足够的吸引力 今天,我将讲解Protocol Buffer使用的源码分析,并解决以下两个问题: a. Protocol Buffer序列化速度 & 反序列化速度为何如此快 b. Pr

Protocol buffer序列化及其在微信蓝牙协议中的应用

Protocol buffer是Google出品的一种轻便高效的结构化数据存储格式,可对结构化数据进行序列化,并具有语言无关.平台无关等特点,在通信协议和数据存储等领域已经得到广泛的应用.目前其已经提供 C/C++.Java.Python 等语言的 API. 一.Protocol buffer和XML 在数据通信传输时,一般需要将结构化的数据序列化成流进行传送,接收方再反序列化为原始格式数据进行处理.在Web通信领域,XML应用算是最通用的了.在时间性能上,虽然XML的序列化开销还可以,但是反序

在C++中使用Protocol Buffer

之前我翻译过两篇关于protocol buffers的文章:<protocol buffers简单介绍><在Python中使用protocol buffers参考指南> 后来想想,现在自己是用在C++中的,不如再翻译一下,顺便看看自己的E文有没有提高.当然,查字典是少不了的. 翻译自:https://developers.google.com/protocol-buffers/docs/cpptutorial Protocol Buffer基础: C++ 这个教程是教你怎样在c++

「Protocol Buffer」之PB在HTTP协议中的应用

「Protocol Buffer」系列教程 1.「Protocol_Buffer」之基本使用与格式定义2.「Protocol Buffer」之PB在HTTP协议中的应用 客户端代码 本例中分别演示了http+json的通信方式与http+Protocol Buffer的通信方式:本例中的测试用例使用qtaf框架进行管理,实际应用可以视需求而定,只关注核心逻辑即可: # -*- coding: utf-8 -*- from testbase.testcase import TestCase fro

Netty对Protocol Buffer多协议的支持(八)

Netty对Protocol Buffer多协议的支持(八) 一.背景 在上篇博文中笔者已经用代码演示了如何在netty中使用Protocol Buffer,然而细心的用户可能会发现一个明显的不足之处就是,我们的Handler只能处理一种特定的类型,而我们的项目中又不可能只有一种类型,那么这个问题该怎么解决了?多的不说,笔者直接上代码. 二.代码实现 2.1 message的编写 syntax = "proto2"; package com.rsy.netty.protobuf; op

Ggoogle Protocol Buffer的使用 (基于C++语言)

首先说明的是Protocol Buffle是灵活高效的.它的一个很好的优点(很重要的,我认为)就是后向兼容性--当我们扩展了了.proto文件后,我们照样可以用它来读取之前生成的文件. 下面的例子,为了实现我们的一个应用 :通讯录,它包含一个人的名字,ID,电子邮件,联系电话,并实现存储与读取. 第一步,定义一个 .proto 文件 /* 首先是一个 package名称的声明,它的作用就是防止出现名字的冲突: 当生成C++代码的时候,对应的pacage名称会生成一个相同名字的命名空间. */ p

protocol buffer和当年corba ,和现在SOA有啥异同点

CORBA是对象管理集团(OMG)的一个标准,使得不同语言编写的,运行在不同计算机上的能够协同工作.标准包括分布式计算的通讯协议(GIOP和IIOP),可映射到多种语言的接口描述语言(IDL),对象请求代理(ORB)以及相关服务,如生命周期,全局事务,持久性等. SOA是以可互操作的服务的形式设计和开发软件的一系列原则和方法.SOQ是一种抽象的方法,和具体的技术无关,但是一般来说,涉及Web服务和企业服务总线(ESB)技术有关.下面比较SOA的异同时主要是指这两项技术. Web服务是用来 支持网