|
|
|
|
公众号矩阵

漫谈序列化之使用、原理、问题

天天跟我说给我介绍对象对象,对象在哪里?哪里有对象?你倒是把对象拿给我看看啊!

作者:积木zz 来源:码上积木|2021-01-20 08:24

前言

天天跟我说给我介绍对象对象,对象在哪里?哪里有对象?

你倒是把对象拿给我看看啊!

拿去拿去 :

  1.  "name""小丽"
  2.  "age""22"
  3.  "sex""女" 

我去~

序列化概念

说到对象,是一个比较宽泛的概念,简单的说,他就是类的一个实例,有状态和行为,存活在内存中,一旦JVM停止运行,对象的状态也会丢失。

那么如何将这个对象当前状态进行一个记录,使其可以进行存储和传输呢?这就要用到序列化了:

序列化 (Serialization)是将对象的状态信息转换为可以存储或传输的形式的过程

比如一个User对象,名字为小丽,年龄22,性别为女。现在要把这个User对象保存下来,不然要是这个对象被别人改成了男可咋办。

所以我们就可以把它当前的状态信息转化成一种固定的格式,比如json格式:

  1.  "name""小丽"
  2.  "age""22"
  3.  "sex""女" 

所以上述的例子就是一个序列化过程,本身这个User对象存活在内存中,是无法直接进行数据持久化的,所以我们需要一些序列化的方式让它可以进行保存传输:

比如xml、JSON、Protobuf、Serializable、Parcelable,这些都是可以进行序列化的方式。

所以关于序列化我们就有很多问题了:

  • 在java有Serializable的前提下,Android为什么设计出了Parcelable?
  • Parcelable一定比Serializable快吗?
  • 为什么Java提供了Serializable的序列化方式,而不是直接使用json或者xml?
  • Serializable、Parcelable、Json等序列化方式我们该怎么选择?

带着这些问题,我们去看看序列化的世界。

Serializable

先说说Java中自带的序列化方式——Serializable。

Serializable是java.io包中定义的、用于实现Java类的序列化操作而提供的一个语义级别的接口

只要我们实现Serializable接口,那么这个类就可以被ObjectOutputStream转换为字节流,也就是进行了序列化。

使用

java:

  1. public class User implements Serializable { 
  2.     private static final long serialVersionUID=519067123721561165l; 
  3.      
  4.     private int id; 
  5.  
  6.     public int getId() { 
  7.         return id; 
  8.     } 
  9.  
  10.     public void setId(int id) { 
  11.         this.id = id; 
  12.     } 

kotlin:

  1. data class User(  
  2.     val id: Int 
  3. ) : Serializable 

这个变量如果不写,系统也会自动生成。它的作用在于标示这个数据对象的一致性。

当序列化的时候,系统会把当前类的serialVersionUID写入序列化的文件中,当反序列化的时候会去检测这个serialVersionUID,看他是否和当前类的serialVersionUID一致,一样则可以正常反序列化,如果不一样就会报错了。

如果我们不写的话,在我们修改类的某些属性之后,serialVersionUID就会改变。

所以我们手动指定serialVersionUID后,就能在修改类之后,让系统认识序列化的过程中标示这是同一个类,从而保证最大限度来恢复数据。

原理

在Serializable的注释中有提到,如果要想在序列化过程中做一些特殊的操作,可以实现这几个特殊方法:

  • writeObject(),负责写入对象的特定类,以便相应的readObject方法可以恢复它
  • readObject(),负责从流中读取并恢复类字段

所以这两个方法其实就是Serializable实现的关键。首先看看写入方法writeObject(伪代码):

  1. private void writeObject(){ 
  2.     //获取类的描述信息ObjectStreamClass(里面包含了类名称、类字段、serialVersionUID等,用到大量反射) 
  3.      desc = ObjectStreamClass.lookup(cl, true); 
  4.      //写入元数据TC_OBJECT,代表是一个新对象 
  5.      bout.writeByte(TC_OBJECT); 
  6.      //写入描述信息(从父类写到子类) 
  7.      writeClassDesc(descfalse); 
  8.      //写入serialVersionUID,serialVersionUID为空的情况下,序列化机制就会调用一个函数根据类内部的属性等计算出一个hash值 
  9.      getSerialVersionUID(); 
  10.      //执行JVM的序列化操作 
  11.      defaultWriteFields(); 
  12.  
  13.  
  14. private void defaultWriteFields(Object obj, ObjectStreamClass desc){ 
  15.     //写入基本数据类型 
  16.     bout.write(primVals, 0, primDataSize, false); 
  17.  
  18.     //写入引用数据类型(又重新调用了writeObject方法) 
  19.     Object[] objVals = new Object[desc.getNumObjFields()]; 
  20.     for (int i = 0; i < objVals.length; i++) { 
  21.         writeObject(objVals[i],fields[numPrimFields + i].isUnshared()); 
  22.     } 

写入数据的流程基本就这些,可以看到Serializable序列化的过程,其实就是一个写入流的过程。然后就可以根据情况将二进制流保持为文件,或者包装成ByteArrayOutStream写入到内存中进行传输。

所以Serializable使用的范围比较广,可以作为文件保存下来,也可以作为二进制流对象用于内存中的传输。但是由于用到反射、IO,而且大量的临时变量会引起频繁的GC,所以效率不算高。

所以,为了提高在Android中对象传输的效率呢,Android就采用了新的序列化方式——Parcelable。

Parcelable

Parcelable是Android为我们提供的序列化的接口,是为了解决Serializable在序列化的过程中消耗资源严重,而Android本身的内存比较紧缺的问题,但是用法较为繁琐,主要用于内存中数据的传输。

使用

java:

  1. public class User implements Parcelable { 
  2.     private int id; 
  3.  
  4.     protected User(Parcel in) { 
  5.         id = in.readInt(); 
  6.     } 
  7.  
  8.     @Override 
  9.     public void writeToParcel(Parcel dest, int flags) { 
  10.         dest.writeInt(id); 
  11.     } 
  12.  
  13.     @Override 
  14.     public int describeContents() { 
  15.         return 0; 
  16.     } 
  17.  
  18.     public static final Creator<User> CREATOR = new Creator<User>() { 
  19.         @Override 
  20.         public User createFromParcel(Parcel in) { 
  21.             return new User(in); 
  22.         } 
  23.  
  24.         @Override 
  25.         public User[] newArray(int size) { 
  26.             return new User[size]; 
  27.         } 
  28.     }; 
  29.  
  30.     public int getId() { 
  31.         return id; 
  32.     } 
  33.  
  34.     public void setId(int id) { 
  35.         this.id = id; 
  36.     } 
  1. androidExtensions { 
  2.     experimental = true 
  3.  
  4. @Parcelize 
  5. data class User(val name: String) : Parcelable 

原理

先说说Parcelable写法中这几个方法参数的意思:

  • createFromParcel,User(Parcel in) ,代表从序列化的对象中创建原始对象
  • newArray,代表创建指定长度的原始对象数组
  • writeToParcel,代表将当前对象写入到序列化结构中。
  • describeContents,代表返回当前对象的内容描述。如果还有文件描述符,返回1,否则返回0。

好了,在了解Parcelable原理之前,我们先要了解下Parcel。

Parcel是一个容器,它主要用于存储序列化数据,然后可以通过Binder在进程间传递这些数据

所以Parcel就是可以进行IPC通信的容器,同样底层也是用到了Binder。(Binder在Android中真是无处不在啊)

  1. //写入数据 
  2. Parcel parcle = Parcel.Obtain(); 
  3. parcel.writeString(String val); 
  4.  
  5. //读取数据 
  6. parcel.setDataPosition(i); 
  7. parcel.readString(); 

再往底层就是Binder的原理了,也就是将数据写到内核的共享内存中,然后其他进程可以从共享内存中进行读取。

而Parcelable的实现就是基于这个Parcel容器,还记得刚才的几个方法吗:

  • writeToParcel,写入数据到Parcel容器。
  • new User(in),从Parcel容器读取数据。

Parcelable的原理就是如此啦。

思考问题

介绍完了两种序列化方式,我们再来看看文章开头的这些问题。

在java有Serializable的前提下,Android为什么设计出了Parcelable?

java中的序列化方式Serializable效率比较低,主要有以下原因:

  • Serializable在序列化过程中会创建大量的临时变量,这样就会造成大量的GC。
  • Serializable使用了大量反射,而反射操作耗时。
  • Serializable使用了大量的IO操作,也影响了耗时。

所以Android就像重新设计了IPC方式Binder一样,重新设计了一种序列化方式,结合Binder的方式,对上述三点进行了优化,一定程度上提高了序列化和反序列化的效率。

Serializable、Parcelable、Json等序列化方式我们该怎么选择?

先说说序列化的用处,主要用在三个方面:

1、内存数据传输

内存传输方面,主要用Parcelable。一是因为Parcelable在内存传输的效率比Serializable高。二是因为在Android中很多传输数据的方法中,自带了对于Serializable、Parcelable类型的传输方法。比如:

  • Bundle.putParcelable,
  • Intent putExtra(String name, Parcelable value)

等等吧,基本上对象传输的方法都支持了,所以这也是Parcelable的优势。

2、 数据持久化(本地存储)

如果只针对Serializable和Parcelable两种序列化方式,需要选择Serializable。

首先,Serializable本身就是存储到二进制文件,所以用于持久化比较方便。而Parcelable序列化是在内存中操作,如果进程关闭或者重启的时候,内存中的数据就会消失,那么Parcelable序列化用来持久化就有可能会失败,也就是数据不会连续完整。而且Parcelable还有一个问题是兼容性,每个Android版本可能内部实现都不一样,知识用于内存中也就是传递数据的话是不影响的,但是如果持久化可能就会有问题了,低版本的数据拿到高版本可能会出现兼容性问题。

但是实际情况,对于Android中的对象本地化存储,一般是以数据库、SP的方式进行保存。

3、 网络传输

而对于网络传输的情况,一般就是使用JSON了。主要有以下几点原因:

  • 轻量级,没有多余的数据。
  • 与语言无关,所以能兼容所有平台语言。
  • 易读性,易解析。

Parcelable一定比Serializable快吗?

正常情况下,对象在内存中进行传输确实是Parcelable比较快,但是Serializable是有缓存的概念的,有人做了一个比较有趣的实验:

当序列化一个超级大的对象图表(表示通过一个对象,拥有通过某路径能访问到其他很多的对象),并且每个对象有10个以上属性时,并且Serializable实现了writeObject()以及readObject(),在平均每台安卓设备上,Serializable序列化速度大于Parcelable 3.6倍,反序列化速度大于1.6倍.

具体原因就是因为Serilazable的实现方式中,是有缓存的概念的,当一个对象被解析过后,将会缓存在HandleTable中,当下一次解析到同一种类型的对象后,便可以向二进制流中,写入对应的缓存索引即可。但是对于Parcel来说,没有这种概念,每一次的序列化都是独立的,每一个对象,都当作一种新的对象以及新的类型的方式来处理。

具体过程可以看看这篇:https://juejin.cn/post/6854573218334769166

为什么Java提供了Serializable的序列化方式,而不是直接使用json或者xml?

我觉得是历史遗留问题。

有的人可能会想到各种理由,比如可以标记哪些类可以被序列化。又或者可以通过UID来标示反序列化为同一个对象。等等。

但是我觉得最大的问题还是历史遗留问题,在以前,json还没有成为大家认同的数据结构,所以Java就设计出了Serializable的序列化方式来解决对象持久化和对象传输的问题。然后Java中各种API就会依赖于这种序列化方式,这么些年过去了,Java体系的庞大也造成难以改变这个问题,牵一发而动全身。

为什么我这么说呢?

主要有两点依据:

  • 曾经Oracle Java平台组的架构师说过,删除Java的序列化机制并且提供给用户可以选择的序列化方式(比如json)是他们计划中的一部分,因为Java序列化也造成了很多Java漏洞。具体可以参见文章:https://www.infoworld.com/article/3275924/oracle-plans-to-dump-risky-java-serialization.html
  • 因为在Serializable类的介绍注释中,明确说到推荐大家选择JSON 和 GSON库,因为它简洁、易读、高效。
  1. <h3>Recommended Alternatives</h3> 
  2.  <strong>JSON</strong> is concise, human-readable and efficient. Android 
  3.  includes both a {@link android.util.JsonReader streaming API} and a {@link 
  4.  org.json.JSONObject tree API} to read and write JSON. Use a binding library 
  5.  like <a href="http://code.google.com/p/google-gson/">GSON</a> to read and 
  6.  write Java objects directly. 

Android体系架构

连载文章、脑图、面试专题:

https://github.com/JiMuzz/Android-Architecture

参考

https://developer.android.google.cn/reference/android/os/Parcel?hl=en https://blog.csdn.net/lwj_zeal/article/details/90743500 https://juejin.cn/post/6854573218334769166#heading http://blog.sina.com.cn/s/blog_6e07f1eb0100rsax.html https://www.zhihu.com/question/283510695 https://www.infoworld.com/article/3275924/oracle-plans-to-dump-risky-java-serialization.html

本文转载自微信公众号「码上积木」,可以通过以下二维码关注。转载本文请联系码上积木公众号。

【编辑推荐】

  1. 基于Rust的Android Native内存分析方案
  2. 神秘!申请内存时底层发生了什么?
  3. 干货:Linux查询 OS、CPU、内存、硬盘信息
  4. 8G内存都撑不住,为何安卓杀后台越来越严重,多大内存才够呢?
  5. 内存条标签能看出啥信息?一文了解
【责任编辑:武晓燕 TEL:(010)68476606】

点赞 0
分享:
大家都在看
猜你喜欢
24H热文
一周话题
本月获赞

订阅专栏+更多

订阅51CTO邮刊

点击这里查看样刊

订阅51CTO邮刊

51CTO服务号

51CTO官微