`
QING____
  • 浏览: 2228424 次
  • 性别: Icon_minigender_1
  • 来自: 北京
社区版块
存档分类
最新评论

Protobuf与JAVA

 
阅读更多

    我们在开发一些RPC调用的程序时,通常会涉及到对象的序列化/反序列化的问题,比如一个“Person”对象从Client端通过TCP方式发送到Server端;因为TCP协议(UDP等这种低级协议)只能发送字节流,所以需要应用层将Java对象序列化成字节流,数据接收端再反序列化成Java对象即可。“序列化”一定会涉及到编码(encoding,format),目前我们可选择的编码方式:

    1)使用JSON,将java对象转换成JSON结构化字符串。在web应用、移动开发方面等,基于Http协议下,这是常用的,因为JSON的可读性较强。性能稍差。

    2)基于XML,和JSON一样,数据在序列化成字节流之前,都转换成字符串。可读性强,性能差,异构系统、open api类型的应用中常用。

    3)使用JAVA内置的编码和序列化机制,可移植性强,性能稍差。无法跨平台(语言)。

    4)其他开源的序列化/反序列化框架,比如Apache Avro,Apache Thrift,这两个框架和Protobuf相比,性能非常接近,而且设计原理如出一辙;其中Avro在大数据存储(RPC数据交换,本地存储)时比较常用;Thrift的亮点在于内置了RPC机制,所以在开发一些RPC交互式应用时,Client和Server端的开发与部署都非常简单。

 

    评价一个序列化框架的优缺点,大概有2个方面:1)结果数据大小,原则上说,序列化后的数据尺寸越小,传输效率越高。 2)结构复杂度,这会影响序列化/反序列化的效率,结构越复杂,越耗时。

 

    Protobuf是一个高性能、易扩展的序列化框架,它的性能测试有关数据可以参看官方文档。通常在TCP Socket通讯(RPC调用)相关的应用中使用;它本身非常简单,易于开发,而且结合Netty框架可以非常便捷的实现一个RPC应用程序,同时Netty也为Protobuf解决了有关Socket通讯中“半包、粘包”等问题(反序列化时,字节成帧)。

 

1、安装Protobuf

    从“https://developers.google.com/protocol-buffers/docs/downloads”下载安装包,windows下的使用不再赘言;在linux或者mac下,下载tar.gz的压缩包,解压后执行:

$ ./configure
$ make
$ make check
$ make install

 

    此后,可以通过“protoc --version”查看是否安装成功了,安装过程不需要配置环境变量。安装主要是为了能够使用命令编译proto文件,实际部署环境并不需要。

 

2、样例

    Protobuf需要一个schema声明文件,后缀为“.proto”的文本文件,内容样例如下:

option java_package = "com.test.protobuf";
option java_outer_classname="PersonProtos";

message Person {
  required string name = 1;
  required int32 id = 2;
  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;
}

 

    如果你曾经使用过thrift、avro,你会发现它们都需要一个类似的schema文件,只是结构规则不同罢了。特别备注:protbuf和thrift的声明文件相似度极高。

    “message”表示,声明一个“类”,即java中的class。message中可以内嵌message,就像java的内部类一样。一个message有多个filed,“required string name = 1”则表示:name字段在序列化、反序列化时为第一个字段,string类型,“required”表示这个字段的值是必选;可以看出每个filed都至少有着三个部分组成,其中filed的“位置index”全局唯一。“optional”表示这个filed是可选的(允许为null)。“repeated”表示这个filed是一个集合(list)。也可以通过[default = ]为一个“optional”的filed指定默认值。

 

    我们可以在一个.proto文件中声明多个“message”,不过大部分情况下我们把互相继承或者依赖的类写入一个.proto文件,将那些没有关联关系的类分别写入不同的文件,这样便于管理。

 

 

    我们可以在.proto文件的头部声明一些额外的信息,比如“java_package”表示当“generate code”时将生成的java代码放入指定的package中。“java_outer_classname”表示生成的java类的名称。

 

    然后执行如下命令,生成JAVA代码:

protoc --java_out=./ Persion.proto

 

    通过“--java_out”指定生成JAVA代码保存的目录,后面紧跟“.proto”文件的路径。此后我们看到生成 了Package和一个PersonProto.java文件,我们只需要把此java文件复制到项目中即可。

 

3、JAVA实例

    1)pom.xml

<dependency>
     <groupId>com.google.protobuf</groupId>
     <artifactId>protobuf-java</artifactId>
     <version>2.6.1</version>
</dependency>

 

    2)测试:

        PersonProtos.Person.Builder personBuilder = PersonProtos.Person.newBuilder();
        personBuilder.setEmail("test@gmail.com");
        personBuilder.setId(1000);
        PersonProtos.Person.PhoneNumber.Builder phone = PersonProtos.Person.PhoneNumber.newBuilder();
        phone.setNumber("18610000000");

        personBuilder.setName("张三");
        personBuilder.addPhones(phone);

        PersonProtos.Person person = personBuilder.build();

 

    获得到person实例后,我们可以通过如下方式,将person对象序列化、反序列化。

        //第一种方式
        //序列化
        byte[] data = person.toByteArray();//获取字节数组,适用于SOCKET或者保存在磁盘。
        //反序列化
        PersonProtos.Person result = PersonProtos.Person.parseFrom(data);
        System.out.println(result.getEmail());

    

   这种方式,适用于很多场景,Protobuf会根据自己的encoding方式,将JAVA对象序列化成字节数组。同时Protobuf也可以从字节数组中重新decoding,得到Java新的实例。

        //第二种序列化:粘包,将一个或者多个protobuf对象字节写入stream。
        ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
        //生成一个由:[字节长度][字节数据]组成的package。特别适合RPC场景
        person.writeDelimitedTo(byteArrayOutputStream);
        //反序列化,从steam中读取一个或者多个protobuf字节对象
        ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(byteArrayOutputStream.toByteArray());
        result = PersonProtos.Person.parseDelimitedFrom(byteArrayInputStream);
        System.out.println(result.getEmail());

 

    第二种方式,是RPC调用中、Socket传输时适用,在序列化的字节数组之前,添加一个varint32的数字表示字节数组的长度;那么在反序列化时,可以通过先读取varint,然后再依次读取此长度的字节;这种方式有效的解决了socket传输时如何“拆包”“封包”的问题。在Netty中,适用了同样的技巧。

 

        //第三种序列化,写入文件或者Socket
        FileOutputStream fileOutputStream = new FileOutputStream(new File("/test.dt"));
        person.writeTo(fileOutputStream);
        fileOutputStream.close();

        FileInputStream fileInputStream = new FileInputStream(new File("/test.dt"));
        result = PersonProtos.Person.parseFrom(fileInputStream);
        System.out.println(result);

 

    第三种方式,比较少用。但是比较通用,意思为将序列化的字节数组写入到OutputStream中,具体的拆包工作,交给了高层框架。

 

4、protobuf入门介绍

    以上述Person.proto文件为例:

message Person {
  required string name = 1;
  required int32 id = 2;
  optional string email = 3;
}

 

    声明了三个filed,每个filed都“规则”、“类型”、“字段名称”和一个“唯一的数字tag”。

    1)其中“规则”可以为如下几个值:

    “required”:表示此字段值必填,一个结构良好的message至少有一个flied为“required”。

    “optional”:表示此字段值为可选的。对于此类型的字段,可以通过default来指定默认值,这是一个良好的设计习惯。

    

optional int32 page = 3 [default = 10];
 

 

    如果没有指定默认值,在encoding时protobuf将会用一个特殊的默认值来替代。对于string,默认值为空,bool类型默认为false,数字类型默认位0,对于enum则默认值为枚举列表的第一个值。

 

    “repeated”:表示这个字段的值可以允许被重复多次,如果转换成JAVA代码,此filed数据结构为list,有序的。可以在“repeated”类型的filed后使用“packed”--压缩,提高数据传输的效率。

 

repeated int32 numbers = 4 [packed=true];
 

 

    特别需要注意:当你指定一个filed位required时,需要慎重考虑这个filed是否永远都是“必须的”。将一个required调整为optional,需要同时重新部署数据通讯的Client和Server端,否则将会对解析带来问题。

 

    2)可以在一个.proto文件中,同时声明多个message,这样是允许的。

    3)为message或者filed添加注释,风格和JAVA一样:

 

optional int32 page = 3;// Which page number do we want?
 

 

    4)数据类型与JAVA对应关系:

protobuf java
double double
float float
int32 int
int64 long
bool boolean
string String
bytes ByteString

 

    其中“ByteString”是Protobuf自定义的JAVA API。

 

     5)枚举:和JAVA中Enum API一致,如果开发者希望某个filed的值只能在一些限定的列表中,可以将次filed声明为enum类型。Protobuf中,enum类型的每个值是一个int32的数字,不像JAVA中那样enum可以定义的非常复杂。如果enum中有些值是相同的,可以将“allow_alias”设定为true。

message Person {
  required Type type = 1;
  
  enum Type {
  option allow_alias = true;
    TEACHER = 0;
    STUDENT = 1;
    OTHER = 1;//the same as STUDENT
  }
}

 

     6)import:如果当前.proto文件中引用了其他proto文件的message类型,那么可以在此文件的开头声明import。

import "other_protos.proto";

 

    不过这会引入一个小小的麻烦,如果你的“other_protos.proto”文件变更了目录,需要连带修改其他文件。

 

    7)嵌入message:类似于java的内部类,即在message中,嵌入其他message。如Person.proto例子中的PhoneNumber。

 

    8)更新message类型:如果一个现有的message类型无法满足当前的需要,比如你需要新增一个filed,但是仍然希望使用生成的旧代码来解析。

        (1)不要修改现有fileds的数字tag,即字段的index数字。

        (2)新增字段必须为optional或者repeated类型,同时还要为它们设置“default”值,这意味着“old”代码序列化的messages能够被“new”代码解析。“new”代码生成的数据也能被“old”代码解析,对于“old”代码而言,那些没有被声明的filed将会在解析式忽略。

        (3)非“required”filed可以被删除,但是它的“数字tag”不能被其他字段重用。

        (4)int32、uint32、int64、uint64、bool,是互相兼容的,它们可以从一个类型修改成另外一个,而不会对程序带来错误。参见源码WireFormat.FiledType

        (5)sint32和sint64是兼容的,但和其他数字类型是不兼容的。

        (6)string和bytes是兼容的,只要为UTF-8编码的。注意protobuf中string默认是UTF-8编码的。

        (7)optional与repeated是兼容的。如果输入的数据格式是repeated,但是client希望接受的数据是optional,对于原生类型,那么client将会使用repeated的最后一个值,对于message类型,client将会merge这些输入的数据。

        (8)修改“default”值通常不会有任何问题,只要保证这个默认值不会被真正的使用。

 

    9)Map结构:

map<key_type, value_type> map = 3;

 

    其中key_type可以为任何“整形”或者string类型,value_type可以为任意类型,只要JAVA API能够支持。map类型不能被“repeated”、“optional”或者“required”修饰,传输过程中无法确保map中数据的顺序,

对于文本格式,map是按照key排序。

 

    10)如下为一些有用的选项:

        (1)java_package:在.proto文件的顶部设定,指定生成JAVA文件时类所在的package。

option java_package = "com.example.foo";

 

        (2)java_outer_classname:在.proto文件的顶部设定,指定生成JAVA文件时类的名字。一个.proto文件只会生成一个JAVA类。

option java_outer_classname = "FooProtos";

 

        (3)packed:对于repeated类型有效,指定输入的数据是否“压缩”。

 

5、protobuf序列化原理:

    其实protobuf的序列化原理并不是什么高超的“绝技”:如果你曾经了解过thrift、avro,或者从事过socket通信,那么你对protobuf的序列化方式并不感到惊奇;如下为protobuf的序列化format:

 

    [serializedSize]{[int32(tag,type)][value]...}

 

 

    对于一个message,序列化时首先就算这个message所有filed序列化需要占用的字节长度,计算这个长度是非常简单的,因为protobuf中每种类型的filed所占用的字节数是已知的(bytes、string除外),只需要累加即可。这个长度就是serializedSize,32为integer,在protobuf的某些序列化方式中可能使用varint32(一个压缩的、根据数字区间,使用不同字节长度的int);此后是filed列表输出,每个filed输出包含int32(tag,type)和value的字节数组,从上文我们知道每个filed都有一个唯一的数字tag表示它的index位置,type为字段的类型,tag和type分别占用一个int的高位、低位字节如果filed为string、bytes类型,还会在value之前额外的补充添加一个varint32类型的数字,表示string、bytes的字节长度。

    那么在反序列化的时候,首先读取一个32为的int表示serializedSize,然后读取serializedSize个字节保存在一个bytebuffer中,即读取一个完整的package。然后读取一个int32数字,从这个数字中解析出tag和type,如果type为string、bytes,然后补充读取一个varint32就知道了string的字节长度了,此后根据type或者字节长度,读取后续的字节数组并转换成java type。重复上述操作,直到整个package解析完毕。

 

    protobuf的这种序列化format,极大的介绍了输入、输出的数据大小,而且复杂度非常低,从而性能较高。

 

6、protobuf与Netty编程:

    1)Netty Server端样例

 

public class ProtobufNettyServerTestMain {

    public static void main(String[] args) {
        //bossGroup : NIO selector threadPool
        EventLoopGroup bossGroup = new NioEventLoopGroup();
        //workerGroup : socket data read-write worker threadPool
        EventLoopGroup workerGroup = new NioEventLoopGroup();
        try {
            ServerBootstrap bootstrap = new ServerBootstrap();
            bootstrap.group(bossGroup,workerGroup)
                    .channel(NioServerSocketChannel.class)
                    .childHandler(new ChannelInitializer<SocketChannel>() {
                        @Override
                        protected void initChannel(SocketChannel ch) throws Exception {
                            ch.pipeline().addLast(new ProtobufVarint32FrameDecoder())
                                    .addLast(new ProtobufDecoder(PersonProtos.Person.getDefaultInstance()))
                                    .addLast(new ProtobufVarint32LengthFieldPrepender())
                                    .addLast(new ProtobufEncoder())
                                    .addLast(new ProtobufServerHandler());//自定义handler
                        }
                    }).childOption(ChannelOption.TCP_NODELAY,true);
            System.out.println("begin");
            //bind到本地的18080端口
            ChannelFuture future = bootstrap.bind(18080).sync();
            //阻塞,直到channel.close
            future.channel().closeFuture().sync();
            System.out.println("end");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            //辅助线程优雅退出
            workerGroup.shutdownGracefully();
            bossGroup.shutdownGracefully();
        }
    }
}

 

 

    备注:channel内部维护一个pipeline,类似一个filter链表一样,所有的socket读写都会经过,对于write操作(outbound)会从pipeline列表的last-->first方向依次调用Encoder处理器;对于read操作(inbound)会从first-->last依次调用Decoder处理器。此外Encoder处理对于read操作不起效,Decoder处理器对write操作不起效,原理 稍后在Netty相关章节介绍。

 

    ProtobufEncoder:非常简单,内部直接使用了message.toByteArray()将字节数据放入bytebuf中输出(out中,交由下一个encoder处理)。

    ProtobufVarint32LengthFieldPrepender:因为ProtobufEncoder只是将message的各个filed按照规则输出了,并没有serializedSize,所以socket无法判定package(封包)。这个Encoder的作用就是在ProtobufEncoder生成的字节数组前,prepender一个varint32数字,表示serializedSize。

    ProtobufVarint32FrameDecoder:这个decoder和Prepender做的工作正好对应,作用就是“成帧”,根据seriaziedSize读取足额的字节数组--一个完整的package。

    ProtobufDecoder:和ProtobufEncoder对应,这个Decoder需要指定一个默认的instance,decoder将会解析byteArray,并根据format规则为此instance中的各个filed赋值。

    

 

    2)ProtobufServerHandler.java

    发送Protobuf数据和接收client发送的数据。一个自定义的处理器,通常我们的业务会在这里处理。

 

public class ProtobufServerHandler extends ChannelInboundHandlerAdapter {


    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        PersonProtos.Person person = (PersonProtos.Person)msg;
       //经过pipeline的各个decoder,到此Person类型已经可以断定
        System.out.println(person.getEmail());
        ChannelFuture future = ctx.writeAndFlush(build());
        //发送数据之后,我们手动关闭channel,这个关闭是异步的,当数据发送完毕后执行。
        future.addListener(ChannelFutureListener.CLOSE);
    }

    /**
     * 构建一个Protobuf实例,测试
     * @return
     */
    public MessageLite build() {
        PersonProtos.Person.Builder personBuilder = PersonProtos.Person.newBuilder();
        personBuilder.setEmail("zhangsan@gmail.com");
        personBuilder.setId(1000);
        PersonProtos.Person.PhoneNumber.Builder phone = PersonProtos.Person.PhoneNumber.newBuilder();
        phone.setNumber("18610000000");

        personBuilder.setName("张三");
        personBuilder.addPhones(phone);

        return personBuilder.build();
    }

}

 

    3)Netty Client样例

 

public class ProtobufNettyClientTestMain {

    public static void main(String[] args) throws Exception{
        EventLoopGroup workerGroup = new NioEventLoopGroup();
        try {
            Bootstrap bootstrap = new Bootstrap();
            bootstrap.group(workerGroup)
                    .channel(NioSocketChannel.class)
                    .option(ChannelOption.CONNECT_TIMEOUT_MILLIS,10000)
                    .handler(new ChannelInitializer<SocketChannel>() {
                        @Override
                        protected void initChannel(SocketChannel ch) throws Exception {
                            System.out.println("initChannel");
                            ch.pipeline().addLast(new ProtobufVarint32FrameDecoder())
                                    .addLast(new ProtobufDecoder(PersonProtos.Person.getDefaultInstance()))
                                    .addLast(new ProtobufVarint32LengthFieldPrepender())
                                    .addLast(new ProtobufEncoder())
                                    .addLast(new ProtobufClientHandler());
                        }
                    });
            ChannelFuture future = bootstrap.connect(new InetSocketAddress("127.0.0.1", 18080));
            System.out.println("begin");
            future.channel().closeFuture().sync();
            System.out.println("Closed");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            workerGroup.shutdownGracefully();
        }

    }
}

 

    4)ProtobufClientHandler.java

 

public class ProtobufClientHandler extends ChannelInboundHandlerAdapter {


    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        //当channel就绪后,我们首先通过client发送一个数据。
        ctx.writeAndFlush(build());
    }

    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {

        PersonProtos.Person person = (PersonProtos.Person)msg;
        System.out.println(person.getEmail());
    }

    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) {
        cause.printStackTrace();;
        ctx.close();
    }

    public MessageLite build() {
        PersonProtos.Person.Builder personBuilder = PersonProtos.Person.newBuilder();
        personBuilder.setEmail("lisi@gmail.com");
        personBuilder.setId(1000);
        PersonProtos.Person.PhoneNumber.Builder phone = PersonProtos.Person.PhoneNumber.newBuilder();
        phone.setNumber("18610000000");

        personBuilder.setName("李四");
        personBuilder.addPhones(phone);

        return personBuilder.build();
    }

}

 

    关于Netty的相关技术,请参考其他文档。

 

    到此为止,我们基本上对protobuf使用方式,有了初步的了解。祝大家好运!

 

 

 

分享到:
评论
2 楼 QING____ 2018-09-26  
penkee 写道
我有疑问,看dubbo的设计,是无侵入式的。意思就是原来类接口参数不改动。你只搞一个Person,那么实际不同的VO是如何转成成对应的Msg的。
比如
UserInfoVo getUser(int id);
AddressVo getAddressByCity(CityVo city);

代理方法拦截所有,怎么将不同类型VO转成通用的呢,然后有怎么转出返回客户端呢


哥们,是不是发错地址了?
1 楼 penkee 2018-09-19  
我有疑问,看dubbo的设计,是无侵入式的。意思就是原来类接口参数不改动。你只搞一个Person,那么实际不同的VO是如何转成成对应的Msg的。
比如
UserInfoVo getUser(int id);
AddressVo getAddressByCity(CityVo city);

代理方法拦截所有,怎么将不同类型VO转成通用的呢,然后有怎么转出返回客户端呢

相关推荐

    protobuf-java-3.11.4-API文档-中文版.zip

    赠送jar包:protobuf-java-3.11.4.jar; 赠送原API文档:protobuf-java-3.11.4-javadoc.jar; 赠送源代码:protobuf-java-3.11.4-sources.jar; 赠送Maven依赖信息文件:protobuf-java-3.11.4.pom; 包含翻译后的API...

    protobuf-java-3.16.1-API文档-中文版.zip

    赠送jar包:protobuf-java-3.16.1.jar; 赠送原API文档:protobuf-java-3.16.1-javadoc.jar; 赠送源代码:protobuf-java-3.16.1-sources.jar; 赠送Maven依赖信息文件:protobuf-java-3.16.1.pom; 包含翻译后的API...

    protobuf-java完整包(jar+source+javadoc)

    protobuf-java完整包(jar+source+javadoc+本地编译器),难得资源,直接导入可用! 使用教程: 1. 编辑build.bat,根据build.bat内设置的路径,把.proto文件放到相应的文件夹内,执行build.bat即可把.proto文件编译...

    protobuf-java-3.2.0.jar

    protobuf-java-3.2.0.jar

    protobuf-java-3.7.1-API文档-中文版.zip

    赠送jar包:protobuf-java-3.7.1.jar; 赠送原API文档:protobuf-java-3.7.1-javadoc.jar; 赠送源代码:protobuf-java-3.7.1-sources.jar; 赠送Maven依赖信息文件:protobuf-java-3.7.1.pom; 包含翻译后的API文档...

    protobuf-java-3.1.0.jar

    protobuf-java-3.1.0.jar

    protobuf-java-2.4.1

    protobuf-java-2.4.1.jar

    protobuf-java-util-shaded-351-0.9-API文档-中英对照版.zip

    赠送jar包:protobuf-java-util-shaded-351-0.9.jar; 赠送原API文档:protobuf-java-util-shaded-351-0.9-javadoc.jar; 赠送源代码:protobuf-java-util-shaded-351-0.9-sources.jar; 赠送Maven依赖信息文件:...

    protobuf-java-3.11.4-API文档-中英对照版.zip

    赠送jar包:protobuf-java-3.11.4.jar; 赠送原API文档:protobuf-java-3.11.4-javadoc.jar; 赠送源代码:protobuf-java-3.11.4-sources.jar; 赠送Maven依赖信息文件:protobuf-java-3.11.4.pom; 包含翻译后的API...

    protobuf-java-2.5.0-API文档-中文版.zip

    赠送jar包:protobuf-java-2.5.0.jar; 赠送原API文档:protobuf-java-2.5.0-javadoc.jar; 赠送源代码:protobuf-java-2.5.0-sources.jar; 赠送Maven依赖信息文件:protobuf-java-2.5.0.pom; 包含翻译后的API文档...

    protobuf-java-3.8.0-API文档-中英对照版.zip

    赠送jar包:protobuf-java-3.8.0.jar; 赠送原API文档:protobuf-java-3.8.0-javadoc.jar; 赠送源代码:protobuf-java-3.8.0-sources.jar; 赠送Maven依赖信息文件:protobuf-java-3.8.0.pom; 包含翻译后的API文档...

    protobuf-java-util-shaded-351-0.9-API文档-中文版.zip

    赠送jar包:protobuf-java-util-shaded-351-0.9.jar; 赠送原API文档:protobuf-java-util-shaded-351-0.9-javadoc.jar; 赠送源代码:protobuf-java-util-shaded-351-0.9-sources.jar; 赠送Maven依赖信息文件:...

    protobuf-java-shaded-351-0.9-API文档-中英对照版.zip

    赠送jar包:protobuf-java-shaded-351-0.9.jar; 赠送原API文档:protobuf-java-shaded-351-0.9-javadoc.jar; 赠送源代码:protobuf-java-shaded-351-0.9-sources.jar; 赠送Maven依赖信息文件:protobuf-java-...

    protoc.exe和protobuf-java-3.6.1集合

    protoc.exe和protobuf-java-2.5.0.jar集合 可以将proto文件直接转换成java文件

    protobuf-java-2.5.0.jar

    Protocol Buffers被定义为一种数据描述语言(Data Description Language,DDL),广泛的应用于Google内部,用于结构... 本jar包为最新的protobuf的java开发包,可以直接进行使用,不需重新生成自己的java的jar包了~~~~

    protobuf-java-3.5.1.zip

    protobuf-java-3.5.1.zip pherl released this on 21 Dec 2017 · 18 commits to 3.5.x since this release

    protobuf-java-2.5.0jar包

    生成好的protobuf jar 无需再用maven构建

    protobuf实例protobuf-java-2.4.1.jar

    protobuf实例 protobuf-java-2.4.1.jar

    protobuf-java-3.6.1.jar

    自己maven编译生成的,最新版,亲测可以用。 已经用在项目中了。

    Protobuf3.4 java

    内含两个原始Protobuf-java-3.4和protoc.exe的压缩包,以及它们解压出来的内容

Global site tag (gtag.js) - Google Analytics