序列化方案
- Java RMI采用的是Java序列化
- Spring Cloud采用的是_JSON序列化_
- Dubbo虽然兼容Java序列化,但默认使用的是_Hessian序列化_
Java序列化
原理
Serializable
- JDK提供了输入流对象ObjectInputStream和输出流对象ObjectOutputStream
- 它们只能对实现了Serializable接口的类的对象进行序列化和反序列化
1 2 3 4 5
|
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(FILE_PATH)); oos.writeObject(new Object()); oos.close();
|
transient
- ObjectOutputStream的默认序列化方式,仅对对象的非transient的实例变量进行序列化
- 不会序列化对象的transient的实例变量,也不会序列化静态变量
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
| @Getter public class A implements Serializable { private transient int f1 = 1; private int f2 = 2; @Getter private static final int f3 = 3; }
A a1 = new A(); ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(FILE_PATH)); oos.writeObject(a1); oos.close();
ObjectInputStream ois = new ObjectInputStream(new FileInputStream(FILE_PATH)); A a2 = (A) ois.readObject(); log.info("f1={}, f2={}, f3={}", a2.getF1(), a2.getF2(), a2.getF3()); ois.close();
|
serialVersionUID
- 在实现了Serializable接口的类的对象中,会生成一个serialVersionUID的版本号
- 在反序列化过程中用来验证序列化对象是否加载了反序列化的类
- 如果是具有相同类名的不同版本号的类,在反序列化中是无法获取对象的
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
| @Data @AllArgsConstructor public class B implements Serializable { private static final long serialVersionUID = 1L; private int id; }
@Test public void test3() throws Exception { B b1 = new B(1); ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(FILE_PATH)); oos.writeObject(b1); oos.close(); }
@Test public void test4() throws Exception { ObjectInputStream ois = new ObjectInputStream(new FileInputStream(FILE_PATH)); B b2 = (B) ois.readObject(); ois.close(); }
|
writeObject/readObject
具体实现序列化和反序列化的是writeObject和readObject
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29
| @Data @AllArgsConstructor public class Student implements Serializable { private long id; private int age; private String name;
private void writeObject(ObjectOutputStream outputStream) throws IOException { outputStream.writeLong(id); outputStream.writeObject(name); }
private void readObject(ObjectInputStream inputStream) throws IOException, ClassNotFoundException { id = inputStream.readLong(); name = (String) inputStream.readObject(); } }
Student s1 = new Student(1, 12, "Bob"); ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(FILE_PATH)); oos.writeObject(s1); oos.close();
ObjectInputStream ois = new ObjectInputStream(new FileInputStream(FILE_PATH)); Student s2 = (Student) ois.readObject(); log.info("s2={}", s2); ois.close();
|
writeReplace/readResolve
- writeReplace:用在序列化之前替换序列化对象
- readResolve:用在反序列化之后对返回对象进行处理
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23
|
public class Singleton1 implements Serializable {
private static final Singleton1 SINGLETON_1 = new Singleton1();
private Singleton1() { }
public static Singleton1 getInstance() { return SINGLETON_1; } }
Singleton1 s1 = Singleton1.getInstance(); ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(FILE_PATH)); oos.writeObject(s1); oos.close();
ObjectInputStream ois = new ObjectInputStream(new FileInputStream(FILE_PATH)); Singleton1 s2 = (Singleton1) ois.readObject(); log.info("{}", s1 == s2); ois.close();
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
| public class Singleton2 implements Serializable {
private static final Singleton2 SINGLETON_2 = new Singleton2();
private Singleton2() { }
public static Singleton2 getInstance() { return SINGLETON_2; }
public Object writeRepalce() { return this; }
private Object readResolve() { return getInstance(); } }
Singleton2 s1 = Singleton2.getInstance(); ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(FILE_PATH)); oos.writeObject(s1); oos.close();
ObjectInputStream ois = new ObjectInputStream(new FileInputStream(FILE_PATH)); Singleton2 s2 = (Singleton2) ois.readObject(); log.info("{}", s1 == s2); ois.close();
|
缺陷
无法跨语言
Java序列化只适用于基于Java语言实现的框架
易被攻击
- Java序列化是不安全的
- Java官网:对不信任数据的反序列化,本质上来说是危险的,应该予以回避
- ObjectInputStream.readObject()
- 将类路径上几乎所有实现了Serializable接口的对象都实例化!!
- 这意味着:在反序列化字节流的过程中,该方法可以执行任意类型的代码,非常危险
- 对于需要长时间进行反序列化的对象,不需要执行任何代码,也可以发起一次攻击
- 攻击者可以创建循环对象链,然后将序列化后的对象传输到程序中进行反序列化
- 这会导致haseCode方法被调用的次数呈次方爆发式增长,从而引发栈溢出异常
- 很多序列化协议都制定了一套数据结构来保存和获取对象,如JSON序列化、ProtocolBuf
- 它们只支持一些基本类型和数组类型,可以避免反序列化创建一些不确定的实例
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30
| int itCount = 27; Set root = new HashSet(); Set s1 = root; Set s2 = new HashSet(); for (int i = 0; i < itCount; i++) { Set t1 = new HashSet(); Set t2 = new HashSet(); t1.add("foo"); s1.add(t1); s1.add(t2); s2.add(t1); s2.add(t2); s1 = t1; s2 = t2; }
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(FILE_PATH)); oos.writeObject(root); oos.close();
long start = System.currentTimeMillis(); ObjectInputStream ois = new ObjectInputStream(new FileInputStream(FILE_PATH)); ois.readObject(); log.info("take : {}", System.currentTimeMillis() - start); ois.close();
|
序列化后的流太大
- 序列化后的二进制流大小能体现序列化的能力
- 序列化后的二进制数组越大,占用的存储空间就越多,存储硬件的成本就越高
- 如果进行网络传输,则占用的带宽就越多,影响到系统的吞吐量
- Java序列化使用ObjectOutputStream来实现对象转二进制编码,可以对比BIO中的ByteBuffer实现的二进制编码
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26
| @Data class User implements Serializable { private String userName; private String password; }
User user = new User(); user.setUserName("test"); user.setPassword("test");
ByteArrayOutputStream os = new ByteArrayOutputStream(); ObjectOutputStream oos = new ObjectOutputStream(os); oos.writeObject(user); log.info("{}", os.toByteArray().length);
ByteBuffer byteBuffer = ByteBuffer.allocate(2048); byte[] userName = user.getUserName().getBytes(); byte[] password = user.getPassword().getBytes(); byteBuffer.putInt(userName.length); byteBuffer.put(userName); byteBuffer.putInt(password.length); byteBuffer.put(password); byteBuffer.flip(); log.info("{}", byteBuffer.remaining());
|
序列化速度慢
- 序列化速度是体现序列化性能的重要指标
- 如果序列化的速度慢,就会影响网络通信的效率,从而增加系统的响应时间
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34
| int count = 10_0000; User user = new User(); user.setUserName("test"); user.setPassword("test");
long t1 = System.currentTimeMillis(); for (int i = 0; i < count; i++) { ByteArrayOutputStream os = new ByteArrayOutputStream(); ObjectOutputStream oos = new ObjectOutputStream(os); oos.writeObject(user); oos.flush(); oos.close(); byte[] bytes = os.toByteArray(); os.close(); } long t2 = System.currentTimeMillis(); log.info("{}", t2 - t1);
long t3 = System.currentTimeMillis(); for (int i = 0; i < count; i++) { ByteBuffer byteBuffer = ByteBuffer.allocate(2048); byte[] userName = user.getUserName().getBytes(); byte[] password = user.getPassword().getBytes(); byteBuffer.putInt(userName.length); byteBuffer.put(userName); byteBuffer.putInt(password.length); byteBuffer.put(password); byteBuffer.flip(); byte[] bytes = new byte[byteBuffer.remaining()]; } long t4 = System.currentTimeMillis(); log.info("{}", t4 - t3);
|
ProtoBuf
- ProtoBuf是由Google推出且支持多语言的序列化框架
- 在序列化框架性能测试报告中,ProtoBuf无论编解码耗时,还是二进制流压缩大小,都表现很好
- ProtoBuf以一个**.proto**后缀的文件为基础,该文件描述了字段以及字段类型,通过工具可以生成不同语言的数据结构文件
- 在序列化该数据对象的时候,ProtoBuf通过.proto文件描述来生成Protocol Buffers格式的编码
存储格式
- Protocol Buffers是一种轻便高效的结构化数据存储格式
- Protocol Buffers使用T-L-V(标识-长度-字段值)的数据格式来存储数据
- T代表字段的正数序列(tag)
- Protocol Buffers将对象中的字段与正数序列对应起来,对应关系的信息是由生成的代码来保证的
- 在序列化的时候用整数值来代替字段名称,传输流量就可以大幅缩减
- L代表Value的字节长度,一般也只占用一个字节
- V代表字段值经过编码后的值
- 这种格式不需要分隔符,也不需要空格,同时减少了冗余字段名
编码方式
- ProtoBuf定义了一套自己的编码方式,几乎可以映射Java/Python等语言的所有基础数据类型
- 不同的编码方式可以对应不同的数据类型,还能采用不同的存储格式
- 对于Varint编码的数据,由于数据占用的存储空间是固定的,因此不需要存储字节长度length,存储方式采用T-V
- Varint编码是一种变长的编码方式,每个数据类型一个字节的最后一位是标志位(msb)
- 0表示当前字节已经是最后一个字节
- 1表示后面还有一个字节
- 对于int32类型的数字,一般需要4个字节表示,如果采用Varint编码,对于很小的int类型数字,用1个字节就能表示
- 对于大部分整数类型数据来说,一般都是小于256,所以这样能起到很好的数据压缩效果
编解码
- ProtoBuf不仅压缩存储数据的效果好,而且编解码的性能也是很好的
- ProtoBuf的编码和解码过程结合**.proto**文件格式,加上Protocol Buffers独特的编码格式
- 只需要简单的数据运算以及位移等操作就可以完成编码和解码
参考资料
Java性能调优实战