你还在用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 只能 在已知格式被修复时使用，因为它们不支持任何形式的向后兼容性。

9、调试

serial 还包含帮助调试的方法：

• dumpSerializedData 将在序列化的字节数组中创建数据的字符串日志
• validateSerializedData 确保序列化的对象具有有效的结构（例如，每个对象起始头具有匹配的结束头）

现在，异常包含有关序列化失败的更多信息，特别是有关要反序列化的预期类型的信息以及基于为每个值编写的标题而找到的类型。