这篇文章次要给大家解说序列化和反序列化。
序列化是网络通信中十分重要的一个机制，好的序列化形式可能间接影响数据传输的性能。
序列化
所谓的序列化，就是把一个对象，转化为某种特定的模式，而后以数据流的形式传输。
比方把一个对象间接转化为二进制数据流进行传输。当然这个对象能够转化为其余模式之后再转化为数据流。
比方XML、JSON等格局。它们通过另外一种数据格式表白了一个对象的状态，而后再把这些数据转化为二进制数据流进行网络传输。
反序列化
反序列化是序列化的逆向过程，把字节数组反序列化为对象，把字节序列复原为对象的过程成为对象的反序列化
序列化的高阶意识
后面的代码中演示了，如何通过JDK提供了Java对象的序列化形式实现对象序列化传输，次要通过输入流java.io.ObjectOutputStream和对象输出流java.io.ObjectInputStream来实现。
java.io.ObjectOutputStream：示意对象输入流 , 它的writeObject(Object obj)办法能够对参数指定的obj对象进行序列化，把失去的字节序列写到一个指标输入流中。
java.io.ObjectInputStream：示意对象输出流 ,它的readObject()办法源输出流中读取字节序列，再把它们反序列化成为一个对象，并将其返回
须要留神的是，被序列化的对象须要实现java.io.Serializable接口
serialVersionUID的作用
在IDEA中通过如下设置能够生成serializeID，如图5-1所示
字面意思上是序列化的版本号，但凡实现Serializable接口的类都有一个示意序列化版本标识符的动态变量。
<center>图5-1</center>
上面演示一下serialVersionUID的作用。首先须要创立一个一般的spring boot我的项目，而后依照上面的步骤来进行演示
创立User对象
public class User implements Serializable { private static final long serialVersionUID = -8826770719841981391L; private String name; private int age;}编写Java序列化的代码
public class JavaSerializer { public static void main(String[] args) { User user=new User(); user.setAge(18); user.setName("Mic"); serialToFile(user); System.out.println("序列化胜利，开始反序列化"); User nuser=deserialFromFile(); System.out.println(nuser); } private static void serialToFile(User user){ try { ObjectOutputStream objectOutputStream= new ObjectOutputStream(new FileOutputStream(new File("user"))); objectOutputStream.writeObject(user); } catch (IOException e) { e.printStackTrace(); } } private static <T> T deserialFromFile(){ try { ObjectInputStream objectInputStream=new ObjectInputStream(new FileInputStream(new File("user"))); return (T)objectInputStream.readObject(); } catch (IOException | ClassNotFoundException e) { e.printStackTrace(); } return null; }}UID验证演示步骤
- 先将user对象序列化到文件中
- 而后批改user对象，减少serialVersionUID字段
- 而后通过反序列化来把对象提取进去
- 演示预期后果：提醒无奈反序列化
论断
Java的序列化机制是通过判断类的serialVersionUID来验证版本一致性的。在进行反序列化时，JVM会把传来的字节流中的serialVersionUID与本地相应实体类的serialVersionUID进行比拟，如果雷同就认为是统一的，能够进行反序列化，否则就会呈现序列化版本不统一的异样，即是InvalidCastException。
从后果能够看出，文件流中的class和classpath中的class，也就是批改过后的class，不兼容了，出于平安机制思考，程序抛出了谬误，并且回绝载入。从谬误后果来看，如果没有为指定的class配置serialVersionUID，那么java编译器会主动给这个class进行一个摘要算法，相似于指纹算法，只有这个文件有任何改变，失去的UID就会截然不同的，能够保障在这么多类中，这个编号是惟一的。所以，因为没有显指定 serialVersionUID，编译器又为咱们生成了一个UID，当然和后面保留在文件中的那个不会一样了，于是就呈现了2个序列化版本号不统一的谬误。因而，只有咱们本人指定了serialVersionUID，就能够在序列化后，去增加一个字段，或者办法，而不会影响到前期的还原，还原后的对象照样能够应用，而且还多了办法或者属性能够用。
tips: serialVersionUID有两种显示的生成形式：
一是默认的1L，比方：private static final long serialVersionUID = 1L;
二是依据类名、接口名、成员办法及属性等来生成一个64位的哈希字段
当实现java.io.Serializable接口的类没有显式地定义一个serialVersionUID变量时候，Java序列化机制会依据编译的Class主动生成一个serialVersionUID作序列化版本比拟用，这种状况下，如果Class文件(类名，办法明等)没有发生变化(减少空格，换行，减少正文等等)，就算再编译屡次，serialVersionUID也不会变动的。
Transient关键字
Transient 关键字的作用是控制变量的序列化，在变量申明前加上该关键字，能够阻止该变量被序列化到文件中，在被反序列化后，transient 变量的值被设为初始值，如 int 型的是 0，对象型的是 null。
如果咱们心愿User类中的name字段不序列化，则依照以下计划进行批改。
批改User类
public class User implements Serializable { private static final long serialVersionUID = -8826770719841981391L; private transient String name; private int age;}测试成果
public class JavaSerializer { public static void main(String[] args) { User user=new User(); user.setAge(18); user.setName("Mic"); serialToFile(user); System.out.println("序列化胜利，开始反序列化"); User nuser=deserialFromFile(); System.out.println(nuser.getName()); //打印反序列化的后果，发现后果是NULL. }}绕开transient机制
在User类中重写writeObject和readObject办法。
public class User implements Serializable { private static final long serialVersionUID = -8826770719841981391L; private transient String name; private int age; private void writeObject(ObjectOutputStream out) throws IOException { out.defaultWriteObject(); out.writeObject(name);//减少写入name字段 } private void readObject(ObjectInputStream in) throws Exception{ in.defaultReadObject(); name=(String)in.readObject(); }}这两个办法是在ObjectInputStream和ObjectOutputStream中，别离反序列化和序列化对象时反射调用指标对象中的这两个办法。
序列化的总结
- Java序列化只是针对对象的状态进行保留，至于对象中的办法，序列化不关怀
- 当一个父类实现了序列化，那么子类会主动实现序列化，不须要显示实现序列化接口
- 当一个对象的实例变量援用了其余对象，序列化这个对象的时候会主动把援用的对象也进行序列化（实现深度克隆）
- 当某个字段被申明为transient后，默认的序列化机制会疏忽这个字段
- 被申明为transient的字段，如果须要序列化，能够增加两个公有办法：writeObject和readObject
常见的序列化技术及优劣剖析
随着分布式架构、微服务架构的遍及。服务与服务之间的通信成了最根本的需要。这个时候，咱们不仅须要思考通信的性能，也须要思考到语言多元化问题
所以，对于序列化来说，如何去晋升序列化性能以及解决跨语言问题，就成了一个重点思考的问题。
因为Java自身提供的序列化机制存在两个问题
- 序列化的数据比拟大，传输效率低
- 其余语言无奈辨认和对接
以至于在起初的很长一段时间，基于XML格局编码的对象序列化机制成为了支流，一方面解决了多语言兼容问题，另一方面比二进制的序列化形式更容易了解。
以至于基于XML的SOAP协定及对应的WebService框架在很长一段时间内成为各个支流开发语言的必备的技术。
再到起初，基于JSON的简略文本格式编码的HTTP REST接口又基本上取代了简单的Web Service接口，成为分布式架构中近程通信的首要抉择。
然而JSON序列化存储占用的空间大、性能低等问题，同时挪动客户端利用须要更高效的传输数据来晋升用户体验。在这种状况下与语言无关并且高效的二进制编码协定就成为了大家谋求的热点技术之一。
首先诞生的一个开源的二进制序列化框架-MessagePack。它比google的Protocol Buffers呈现得还要早。
XML序列化框架介绍
XML序列化的益处在于可读性好，不便浏览和调试。然而序列化当前的字节码文件比拟大，而且效率不高，实用于对性能不高，而且QPS较低的企业级外部零碎之间的数据交换的场景，同时XML又具备语言无关性，所以还能够用于异构零碎之间的数据交换和协定。比方咱们熟知的Webservice，就是采纳XML格局对数据进行序列化的。XML序列化/反序列化的实现形式有很多，熟知的形式有XStream和Java自带的XML序列化和反序列化两种。
引入jar包
<dependency> <groupId>com.thoughtworks.xstream</groupId> <artifactId>xstream</artifactId> <version>1.4.12</version></dependency>编写测试程序
public class XMLSerializer { public static void main(String[] args) { User user=new User(); user.setName("Mic"); user.setAge(18); String xml=serialize(user); System.out.println("序列化实现："+xml); User nuser=deserialize(xml); System.out.println(nuser); } private static String serialize(User user){ return new XStream(new DomDriver()).toXML(user); } private static User deserialize(String xml){ return (User)new XStream(new DomDriver()).fromXML(xml); }}JSON序列化框架
JSON（JavaScript Object Notation）是一种轻量级的数据交换格局，绝对于XML来说，JSON的字节流更小，而且可读性也十分好。当初JSON数据格式在企业使用是最广泛的
JSON序列化罕用的开源工具有很多
- Jackson （https://github.com/FasterXML/...）
- 阿里开源的FastJson （https://github.com/alibaba/fa...）
- Google的GSON (https://github.com/google/gson)
这几种json序列化工具中，Jackson与fastjson要比GSON的性能要好，然而Jackson、GSON的稳定性要比Fastjson好。而fastjson的劣势在于提供的api非常容易应用
引入jar包
<dependency> <groupId>com.alibaba</groupId> <artifactId>fastjson</artifactId> <version>1.2.72</version></dependency>编写测试程序
public class JsonSerializer{ public static void main(String[] args) { User user=new User(); user.setName("Mic"); user.setAge(18); String xml=serializer(user); System.out.println("序列化实现："+xml); User nuser=deserializer(xml); System.out.println(nuser); } private static String serializer(User user){ return JSON.toJSONString(user); } private static User deserializer(String json){ return (User)JSON.parseObject(json,User.class); }}Hessian序列化
Hessian是一个反对跨语言传输的二进制序列化协定，绝对于Java默认的序列化机制来说，Hessian具备更好的性能和易用性，而且反对多种不同的语言
实际上Dubbo采纳的就是Hessian序列化来实现，只不过Dubbo对Hessian进行了重构，性能更高
引入jar包
<dependency> <groupId>com.caucho</groupId> <artifactId>hessian</artifactId> <version>4.0.63</version></dependency>编写测试程序
public class HessianSerializer { public static void main(String[] args) throws IOException { User user=new User(); user.setName("Mic"); user.setAge(18); byte[] bytes=serializer(user); System.out.println("序列化实现"); User nuser=deserializer(bytes); System.out.println(nuser); } private static byte[] serializer(User user) throws IOException { ByteArrayOutputStream bos=new ByteArrayOutputStream(); //示意输入到内存的实现 HessianOutput ho=new HessianOutput(bos); ho.writeObject(user); return bos.toByteArray(); } private static User deserializer(byte[] data) throws IOException { ByteArrayInputStream bis=new ByteArrayInputStream(data); HessianInput hi=new HessianInput(bis); return (User)hi.readObject(); }}Avro序列化
Avro是一个数据序列化零碎，设计用于反对大批量数据交换的利用。它的次要特点有：反对二进制序列化形式，能够便捷，疾速地解决大量数据；动静语言敌对，Avro提供的机制使动静语言能够不便地解决Avro数据。
Avro是apache下hadoop的子项目，领有序列化、反序列化、RPC性能。序列化的效率比jdk更高，与Google的protobuffer相当，比facebook开源Thrift（后由apache治理了）更优良。
因为avro采纳schema，如果是序列化大量类型雷同的对象，那么只须要保留一份类的构造信息+数据，大大减少网络通信或者数据存储量。
引入jar包
<dependency> <groupId>org.apache.avro</groupId> <artifactId>avro</artifactId> <version>1.8.2</version></dependency><dependency> <groupId>org.apache.avro</groupId> <artifactId>avro-ipc</artifactId> <version>1.8.2</version></dependency><build> <plugins> <plugin> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-maven-plugin</artifactId> </plugin> <plugin> <groupId>org.apache.avro</groupId> <artifactId>avro-maven-plugin</artifactId> <version>1.8.2</version> <executions> <execution> <id>schemas</id> <phase>generate-sources</phase> <goals> <goal>schema</goal> </goals> <configuration> <sourceDirectory>${project.basedir}/src/main/avro</sourceDirectory> <outputDirectory>${project.basedir}/src/main/java</outputDirectory> </configuration> </execution> </executions> </plugin> </plugins></build>编写avsc文件
创立/src/main/avro目录，专门用来存储Avrode scheme定义文件。
{"namespace":"com.gupao.example","type":"record","name":"Person","fields":[ {"name":"name","type":"string"}, {"name":"age","type":"int"}, {"name":"sex","type":"string"} ]}avsc文件中的语法定义如下：
- namespace:命名空间，在应用插件生成代码的时候，User类的包名就是它
- type:有 records, enums, arrays, maps, unions , fixed 取值，records是相当于一般的class
- name:类名，类的全名有namespace+name形成
- doc:正文
- aliases:取的别名，其余中央应用能够应用别名来援用
fields:属性
- name:属性名
- type:属性类型，能够是用["int","null"]或者["int",1]执行默认值
- default:也能够应用该字段指定默认值
- doc:正文
生成代码
执行maven install，
会在main/java目录下生成Person类。
编写测试程序
public class AvroSerializer { public static void main(String[] args) throws IOException { Person person=Person.newBuilder().setName("Mic").setAge(18).setSex("男").build(); ByteBuffer byteBuffer=person.toByteBuffer(); //序列化 System.out.println("序列化大小："+byteBuffer.array().length); Person nperson=Person.fromByteBuffer(byteBuffer); System.out.println("反序列化："+nperson); }}上面这种形式是基于文件的模式来实现序列化和反序列化
public class AvroSerializer { public static void main(String[] args) throws IOException { Person person=Person.newBuilder().setName("Mic").setAge(18).setSex("男").build(); /* ByteBuffer byteBuffer=person.toByteBuffer(); //序列化 System.out.println("序列化大小："+byteBuffer.array().length); Person nperson=Person.fromByteBuffer(byteBuffer); System.out.println("反序列化："+nperson);*/ DatumWriter<Person> personDatumWriter=new SpecificDatumWriter<>(Person.class); DataFileWriter<Person> dataFileWriter=new DataFileWriter<>(personDatumWriter); dataFileWriter.create(person.getSchema(),new File("person.avro")); dataFileWriter.append(person); dataFileWriter.close(); System.out.println("序列化胜利....."); DatumReader<Person> personDatumReader=new SpecificDatumReader<>(Person.class); DataFileReader<Person> dataFileReader=new DataFileReader<Person>(new File("person.avro"),personDatumReader); Person nper=dataFileReader.next(); System.out.println(nper); }}kyro序列化框架
Kryo是一种十分成熟的序列化实现，曾经在Hive、Storm）中应用得比拟宽泛，不过它不能跨语言. 目前dubbo曾经在2.6版本反对kyro的序列化机制。它的性能要优于之前的hessian2
zookeeper中应用jute作为序列化
Protobuf序列化
Protobuf是Google的一种数据交换格局，它独立于语言、独立于平台。Google提供了多种语言来实现，比方Java、C、Go、Python，每一种实现都蕴含了相应语言的编译器和库文件，Protobuf是一个纯正的表示层协定，能够和各种传输层协定一起应用。
Protobuf应用比拟宽泛，次要是空间开销小和性能比拟好，非常适合用于公司外部对性能要求高的RPC调用。 另外因为解析性能比拟高，序列化当前数据量绝对较少，所以也能够利用在对象的长久化场景中
然而要应用Protobuf会相对来说麻烦些，因为他有本人的语法，有本人的编译器，如果须要用到的话必须要去投入老本在这个技术的学习中
protobuf有个毛病就是要传输的每一个类的构造都要生成对应的proto文件，如果某个类产生批改，还得从新生成该类对应的proto文件
应用protobuf开发的个别步骤是
- 配置开发环境，装置protocol compiler代码编译器
- 编写.proto文件，定义序列化对象的数据结构
- 基于编写的.proto文件，应用protocol compiler编译器生成对应的序列化/反序列化工具类
- 基于主动生成的代码，编写本人的序列化利用
装置protobuf编译工具
- https://github.com/google/pro... 找到 protoc-3.5.1-win32.zip
编写proto文件
syntax="proto2";package com.gupao.example; option java_outer_classname="UserProtos";message User { required string name=1; required int32 age=2;}数据类型阐明如下：
- string / bytes / bool / int32（4个字节）/int64/float/double
- enum 枚举类
- message 自定义类
修饰符
- required 示意必填字段
- optional 示意可选字段
- repeated 可反复，示意汇合
- 1，2，3，4须要在以后范畴内是惟一的，示意程序
生成实例类，在cmd中运行如下命令
protoc.exe --java_out=./ ./User.proto
实现序列化
<dependency> <groupId>com.google.protobuf</groupId> <artifactId>protobuf-java</artifactId> <version>3.12.2</version></dependency>编写测试代码.
public class ProtobufSerializer { public static void main(String[] args) throws InvalidProtocolBufferException { UserProtos.User user=UserProtos.User.newBuilder().setName("Mic").setAge(18).build(); ByteString bytes=user.toByteString(); System.out.println(bytes.toByteArray().length); UserProtos.User nUser=UserProtos.User.parseFrom(bytes); System.out.println(nUser); }}Protobuf序列化原理解析
咱们能够把序列化当前的数据打印进去看看后果
public static void main(String[] args) { UserProtos.User user=UserProtos.User.newBuilder(). setAge(300).setName("Mic").build(); byte[] bytes=user.toByteArray(); for(byte bt:bytes){ System.out.print(bt+" "); }}10 3 77 105 99 16 -84 2咱们能够看到，序列化进去的数字根本看不懂，然而序列化当前的数据的确很小，那咱们接下来带大家去理解一下底层的原理
失常来说，要达到最小的序列化后果，肯定会用到压缩的技术，而protobuf外面用到了两种压缩算法，一种是varint，另一种是zigzag
varint
先说第一种，咱们先来看【Mic】是怎么被压缩的
“Mic”这个字符，须要依据ASCII对照表转化为数字。
M =77、i=105、c=99
所以后果为 77 105 99
大家必定有个疑难，这里的后果为什么间接就是ASCII编码的值呢？怎么没有做压缩呢？有没有同学可能答复进去
起因是，varint是对字节码做压缩，然而如果这个数字的二进制只须要一个字节示意的时候，其实最终编码进去的后果是不会变动的。 如果呈现须要大于一个字节的形式来示意，则须要进行压缩。
比方，咱们设置的age=300， 这里须要2个字节来存储。那看一下它是如何被压缩的。
300如何被压缩
这两个字节字节别离的后果是：-84 、2
-84怎么计算来的呢？ 咱们晓得在二进制中示意正数的办法，高位设置为1， 并且是对应数字的二进制取反当前再计算补码示意（补码是反码+1）
所以如果要反过来计算
- 【补码】10101100 -1 失去 10101011
- 【反码】01010100 失去的后果为84. 因为高位是1，示意正数所以后果为-84
存储格局
protobuf采纳T-L-V作为存储形式
tag的计算形式是 field_number(以后字段的编号) << 3 | wire_type
比方Mic的字段编号是1 ，类型wire_type的值为 2 所以 ： 1 <<3 | 2 =10
age=300的字段编号是2，类型wire_type的值是0， 所以 : 2<<3|0 =16
所以依照T-L-V的格局，第一个字段为name，所以它的数据为 {10} {3} {77 105 99}，第二个字段为age ，{16} {2} {-82 2}
5.5.3 正数的存储形式
在计算机中，正数会被示意为很大的整数，因为计算机定义正数符号位为数字的最高位，所以如果采纳varint编码表示一个正数，那么肯定须要5个比特位。所以在protobuf中通过sint32/sint64类型来示意正数，正数的解决模式是先采纳zigzag编码（把符号数转化为无符号数），在采纳varint编码。
sint32：(n << 1) ^ (n >> 31)
sint64：(n << 1) ^ (n >> 63)
比方存储一个（-300）的值。
批改proto原始文件
message User { required string name=1; required int32 age=2; required sint32 status=3; //减少一个sint的字段}设置一个值
UserProtos.User user=UserProtos.User.newBuilder().setAge(300).setName("Mic").setStatus(-300).build();- 此时的输入后果：
10 3 77 105 99 16 -84 2 24 -41 4
咱们发现，针对于正数类型，压缩进去的数据是不一样的，这里采纳的编码方式是zigzag的编码，再采纳varint进行编码压缩。
比方存储一个（-300）的值
-300
原码：0001 0010 1100
取反：1110 1101 0011
加1 ：1110 1101 0100
n<<1: 整体左移一位，左边补0 -> 1101 1010 1000
n>>31: 整体右移31位，右边补1 -> 1111 1111 1111
n<<1 ^ n >>31
1101 1010 1000 ^ 1111 1111 1111 = 0010 0101 0111
十进制： 0010 0101 0111 = 599
这样做的目标，是打消高位的1，从而造成一个能够被压缩的数据。针对599再采纳varint进行编码。
varint算法： 从右往做，选取7位，高位补1/0（取决于字节数）
失去两个字节
1101 0111 0000 0100
-41 、 4
5.5.4 总结
Protocol Buffer的性能好，次要体现在 序列化后的数据体积小 & 序列化速度快，最终使得传输效率高，其起因如下：
序列化速度快的起因：
a. 编码 / 解码 形式简略（只须要简略的数学运算 = 位移等等）
b. 采纳 Protocol Buffer 本身的框架代码 和 编译器 共同完成
序列化后的数据量体积小（即数据压缩成果好）的起因：
a. 采纳了独特的编码方式，如Varint、Zigzag编码方式等等
b. 采纳T - L - V 的数据存储形式：缩小了分隔符的应用 & 数据存储得紧凑
序列化技术选型
技术层面
- 序列化空间开销，也就是序列化产生的后果大小，这个影响到传输的性能
- 序列化过程中耗费的时长，序列化耗费工夫过长影响到业务的响应工夫
- 序列化协定是否反对跨平台，跨语言。因为当初的架构更加灵便，如果存在异构零碎通信需要，那么这个是必须要思考的
- 可扩展性/兼容性，在理论业务开发中，零碎往往须要随着需要的疾速迭代来实现疾速更新，这就要求咱们采纳的序列化协定基于良好的可扩展性/兼容性，比方在现有的序列化数据结构中新增一个业务字段，不会影响到现有的服务
- 技术的风行水平，越风行的技术意味着应用的公司多，那么很多坑都曾经淌过并且失去了解决，技术解决方案也绝对成熟
- 学习难度和易用性
选型倡议
- 对性能要求不高的场景，能够采纳基于XML的SOAP协定
- 对性能和间接性有比拟高要求的场景，那么Hessian、Protobuf、Thrift、Avro都能够。
- 基于前后端拆散，或者独立的对外的api服务，选用JSON是比拟好的，对于调试、可读性都很不错
- Avro设计理念偏于动静类型语言，那么这类的场景应用Avro是能够的
版权申明：本博客所有文章除特地申明外，均采纳 CC BY-NC-SA 4.0 许可协定。转载请注明来自Mic带你学架构！
如果本篇文章对您有帮忙，还请帮忙点个关注和赞，您的保持是我一直创作的能源。欢送关注同名微信公众号获取更多技术干货！