Java Object JDK序列化总结
Posted IXENOS
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了Java Object JDK序列化总结相关的知识，希望对你有一定的参考价值。
Java 序列化 JDK序列化总结
@author ixenos
Java序列化是在JDK 1.1中引入的，是Java内核的重要特性之一。Java序列化API允许我们将一个对象转换为流，并通过网络发送，或将其存入文件或数据库以便未来使用，反序列化则是将对象流转换为实际程序中使用的Java对象的过程。Java同步化过程乍看起来很好用，但它会带来一些琐碎的安全性和完整性问题，在文章的后面部分我们会涉及到，以下是本教程涉及的主题。
- Java序列化接口
- 使用序列化和serialVersionUID进行类重构
- Java外部化接口
- Java序列化方法
- 序列化结合继承
- 序列化代理模式
Java序列化接口 java.io.Serializable
如果你希望一个类对象是可序列化的，你所要做的是实现java.io.Serializable接口。序列化一种标记接口，不需要实现任何字段和方法，这就像是一种选择性加入的处理，通过它可以使类对象成为可序列化的对象。
序列化处理是通过ObjectInputStream和ObjectOutputStream实现的，因此我们所要做的是基于它们进行一层封装，要么将其保存为文件，要么将其通过网络发送。我们来看一个简单的序列化示例。
1 package com.journaldev.serialization; 2 3 import java.io.Serializable; 4 5 public class Employee implements Serializable { 6 7 // private static final long serialVersionUID = -6470090944414208496L; 8 9 private String name; 10 private int id; 11 transient private int salary; 12 // private String password; 13 14 @Override 15 public String toString(){ 16 return "Employee{name="+name+",id="+id+",salary="+salary+"}"; 17 } 18 19 //getter and setter methods 20 public String getName() { 21 return name; 22 } 23 24 public void setName(String name) { 25 this.name = name; 26 } 27 28 public int getId() { 29 return id; 30 } 31 32 public void setId(int id) { 33 this.id = id; 34 } 35 36 public int getSalary() { 37 return salary; 38 } 39 40 public void setSalary(int salary) { 41 this.salary = salary; 42 } 43 44 // public String getPassword() { 45 // return password; 46 // } 47 // 48 // public void setPassword(String password) { 49 // this.password = password; 50 // } 51 52 }
注意一下，这是一个简单的java bean，拥有一些属性以及getter-setter方法，如果你想要某个对象属性不被序列化成流，你可以使用transient关键字，正如示例中我在salary变量上的做法那样。
现在我们假设需要把我们的对象写入文件，之后从相同的文件中将其反序列化，因此我们需要一些工具方法，通过使用ObjectInputStream和ObjectOutputStream来达到序列化的目的。
1 package com.journaldev.serialization; 2 3 import java.io.FileInputStream; 4 import java.io.FileOutputStream; 5 import java.io.IOException; 6 import java.io.ObjectInputStream; 7 import java.io.ObjectOutputStream; 8 9 /** 10 * A simple class with generic serialize and deserialize method implementations 11 * 12 * @author pankaj 13 * 14 */ 15 public class SerializationUtil { 16 17 // deserialize to Object from given file 18 public static Object deserialize(String fileName) throws IOException, 19 ClassNotFoundException { 20 FileInputStream fis = new FileInputStream(fileName); 21 ObjectInputStream ois = new ObjectInputStream(fis); 22 Object obj = ois.readObject(); 23 ois.close(); 24 return obj; 25 } 26 27 // serialize the given object and save it to file 28 public static void serialize(Object obj, String fileName) 29 throws IOException { 30 FileOutputStream fos = new FileOutputStream(fileName); 31 ObjectOutputStream oos = new ObjectOutputStream(fos); 32 oos.writeObject(obj); 33 34 fos.close(); 35 } 36 37 }
注意一下，方法的参数是Object，它是任何Java类的基类，这样写法以一种很自然的方式保证了通用性。
现在我们来写一个测试程序，看一下Java序列化的实战。
1 package com.journaldev.serialization; 2 3 import java.io.IOException; 4 5 public class SerializationTest { 6 7 public static void main(String[] args) { 8 String fileName="employee.ser"; 9 Employee emp = new Employee(); 10 emp.setId(100); 11 emp.setName("Pankaj"); 12 emp.setSalary(5000); 13 14 //serialize to file 15 try { 16 SerializationUtil.serialize(emp, fileName); 17 } catch (IOException e) { 18 e.printStackTrace(); 19 return; 20 } 21 22 Employee empNew = null; 23 try { 24 empNew = (Employee) SerializationUtil.deserialize(fileName); 25 } catch (ClassNotFoundException | IOException e) { 26 e.printStackTrace(); 27 } 28 29 System.out.println("emp Object::"+emp); 30 System.out.println("empNew Object::"+empNew); 31 } 32 33 }
运行以上测试程序，可以得到以下输出。
1 emp Object::Employee{name=Pankaj,id=100,salary=5000} 2 empNew Object::Employee{name=Pankaj,id=100,salary=0}
由于salary是一个transient变量，它的值不会被存入文件中，因此也不会在新的对象中被恢复。类似的，静态变量的值也不会被序列化，因为他们是属于类而非对象的。
使用序列化和serialVersionUID进行类重构
Java序列化允许java类中的一些变化，如果他们可以被忽略的话。一些不会影响到反序列化处理的变化有：
- 在类中添加一些新的变量。
- 将变量从transient转变为非tansient，对于序列化来说，就像是新加入了一个变量而已。
- 将变量从静态的转变为非静态的，对于序列化来说，就也像是新加入了一个变量而已。
不过这些变化要正常工作，java类需要具有为该类定义的serialVersionUID，我们来写一个测试类，只对之前测试类已经生成的序列化文件进行反序列化。
1 package com.journaldev.serialization; 2 3 import java.io.IOException; 4 5 public class DeserializationTest { 6 7 public static void main(String[] args) { 8 9 String fileName="employee.ser"; 10 Employee empNew = null; 11 12 try { 13 empNew = (Employee) SerializationUtil.deserialize(fileName); 14 } catch (ClassNotFoundException | IOException e) { 15 e.printStackTrace(); 16 } 17 18 System.out.println("empNew Object::"+empNew); 19 20 } 21 22 }
现在，在Employee类中去掉”password”变量的注释和它的getter-setter方法，运行。你会得到以下异常。
1 java.io.InvalidClassException: com.journaldev.serialization.Employee; local class incompatible: stream classdesc serialVersionUID = -6470090944414208496, local class serialVersionUID = -6234198221249432383 2 at java.io.ObjectStreamClass.initNonProxy(ObjectStreamClass.java:604) 3 at java.io.ObjectInputStream.readNonProxyDesc(ObjectInputStream.java:1601) 4 at java.io.ObjectInputStream.readClassDesc(ObjectInputStream.java:1514) 5 at java.io.ObjectInputStream.readOrdinaryObject(ObjectInputStream.java:1750) 6 at java.io.ObjectInputStream.readObject0(ObjectInputStream.java:1347) 7 at java.io.ObjectInputStream.readObject(ObjectInputStream.java:369) 8 at com.journaldev.serialization.SerializationUtil.deserialize(SerializationUtil.java:22) 9 at com.journaldev.serialization.DeserializationTest.main(DeserializationTest.java:13) 10 empNew Object::null
原因很显然，上一个类和新类的serialVersionUID是不同的，事实上如果一个类没有定义serialVersionUID，它会自动计算出来并分配给该类。Java使用类变量、方法、类名称、包，等等来产生这个特殊的长数。如果你在任何一个IDE上工作，你都会得到警告“可序列化类Employee没有定义一个静态的final的serialVersionUID，类型为long”。
我们可以使用java工具”serialver”来产生一个类的serialVersionUID，对于Employee类，可以执行以下命令。
1 SerializationExample/bin$serialver -classpath . com.journaldev.serialization.Employee
记住，从程序本身生成序列版本并不是必须的，我们可以根据需要指定值，这个值的作用仅仅是告知反序列化处理机制，新的类是相同的类的新版本，应该进行可能的反序列化处理。
举个例子，在Employee类中仅仅将serialVersionUID字段的注释去掉，运行SerializationTest程序。现在再将Employee类中的password字段的注释去掉，运行DeserializationTest程序，你会看到对象流被成功地反序列化了，因为Employee类中的变动与序列化处理是相容的。
Java外部化接口 java.io.Externalizable
如果你在序列化处理中留个心，你会发现它是自动处理的。有时候我们想要去隐藏对象数据，来保持它的完整性，可以通过实现java.io.Externalizable接口，并提供writeExternal()和readExternal()方法的实现，它们被用于序列化处理。
1 package com.journaldev.externalization; 2 3 import java.io.Externalizable; 4 import java.io.IOException; 5 import java.io.ObjectInput; 6 import java.io.ObjectOutput; 7 8 public class Person implements Externalizable{ 9 10 private int id; 11 private String name; 12 private String gender; 13 14 @Override 15 public void writeExternal(ObjectOutput out) throws IOException { 16 out.writeInt(id); 17 out.writeObject(name+"xyz"); 18 out.writeObject("abc"+gender); 19 } 20 21 @Override 22 public void readExternal(ObjectInput in) throws IOException, 23 ClassNotFoundException { 24 id=in.readInt(); 25 //read in the same order as written 26 name=(String) in.readObject(); 27 if(!name.endsWith("xyz")) throw new IOException("corrupted data"); 28 name=name.substring(0, name.length()-3); 29 gender=(String) in.readObject(); 30 if(!gender.startsWith("abc")) throw new IOException("corrupted data"); 31 gender=gender.substring(3); 32 } 33 34 @Override 35 public String toString(){ 36 return "Person{id="+id+",name="+name+",gender="+gender+"}"; 37 } 38 public int getId() { 39 return id; 40 } 41 42 public void setId(int id) { 43 this.id = id; 44 } 45 46 public String getName() { 47 return name; 48 } 49 50 public void setName(String name) { 51 this.name = name; 52 } 53 54 public String getGender() { 55 return gender; 56 } 57 58 public void setGender(String gender) { 59 this.gender = gender; 60 } 61 62 }
注意，在将其转换为流之前，我已经更改了字段的值，之后读取时会得到这些更改，通过这种方式，可以在某种程度上保证数据的完整性，我们可以在读取流数据之后抛出异常，表明完整性检查失败。
来看一个测试程序。
1 package com.journaldev.externalization; 2 3 import java.io.FileInputStream; 4 import java.io.FileOutputStream; 5 import java.io.IOException; 6 import java.io.ObjectInputStream; 7 import java.io.ObjectOutputStream; 8 9 public class ExternalizationTest { 10 11 public static void main(String[] args) { 12 13 String fileName = "person.ser"; 14 Person person = new Person(); 15 person.setId(1); 16 person.setName("Pankaj"); 17 person.setGender("Male"); 18 19 try { 20 FileOutputStream fos = new FileOutputStream(fileName); 21 ObjectOutputStream oos = new ObjectOutputStream(fos); 22 oos.writeObject(person); 23 oos.close(); 24 } catch (IOException e) { 25 // TODO Auto-generated catch block 26 e.printStackTrace(); 27 } 28 29 FileInputStream fis; 30 try { 31 fis = new FileInputStream(fileName); 32 ObjectInputStream ois = new ObjectInputStream(fis); 33 Person p = (Person)ois.readObject(); 34 ois.close(); 35 System.out.println("Person Object Read="+p); 36 } catch (IOException | ClassNotFoundException e) { 37 e.printStackTrace(); 38 } 39 40 } 41 42 }
运行以上测试程序，可以得到以下输出。
1 Person Object Read=Person{id=1,name=Pankaj,gender=Male}
那么哪个方式更适合被用来做序列化处理呢？实际上使用序列化接口更好，当你看到这篇教程的末尾时，你会知道原因的。
Serializable和Externalizable的区别与联系
1、Externalizable继承自Serializable；Externalizable 实例也可以通过 Serializable 接口中记录的 writeReplace 和 readResolve 方法来指派一个替代对象
2、实现Externalizable接口的类必须有默认构造方法。在读入可外部化的(Externalizable)类时，对象流将先用无参构造器创建一个对象，然后调用readExternal方法按writeExternal定义的机制反序列化；
3、若要完全控制某一对象及其超类型的流格式和内容，则它要实现 Externalizable 接口的 writeExternal 和 readExternal 方法。这些方法必须显式与超类型进行协调以保存其状态。这些方法将代替定制的 writeObject 和 readObject 方法实现；write/readExternal要对包括超类数据在内的整个对象的存储和恢复负全责，而Serializable在流中仅仅记录该对象所属的类的属性状态；
1 public void readExternal(ObjectInput in) throws IOException, 2 ClassNotFoundException { 3 name = (String) in.readObject(); 4 password = (String) in.readObject(); 5 } 6 7 public void writeExternal(ObjectOutput out) throws IOException { 8 out.writeObject( name); 9 out.writeObject( password); 10 }
但是，如果多个对象a是多次被序列化的，在反序列后对象b会被反序列化多次，因为反序列化时都调用构造器(Externalizable调用无参构造器)在堆中生成新对象，内存地址都是不同的，即多个a对象的属性b是不一样的。
6、Serialization 对象将使用 Serializable 和 Externalizable 接口。对象持久性机制也可以使用它们。要存储的每个对象都需要检测是否支持 Externalizable 接口。
a) 如果对象支持 Externalizable，则调用 writeExternal 方法。如果对象不支持 Externalizable 但实现了 Serializable，则使用 ObjectOutputStream 保存该对象。
b) 在重构 Externalizable 对象时，先使用无参数的公共构造方法创建一个实例，然后调用 readExternal 方法。通过从 ObjectInputStream 中读取 Serializable 对象可以恢复这些对象。
Java序列化方法 java.io.Serializable
我们已经看到了，java的序列化是自动的，我们所要做的仅仅是实现序列化接口，其实现已经存在于ObjectInputStream和ObjectOutputStream类中了。不过如果我们想要更改存储数据的方式，比如说在对象中含有一些敏感信息，在存储/获取它们之前我们要进行加密/解密，这该怎么办呢？这就是为什么在类中我们拥有四种方法，能够改变序列化行为。
如果以下方法在被序列化类中存在，它们就会被用于序列化处理。
- readObject(ObjectInputStream ois)：如果这个方法存在，ObjectInputStream readObject()方法会调用该方法从流中读取对象。
- writeObject(ObjectOutputStream oos)：如果这个方法存在，ObjectOutputStream writeObject()方法会调用该方法从流中写入对象。一种普遍的用法是隐藏对象的值来保证完整性。
- Object writeReplace()：如果这个方法存在，那么在序列化处理之后，该方法会被调用并将返回的对象序列化到流中。
- Object readResolve()：如果这个方法存在，那么在序列化处理之后，该方法会被调用并返回一个最终的对象给调用程序（keyijinxing）。一种使用方法是在序列化类中实现单例模式，你可以从序列化和单例中读到更多知识。此方法返回的对象，会被作为readOjbect的返回值（即使readObject方法定义并没有返回任何对象）
通常情况下，当实现以上方法时，应该将其设定为私有类型，这样子类就无法覆盖它们了，因为它们本来就是为了序列化而建立的，设定为私有类型能避免一些安全性问题。
readObejct和writeObject的具体示例：Java Object 对象序列化和反序列化
writeReplace和readResolve的具体示例：Java Object 序列化与单例模式 以及本文的 序列化代理模式
序列化结合继承
有时候我们需要对一个没有实现序列化接口的类进行扩展，如果依赖于自动化的序列化行为，而一些状态是父类拥有的，那么它们将不会被转换为流，因此以后也无法获取。
在此，readObject()和writeObject()就可以派上大用处了，通过提供它们的实现，我们可以将父类的状态存入流中，以便今后获取。我们来看一下实战。
1 package com.journaldev.serialization.inheritance; 2 3 public class SuperClass { 4 5 private int id; 6 private String value; 7 8 public int getId() { 9 return id; 10 } 11 public void setId(int id) { 12 this.id = id; 13 } 14 public String getValue() { 15 return value; 16 } 17 public void setValue(String value) { 18 this.value = value; 19 } 20 21 }
父类是一个简单的java bean，没有实现序列化接口。
1 package com.journaldev.serialization.inheritance; 2 3 import java.io.IOException; 4 import java.io.InvalidObjectException; 5 import java.io.ObjectInputStream; 6 import java.io.ObjectInputValidation; 7 import java.io.ObjectOutputStream; 8 import java.io.Serializable; 9 10 public class SubClass extends SuperClass implements Serializable, ObjectInputValidation{ 11 12 private static final long serialVersionUID = -1322322139926390329L; 13 14 private String name; 15 16 public String getName() { 17 return name; 18 } 19 20 public void setName(String name) { 21 this.name = name; 22 } 23 24 @Override 25 public String toString(){ 26 return "SubClass{id="+getId()+",value="+getValue()+",name="+getName()+"}"; 27 } 28 29 //adding helper method for serialization to save/initialize super class state 30 private void readObject(ObjectInputStream ois) throws ClassNotFoundException, IOException{ 31 ois.defaultReadObject(); 32 33 //注意读和写的顺序要一致，反序列化出值，再赋给父类属性 34 setId(ois.readInt()); 35 setValue((String) ois.readObject()); 36 37 } 38 39 private void writeObject(ObjectOutputStream oos) throws IOException{ 40 oos.defaultWriteObject(); 41 //调用父类的getId获得值单独写到序列化流中 42 oos.writeInt(getId()); 43 oos.writeObject(getValue()); 44 } 45 46 @Override 47 public void validateObject() throws InvalidObjectException { 48 //validate the object here 49 if(name == null || "".equals(name)) throw new InvalidObjectException("name can\'t be null or empty"); 50 if(getId() <=0) throw new InvalidObjectException("ID can\'t be negative or zero"); 51 } 52 53 }
注意，将额外数据写入流和读取流的顺序应该是一致的，我们可以在读与写之中添加一些逻辑，使其更安全。
同时还需要注意，这个类实现了ObjectInputValidation接口，通过实现validateObject()方法，可以添加一些业务验证来确保数据完整性没有遭到破坏。
以下通过编写一个测试类，看一下我们是否能够从序列化的数据中获取父类的状态。
1 package com.journaldev.serialization.inheritance; 2 3 import java.io.IOException; 4 5 import com.journaldev.serialization.SerializationUtil; 6 7 public class InheritanceSerializationTest { 8 9 以上是关于Java Object JDK序列化总结的主要内容，如果未能解决你的问题，请参考以下文章