- 在進行序列化操作之前，我們還對系統(tǒng)進行壓測，通過
jvisualvm分析cpu，線程，垃圾回收情況等；運用火焰圖async-profiler分析系統(tǒng)性能，找出程序中占用CPU資源時間最長的代碼塊。 - 代碼放置GitHub：https://github.com/nateshao/leetcode/tree/main/source-code/src/main/java/com/nateshao/source/code/serializable
1.什么是序列化與反序列化？
聊到序列化與反序列化，先看看這個這個是什么或者是干嘛的
定義：序列化是指把
對象轉(zhuǎn)換為字節(jié)序列的過程；反序列化是指把字節(jié)序列恢復為對象的過程；
一般都會知道有兩個目的：對象持久化和網(wǎng)絡(luò)傳輸。
- 對象持久化。實現(xiàn)了數(shù)據(jù)的持久化，通過序列化可以把數(shù)據(jù)永久的保存在硬盤上；
- 網(wǎng)絡(luò)傳輸。我們知道網(wǎng)絡(luò)傳輸?shù)氖亲止?jié)序列，那么利用序列化實現(xiàn)遠程通信，即在網(wǎng)絡(luò)上傳遞對象的字節(jié)序列。 （序列化與反序列化則實現(xiàn)了 進程通信間的對象傳送，發(fā)送方需要把這個Java對象轉(zhuǎn)換為字節(jié)序列，才能在網(wǎng)絡(luò)上傳送；接收方則需要把字節(jié)序列再恢復為Java對象）
總結(jié)：序列化的目的是將對象變成字節(jié)序列，這樣一來方便持久化存儲到磁盤，避免程序運行結(jié)束后對象就從內(nèi)存里消失，另外字節(jié)序列也更便于網(wǎng)絡(luò)運輸和傳播
2.選擇序列化技術(shù)有哪些維度
這里并不是說哪個是最好，只能說是各有千秋，所以面對不同的背景采用不同的技術(shù)方案。
在同等情況下，編碼后的字節(jié)數(shù)組越大，存儲占空間，存儲硬件成本高，網(wǎng)絡(luò)傳輸時也占帶寬，導致系統(tǒng)的吞吐量降低。
- 開發(fā)工作量和難度。工作量越少越好對吧，發(fā)揮的價值最大。
- 性能：需要考慮性能需求，序列化的速度和性能越高越好。
- 是否支持跨語言，支持的語言種類是否豐富。
- 安全性：對于安全性的需要考量。JDK序列化可能有卡死線程的漏洞。
- 占用空間大?。盒蛄谢慕Y(jié)果所占用的空間大小，序列化后的字節(jié)數(shù)據(jù)通常會持久化到硬盤（占用存儲資源）或者在網(wǎng)絡(luò)上傳輸給其他服務(wù)器（占用帶寬資源），這個指標當然是越小越好。
- 可維護性：技術(shù)流行程序，越流行的技術(shù)可維護性就越高，維護成本會越低。
3.為什么采用字節(jié)序列MessagePack，有什么依據(jù)？
這個要結(jié)合當時的項目背景了。當時的項目痛點是：
- 老項目的結(jié)構(gòu)調(diào)整比較大，交易性能上不去，所以先采取細節(jié)方面的優(yōu)化。MessagePack是滿足性能要求。
- 老系統(tǒng)業(yè)務(wù)變化不多，MessagePack是滿足要求。
- 序列化反序列化效率高（比json快一倍），文件體積小，比json小一倍。MessagePack是滿足要求
所以，存在MessagePack也有不好的地方，如果是針對業(yè)務(wù)變化比較多，那就不適合，需要比較不同的版本，然后選擇不同版本去解析。
我在京東內(nèi)部文章有看到，引用的MessagePack反序列化出現(xiàn)了一些線上的問題，原因是：新增了一些字段導致反序列化失敗。
這里對比了JDK(不支持跨語言)，JSON，Protobuf，MessagePack幾種序列化的方式。
當然，還有其他的XML、Hessian、Kryo（不支持跨語言）、FST（不支持跨語言）Thrift等。
4.JDK序列化
JDK序列化是Java默認自帶的序列化方式。在Java中，一個對象要想實現(xiàn)序列化，實現(xiàn)Serializable接口或者Externalizable接口即可。其中Externalizable接口繼承自Serializable接口。
public class Person implements Serializable {
private static final long serialVersionUID = 1L;
private String name = null;
private Integer age = null;
private SerializeDemo01.Sex sex;
//....
}
serialVersionUID版本控制的作用
- 序列化的時候
serialVersionUID也會被寫入二進制序列 - 反序列化時會檢查
serialVersionUID是否和當前類的serialVersionUID一致。不一致則會拋出InvalidClassException?異常（序列化之后給類增加字段再反序列化的時候就會報錯）
serialVersionUID必須保證實體類在序列化前后嚴格一致，否則將會導致無法反序列化。
JDK默認的序列化機制。需要實現(xiàn)java.io.Serializable接口
- 序列化后的碼流太大：jdk序列化機制編碼后的二進制數(shù)組大小竟然是二進制編碼的5.29倍。
- 不支持跨語言平臺調(diào)用， 性能較差（序列化后字節(jié)數(shù)組體積大）
- 序列化性能太低：java序列化的性能只有二進制編碼的6.17%左右，Java原生序列化的性能實在太差。
JDK默認的序列化機制很差。所以我們通常不會選擇Java默認序列化這種
5.JSON序列化
json格式也是常見的一種，但是在json在解析的時候非常耗時，而且json結(jié)構(gòu)非常占內(nèi)存。JSON不適合存數(shù)字，特別是DOUBLE
這里基于Fastjson ，加載maven依賴
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>fastjson</artifactId>
<version>1.2.70</version>
</dependency>
序列化對象
利用JSON.toJSONString方法序列化對象：
UserVO user = ...;String text = JSON.toJSONString(user);
序列化數(shù)組
利用JSON.toJSONString方法序列化數(shù)組：
UserVO[] users = ...;String text = JSON.toJSONString(users);
序列化集合
利用JSON.toJSONString方法序列化集合（繼承至Collection，比如List、Set等集合）：
List<UserVO> userList = ...;String text = JSON.toJSONString(userList);
序列化映射
利用JSON.toJSONString方法序列化映射：
Map<Long, UserVO> userMap = ...;String text = JSON.toJSONString(userMap, SerializerFeature.MapSortField);
其中，為了保證每次序列化的映射字符串一致，需要指定序列化參數(shù)MapSortField進行排序。
序列化模板對象
利用JSON.toJSONString方法序列化模板對象：
Result<UserVO> result = ...;String text = JSON.toJSONString(result);
代碼
package com.nateshao.source.code.serializable.json_Serializable.serializable;
import com.alibaba.fastjson.annotation.JSONField;
/**
* @date Created by 邵桐杰 on 2023/2/25 17:11
* @微信公眾號 千羽的編程時光
* @博客 https://nateshao.gitlab.io
* @GitHub https://github.com/nateshao
* Description:
*/
public class User {
/**
* @JSONField 作用：自定義對象屬性所對應的 JSON 鍵名
* @JSONField 的作用對象:
* 1. Field
* 2. Setter 和 Getter 方法
* 注意：
* 1. 若屬性是私有的，必須要有 set 方法，否則反序列化會失敗。
* 2. 若沒有 @JSONField 注解，則直接使用屬性名。
*/
@JSONField(name = "NAME")
private String name;
@JSONField(name = "AGE")
private int age;
public User(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
序列化ObjectTest
package com.nateshao.source.code.serializable.json_Serializable.serializable;
import com.alibaba.fastjson.JSON;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
/**
* @date Created by 邵桐杰 on 2023/2/25 17:12
* @微信公眾號 千羽的編程時光
* @博客 https://nateshao.gitlab.io
* @GitHub https://github.com/nateshao
* Description:
*/
public class ObjectTest {
private static List<User> userList = new ArrayList<User>();
@BeforeAll
public static void setUp() {
userList.add(new User("千羽", 18));
userList.add(new User("千尋", 19));
}
@DisplayName("序列化對象")
@Test
public void testObjectToJson() {
String userJson = JSON.toJSONString(userList.get(0));
System.out.println(userJson); // {"AGE":18,"NAME":"千羽"}
}
@DisplayName("序列化集合")
@Test
public void testListToJson() {
String userListJson = JSON.toJSONString(userList);
System.out.println(userListJson); // [{"AGE":18,"NAME":"千羽"},{"AGE":19,"NAME":"千尋"}]
}
@DisplayName("序列化數(shù)組")
@Test
public void testArrayToJson() {
User[] userArray = new User[5];
userArray[0] = new User("zhangsan", 20);
userArray[1] = new User("lisi", 21);
String userArrayJson = JSON.toJSONString(userArray);
System.out.println(userArrayJson); // [{"AGE":20,"NAME":"zhangsan"},{"AGE":21,"NAME":"lisi"},null,null,null]
}
@DisplayName("序列化映射")
@Test
public void testMapToJson() {
Map<Integer, User> userMap = new HashMap<Integer, User>();
userMap.put(1, new User("xiaotie", 10));
userMap.put(2, new User("xiaoliu", 11));
String userMapJson = JSON.toJSONString(userMap);
System.out.println(userMapJson); // {1:{"AGE":10,"NAME":"xiaotie"},2:{"AGE":11,"NAME":"xiaoliu"}}
}
}
反序列化UN_ObjectTest
package com.nateshao.source.code.serializable.json_Serializable.un_serializable;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.TypeReference;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.Set;
/**
* @date Created by 邵桐杰 on 2023/2/25 17:16
* @微信公眾號 千羽的編程時光
* @博客 https://nateshao.gitlab.io
* @GitHub https://github.com/nateshao
* Description:
*/
public class UN_ObjectTest {
@DisplayName("反序列化對象")
@Test
public void testJsonToObject() {
String text = "{"age":18,"name":"千羽"}";
User user = JSON.parseObject(text, User.class);
System.out.println(user); // User{name='千羽', age=18}
}
@DisplayName("反序列化數(shù)組")
@Test
public void testJsonToArray() {
String text = "[{"age":18,"name":"千羽"}, {"age":19,"name":"千尋"}]";
User[] users = JSON.parseObject(text, User[].class);
System.out.println(Arrays.toString(users)); // [User{name='千羽', age=18}, User{name='千尋', age=19}]
}
@DisplayName("反序列化集合")
@Test
public void testJsonToCollection() {
String text = "[{"age":18,"name":"千羽"}, {"age":19,"name":"千尋"}]";
// List 集合
List<User> userList = JSON.parseArray(text, User.class);
System.out.println(Arrays.toString(userList.toArray())); // [User{name='千羽', age=18}, User{name='千尋', age=19}]
// Set 集合
Set<User> userSet = JSON.parseObject(text, new TypeReference<Set<User>>() {
});
System.out.println(Arrays.toString(userSet.toArray())); // [User{name='千尋', age=19}, User{name='千羽', age=18}]
}
@DisplayName("反序列化映射")
@Test
public void testJsonToMap() {
String text = "{1:{"age":18,"name":"千羽"}, 2:{"age":19,"name":"千尋"}}";
Map<Integer, User> userList = JSON.parseObject(text, new TypeReference<Map<Integer, User>>() {
});
for (Integer i : userList.keySet()) {
System.out.println(userList.get(i));
}
/*
User{name='千羽', age=18}
User{name='千尋', age=19}
*/
}
}
json序列化總結(jié)
-
好處
- 簡單易用開發(fā)成本低
- 跨語言
- 輕量級數(shù)據(jù)交換
- 非冗長性（對比xml標簽簡單括號閉環(huán)）
-
缺點
- 體積大，影響高并發(fā)
- 無版本檢查，自己做兼容
- 片段的創(chuàng)建和驗證過程比一般的XML復雜
- 缺乏命名空間導致信息混合
6.Protobuf
Protobuf是谷歌推出的，是一種語言無關(guān)、平臺無關(guān)、可擴展的序列化結(jié)構(gòu)數(shù)據(jù)的方法，它可用于通信協(xié)議、數(shù)據(jù)存儲等。序列化后體積小，一般用于對傳輸性能有較高要求的系統(tǒng)。前期需要額外配置環(huán)境變量，學習他的語法也是需要時間。
但是要使用Protobuf會相對來說麻煩一些，因為他有自己的語法，有自己的編譯器，如果需要用到的話必須要去投入成本在這個技術(shù)的學習中。
Protobuf有個缺點就是傳輸?shù)拿恳粋€類的結(jié)構(gòu)都要生成相對應的proto文件，如果某個類發(fā)生修改，還要重新生成該類對應的proto文件。另外，Protobuf對象冗余，字段很多，生成的類較大，占用空間。維護成本較高。
// 聲明語法，不顯示聲明默認是2.0的語法。
syntax = "proto3";
// 指定模板類的包路徑
option java_package = "com.test.basic.java.serialize.proto.dto";
// 指定模板類的名稱，名稱必須是有實際業(yè)務(wù)意義的
option java_outer_classname = "UserProto";
// 定義用戶對象
message User {
// 名字
string name = 1;
// 年齡
int32 age = 2;
}
// 聲明語法，不顯示聲明默認是2.0的語法。
syntax = "proto3";
// 指定模板類的包路徑
option java_package = "com\nateshao\source\code\serializable\protobuf_Serializable\User.proto";
// 指定模板類的名稱，名稱必須是有實際業(yè)務(wù)意義的
option java_outer_classname = "UserProto";
// 定義用戶對象
message User {
// 名字
string name = 1;
// 年齡
int32 age = 2;
}
7.MessagePack（推薦）
- 序列化反序列化效率高（比json快一倍），文件體積小，比json小一倍。
- 兼容json數(shù)據(jù)格式
- 跨語言，多語言支持(超多)
不好的地方：
- 缺乏復雜模型支持。msgpack對復雜的數(shù)據(jù)類型（List、Map）支持的不夠，序列化沒有問題，但是反序列化回來就很麻煩，尤其是對于java開發(fā)人員。
- 維護成本較高。msgpack通過value的順序來定位屬性的，需要在不同的語言中都要維護同樣的模型以及模型中屬性的順序。
- 不支持模型嵌套。msgpack無法支持在模型中包含和嵌套其他自定義的模型（如weibo模型中包含comment的列表）。
上手
通過配置msgpack的maven依賴
<dependency>
<groupId>org.msgpack</groupId>
<artifactId>msgpack</artifactId>
<version>0.6.12</version>
</dependency>
封裝MsgPackTemplate抽象類，對原有msgpack進行二次加工，比如int，Short，Byte，BigDecimal進行read和write處理
MsgPackTemplate.java
package com.nateshao.source.code.serializable.msgpack_Serializable;
import java.io.IOException;
import java.math.BigDecimal;
import java.util.Date;
import org.msgpack.packer.Packer;
import org.msgpack.template.CharacterTemplate;
import org.msgpack.template.Template;
import org.msgpack.unpacker.Unpacker;
/**
* @date Created by 邵桐杰 on 2023/2/25 23:11
* @微信公眾號 千羽的編程時光
* @博客 https://nateshao.gitlab.io
* @GitHub https://github.com/nateshao
* Description:
*/
public abstract class MsgPackTemplate <T> implements Template<T> {
public void write(Packer pk, T v) throws IOException {
write(pk, v, false);
}
public T read(Unpacker u, T to) throws IOException {
return read(u, to, false);
}
public BigDecimal readBigDecimal(Unpacker u) throws IOException {
if (u.trySkipNil()) {
return null;
}
String temp = u.readString();
if (temp != null) {
return new BigDecimal(temp);
}
return null;
}
public Date readDate(Unpacker u) throws IOException {
if (u.trySkipNil()) {
return null;
}
long temp = u.readLong();
if (temp > 0) {
return new Date(temp);
}
return null;
}
public String readString(Unpacker u) throws IOException {
if (u.trySkipNil()) {
return null;
}
return u.readString();
}
public Integer readInteger(Unpacker u) throws IOException {
if (u.trySkipNil()) {
return null;
}
return u.readInt();
}
public Byte readByte(Unpacker u) throws IOException {
if (u.trySkipNil()) {
return null;
}
return u.readByte();
}
public Short readShort(Unpacker u) throws IOException {
if (u.trySkipNil()) {
return null;
}
return u.readShort();
}
public Float readFloat(Unpacker u) throws IOException {
if (u.trySkipNil()) {
return null;
}
return u.readFloat();
}
public Double readDouble(Unpacker u) throws IOException {
if (u.trySkipNil()) {
return null;
}
return u.readDouble();
}
public Character readCharacter(Unpacker u) throws IOException {
if (u.trySkipNil()) {
return null;
}
return u.read(CharacterTemplate.getInstance());
}
public Long readLong(Unpacker u) throws IOException {
if (u.trySkipNil()) {
return null;
}
return u.readLong();
}
public Boolean readBoolean(Unpacker u) throws IOException {
if (u.trySkipNil()) {
return null;
}
return u.readBoolean();
}
public void writeBigDecimal(Packer pk, BigDecimal v) throws IOException {
if (v == null) {
pk.writeNil();
} else {
pk.write(v.toString());
}
}
public void writeDate(Packer pk, Date v) throws IOException {
if (v == null) {
pk.writeNil();
} else {
pk.write(v.getTime());
}
}
public void writeString(Packer pk, String v) throws IOException {
if (v == null) {
pk.writeNil();
} else {
pk.write(v);
}
}
public void writeInt(Packer pk, int v) throws IOException {
pk.write(v);
}
public void writeInteger(Packer pk, Integer v) throws IOException {
if (v == null) {
pk.writeNil();
} else {
pk.write(v.intValue());
}
}
public void writeByte(Packer pk, Byte v) throws IOException {
if (v == null) {
pk.writeNil();
} else {
pk.write(v.byteValue());
}
}
public void writeShort(Packer pk, Short v) throws IOException {
if (v == null) {
pk.writeNil();
} else {
pk.write(v.shortValue());
}
}
public void writeFloat(Packer pk, Float v) throws IOException {
if (v == null) {
pk.writeNil();
} else {
pk.write(v.floatValue());
}
}
public void writeDouble(Packer pk, Double v) throws IOException {
if (v == null) {
pk.writeNil();
} else {
pk.write(v.doubleValue());
}
}
public void writeCharacter(Packer pk, Character v) throws IOException {
if (v == null) {
pk.writeNil();
} else {
pk.write(v.charValue());
}
}
public void writeLong(Packer pk, Long v) throws IOException {
if (v == null) {
pk.writeNil();
} else {
pk.write(v.longValue());
}
}
public void writeLong(Packer pk, long v) throws IOException {
pk.write(v);
}
public void writeBoolean(Packer pk, Boolean v) throws IOException {
if (v == null) {
pk.writeNil();
} else {
pk.write(v.booleanValue());
}
}
}
然后針對實體類進行讀和寫的序列化與反序列化操作。
User.java
package com.nateshao.source.code.serializable.msgpack_Serializable;
@Data
@ToString
@AllArgsConstructor
@NoArgsConstructor
public class User {
private static final long serialVersionUID = 4719921525393585541L;
protected String id;
private String userID;
private String type;
private BigDecimal rate;
private Date createTime;
private Date UpdateTime;
}
UserTemplate.java
package com.nateshao.source.code.serializable.msgpack_Serializable;
import org.msgpack.packer.Packer;
import org.msgpack.unpacker.Unpacker;
import java.io.IOException;
/**
* protected String id;
* private String userID;
* private String type;
* private BigDecimal rate;
* private Date createTime;
* private Date UpdateTime;
*/
public class UserTemplate extends MsgPackTemplate<User> {
public void write(Packer packer, User user, boolean b) throws IOException {
if (user == null) {
packer.write(user);
return;
}
// 字段保持一致
writeString(packer, user.id);
writeString(packer, user.getUserID());
writeString(packer, user.getType());
writeBigDecimal(packer, user.getRate());
writeDate(packer, user.getCreateTime());
writeDate(packer, user.getUpdateTime());
}
public User read(Unpacker unpacker, User user, boolean req) throws IOException {
if (!req && unpacker.trySkipNil()) {
return null;
}
if (unpacker == null) return new User();
user.setId(readString(unpacker));
user.setUserID(readString(unpacker));
user.setType(readString(unpacker));
user.setRate(readBigDecimal(unpacker));
user.setCreateTime(readDate(unpacker));
user.setUpdateTime(readDate(unpacker));
return user;
}
}
參考文獻：
- 官網(wǎng)：MessagePack: It's like JSON. but fast and small：https://msgpack.org/)
- msgpack-java：https://github.com/msgpack/msgpack-java
- MessagePack for C＃譯文：快速序列化組件MessagePack介紹 - 曉晨Master - 博客園：https://www.cnblogs.com/stulzq/p/8039933.html
- 原理分析和使用：https://www.jianshu.com/p/8c24bef40e2f
- https://blog.csdn.net/wzngzaixiaomantou/article/details/123031809
- https://blog.csdn.net/weixin_44299027/article/details/129050484
- https://www.cnblogs.com/juno3550/p/15431623.html
- Protobuf：https://blog.csdn.net/wxw1997a/article/details/116755542
作者：京東零售?邵桐杰文章來源：http://www.zghlxwxcb.cn/news/detail-515750.html
來源：京東云開發(fā)者社區(qū)文章來源地址http://www.zghlxwxcb.cn/news/detail-515750.html
到了這里，關(guān)于【序列化與反序列化】關(guān)于序列化與反序列化MessagePack的實踐的文章就介紹完了。如果您還想了解更多內(nèi)容，請在右上角搜索TOY模板網(wǎng)以前的文章或繼續(xù)瀏覽下面的相關(guān)文章，希望大家以后多多支持TOY模板網(wǎng)！
