推特开源的Serial，轻量级，快速的json解析框架

AWeiLoveAndroid

发布于 2018-09-03 16:43:15

1.1K0

发布于 2018-09-03 16:43:15

文章被收录于专栏：Flutter入门到实战Flutter入门到实战

你还在用Gson,fastjson吗？最近几个月推特开源了她们的json解析和序列化框架 Serial，这是一个轻量级框架，操作起来也很简单。下面简单的介绍一下。

github地址： https://github.com/twitter/Serial

1、下载

从Maven中心通过Gradle抓取最新版本：

repositories {
  mavenCentral()
}

dependencies {
  compile 'com.twitter.serial:serial:0.1.5'
}

2、概要

Serial是一个定制的序列化实现，旨在提高性能并提高开发人员对对象序列化的可见性和控制能力。

这个框架使用Serializer来明确地定义一个类应该如何被序列化。这种方法的一些主要优点包括：

更高效的序列化避免反射 - 大型对象的初步指标显示
- 双向串行化速度提高3倍以上（序列化速度提高5倍，反串行化速度提高2.5倍）
- 字节数组大小约减少5倍
更好地控制对象的序列化 - 所有的序列化都是明确定义的
更好的调试功能（请参阅调试 )

3、基本结构

序列化：要将对象序列化为字节数组，使用如下：

final Serial serial = new Serial();
final byte[] serializedData = serial.toByteArray(object, ExampleObject.SERIALIZER)

反序列化：要将字节数组反序列化为对象，使用如下：

final ExampleObject object = serial.fromByteArray(ExampleObject.SERIALIZER)

4、定义 Serializers

为每个需要序列化的对象定义一个Serializers，而不是实现Serializable
Serializers通过使用读/写原语或递归地调用其他对象的Serializers来显式地写入和读取对象的每个字段
Serializers为您处理空对象，就像read / writeString一样;原始读/写方法不需要了。
Serializers是无状态的，所以它们被写成对象的静态内部类，并作为静态实例变量来访问SERIALIZER

对于大多数类，你可以创建一个ObjectSerializer 的子类，并实现 serializeObject 和 deserializeObject

public static class ExampleObject {
    public static final ObjectSerializer<ExampleObject> SERIALIZER = new ExampleObjectSerializer();

    public final int num;
    public final SubObject obj;

    public ExampleObject(int num, @NotNull SubObject obj) {
        this.num = num;
        this.obj = obj;
    }

    ...

    private static final ExampleObjectSerializer extends ObjectSerializer<ExampleObject> {
        @Override
        protected void serializeObject(@NotNull SerializerOutput output,
                @NotNull ExampleObject object) throws IOException {
            output.writeInt(object.num)
                .writeObject(object.obj, SubObject.SERIALIZER);
        }

        @Override
        @NotNull
        protected ExampleObject deserializeObject(@NotNull SerializerInput input,
                int versionNumber) throws IOException, ClassNotFoundException {
            final int num = input.readInt();
            final SubObject obj = input.readObject(SubObject.SERIALIZER);
            return new ExampleObject(num, obj);
        }
    }
}

对于使用构建器构建的类，或者添加了可选字段（请参阅更新 Serializer），可以使用，在其中实现方法createBuilder（只返回该类的新构建器对象）和deserializeToBuilder（在其中填充构建器与反序列化的领域）

public static class ExampleObject {
    ...

    public ExampleObject(@NotNull Builder builder) {
        this.num = builder.mNum;
        this.obj = builder.mObj;
    }

    ...

    public static Builder extends ModelBuilder<ExampleObject> {
        ...
    }

    private static final ExampleObjectSerializer extends BuilderSerializer<ExampleObject, Builder> {
        @Override
        @NotNull
        protected Builder createBuilder() {
            return new Builder();
        }

        @Override
        protected void serializeObject(@NotNull SerializerOutput output,
                @NotNull ExampleObject object) throws IOException {
            output.writeInt(object.num)
                .writeObject(object.obj, SubObject.SERIALIZER);
        }

         @Override
        protected void deserializeToBuilder(@NotNull SerializerInput input,
                @NotNull Builder builder, int versionNumber) throws IOException, ClassNotFoundException {
            builder.setNum(input.readInt())
                .setObj(input.readObject(SubObject.SERIALIZER));
        }
    }
}

5、序列化实用程序方法

CoreSerializers 和 CollectionSerializers 包含用于装箱原语的serializers ，并具有序列化集合，enums 和 comparators.等对象的辅助方法。
- 例如，要序列化一个字符串列表，您可以使用：
CollectionSerializers.getListSerializer(Serializers.STRING);
为了序列化一个对象作为它的基类，你可以使用getBaseClassSerializer在子类的序列化器中构造一个基类序列化器 Serializers
- 例如，如果您具有扩展ClassA的ClassB和ClassC，并且想要将对象序列化为ClassA对象，则可以使用子类的serializers 在ClassA中创建一个序列化程序：
final Serializer<ClassC> SERIALIZER = Serializers.getBaseClassSerializer( SerializableClass.create(ClassA.class, new ClassA.ClassASerializer()), SerializableClass.create(ClassB.class, new ClassB.ClassBSerializer()));

注意:

您必须创建ClassA和B 的 `serializers` 的新实例，而不是使用这些类中定义的静态对象。由于ClassC被初始化为其子类的一部分，所以在其初始化中使用其子类的静态对象将创建一个循环依赖，这可能导致一个神秘的NPE。

6、更新序列化器

如果您添加或删除存储为序列化数据的对象的字段，有几种方法来处理它：

OptionalFieldException 如果你添加一个字段到一个对象的末尾，新的序列化程序会在试图读取新字段的时候到达一个旧对象的末尾，这会导致它抛出一个OptionalFieldException。
BuilderSerializer通过忽略构建器中的该字段，停止反序列化以及按原样构建对象的其余部分来处理OptionalFieldExceptions。如果您使用的是正则序列化器，则可以显式捕获OptionalFieldException，并根据需要将其余字段设置为默认值。
比如说，你想在上面的ExampleObject的末尾添加一个字符串“name”：对于这两种序列化器类型，您可以简单地添加.writeString(obj.name)到serializeObject 对于BuilderSerializer，要反序列化你会添加.setName(input.readString())到结尾 deserializeToBuilder。在没有名称字段的旧对象被反序列化的情况下，OptionalFieldException当读取字符串时，</font> <font style="box-sizing: border-box; vertical-align: inherit;">将会抛出并捕获该字符串，从而导致该对象按照原样被生成，而没有显式地设置名称字段。对于常规的串行器，你可以改变deserializeObject如下： @Override @NotNull protected ExampleObject deserializeObject(@NotNull SerializerInput input, int versionNumber) throws IOException, ClassNotFoundException { final int num = input.readInt(); final SubObject obj = input.readObject(SubObject.SERIALIZER); final String name; try { name = input.readString(); } catch (OptionalFieldException e) { name = DEFAULT_NAME; } return new ExampleObject(num, obj, name); }

7、版本号

另一种选择是增加序列化程序的版本号，并为旧版本定义反序列化行为。为此，请将版本号传递给SERIALIZER对象的构造函数，然后在反序列化方法中，您可以指定对于以前版本做不同的操作。

要更改上述示例以使用版本号，请执行以下操作：

final Serializer<ExampleObject> SERIALIZER = new ExampleObjectSerializer(1);
//...

@Override
@NotNull
protected ExampleObject deserializeObject(@NotNull SerializerInput input, int versionNumber)
        throws IOException, ClassNotFoundException {
    final int num = input.readInt();
    final SubObject obj = input.readObject(SubObject.SERIALIZER);
    final String name;
    if (versionNumber < 1) {
        name = DEFAULT_NAME;
    } else {
        name = input.readString();
    }
    return new ExampleObject(num, obj, name);
}

如果从对象中间删除一个字段，则需要使用skipObjectin中的方法在反序列化过程中忽略整个对象SerializationUtils。这样，如果您一起删除对象，则不需要保留序列化程序。

如果在上面的例子中你也想删除obj字段并删除SubObject：

@Override
@NotNull
protected ExampleObject deserializeObject(@NotNull SerializerInput input, int versionNumber)
        throws IOException, ClassNotFoundException {
    final int num = input.readInt();
    if (versionNumber < 1) {
        SerializationUtils.skipObject()
        name = DEFAULT_NAME;
    } else {
        name = input.readString();
    }
    return new ExampleObject(num, name);
}

另一个选择是调用input.peekType（），它允许您在读取对象之前检查下一个字段的类型。如果您在更改之前没有更新版本，并且不想擦除数据库，这是特别有用的，因为它允许您在没有版本号的情况下区分这两个版本。请注意，这只适用于两种类型不同。

@Override
@NotNull
protected ExampleObject deserializeObject(@NotNull SerializerInput input, int versionNumber)
        throws IOException, ClassNotFoundException {
    final int num = input.readInt();
    if (input.peekType() == SerializerDefs.TYPE_START_OBJECT) {
        SerializationUtils.skipObject();
        name = DEFAULT_NAME;
    } else {
        name = input.readString();
    }
    return new ExampleObject(num, name);
}

8、ValueSerializer

一些对象非常简单，无需支持版本控制：Integer，String，Size，Rect ...在这些对象中使用ObjectSerializer会在序列化的数据周围添加2-3个字节的开销，这可能会增加大量开销。在不需要版本控制时，ValueSerializer是更好的选择：

public static final Serializer<Boolean> BOOLEAN = new ValueSerializer<Boolean>() {
    @Override
    protected void serializeValue(@NotNull SerializerOutput output, @NotNull Boolean object) throws IOException {
        output.writeBoolean(object);
    }

    @NotNull
    @Override
    protected Boolean deserializeValue(@NotNull SerializerInput input) throws IOException {
        return input.readBoolean();
    }
};

这只是处理null的ObjectSerializer的一个简单版本，否则只是将值写入流中。

注意:

当给定一个空值时，ValueSerializer将null写入流。因此，由serializeValue写入流的第一个字段不能为空，因为它是不明确的。ValueSerializer将此检测为错误并引发异常。

警告！

ValueSerializer 只能在已知格式被修复时使用，因为它们不支持任何形式的向后兼容性。