几种序列化协议(protobuf,xstream,jackjson,jdk,hessian)相关数据对比

最新推荐文章于 2024-03-04 20:00:00 发布
最新推荐文章于 2024-03-04 20:00:00 发布
阅读量1.1k 收藏 2
点赞数
分类专栏： java 文章标签： 数据结构 Bean json Google IDEA

最近研究了下google protobuf协议，顺便对比了一下json,xml,java序列化相关的数据对比，从几个纬度进行对比。

 

别人的相关测试数据： http://code.google.com/p/thrift-protobuf-compare/wiki/Benchmarking

 

测试纬度

  • 序列化时间
  • 反序列化时间
  • bytes大小

测试代码

准备protobuf文件

 

import "InnerMessage.proto";
package demo; 
option java_package = "com.agapple.protobuf.data";
option java_outer_classname = "MessageProtos";
option optimize_for = SPEED ;  //CODE_SIZE,LITE_RUNTIME
option java_generic_services = false;
message Message {
	
	required string strObj = 1 [default="hello"];
	optional int32 int32Obj = 2;
	optional int64 int64Obj = 3;
	optional uint32 uint32Obj = 4;
	optional uint64 uint64Obj = 5;
	optional sint32 sint32Obj = 6;
	optional sint64 sint64Obj = 7;
	optional fixed32 fixed32Obj = 8;
	optional fixed64 fixed64Obj = 9;
	optional sfixed32 sfixed32Obj = 10;
	optional sfixed64 sfixed64Obj = 11;
	optional bool 	boolObj = 12;
	optional bytes 	bytesObj = 13;
	optional float folatObj = 14 [deprecated=true];
	repeated double doubleObj = 15 [packed=true]; //
	optional InnerMessage innerMessage = 16;
}

 

 

import "EnumType.proto";

package demo; 
option java_package = "com.agapple.protobuf.data";
option java_outer_classname = "InnerMessageProtos";

message InnerMessage { 
	optional string name = 1 [default = "name"];
	optional int32 id = 2;
	optional EnumType type = 3 [default = UNIVERSAL];
}

 

 

package demo; 
option java_package = "com.agapple.protobuf.data";
option java_outer_classname = "EnumTypeProtos";

enum EnumType {
	UNIVERSAL = 0; 
	WEB = 1; 
	IMAGES = 2; 
	LOCAL = 3; 
	NEWS = 4; 
	PRODUCTS = 5; 
	VIDEO = 6; 
}

 

 

基本上把protobuf支持的类型都囊括了，包括嵌套类型，枚举类型，以及各种int,uint,bool,bytes。  

 

依赖关系是Message.proto依赖了InnerMessage对象，而InnerMessage对象里包含了一个自定义枚举类型EnumType。

 

关于类型的使用可参见： 
      http://code.google.com/intl/zh/apis/protocolbuffers/docs/reference/java-generated.html
      http://code.google.com/intl/zh/apis/protocolbuffers/docs/proto.html

 

 

 

生成protobuf javabean

 

 

cd /home/ljh/work/code/src/main/java

/home/ljh/work/protobuf/bin/protoc --proto_path=com/agapple/protobuf/ --java_out=. com/agapple/protobuf/EnumType.proto
/home/ljh/work/protobuf/bin/protoc --proto_path=com/agapple/protobuf/ --java_out=. com/agapple/protobuf/InnerMessage.proto
/home/ljh/work/protobuf/bin/protoc --proto_path=com/agapple/protobuf/ --java_out=. com/agapple/protobuf/Message.proto

 

 通过protobuf自带的protoc进行编译，指定了protobuf文件的路径， 具体的文档： http://code.google.com/intl/zh/apis/protocolbuffers/docs/proto.html#generating

 

 

运行脚本后就会生成对应的3个javabean文件: MessageProtos , InnerMessageProtos , EnumTypeProtos。

 

最后构造测试的protobuf bean代码

 

private static MessageProtos.Message getProtobufBean() {
        com.agapple.protobuf.data.MessageProtos.Message.Builder messageBuilder = MessageProtos.Message.newBuilder();

        messageBuilder.setStrObj("message");
        messageBuilder.setFolatObj(1f);
        messageBuilder.addDoubleObj(1d);
        messageBuilder.addDoubleObj(2d);
        messageBuilder.setBoolObj(true);

        messageBuilder.setBytesObj(ByteString.copyFrom(new byte[] { 1, 2, 3 }));
        messageBuilder.setInt32Obj(32);
        messageBuilder.setInt64Obj(64l);
        messageBuilder.setSint32Obj(232);
        messageBuilder.setSint64Obj(264);
        messageBuilder.setFixed32Obj(532);
        messageBuilder.setFixed64Obj(564);
        messageBuilder.setSfixed32Obj(2532);
        messageBuilder.setSfixed64Obj(2564);
        messageBuilder.setUint32Obj(632);
        messageBuilder.setUint64Obj(664);

        com.agapple.protobuf.data.InnerMessageProtos.InnerMessage.Builder innerMessageBuilder = InnerMessageProtos.InnerMessage.newBuilder();
        innerMessageBuilder.setId(1);
        innerMessageBuilder.setName("inner");
        innerMessageBuilder.setType(EnumType.PRODUCTS);

        messageBuilder.setInnerMessage(innerMessageBuilder);

        return messageBuilder.build();
    }

 

 

 

准备纯Pojo Bean 

同样的，为了和json , xml以及java序列化有个很好的对比，新建了3个纯的pojo bean:  MessagePojo , InnerMessagePojo , EnumTypePojo。

属性和proto的bean保持一致。

 

构建bean对象

 

private static MessagePojo getPojoBean() {
        MessagePojo bean = new MessagePojo();

        bean.setStrObj("message");
        bean.setFolatObj(1f);
        List<Double> doubleObj = new ArrayList<Double>();
        doubleObj.add(1d);
        doubleObj.add(2d);
        bean.setDoubleObj(doubleObj);
        bean.setBoolObj(true);

        bean.setBytesObj(new byte[] { 1, 2, 3 });
        bean.setInt32Obj(32);
        bean.setInt64Obj(64l);
        bean.setSint32Obj(232);
        bean.setSint64Obj(264);
        bean.setFixed32Obj(532);
        bean.setFixed64Obj(564);
        bean.setSfixed32Obj(2532);
        bean.setSfixed64Obj(2564);
        bean.setUint32Obj(632);
        bean.setUint64Obj(664);

        InnerMessagePojo innerMessagePojo = new InnerMessagePojo();
        innerMessagePojo.setId(1);
        innerMessagePojo.setName("inner");
        innerMessagePojo.setType(EnumTypePojo.PRODUCTS);

        bean.setInnerMessage(innerMessagePojo);

        return bean;
    }

 

 

 

具体的测试代码

定义测试Template接口

 

interface TestCallback {

    String getName();

    byte[] writeObject(Object source);

    Object readObject(byte[] bytes);
}

 

 

统一的测试模板

 

private static void testTemplate(TestCallback callback, Object source, int count) {
        int warmup = 10;
        // 先进行预热，加载一些类，避免影响测试
        for (int i = 0; i < warmup; i++) {
            byte[] bytes = callback.writeObject(source);
            callback.readObject(bytes);
        }
        restoreJvm(); // 进行GC回收
        // 进行测试
        long start = System.nanoTime();
        long size = 0l;
        for (int i = 0; i < count; i++) {
            byte[] bytes = callback.writeObject(source);
            size = size + bytes.length;
            callback.readObject(bytes);
            // System.out.println(callback.readObject(bytes));
            bytes = null;
        }
        long nscost = (System.nanoTime() - start);
        System.out.println(callback.getName() + " total cost=" + integerFormat.format(nscost) + "ns , each cost="
                           + integerFormat.format(nscost / count) + "ns , and byte sizes = " + size / count);
        restoreJvm();// 进行GC回收

    }

 

 

  在测试模板方法中，使用了warmup预热的概念，就是预先执行目标方法一定的次数，用于避免因为jit的优化影响系统测试。 同时包含了每次测试模板调用完成后system.gc保证下一轮的功能测试

 

  相应的restoreJvm方法： 

private static void restoreJvm() {
        int maxRestoreJvmLoops = 10;
        long memUsedPrev = memoryUsed();
        for (int i = 0; i < maxRestoreJvmLoops; i++) {
            System.runFinalization();
            System.gc();

            long memUsedNow = memoryUsed();
            // break early if have no more finalization and get constant mem used
            if ((ManagementFactory.getMemoryMXBean().getObjectPendingFinalizationCount() == 0)
                && (memUsedNow >= memUsedPrev)) {
                break;
            } else {
                memUsedPrev = memUsedNow;
            }
        }
    }

    private static long memoryUsed() {
        Runtime rt = Runtime.getRuntime();
        return rt.totalMemory() - rt.freeMemory();
    }

 

最后相应的测试例子：

 

        final int testCount = 1000 * 500;        
        final MessageProtos.Message protoObj = getProtobufBean();
        final MessagePojo pojoOBj = getPojoBean();

        // Serializable测试
        testTemplate(new TestCallback() {

            public String getName() {
                return "Serializable Test";
            }

            @Override
            public byte[] writeObject(Object source) {
                try {
                    ByteArrayOutputStream bout = new ByteArrayOutputStream();
                    ObjectOutputStream output = new ObjectOutputStream(bout);
                    output.writeObject(source);
                    return bout.toByteArray();
                } catch (IOException e) {
                    e.printStackTrace();
                }
                return null;
            }

            @Override
            public Object readObject(byte[] bytes) {
                try {
                    ByteArrayInputStream bin = new ByteArrayInputStream(bytes);
                    ObjectInputStream input = new ObjectInputStream(bin);
                    return input.readObject();
                } catch (Exception e) {
                    e.printStackTrace();
                }
                return null;
            }
        }, pojoOBj, testCount);

        // protobuf测试
        testTemplate(new TestCallback() {

            public String getName() {
                return "protobuf test";
            }

            @Override
            public byte[] writeObject(Object source) {
                if (source instanceof MessageProtos.Message) {
                    MessageProtos.Message message = (MessageProtos.Message) source;
                    return message.toByteArray();
                }

                return null;
            }

            @Override
            public Object readObject(byte[] bytes) {
                try {
                    return MessageProtos.Message.parseFrom(bytes);
                } catch (InvalidProtocolBufferException e) {
                    e.printStackTrace();
                }
                return null;
            }
        }, protoObj, testCount);

        // json测试
        final ObjectMapper objectMapper = new ObjectMapper();
        final JavaType javaType = TypeFactory.type(pojoOBj.getClass());

        // JSON configuration not to serialize null field
        objectMapper.getSerializationConfig().setSerializationInclusion(JsonSerialize.Inclusion.NON_NULL);

        // JSON configuration not to throw exception on empty bean class
        objectMapper.getSerializationConfig().disable(SerializationConfig.Feature.FAIL_ON_EMPTY_BEANS);

        // JSON configuration for compatibility
        objectMapper.configure(Feature.ALLOW_UNQUOTED_FIELD_NAMES, true);
        objectMapper.configure(Feature.ALLOW_UNQUOTED_CONTROL_CHARS, true);

        testTemplate(new TestCallback() {

            public String getName() {
                return "Jackson Test";
            }

            @Override
            public byte[] writeObject(Object source) {
                try {
                    return objectMapper.writeValueAsBytes(source);
                } catch (JsonGenerationException e) {
                    e.printStackTrace();
                } catch (JsonMappingException e) {
                    e.printStackTrace();
                } catch (IOException e) {
                    e.printStackTrace();
                }

                return null;
            }

            @Override
            public Object readObject(byte[] bytes) {
                try {
                    return objectMapper.readValue(bytes, 0, bytes.length, javaType);
                } catch (JsonParseException e) {
                    e.printStackTrace();
                } catch (JsonMappingException e) {
                    e.printStackTrace();
                } catch (IOException e) {
                    e.printStackTrace();
                }
                return null;
            }
        }, pojoOBj, testCount);

        // Xstream测试
        final XStream xstream = new XStream();
        testTemplate(new TestCallback() {

            public String getName() {
                return "Xstream test";
            }

            @Override
            public byte[] writeObject(Object source) {
                return xstream.toXML(source).getBytes();
            }

            @Override
            public Object readObject(byte[] bytes) {
                return xstream.fromXML(new ByteArrayInputStream(bytes));
            }
        }, pojoOBj, testCount);

 

 

2011年3月10号补充 =========================================================

增加了hessian 3.1.5版本基于二进制序列化的测试

 

<dependency>
    <groupId>com.caucho</groupId>
    <artifactId>hessian</artifactId>
    <version>3.1.5</version>
</dependency>

 

 

测试了3种情况：

 

  1. hessian 2协议
  2. hessian 2协议 + deflat压缩
  3. hessian 1协议

 

 

测试代码：

 

// hessian 2 with no deflat
        testTemplate(new TestCallback() {

            public String getName() {
                return "hessian 2 with no deflat";
            }

            @Override
            public byte[] writeObject(Object source) {
                try {
                    ByteArrayOutputStream bos = new ByteArrayOutputStream();
                    Hessian2Output out = new Hessian2Output(bos);
                    // out.startMessage();
                    out.writeObject(source);
                    // out.completeMessage();
                    out.flush();
                    return bos.toByteArray();
                } catch (IOException e) {
                    e.printStackTrace();
                }
                return null;
            }

            @Override
            public Object readObject(byte[] bytes) {
                try {
                    ByteArrayInputStream bin = new ByteArrayInputStream(bytes);
                    Hessian2Input in = new Hessian2Input(bin);
                    // in.startMessage();
                    Object obj = in.readObject();
                    // in.completeMessage();
                    return obj;
                } catch (IOException e) {
                    e.printStackTrace();
                }
                return null;
            }
        }, pojoOBj, testCount);

        // hessian 2 with deflat
        final Deflation envelope = new Deflation();
        testTemplate(new TestCallback() {

            public String getName() {
                return "hessian 2 with deflat";
            }

            @Override
            public byte[] writeObject(Object source) {
                try {
                    ByteArrayOutputStream bos = new ByteArrayOutputStream();
                    Hessian2Output out = new Hessian2Output(bos);
                    out = envelope.wrap(out);
                    out.writeObject(source);
                    out.flush();
                    out.close(); // 记得关闭
                    return bos.toByteArray();
                } catch (Exception e) {
                    e.printStackTrace();
                }
                return null;
            }

            @Override
            public Object readObject(byte[] bytes) {
                try {
                    ByteArrayInputStream bin = new ByteArrayInputStream(bytes);
                    Hessian2Input in = new Hessian2Input(bin);
                    in = envelope.unwrap(in);
                    Object obj = in.readObject();
                    in.close();
                    return obj;
                } catch (IOException e) {
                    e.printStackTrace();
                }
                return null;
            }
        }, pojoOBj, testCount);

        // hessian 1 with no deflat
        testTemplate(new TestCallback() {

            public String getName() {
                return "hessian 1 with no deflat";
            }

            @Override
            public byte[] writeObject(Object source) {
                try {
                    ByteArrayOutputStream bos = new ByteArrayOutputStream();
                    HessianOutput out = new HessianOutput(bos);
                    out.writeObject(source);
                    out.flush();
                    return bos.toByteArray();
                } catch (Exception e) {
                    e.printStackTrace();
                }
                return null;
            }

            @Override
            public Object readObject(byte[] bytes) {
                try {
                    ByteArrayInputStream bin = new ByteArrayInputStream(bytes);
                    HessianInput in = new HessianInput(bin);
                    Object obj = in.readObject();
                    in.close();
                    return obj;
                } catch (IOException e) {
                    e.printStackTrace();
                }
                return null;
            }
        }, pojoOBj, testCount);
 

 


测试结果

序列化数据对比



 

bytes字节数对比

具体的数字: 

protobufjacksonxstreamSerializablehessian2hessian2压缩hessian1
序列化(单位ns)11545421 92406 101892679410076629027
反序列化(单位ns)13348743 117329 640273787118843237596
bytes97311 664 824374283495

 

  1. protobuf 不管是处理时间上，还是空间占用上都优于现有的其他序列化方式。内存暂用是java 序列化的1/9，时间也是差了一个数量级，一次操作在1us左右。缺点：就是对象结构体有限制，只适合于内部系统使用。
  2. json格式在空间占用还是有一些优势，是java序列化的1/2.6。序列化和反序列化处理时间上差不多，也就在5us。当然这次使用的jackson，如果使用普通的jsonlib可能没有这样好的性能，jsonlib估计跟java序列化差不多。
  3. xml相比于java序列化来说，空间占用上有点优势，但不明显。处理时间上比java序列化多了一个数量级，在100us左右。
  4. 以前一种的java序列化，表现得有些失望
  5. hessian测试有点意外，具体序列化数据上还步入json。性能上也不如jackjson，输得比较彻底。
  6. hessian使用压缩，虽然在字节上有20%以上的空间提升，但性能上差了4,5倍，典型的以时间换空间。总的来说还是google protobuf比较给力

 

总结　

以后在内部系统，数据cache存储上可以考虑使用protobuf。跟外部系统交互上可以考虑使用json。

 

有兴趣的同学，可以研究一下google protobuf的marshall的方式: http://code.google.com/intl/zh/apis/protocolbuffers/docs/encoding.html

iteye_7245
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
浅谈序列化之protobuf与avro对比(Java)
08-29
序列化之 Protobuf 与 Avro 对比 (Java) 在 Java 中，序列化是指将对象转换为字节流的过程，以便于存储或传输。目前，常用的序列化工具有 Protobuf 和 Avro，本文将对这两种序列化工具进行比较。 序列化的重要性 ...
Unity 中使用Protobuf进行序列化和反序列化的Demo
01-27
Protocol Buffers（Protobuf）是一种高效、跨平台的数据序列化协议，由Google开发。本Demo将展示如何在Unity中集成并使用Protobuf进行数据的序列化和反序列化操作。 首先，你需要了解什么是序列化和反序列化。序列...
序列化协议与自定义序列化协议
yswKnight的博客
02-24 1295
序列化协议与自定义序列化协议 序列化定义 序列化（serialization）就是将对象序列化为二进制形式（字节数组），一般也将序列化称为编码（Encode），主要用于网络传输、数据持久化等； 反序列化（deserialization）则是将从网络、磁盘等读取的字节数组还原成原始对象，以便后续业务的进行，一般也将反序列化称为解码（Decode），主要用于网络传输对象的解码，以便...
浅谈几种序列化协议
weixin_33735077的博客
03-04 311
    工作中用过几种知名的序列化协议，说说自己的感受吧，先独立讲各自的概念，然后比较下他们的优缺点。JSON（Javascript Object Notation）    官方网站是这样叙述的：一种轻量级的资料交换语言。易于人阅读和编写。同时也易于机器解析和生成。json有两种结构：1.名称/值，例如：{  "name"  : "xiaoming",  "age"  :    12}你也可以再嵌...
几种流行的序列化协议比较
weixin_37830196的博客
10-31 2663
XML    1）定义： XML（Extensible Markup Language）是一种常用的序列化和反序列化协议， 它历史悠久，从1998年的1.0版本被广泛使用至今。 （2）优点 人机可读性好 可指定元素或特性的名称 （3）缺点 序列化数据只包含数据本身以及类的结构，不包括类型标识和程序集信息。 类必须有一个将由 XmlSerializer 序列化的默认构造函数。 只能...
xml、json、protobuf序列化协议
木牛的博客
10-19 437
XML指可扩展标记语言（eXtensibleMarkupLanguage）。是一种通用和重量级的数据交换格式。以文本结构存储。JSON(JavaScriptObjectNotation, JS 对象简谱) 是一种通用和轻量级的数据交换格式。以文本结构存储。是Google的一种独立和轻量级的数据交换格式。以二进制结构进行存储。名词解释：通用：协议是标准的，不同的第三方软件都可以相互进行序列化和反序列化，比如使用cjson序列化后的数据，可以使用jsoncpp反序列化。
八种流行的网络协议
qq_40135848的博客
11-05 679
八种流行的网络协议
Python调用序列化数据工具Protocol Buffers——protobuf
10-22
Protocol Buffers是Google开发的一种高效的数据序列化协议，它允许开发者将结构化的数据串行化，可用于数据存储、通信协议等方面。Python作为一门广泛使用的编程语言，可以方便地集成protobuf进行数据交换。在本文中...
高性能序列化协议protobuf及源码分析.pptx
07-16
高性能序列化协议protobuf及源码分析 分享仅供非商业用途，请于24小时内删除！如有侵权请联系本人删除
Java实现几种序列化方式总结
10-20
Protocol Buffers（简称Protobuf）是Google开发的一种数据序列化协议，它提供了一种更高效、更紧凑的二进制序列化格式。相比Java原生序列化和JSON，Protobuf序列化后的数据体积更小，解析速度更快，特别适合于网络...
protobuf 性能对比
07-18
protobuf 性能对比 和fastjson对比，测试程序
转载-七种Java常用序列化框架的选型与对比
最新发布
qq_31515997的博客
03-04 870
序列化与反序列化是我们日常数据持久化和网络传输中经常使用的技术，但是目前各种序列化框架让人眼花缭乱，不清楚什么场景到底采用哪种序列化框架。本文会将业界开源的序列化框架进行对比测试，分别从通用性、易用性、可扩展性、性能和数据类型与Java语法支持五方面给出对比测试。下面分别对JDK Serializable、FST、Kryo、Protobuf、Thrift、Hession和Avro进行对比测试。下面是从通用性上对比各个序列化框架，可以看出Protobuf在通用上是最佳的，能够支持多种主流变成语言。
oracle java rmi 漏洞,learnjavabug: Java安全相关的漏洞和技术demo，其中包括原生Java、Fastjson、Jackson、Hessian2以及XML反序列化漏洞利...
weixin_42515056的博客
04-05 150
fastjsoncom.threedr3am.bug.fastjson.FastjsonSerialize(TemplatesImpl) 利用条件：fastjson <= 1.2.24 + Feature.SupportNonPublicFieldcom.threedr3am.bug.fastjson.NoNeedAutoTypePoc 利用条件：fastjson < 1.2.48 不...
序列化：serializable,hessian,protobuf性能对比
Future is in your hands, believe it!!
10-31 1721
 分布式应用系统中，系统之间的通讯的质量决定了系统的可用性，当然很多可以选择的技术：XML-RPC，RMI，SOAP，CORBA，JMS，EJB，NIO等。在传输数据的过程中，数据包越小，占用的带宽就越少，同等条件下资源利用就会越小。目前基于SOA的ESB系统中，很多采用NIO来传输数据，就涉及到对象的序列化的问题。     本文主要讨论jdk自带序列化，hessian，Google的pro...
几种序列化协议的介绍
木牛的博客
10-19 1235
它基于 ECMAScript (w3c制定的js规范)的一个子集， JSON采用与编程语言无关的文本格式，但是也使用了类C语言（包括C， C++， C#， Java， JavaScript， Perl， Python等）的习惯，简洁和清晰的层次结构使得 JSON 成为理想的数据交换语言。（deserialization）则是将从网络、磁盘等读取的字节数组还原成原始对象，以便后续业务的进行，一般也将反序列化称为解码（Decode），主要用于网络传输对象的解码，以便完成远程调用。
Protobuf：一种更小、更快、更高效的协议
C/C++Linux、音视频、DPDK
08-24 1813
Protobuf介绍 Protobuf (Protocol Buffers) 是谷歌开发的一款无关平台，无关语言，可扩展，轻量级高效的序列化结构的数据格式，用于将自定义数据结构序列化成字节流，和将字节流反序列化为数据结构。所以很适合做数据存储和为不同语言，不同应用之间互相通信的数据交换格式，只要实现相同的协议格式，即后缀为proto文件被编译成不同的语言版本，加入各自的项目中，这样不同的语言可以解析其它语言通过Protobuf序列化的数据。目前官方提供c++，java，go等语言支持。 下面表格是支持语言的
java,jackson,fastjson,hessian序列化 "单个对象“ 与 "List里面装1000个对象”，性能对比...
09-29 327
      JavaSerDeImpl serialize single BLOG cost:16778 tps:59601 count:1000000 JavaSerDeImpl serialize blogList.size:1000 cost:12146 tps:823 count:10000 JacksonSerDeImpl serialize single...
【Netty入门】几种序列化协议的介绍
热门推荐
白夜行
06-14 1万+
序列化概述1.序列化定义 序列化（serialization）就是将对象序列化为二进制形式（字节数组），一般也将序列化称为编码（Encode），主要用于网络传输、数据持久化等； 反序列化（deserialization）则是将从网络、磁盘等读取的字节数组还原成原始对象，以便后续业务的进行，一般也将反序列化称为解码（Decode），主要用于网络传输对象的解码，以便完成远程调用。 2.序列化的“鼻祖”我
抖音弹幕协议protobuf反序列化原理
05-25
抖音弹幕协议使用的是Google Protocol Buffers，它是一种轻便高效的数据交换格式。...总的来说，抖音弹幕协议的protobuf反序列化原理与一般的protobuf数据解析类似，但需要根据具体的业务场景来自定义解析规则。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值