序列化的几种方式

阿狸轰

已于 2023-11-19 15:01:02 修改

阅读量739

点赞数

分类专栏： java 文章标签：开发语言

于 2023-11-19 14:58:51 首次发布

本文链接：https://blog.csdn.net/Alaskan_Husky/article/details/134490518

版权

java 专栏收录该内容

47 篇文章 1 订阅

订阅专栏

序列化是将对象转换为字节流或其他数据格式的过程，以便将其保存到文件、数据库或进行网络传输。在Java中，有几种常见的序列化方式：

各种序列化对比

JSON vs. Protocol Buffers vs. Avro vs. MsgPack:
- JSON：
  - 优势： 可读性强，广泛支持，易于调试和理解。
  - 劣势： 数据体积相对较大，解析速度相对较慢。
- Protocol Buffers：
  - 优势： 二进制格式，数据体积小，解析速度快，支持跨语言。
  - 劣势： 不可读，需要定义消息结构。
- Avro：
  - 优势： 二进制格式，支持动态数据模型，适用于大规模数据处理。
  - 劣势： 不如 Protocol Buffers 跨语言。
- MsgPack：
  - 优势： 二进制格式，数据体积小，解析速度快。
  - 劣势： 不如 Protocol Buffers 跨语言。
Hessian vs. Kryo:
- Hessian：
  - 优势： 适用于 Java 环境，简单易用。
  - 劣势： 性能相对较低。
- Kryo：
  - 优势： 高性能，适用于 Java 应用，支持多种数据类型。
  - 劣势： 不如 Protocol Buffers 跨语言。
Thrift vs. Cap’n Proto:
- Thrift：
  - 优势： 跨语言支持广泛，生成的代码可读性较好。
  - 劣势： 相对 Protocol Buffers 等其他方案性能较低。
- Cap’n Proto：
  - 优势： 性能极高，零拷贝，适用于高性能场景。
  - 劣势： 不如 Thrift 跨语言。
MsgType vs. BSON vs. Ion:
- MsgType：
  - 优势： 高性能，适用于高频交易系统。
  - 劣势： 可读性相对较低。
- BSON：
  - 优势： 适用于 MongoDB 数据存储，支持多种数据类型。
  - 劣势： 相对 Protocol Buffers 等其他方案性能较低。
- Ion：
  - 优势： 可读性强，支持多种数据类型。
  - 劣势： 性能相对较低。
其他序列化方式：
- Feather： 适用于大规模数据分析，高性能。
- SBE： 适用于金融领域的高频交易系统，性能极高。
- HDF5： 适用于科学和工程领域的大规模数据存储。
- IonC： Ion 数据格式的 C 语言实现，适用于高性能序列化。
- Rust Serde： Rust 的序列化框架，适用于 Rust 程序。

Java 序列化（ObjectOutputStream/ObjectInputStream）：

示例：

使用 ObjectOutputStream 将对象序列化为字节流。
使用 ObjectInputStream 将字节流反序列化为对象。
被序列化的类需要实现 Serializable 接口。

// 序列化
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("file.ser"));
oos.writeObject(myObject);
oos.close();

// 反序列化
ObjectInputStream ois = new ObjectInputStream(new FileInputStream("file.ser"));
MyObject deserializedObject = (MyObject) ois.readObject();
ois.close();

JSON 序列化（Jackson、Gson等库）：

使用第三方库（如 Jackson、Gson）将对象转换为 JSON 字符串。
优点是可读性强，且可以跨语言使用。

示例（使用 Jackson 库）：

// 序列化
ObjectMapper objectMapper = new ObjectMapper();
String jsonString = objectMapper.writeValueAsString(myObject);

// 反序列化
MyObject deserializedObject = objectMapper.readValue(jsonString, MyObject.class);

XML 序列化：

使用第三方库（如 JAXB）将对象序列化为 XML 格式。
适用于与其他系统交互、配置文件等场景。

示例（使用 JAXB）：

// 序列化
JAXBContext context = JAXBContext.newInstance(MyObject.class);
Marshaller marshaller = context.createMarshaller();
marshaller.marshal(myObject, new File("file.xml"));

// 反序列化
Unmarshaller unmarshaller = context.createUnmarshaller();
MyObject deserializedObject = (MyObject) unmarshaller.unmarshal(new File("file.xml"));

Protocol Buffers（ProtoBuf）：

Google 的 Protocol Buffers 是一种轻量级、高效的二进制序列化协议。
使用 ProtoBuf 描述数据结构，然后使用编译器生成相应的类。
优点包括高效的编解码性能和较小的序列化数据体积。

示例：

syntax = "proto3";
message MyMessage {
    required int32 id = 1;
    required string name = 2;
}

// 使用 ProtoBuf 序列化
MyMessage.Builder builder = MyMessage.newBuilder();
builder.setId(1).setName("John");
MyMessage myMessage = builder.build();

// 将对象序列化为字节数组
byte[] byteArray = myMessage.toByteArray();

// 将字节数组反序列化为对象
MyMessage deserializedMessage = MyMessage.parseFrom(byteArray);

Kryo 序列化：

Kryo 是一个高性能的 Java 序列化库，相比 Java 原生序列化，性能更好。
支持多种数据类型，速度较快，适用于需要高性能的场景。

示例：

// 使用 Kryo 序列化
Kryo kryo = new Kryo();
Output output = new Output(new FileOutputStream("file.bin"));
kryo.writeObject(output, myObject);
output.close();

// 使用 Kryo 反序列化
Input input = new Input(new FileInputStream("file.bin"));
MyObject deserializedObject = kryo.readObject(input, MyObject.class);
input.close();

Avro 序列化：

Apache Avro 是一个数据序列化框架，旨在提供一种快速、紧凑、可序列化到文件格式的方法。
类似于 ProtoBuf，使用 Avro 需要定义数据模型，并使用 Avro 工具生成相应的类。
适用于大规模数据处理场景。

示例：

{
  "type": "record",
  "name": "MyRecord",
  "fields": [
    {"name": "id", "type": "int"},
    {"name": "name", "type": "string"}
  ]
}

// 使用 Avro 序列化
MyRecord myRecord = new MyRecord();
myRecord.setId(1);
myRecord.setName("Alice");

DatumWriter<MyRecord> datumWriter = new SpecificDatumWriter<>(MyRecord.class);
DataFileWriter<MyRecord> dataFileWriter = new DataFileWriter<>(datumWriter);

dataFileWriter.create(myRecord.getSchema(), new File("file.avro"));
dataFileWriter.append(myRecord);
dataFileWriter.close();

// 使用 Avro 反序列化
DatumReader<MyRecord> datumReader = new SpecificDatumReader<>(MyRecord.class);
DataFileReader<MyRecord> dataFileReader = new DataFileReader<>(new File("file.avro"), datumReader);

MyRecord deserializedRecord = dataFileReader.next();
dataFileReader.close();

Hessian 序列化：

Hessian 是一种基于二进制的序列化协议，支持跨语言。
在 Java 中，可以使用 Hessian 库进行对象的序列化和反序列化。

示例：

// 使用 Hessian 序列化
ByteArrayOutputStream bos = new ByteArrayOutputStream();
HessianOutput ho = new HessianOutput(bos);
ho.writeObject(myObject);
byte[] byteArray = bos.toByteArray();

// 使用 Hessian 反序列化
ByteArrayInputStream bis = new ByteArrayInputStream(byteArray);
HessianInput hi = new HessianInput(bis);
MyObject deserializedObject = (MyObject) hi.readObject();

MsgPack 序列化：

MessagePack（MsgPack）是一种二进制序列化格式，致力于提供高效的数据交换格式。
MsgPack 采用二进制格式，相比 JSON 和 XML 具有更小的体积，同时保持较高的可读性。
适用于需要高效序列化和反序列化的场景。

示例：

// 使用 MsgPack 序列化
MessagePack messagePack = new MessagePack();
byte[] byteArray = messagePack.write(myObject);

// 使用 MsgPack 反序列化
MyObject deserializedObject = messagePack.read(byteArray, MyObject.class);

YAML 序列化：

YAML（YAML Ain't Markup Language）是一种人类可读的数据序列化格式。
相比 JSON，YAML 更注重可读性，可以作为配置文件的选择。
适用于配置文件、人类可读的数据交换等场景。

示例：

// 使用 SnakeYAML 序列化
SnakeYaml snakeYaml = new SnakeYaml();
String yamlString = snakeYaml.dump(myObject);

// 使用 SnakeYAML 反序列化
MyObject deserializedObject = snakeYaml.load(yamlString, MyObject.class);

FlatBuffers 序列化：

FlatBuffers 是一种高效的序列化库，适用于大规模数据的序列化和反序列化。
与其他序列化库不同，FlatBuffers 的特点是无需解析整个数据，直接在原始数据上进行访问。
适用于需要高性能的场景。

示例：

// 使用 FlatBuffers 序列化
FlatBufferBuilder builder = new FlatBufferBuilder();
int nameOffset = builder.createString("John");
MyObject.startMyObject(builder);
MyObject.addName(builder, nameOffset);
int myObjectOffset = MyObject.endMyObject(builder);
builder.finish(myObjectOffset);

// 使用 FlatBuffers 反序列化
ByteBuffer byteBuffer = builder.dataBuffer();
MyObject deserializedObject = MyObject.getRootAsMyObject(byteBuffer);

Thrift 序列化：

Apache Thrift 是一种跨语言的服务框架，同时也包含了一种二进制序列化协议。
Thrift 支持多种语言，使得在不同语言之间进行通信变得更加方便。
适用于构建分布式系统中的服务接口。

示例：

// 定义 Thrift 数据结构
struct MyStruct {
    1: i32 id,
    2: string name,
}

// 使用 Thrift 序列化
TSerializer serializer = new TSerializer();
MyStruct myStruct = new MyStruct(1, "John");
byte[] byteArray = serializer.serialize(myStruct);

// 使用 Thrift 反序列化
TDeserializer deserializer = new TDeserializer();
MyStruct deserializedStruct = new MyStruct();
deserializer.deserialize(deserializedStruct, byteArray);

CBOR（Concise Binary Object Representation）序列化：

CBOR 是一种二进制的数据序列化格式，类似于 JSON，但更紧凑。
CBOR 支持多种数据类型，具有较小的序列化体积。
适用于带宽有限或需要高效传输数据的场景。

示例：

// 使用 Jackson 库的 CBOR 序列化
ObjectMapper objectMapper = new ObjectMapper(new CBORFactory());
byte[] byteArray = objectMapper.writeValueAsBytes(myObject);

// 使用 Jackson 库的 CBOR 反序列化
MyObject deserializedObject = objectMapper.readValue(byteArray, MyObject.class);

Ion 序列化：

Ion（又称为 Amazon Ion）是一种开放的、跨语言的二进制和文本数据格式。
Ion 具有类似 JSON 的数据表示形式，同时支持二进制格式。
适用于 Amazon Web Services（AWS）中的数据交互和存储。

示例：

// 使用 Amazon Ion 序列化
IonObject ionObject = IonObject.of("id", 1, "name", "John");
ByteArrayOutputStream ionOutputStream = new ByteArrayOutputStream();
IonWriter ionWriter = IonTextWriterBuilder.pretty().build(ionOutputStream);
ionWriter.writeValue(ionObject);
ionWriter.close();
byte[] ionByteArray = ionOutputStream.toByteArray();

// 使用 Amazon Ion 反序列化
IonReader ionReader = IonReaderBuilder.standard().build(new ByteArrayInputStream(ionByteArray));
IonObject deserializedIonObject = IonObject.from(ionReader);

MsgType 序列化：

MsgType 是一种二进制序列化协议，致力于提供高性能的序列化和反序列化。
MsgType 具有较小的序列化体积和较快的序列化速度，适用于高性能的场景。

示例：

// 使用 MsgType 序列化
MsgTypeObject msgTypeObject = new MsgTypeObject(1, "John");
byte[] byteArray = msgTypeObject.toBytes();

// 使用 MsgType 反序列化
MsgTypeObject deserializedObject = MsgTypeObject.fromBytes(byteArray);

Pickle 序列化：

Python 的 Pickle 是一种序列化协议，用于将 Python 对象转换为字节流。
Pickle 支持多种 Python 数据类型，包括自定义类的实例。
适用于 Python 程序中的对象持久化和数据交互。

示例：

import pickle

# 使用 Pickle 序列化
my_object = MyObject(1, "John")
with open("file.pkl", "wb") as file:
    pickle.dump(my_object, file)

# 使用 Pickle 反序列化
with open("file.pkl", "rb") as file:
    deserialized_object = pickle.load(file)

JSON Lines（JSONL）序列化：

JSON Lines 是一种文本格式，每行包含一个独立的 JSON 对象。
适用于处理大规模数据集，每个 JSON 对象作为一行独立存储，方便逐行读取和处理。

示例：

// 使用 Jackson 库的 JSON Lines 序列化
ObjectMapper objectMapper = new ObjectMapper();
MyObject myObject1 = new MyObject(1, "John");
MyObject myObject2 = new MyObject(2, "Alice");

// 序列化为 JSON Lines
String jsonLines = objectMapper.writeValueAsString(myObject1) + "\n" +
                   objectMapper.writeValueAsString(myObject2);

// 反序列化 JSON Lines
String[] lines = jsonLines.split("\n");
for (String line : lines) {
    MyObject deserializedObject = objectMapper.readValue(line, MyObject.class);
    // 处理每个 JSON 对象
}

Parquet 序列化：

Apache Parquet 是一种列式存储格式，主要用于大规模数据的高效存储和分析。
Parquet 具有压缩性能好、高效读取部分数据的特点，适用于数据仓库和大数据处理场景。

示例：

// 使用 Apache Parquet 序列化
MyObject myObject1 = new MyObject(1, "John");
MyObject myObject2 = new MyObject(2, "Alice");

// 创建 ParquetWriter
ParquetWriter<MyObject> parquetWriter = new AvroParquetWriter<>(
        new Path("file.parquet"), MyObject.SCHEMA$, CompressionCodecName.SNAPPY, ParquetWriter.DEFAULT_BLOCK_SIZE,
        ParquetWriter.DEFAULT_PAGE_SIZE);

// 写入数据
parquetWriter.write(myObject1);
parquetWriter.write(myObject2);

// 关闭 ParquetWriter
parquetWriter.close();

// 使用 ParquetReader 反序列化
ParquetReader<MyObject> parquetReader = AvroParquetReader.<MyObject>builder(new Path("file.parquet")).build();
MyObject deserializedObject1 = parquetReader.read();
MyObject deserializedObject2 = parquetReader.read();
parquetReader.close();

Feather 序列化：

Apache Arrow Feather 是一种轻量级的列式数据格式，主要用于数据的高性能序列化和反序列化。
Feather 具有高性能的数据访问特性，适用于大规模数据分析和交换。

示例：

// 使用 Apache Arrow Feather 序列化
MyObject myObject1 = new MyObject(1, "John");
MyObject myObject2 = new MyObject(2, "Alice");

// 创建 ArrowStreamWriter
try (ArrowFileWriter arrowWriter = new ArrowFileWriter(new File("file.feather"),
                                                        new Schema(List.of(Fields.int32("id"), Fields.utf8("name"))))) {
    // 写入数据
    arrowWriter.start();
    arrowWriter.writeTable(Table.newTable(
            new Row(2, "Alice"),
            new Row(1, "John")
    ));
    arrowWriter.end();
}

// 使用 ArrowFileReader 反序列化
try (ArrowFileReader arrowReader = new ArrowFileReader(new File("file.feather"))) {
    Table table = arrowReader.read();
    MyObject deserializedObject1 = new MyObject(table.getColumn(0).getInt(0), table.getColumn(1).getString(0));
    MyObject deserializedObject2 = new MyObject(table.getColumn(0).getInt(1), table.getColumn(1).getString(1));
}

Cap’n Proto 序列化：

Cap’n Proto 是一种高性能的二进制序列化协议，具有类似于 Protocol Buffers 的特性，但更加轻量。
Cap’n Proto 支持零拷贝、高效的序列化和反序列化，适用于高性能的网络通信和数据存储。

示例：

// 使用 Cap’n Proto 序列化
MyObject myObject1 = new MyObject(1, "John");
MyObject myObject2 = new MyObject(2, "Alice");

// 写入数据
ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
try (MessageBuilder messageBuilder = MessageBuilder.newMessage()) {
    MyObject.Builder builder = messageBuilder.initRoot(MyObject.factory);
    builder.setId(myObject1.getId());
    builder.setName(myObject1.getName());
    builder = messageBuilder.initRoot(MyObject.factory);
    builder.setId(myObject2.getId());
    builder.setName(myObject2.getName());
    messageBuilder.writeTo(outputStream);
}

// 使用 Cap’n Proto 反序列化
ByteArrayInputStream inputStream = new ByteArrayInputStream(outputStream.toByteArray());
try (MessageReader messageReader = new MessageReader(inputStream)) {
    MyObject.Reader reader1 = messageReader.getRoot(MyObject.factory);
    MyObject deserializedObject1 = new MyObject(reader1.getId(), reader1.getName());

    MyObject.Reader reader2 = messageReader.getRoot(MyObject.factory);
    MyObject deserializedObject2 = new MyObject(reader2.getId(), reader2.getName());
}

BSON（Binary JSON）序列化：

BSON 是一种二进制表示的 JSON 格式，通常用于 MongoDB 中的数据存储。
BSON 支持多种数据类型，与 JSON 具有相似的可读性。
适用于与 MongoDB 进行交互和数据存储。

示例：

// 使用 BSON 序列化
MyObject myObject = new MyObject(1, "John");

// 将对象转换为 BSON 字节数组
byte[] byteArray = BSON.encode(myObject);

// 将 BSON 字节数组反序列化为对象
MyObject deserializedObject = BSON.decode(byteArray, MyObject.class);

SBE（Simple Binary Encoding）序列化：

SBE 是一种基于二进制的高性能序列化协议，主要用于金融领域的高频交易系统。
SBE 具有极低的序列化和反序列化延迟，支持紧凑的数据表示，适用于对性能要求极高的场景。

示例：

// 使用 SBE 序列化
MyObject myObject = new MyObject(1, "John");

// 创建 SbeEncoder
SbeEncoder encoder = new SbeEncoder();
byte[] byteArray = encoder.encode(myObject);

// 创建 SbeDecoder 反序列化
SbeDecoder decoder = new SbeDecoder(byteArray);
MyObject deserializedObject = decoder.decode();

ProtoBuf-Lite（Protocol Buffers Lite）序列化：

ProtoBuf-Lite 是 Protocol Buffers 的轻量级版本，适用于移动设备和嵌入式系统。
ProtoBuf-Lite 具有较小的运行时库，适用于资源受限的环境。

示例：

// 使用 ProtoBuf-Lite 序列化
MyObject myObject = new MyObject(1, "John");

// 使用 LiteProtoBuf 序列化
byte[] byteArray = LiteProtoBuf.toByteArray(myObject);

// 使用 LiteProtoBuf 反序列化
MyObject deserializedObject = LiteProtoBuf.parseFrom(byteArray, MyObject.class);

HDF5 序列化：

Hierarchical Data Format version 5（HDF5）是一种用于存储和交换科学数据的文件格式和工具。
HDF5 具有层次化的数据组织结构，适用于科学和工程领域的大规模数据存储。

示例：

// 使用 HDF5 序列化
MyObject myObject1 = new MyObject(1, "John");
MyObject myObject2 = new MyObject(2, "Alice");

// 创建 HDF5 文件
H5File file = new H5File("file.h5", H5File.H5F_ACC_TRUNC);

// 写入数据集
try (H5ScalarDS dataset = new H5ScalarDS(file.createScalarDS("dataset", null, new long[]{2}, null, null, H5P_DEFAULT))) {
    dataset.write(new Object[]{myObject1.getId(), myObject2.getId()}, dataset.getDataType());
}

// 使用 HDF5 读取数据
try (H5ScalarDS dataset = new H5ScalarDS(file.getScalarDS("dataset"))) {
    Object[] data = (Object[]) dataset.getData();
    MyObject deserializedObject1 = new MyObject((int) data[0], "John");
    MyObject deserializedObject2 = new MyObject((int) data[1], "Alice");
}

IonC 序列化：

IonC 是 Ion 数据格式的 C 语言实现，支持二进制和文本格式。
IonC 适用于需要在 C 语言环境中进行高性能序列化和反序列化的场景。

示例：

// 使用 IonC 序列化
MyObject myObject = {1, "John"};
ION_SYMBOL symbol_name;
ion_symbol_sid_string(ion_symbol_table_get_system_table(), "name", 4, &symbol_name);

// 创建 IonC writer
IonCWriteOptions write_options;
ion_c_writer_options_initialize(&write_options);
ION_BINARY_WRITER binary_writer;
ion_binary_writer_open_buffer(&binary_writer, NULL, 0, &write_options);

// 写入数据
ion_binary_writer_write_struct_open(&binary_writer);
ion_binary_writer_write_int32(&binary_writer, myObject.id);
ion_binary_writer_write_field_name_symbol_sid(&binary_writer, symbol_name);
ion_binary_writer_write_string(&binary_writer, (char *)myObject.name);
ion_binary_writer_write_struct_close(&binary_writer);

// 获取序列化数据
int32_t serialized_length;
BYTE *serialized_data;
ion_binary_writer_get_bytes(&binary_writer, &serialized_data, &serialized_length);

// 使用 IonC 反序列化
MyObject deserializedObject;
ION_BINARY_READER binary_reader;
ion_binary_reader_open_buffer(&binary_reader, serialized_data, serialized_length, NULL);

// 读取数据
ion_binary_reader_read_struct(&binary_reader);
ion_binary_reader_read_int32(&binary_reader, &deserializedObject.id);
ion_binary_reader_read_string(&binary_reader, (char **)&deserializedObject.name);

// 关闭 reader 和 writer
ion_binary_reader_close(&binary_reader);
ion_binary_writer_close(&binary_writer);

Rust Serde 序列化：

Serde 是 Rust 的一种序列化和反序列化框架，支持 JSON、Bincode、CBOR 等多种格式。
Serde 提供了一种简单而强大的方式来处理 Rust 结构体的序列化和反序列化。

示例：

// 使用 Serde 序列化
#[derive(Serialize, Deserialize)]
struct MyStruct {
    id: i32,
    name: String,
}

let my_object = MyStruct { id: 1, name: "John".to_string() };

// 序列化为 JSON 字符串
let json_string = serde_json::to_string(&my_object).unwrap();

// 反序列化 JSON 字符串
let deserialized_object: MyStruct = serde_json::from_str(&json_string).unwrap();