将数据结构或对象转换成二进制串的过程。
将在序列化过程中所生成的二进制串转换成数据结构或者对象的过程
不同的计算机语言中,数据结构,对象以及二进制串的表示方式并不相同。
数据结构和对象:对于类似 Java 这种完全面向对象的语言,工程师所操作的一切都是对象(Object),来自于类的实例化。在 Java 语言中最接近数据结构的概念,就是 POJO(Plain Old Java Object)或者 Javabean--那些只有 setter/getter 方法的类。而在 C 二进制串:序列化所生成的二进制串指的是存储在内存中的一块数据。C 语言的字符串可以直接被传输层使用,因为其本质上就是以’0’结尾的存储在内存中的二进制串。在 Java 语言里面,二进制串的概念容易和 String 混淆。实际上 String 是 Java 的一等公民,是一种特殊对象(Object)。对于跨语言间的通讯,序列化后的数据当然不能是某种语言的特殊数据类型。二进制串在 Java 里面所指的是 byte[],byte 是 Java 的 8 中原生数据类型之一(Primitive data types)。
简单的概括
具体的讲:
性能包括两个方面,时间复杂度和空间复杂度。
移动互联时代,业务系统需求的更新周期变得更快,新的需求不断涌现,而老的系统还是需要继续维护。如果序列化协议具有良好的可扩展性,支持自动增加新的业务字段,而不影响老的服务,这将大大提供系统的灵活度。
在序列化选型的过程中,安全性的考虑往往发生在跨局域网访问的场景。当通讯发生在公司之间或者跨机房的时候,出于安全的考虑,对于跨局域网的访问往往被限制为基于 HTTP/HTTPS 的 80 和 443 端口。如果使用的序列化协议没有兼容而成熟的 HTTP 传输层框架支持,可能会导致以下三种结果之一:
最近几个月,Android安全公告公布了一系列系统框架层的高危提权漏洞,如下表所示。
https://www.anquanke.com/post/id/103570
XML 是一种常用的序列化和反序列化协议,具有跨机器,跨语言等优点,SOAP(Simple Object Access protocol) 是一种被广泛应用的,基于 XML 为序列化和反序列化协议的结构化消息传递协议
JSON 起源于弱类型语言 Javascript, 它的产生来自于一种称之为”Associative array”的概念,其本质是就是采用”Attribute-value”的方式来描述对象。实际上在 Javascript 和 PHP 等弱类型语言中,类的描述方式就是 Associative array。JSON 的如下优点,使得它快速成为最广泛使用的序列化协议之一。
Protobuf 具备了优秀的序列化协议的所需的众多典型特征。
是 Java 提供的序列化接口,它是一个空接口:
public interface Serializable { }
Serializable 用来标识当前类可以被 ObjectOutputStream 序列化,以及被 ObjectInputStream 反序列化。
public class Student implements Serializable { //serialVersionUID唯一标识了一个可序列化的类 private static final long serialVersionUID = -2100492893943893602L; private String name; private String sax; private Integer age; //Course也需要实现Serializable接口 private List<Course> courses; //用transient关键字标记的成员变量不参与序列化(在被反序列化后,transient 变量的值被设为初始值,如 int 型的是 0,对象型的是 null) private transient Date createTime; //静态成员变量属于类不属于对象,所以不会参与序列化(对象序列化保存的是对象的“状态”,也就是它的成员变量,因此序列化不会关注静态变量) private static SimpleDateFormat simpleDateFormat = new SimpleDateFormat(); public Student() { System.out.println("Student: empty"); } public Student(String name, String sax, Integer age) { System.out.println("Student: " + name + " " + sax + " " + age); this.name = name; this.sax = sax; this.age = age; courses = new ArrayList<>(); createTime = new Date(); } ... } ////Course也需要实现Serializable接口 public class Course implements Serializable { private static final long serialVersionUID = 667279791530738499L; private String name; private float score; ... }
Serializable 有以下几个特点:
因此 JVM 规范强烈 建议我们手动声明一个版本号,这个数字可以是随机的,只要固定不变就可以。同时最好是 private 和 final 的,尽量保证不变。
public interface Externalizable extends Serializable { void writeExternal(ObjectOutput var1) throws IOException; void readExternal(ObjectInput var1) throws IOException, ClassNotFoundException; }
简单使用
public class Course1 implements Externalizable { private static final long serialVersionUID = 667279791530738499L; private String name; private float score; ... @Override public void writeExternal(ObjectOutput objectOutput) throws IOException { System.out.println("writeExternal"); objectOutput.writeObject(name); objectOutput.writeFloat(score); } @Override public void readExternal(ObjectInput objectInput) throws IOException, ClassNotFoundException { System.out.println("readExternal"); name = (String)objectInput.readObject(); score = objectInput.readFloat(); } ... public static void main(String... args) throws Exception { //TODO: //TODO: Course1 course = new Course1("英语", 12f); ByteArrayOutputStream out = new ByteArrayOutputStream(); ObjectOutputStream oos = new ObjectOutputStream(out); oos.writeObject(course); course.setScore(78f); ); oos.close(); ObjectInputStream ois = new ObjectInputStream(new ByteArrayInputStream(bs)); Course1 course1 = (Course1) ois.readObject(); System.out.println("course1: " + course1); }
Serializable 的序列化与反序列化分别通过 ObjectOutputStream 和 ObjectInputStream 进行
/** * 序列化对象 * * @param obj * @param path * @return */ synchronized public static boolean saveObject(Object obj, String path) { if (obj == null) { return false; } ObjectOutputStream oos = null; try { // 创建序列化流对象 oos = new ObjectOutputStream(new FileOutputStream(path)); //序列化 oos.writeObject(obj); oos.close(); return true; } catch (IOException e) { e.printStackTrace(); } finally { if (oos != null) { try { // 释放资源 oos.close(); } catch (IOException e) { e.printStackTrace(); } } } return false; } /** * 反序列化对象 * * @param path * @param <T> * @return */ @SuppressWarnings("unchecked ") synchronized public static <T> T readObject(String path) { ObjectInputStream ojs = null; try { // 创建反序列化对象 ojs = new ObjectInputStream(new FileInputStream(path)); // 还原对象 return (T) ojs.readObject(); } catch (IOException | ClassNotFoundException e) { e.printStackTrace(); } finally { if(ojs!=null){ try { // 释放资源 ojs.close(); } catch (IOException e) { e.printStackTrace(); } } } return null; }
序列化算法一般会按步骤做如下事情:
格式化后以二进制打开
aced 0005 7372 002e 636f 6d2e 7a65 726f 2e73 6572 6961 6c69 7a61 626c 6564 656d 6f2e 7365 7269 616c 697a 6162 6c65 2e53 7475 6465 6e74 e2d9 8cd7 833d f19e 0200 044c 0003 6167 6574 0013 4c6a 6176 612f 6c61 6e67 2f49 6e74 6567 6572 3b4c 0007 636f 7572 7365 7374 0010 4c6a 6176 612f 7574 696c 2f4c 6973 743b 4c00 046e 616d 6574 0012 4c6a 6176 612f 6c61 6e67 2f53 7472 696e 673b 4c00 0373 6178 7100 7e00 0378 7073 7200 116a 6176 612e 6c61 6e67 2e49 6e74 6567 6572 12e2 a0a4 f781 8738 0200 0149 0005 7661 6c75 6578 7200 106a 6176 612e 6c61 6e67 2e4e 756d 6265 7286 ac95 1d0b 94e0 8b02 0000 7870 0000 0012 7372 0013 6a61 7661 2e75 7469 6c2e 4172 7261 794c 6973 7478 81d2 1d99 c761 9d03 0001 4900 0473 697a 6578 7000 0000 0277 0400 0000 0273 7200 2d63 6f6d 2e7a 6572 6f2e 7365 7269 616c 697a 6162 6c65 6465 6d6f 2e73 6572 6961 6c69 7a61 626c 652e 436f 7572 7365 0942 a76f 5bfc 8343 0200 0246 0005 7363 6f72 654c 0004 6e61 6d65 7100 7e00 0378 7042 b466 6674 0006 e8af ade6 9687 7371 007e 000a 42b2 999a 7400 06e6 95b0 e5ad a678 7400 045a 6572 6f74 0003 e794 b7
以
1. ObjectOutputStream的构造函数设置enableOverride = false ```java public ObjectOutputStream(OutputStream out) throws IOException { verifySubclass(); bout = new BlockDataOutputStream(out); handles = new HandleTable(10, (float) 3.00); subs = new ReplaceTable(10, (float) 3.00); enableOverride = false;//enableOverride = false ... }
public final void writeObject(Object obj) throws IOException { //enableOverride=false,不走这里 if (enableOverride) { writeObjectOverride(obj); return; } try {//一般情况都走这里 writeObject0(obj, false); ... }
/** * Underlying writeObject/writeUnshared implementation. */ private void writeObject0(Object obj, boolean unshared) throws IOException ... // remaining cases if (obj instanceof String) { writeString((String) obj, unshared); } else if (cl.isArray()) { writeArray(obj, desc, unshared); } else if (obj instanceof Enum) { writeEnum((Enum<?>) obj, desc, unshared); } else if (obj instanceof Serializable) { //看这里 writeOrdinaryObject(obj, desc, unshared); } else {//如果没有实现Serializable接口,会报NotSerializableException if (extendedDebugInfo) { throw new NotSerializableException( cl.getName() + "/n" + debugInfoStack.toString()); } else { throw new NotSerializableException(cl.getName()); ... }
private void writeOrdinaryObject(Object obj, ObjectStreamClass desc, boolean unshared) ... if (desc.isExternalizable() && !desc.isProxy()) { //如果对象实现了Externalizable接口,那么执行writeExternalData((Externalizable) obj)方法 writeExternalData((Externalizable) obj); } else {//如果对象实现的是Serializable接口,那么执行的是writeSerialData(obj, desc) writeSerialData(obj, desc); } ... } //这里我们看看writeExternalData
/** * Writes instance data for each serializable class of given object, from * superclass to subclass. * 最终写序列化的方法 */ private void writeSerialData(Object obj, ObjectStreamClass desc) throws IOException { ... if (slotDesc.hasWriteObjectMethod()) { //如果writeObjectMethod != null(目标类中定义了私有的writeObject方法),那么将调用目标类中的writeObject方法 ... slotDesc.invokeWriteObject(obj, this); ... } else { //如果如果writeObjectMethod == null, 那么将调用默认的defaultWriteFields方法来读取目标类中的属性 defaultWriteFields(obj, slotDesc); } } }
/** * Creates local class descriptor representing given class. */ private ObjectStreamClass(final Class<?> cl) { ... if (externalizable) { cons = getExternalizableConstructor(cl); } else {//,在序列化(反序列化)的时候,ObjectOutputStream(ObjectInputStream) // 会寻找目标类中的私有的writeObject(readObject)方法, // 赋值给变量writeObjectMethod(readObjectMethod) cons = getSerializableConstructor(cl); writeObjectMethod = getPrivateMethod(cl, "writeObject", new Class<?>[] { ObjectOutputStream.class }, Void.TYPE); readObjectMethod = getPrivateMethod(cl, "readObject", new Class<?>[] { ObjectInputStream.class }, Void.TYPE); readObjectNoDataMethod = getPrivateMethod( cl, "readObjectNoData", null, Void.TYPE); hasWriteObjectData = (writeObjectMethod != null); } domains = getProtectionDomains(cons, cl); writeReplaceMethod = getInheritableMethod( cl, "writeReplace", null, Object.class); readResolveMethod = getInheritableMethod( cl, "readResolve", null, Object.class); return null; } }); ... } //ObjectStreamClass类中的一个判断方法 boolean hasWriteObjectMethod() { requireInitialized(); return (writeObjectMethod != null); }
public class Course implements Serializable { private static final long serialVersionUID = 667279791530738499L; private String name; private float score; ... public static void main(String... args) throws Exception { //TODO: //TODO: Course course = new Course("英语", 12f); ByteArrayOutputStream out = new ByteArrayOutputStream(); ObjectOutputStream oos = new ObjectOutputStream(out); oos.writeObject(course); course.setScore(78f); // oos.reset(); oos.writeUnshared(course); // oos.writeObject(course); byte[] bs = out.toByteArray(); oos.close(); ObjectInputStream ois = new ObjectInputStream(new ByteArrayInputStream(bs)); Course course1 = (Course) ois.readObject(); Course course2 = (Course) ois.readObject(); System.out.println("course1: " + course1); System.out.println("course2: " + course2); } }
执行结果:
course1: Course{name='英语', score=12.0} course2: Course{name='英语', score=12.0}
在默认情况下, 对于一个实例的多个引用,为了节省空间,只会写入一次,后面会追加几个字节代表某个实例的引用。
public class Person { private String name; private String sax; // public Person() { // } public Person(String name, String sax) { this.name = name; this.sax = sax; } } public class Student1 extends Person implements Serializable { private static final long serialVersionUID = -2100492893943893602L; private Integer age; private List<Course> courses; public Student1(String name, String sax, Integer age) { super(name,sax); ... } ... public static void main(String ... args) throws Exception{ //TODO: Student1 student = new Student1("Zero", "男", 18); student.addCourse(new Course("语文", 90.2f)); //序列化 byte[] bytes = SerializeableUtils.serialize(student); System.out.println(Arrays.toString(bytes)); //反序列化 //在readObject时抛出java.io.NotSerializableException异常。 //需要Person添加一个无参数构造器 Student1 student1 = SerializeableUtils.deserialize(bytes); System.out.println("Student: " + student1); }
在readObject时抛出java.io.NotSerializableException异常。
//反序列化目标类多一个字段(height) public class Student implements Serializable { private static final long serialVersionUID = -2100492893943893602L; private String name; private String sax; private Integer age; private List<Course> courses; ... @Override public String toString() { return "Student{" + "name='" + name + '/'' + ", sax='" + sax + '/'' + ", age=" + age + // ", height=" + height + ", courses=" + courses + '}'; } //private float height; public static void main(String ... args)throws Exception{ //TODO: String path = System.getProperty("user.dir") +"/a.out"; // Student student = new Student("Zero", "男", 18); // student.addCourse(new Course("语文", 90.2f)); // //序列化 // SerializeableUtils.saveObject(student,path); //反序列化 Student student1 = SerializeableUtils.readObject(path); System.out.println("Student: " + student1); } }
执行结果:
//序列化的时候 Student: Zero 男 18 Course: 语文 90.2 //反序列化的时候 添加一个float height Student: Student{name='Zero', sax='男', age=18, height=0.0, courses=[Course{name='语文', score=90.2}]}
可以看出反序列化之后,并没有报错,只是height实赋成了默认值。类似的其它对象也会赋值为默认值。
还有 相反,如果写入的多一个字段,读出的少一个字段,也是不会报错的
其它演化,比如更改类型等,这种演化本身就有问题,没必再探讨
public enum Num { TWO, ONE, THREE; public void printValues() { System.out.println(ONE + " ONE.ordinal " + ONE.ordinal()); System.out.println(TWO + " TWO.ordinal " + TWO.ordinal()); System.out.println(THREE + " THREE.ordinal " + THREE.ordinal()); } public static void testSerializable() throws Exception { File file = new File("p.dat"); // ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(file)); // oos.writeObject(Num.ONE); // oos.close(); Num.ONE.printValues(); System.out.println("=========反序列化后======="); ObjectInputStream ois = new ObjectInputStream(new FileInputStream(file)); Num s1 = (Num) ois.readObject(); s1.printValues(); ois.close(); } public static void main(String... args) throws Exception { //TODO: testSerializable(); } }
执行结果:
ONE ONE.ordinal 1 TWO TWO.ordinal 0 THREE THREE.ordinal 2 =========反序列化后======= //调换(ONE,TWO)的位置: TWO, ONE, THREE; ->ONE, TWO, THREE; ONE ONE.ordinal 0 TWO TWO.ordinal 1 THREE THREE.ordinal 2
可以看到ONE的值变成了0.
事实上序列化Enum对象时,并不会保存元素的值,只会保存元素的name。这样,在不依赖元素值的前提下,ENUM对象如何更改都会保持兼容性。
“只有当你自行设计的自定义序列化形式与默认的序列化形式基本相同时,才能接受默认的序列化> 形式”.“当一个对象的物理表示方法与它的逻辑数据内容有实质性差别时,使用默认序列化形式有> > N种缺陷”.其实从effective java的角度来讲,是强烈建议我们重写的,这样有助于我们更好地把控> > 序列化过程,防范未知风险
public class Course3 implements Serializable { private static final long serialVersionUID = 667279791530738499L; private String name; private float score; ... private void readObject(ObjectInputStream inputStream) throws ClassNotFoundException, IOException { System.out.println("readObject"); inputStream.defaultReadObject(); name = (String)inputStream.readObject(); score = inputStream.readFloat(); } private void writeObject(ObjectOutputStream outputStream) throws IOException { System.out.println("writeObject"); outputStream.defaultWriteObject(); outputStream.writeObject(name); outputStream.writeFloat(score); } private Object readResolve() { System.out.println("readResolve"); return new Course3(name, 85f); } private Object writeReplace(){ System.out.println("writeReplace"); return new Course3(name +"replace",score); } ... public static void main(String... args) throws Exception { //TODO: Course3 course = new Course3("英语", 12f); ByteArrayOutputStream out = new ByteArrayOutputStream(); ObjectOutputStream oos = new ObjectOutputStream(out); oos.writeObject(course); byte[] bs = out.toByteArray(); oos.close(); ObjectInputStream ois = new ObjectInputStream(new ByteArrayInputStream(bs)); Course3 course1 = (Course3) ois.readObject(); System.out.println("course1: " + course1); } }
执行结果:
Course: 英语 12.0 writeReplace Course: 英语replace 12.0 writeObject readObject readResolve Course: 英语replace 85.0 course1: Course{name='英语replace', score=85.0}
public class SingleTest { static final String CurPath = System.getProperty("user.dir"); public static void main(String ... args) throws Exception { //TODO: Single instance = Single.getInstance(); System.out.println(instance.hashCode()); System.out.println(copyInstance(instance).hashCode()); System.out.println("=================反射======================"); //使用反射方式直接调用私有构造器 Class<Single> clazz = (Class<Single>)Class.forName("com.zero.serializabledemo.serializable.Single"); Constructor<Single> con = clazz.getDeclaredConstructor(null); con.setAccessible(true);//绕过权限管理,即在true的情况下,可以通过构造函数新建对象 Single instance1 = con.newInstance(); Single instance2 = con.newInstance(); System.out.println(instance1.hashCode()); System.out.println(instance2.hashCode()); } private static Single copyInstance(Single instance) throws Exception{ //序列化会导致单例失效 FileOutputStream fos = new FileOutputStream(CurPath+"/a.txt"); ObjectOutputStream oos = new ObjectOutputStream(fos); oos.writeObject(instance); ObjectInputStream ois = new ObjectInputStream(new FileInputStream(CurPath+"/a.txt")); Single single2 = (Single)ois.readObject(); oos.close(); ois.close(); return single2; } } class Single implements Serializable { private static final long serialVersionUID = 1L; private static boolean flag = false; private Single(){ synchronized (Single.class) { if (!flag) { // flag = true; } else { throw new RuntimeException("单例模式被侵犯!"); } } } private static Single single; public static Single getInstance(){ if ( single == null ) { synchronized (Single.class) { if ( single == null ) { single = new Single(); } } } return single; } //如果不重写readResolve,会导致单例模式在序列化->反序列化后失败 // private Object readResolve() { // return single; // } }
介绍Parcelable不得不先提一下Serializable接口,Serializable是Java为我们提供的一个标准化的序列化接口,那什么是序列化呢? —- 简单来说就是将对象转换为可以传输的二进制流(二进制序列)的过程,这样我们就可以通过序列化,转化为可以在网络传输或者保存到本地的流(序列),从而进行传输数据 ,那反序列化就是从二进制流(序列)转化为对象的过程.
Parcelable是Android为我们提供的序列化的接口,Parcelable相对于Serializable的使用相对复杂一些,但Parcelable的效率相对Serializable也高很多,这一直是Google工程师引以为傲的,有时间的可以看一下Parcelable和Serializable的效率对比 Parcelable vs Serializable 号称快10倍的效率
Parcelable是Android SDK提供的,它是基于内存的,由于内存读写速度高于硬盘,因此Android中的跨进程对象的传递一般使用Parcelable
public class Course implements Parcelable { private String name; private float score; ... /** * 描述当前 Parcelable 实例的对象类型 * 比如说,如果对象中有文件描述符,这个方法就会返回上面的 CONTENTS_FILE_DESCRIPTOR * 其他情况会返回一个位掩码 * @return */ @Override public int describeContents() { return 0; } /** * 将对象转换成一个 Parcel 对象 * @param dest 表示要写入的 Parcel 对象 * @param flags 示这个对象将如何写入 */ @Override public void writeToParcel(Parcel dest, int flags) { dest.writeString(this.name); dest.writeFloat(this.score); } protected Course(Parcel in) { this.name = in.readString(); this.score = in.readFloat(); } /** * 实现类必须有一个 Creator 属性,用于反序列化,将 Parcel 对象转换为 Parcelable * @param <T> */ public static final Parcelable.Creator<Course> CREATOR = new Parcelable.Creator<Course>() { //反序列化的方法,将Parcel还原成Java对象 @Override public Course createFromParcel(Parcel source) { return new Course(source); } //提供给外部类反序列化这个数组使用。 @Override public Course[] newArray(int size) { return new Course[size]; } }; }
在介绍之前我们需要先了解Parcel是什么?Parcel翻译过来是打包的意思,其实就是包装了我们需要传输的数据,然后在Binder中传输,也就是用于跨进程传输数据
简单来说,Parcel提供了一套机制,可以将序列化之后的数据写入到一个共享内存中,其他进程通过Parcel可以从这块共享内存中读出字节流,并反序列化成对象,下图是这个过程的模型。
Parcel可以包含原始数据类型(用各种对应的方法写入,比如writeInt(),writeFloat()等),可以包含Parcelable对象,它还包含了一个活动的IBinder对象的引用,这个引用导致另一端接收到一个指向这个IBinder的代理IBinder。
Parcelable通过Parcel实现了read和write的方法,从而实现序列化和反序列化,
Serializable是Java中的序列化接口,其使用起来简单但开销较大(因为Serializable在序列化过程中使用了反射机制,故而会产生大量的临时变量,从而导致频繁的GC),并且在读写数据过程中,它是通过IO流的形式将数据写入到硬盘或者传输到网络上。
Parcelable则是以IBinder作为信息载体,在内存上开销比较小,因此在内存之间进行数据传递时,推荐使用Parcelable,而Parcelable对数据进行持久化或者网络传输时操作复杂,一般这个时候推荐使用Serializable。
首先Parcelable的性能要强于Serializable的原因我需要简单的阐述一下