欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  IT编程

干货系列性能篇之——序列化

程序员文章站 2022-05-29 10:24:58
序列化方案 Java序列化 原理 Serializable transient serialVersionUID writeObject/readObject 具体实现序列化和反序列化的是writeObject和readObject writeReplace/readResolve 缺陷 无法跨语言 ......

干货系列性能篇之——序列化

 

 

序列化方案

  1. java rmi采用的是java序列化
  2. spring cloud采用的是json序列化
  3. dubbo虽然兼容java序列化,但默认使用的是hessian序列化

java序列化

原理

干货系列性能篇之——序列化

 

serializable

  1. jdk提供了输入流对象objectinputstream和输出流对象objectoutputstream
  2. 它们只能对实现了serializable接口的类的对象进行序列化和反序列化
// 只能对实现了serializable接口的类的对象进行序列化
// java.io.notserializableexception: java.lang.object
objectoutputstream oos = new objectoutputstream(new fileoutputstream(file_path));
oos.writeobject(new object());
oos.close();

transient

  1. objectoutputstream的默认序列化方式,仅对对象的非transient的实例变量进行序列化
  2. 不会序列化对象的transient的实例变量,也不会序列化静态变量
@getter
public class a implements serializable {
 private transient int f1 = 1;
 private int f2 = 2;
 @getter
 private static final int f3 = 3;
}
// 序列化
// 仅对对象的非transient的实例变量进行序列化
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()); // f1=0, f2=2, f3=3
ois.close();

serialversionuid

  1. 在实现了serializable接口的类的对象中,会生成一个serialversionuid的版本号
  2. 在反序列化过程中用来验证序列化对象是否加载了反序列化的类
  3. 如果是具有相同类名的不同版本号的类,在反序列化中是无法获取对象的
@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 {
 // 如果先将b的serialversionuid修改为1,直接反序列化磁盘上的文件,会报异常
 // java.io.invalidclassexception: xxx.b; local class incompatible: stream classdesc serialversionuid = 0, local class serialversionuid = 1
 objectinputstream ois = new objectinputstream(new fileinputstream(file_path));
 b b2 = (b) ois.readobject();
 ois.close();
}

writeobject/readobject

具体实现序列化和反序列化的是writeobject和readobject

@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); // s2=student(id=1, age=0, name=bob)
ois.close();

writereplace/readresolve

  1. writereplace:用在序列化之前替换序列化对象
  2. readresolve:用在反序列化之后对返回对象进行处理
// 反序列化会通过反射调用无参构造器返回一个新对象,破坏单例模式
// 可以通过readresolve()来解决
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); // false
ois.close();

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); // true
ois.close();

缺陷

无法跨语言

java序列化只适用于基于java语言实现的框架

易被攻击

1.java序列化是不安全的

  • java官网:对不信任数据的反序列化,本质上来说是危险的,应该予以回避

2.objectinputstream.readobject()

  • 将类路径上几乎所有实现了serializable接口的对象都实例化!!
  • 这意味着:在反序列化字节流的过程中,该方法可以执行任意类型的代码,非常危险

3.对于需要长时间进行反序列化的对象,不需要执行任何代码,也可以发起一次攻击

  • 攻击者可以创建循环对象链,然后将序列化后的对象传输到程序中进行反序列化
  • 这会导致hasecode方法被调用的次数呈次方爆发式增长,从而引发栈溢出异常

4.很多序列化协议都制定了一套数据结构来保存和获取对象,如json序列化、protocolbuf

  • 它们只支持一些基本类型和数组类型,可以避免反序列化创建一些不确定的实例
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"); // 使t2不等于t1
 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();
// itcount - take
// 25 - 3460
// 26 - 7346
// 27 - 11161

序列化后的流太大

1.序列化后的二进制流大小能体现序列化的能力

2.序列化后的二进制数组越大,占用的存储空间就越多,存储硬件的成本就越高

  • 如果进行网络传输,则占用的带宽就越多,影响到系统的吞吐量

3.java序列化使用objectoutputstream来实现对象转二进制编码,可以对比bio中的 bytebuffer实现的二进制编码

@data
class user implements serializable {
 private string username;
 private string password;
}
user user = new user();
user.setusername("test");
user.setpassword("test");
// objectoutputstream
bytearrayoutputstream os = new bytearrayoutputstream();
objectoutputstream oos = new objectoutputstream(os);
oos.writeobject(user);
log.info("{}", os.tobytearray().length); // 107
// nio bytebuffer
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()); // 16

序列化速度慢

  1. 序列化速度是体现序列化性能的重要指标
  2. 如果序列化的速度慢,就会影响网络通信的效率,从而增加系统的响应时间
int count = 10_0000;
user user = new user();
user.setusername("test");
user.setpassword("test");
// objectoutputstream
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); // 731
// nio bytebuffer
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); // 182

protobuf

  1. protobuf是由google推出且支持多语言的序列化框架
  • 在序列化框架性能测试报告中,protobuf无论编解码耗时,还是二进制流压缩大小,都表现很好
  1. protobuf以一个.proto后缀的文件为基础,该文件描述了字段以及字段类型,通过工具可以生成不同语言的数据结构文件
  2. 在序列化该数据对象的时候,protobuf通过.proto文件描述来生成protocol buffers格式的编码

存储格式

  1. protocol buffers是一种轻便高效的结构化数据存储格式
  2. protocol buffers使用t-l-v(标识-长度-字段值)的数据格式来存储数据
  • t代表字段的正数序列(tag)
  • protocol buffers将对象中的字段与正数序列对应起来,对应关系的信息是由生成的代码来保证的
  • 在序列化的时候用整数值来代替字段名称,传输流量就可以大幅缩减
  • l代表value的字节长度,一般也只占用一个字节
  • v代表字段值经过编码后的值
  1. 这种格式不需要分隔符,也不需要空格,同时减少了冗余字段名

编码方式

干货系列性能篇之——序列化

 

1.protobuf定义了一套自己的编码方式,几乎可以映射java/python等语言的所有基础数据类型

2.不同的编码方式可以对应不同的数据类型,还能采用不同的存储格式

3.对于varint编码的数据,由于数据占用的存储空间是固定的,因此不需要存储字节长度length,存储方式采用t-v

4.varint编码是一种变长的编码方式,每个数据类型一个字节的最后一位是标志位(msb)

  • 0表示当前字节已经是最后一个字节
  • 1表示后面还有一个字节

5.对于int32类型的数字,一般需要4个字节表示,如果采用varint编码,对于很小的int类型数字,用1个字节就能表示

  • 对于大部分整数类型数据来说,一般都是小于256,所以这样能起到很好的数据压缩效果

编解码

  1. protobuf不仅压缩存储数据的效果好,而且编解码的性能也是很好的
  2. protobuf的编码和解码过程结合.proto文件格式,加上protocol buffers独特的编码格式
  • 只需要简单的数据运算以及位移等操作就可以完成编码和解码

我是小架,需要java学习进阶架构资料。加我的交流群

772300343  即可领取!

我们下篇文章见!

感谢!