Java 序列化 JDK序列化总结

 Java 序列化 JDK序列化总结

 @author ixenos

 

 

 

Java序列化是在JDK 1.1中引入的,是Java内核的重要特性之一。Java序列化API允许我们将一个对象转换为流,并通过网络发送,或将其存入文件或数据库以便未来使用,反序列化则是将对象流转换为实际程序中使用的Java对象的过程。Java同步化过程乍看起来很好用,但它会带来一些琐碎的安全性和完整性问题,在文章的后面部分我们会涉及到,以下是本教程涉及的主题。

  1. Java序列化接口
  2. 使用序列化和serialVersionUID进行类重构
  3. Java外部化接口
  4. Java序列化方法
  5. 序列化结合继承
  6. 序列化代理模式

 

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 }

 

4、相比Serializable,Externalizable序列化的速度更快,序列化之后的数据更小,但读和取都需要开发人员自行实现, Serializable开发相对简单,速度慢,序列化后的数据更大些。 
 
5、这两种序列化方式都有一个特点,如果多个对象a的 内部属性b同时指向同一个对象,即同时引用了另外一个对象b。序列化->反序列化之后,这几个对象属性还是会同时指向同一个对象b,不会反序列化出多个b对象。 
但是,如果多个对象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类中了。不过如果我们想要更改存储数据的方式,比如说在对象中含有一些敏感信息,在存储/获取它们之前我们要进行加密/解密,这该怎么办呢?这就是为什么在类中我们拥有四种方法,能够改变序列化行为。

如果以下方法在被序列化类中存在,它们就会被用于序列化处理

  1. readObject(ObjectInputStream ois):如果这个方法存在,ObjectInputStream readObject()方法会调用该方法从流中读取对象
  2. writeObject(ObjectOutputStream oos):如果这个方法存在,ObjectOutputStream writeObject()方法会调用该方法从流中写入对象一种普遍的用法是隐藏对象的值来保证完整性。
  3. Object writeReplace():如果这个方法存在,那么在序列化处理之后,该方法会被调用并将返回的对象序列化到流中
  4. 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     public static void main(String[] args) {
10         String fileName = "subclass.ser";
11  
12         SubClass subClass = new SubClass();
13         subClass.setId(10);
14         subClass.setValue("Data");
15         subClass.setName("Pankaj");
16  
17         try {
18             SerializationUtil.serialize(subClass, fileName);
19         } catch (IOException e) {
20             e.printStackTrace();
21             return;
22         }
23  
24         try {
25             SubClass subNew = (SubClass) SerializationUtil.deserialize(fileName);
26             System.out.println("SubClass read = "+subNew);
27         } catch (ClassNotFoundException | IOException e) {
28             e.printStackTrace();
29         }
30     }
31  
32 }

 

运行以上测试程序,可以得到以下输出。

1 SubClass read = SubClass{id=10,value=Data,name=Pankaj}

因此通过这种方式,可以序列化父类的状态,即便它没有实现序列化接口当父类是一个我们无法改变的第三方的类,这个策略就有用武之地了

 

 

序列化代理模式


Java序列化也带来了一些严重的误区,比如:

  • 类的结构无法大量改变,除非中断序列化处理,因此即便我们之后已经不需要某些变量了,我们也需要保留它们,仅仅是为了向后兼容。
  • 序列化会导致巨大的安全性危机,一个攻击者可以更改流的顺序,继而对系统造成伤害。举个例子,用户角色被序列化了,攻击者可以更改流的值为admin,再执行恶意代码。

序列化代理模式是一种使序列化能达到极高安全性的方式,在这个模式下,一个内部的私有静态类被用作序列化的代理类,该类的设计目的是用于保留主类的状态。这个模式的实现需要合理实现readResolve()和writeReplace()方法。

让我们先来写一个类,实现了序列化代码模式,之后再对其进行分析,以便更好的理解原理。

 1 package com.journaldev.serialization.proxy;
 2  
 3 import java.io.InvalidObjectException;
 4 import java.io.ObjectInputStream;
 5 import java.io.Serializable;
 6  
 7 public class Data implements Serializable{
 8  
 9     private static final long serialVersionUID = 2087368867376448459L;
10  
11     private String data;
12  
13     public Data(String d){
14         this.data=d;
15     }
16  
17     public String getData() {
18         return data;
19     }
20  
21     public void setData(String data) {
22         this.data = data;
23     }
24  
25     @Override
26     public String toString(){
27         return "Data{data="+data+"}";
28     }
29  
30     //serialization proxy class
31     private static class DataProxy implements Serializable{
32  
33         private static final long serialVersionUID = 8333905273185436744L;
34  
35         private String dataProxy;
36         private static final String PREFIX = "ABC";
37         private static final String SUFFIX = "DEFG";
38  
39         public DataProxy(Data d){
40             //obscuring data for security
41             this.dataProxy = PREFIX + d.data + SUFFIX;
42         }
43  
44         private Object readResolve() throws InvalidObjectException {
45             if(dataProxy.startsWith(PREFIX) && dataProxy.endsWith(SUFFIX)){
46             return new Data(dataProxy.substring(3, dataProxy.length() -4));
47             }else throw new InvalidObjectException("data corrupted");
48         }
49  
50     }
51  
52     //replacing serialized object to DataProxy object
53     private Object writeReplace(){
54         return new DataProxy(this);
55     }
56  
57     private void readObject(ObjectInputStream ois) throws InvalidObjectException{
58         throw new InvalidObjectException("Proxy is not used, something fishy");
59     }
60 }

 

  • Data和DataProxy类都应该实现序列化接口。
  • DataProxy应该能够保留Data对象的状态。
  • DataProxy是一个内部的私有静态类,因此其他类无法访问它。
  • DataProxy应该有一个单独的构造方法,接收Data作为参数。
  • Data类应该提供writeReplace()方法,返回DataProxy实例,这样当Data对象被序列化时,返回的流是属于DataProxy类的,不过DataProxy类在外部是不可见的,所有它不能被直接使用。
  • DataProxy应该实现readResolve()方法,返回Data对象,这样当Data类被反序列化时,在内部其实是DataProxy类被反序列化了,之后它的readResolve()方法被调用,我们得到了Data对象。
  • 最后,在Data类中实现readObject()方法,抛出InvalidObjectException异常,防止黑客通过伪造Data对象的流并对其进行解析,继而执行攻击。

 

我们来写一个小测试,检查一下这样的实现是否能工作。

 1 package com.journaldev.serialization.proxy;
 2  
 3 import java.io.IOException;
 4  
 5 import com.journaldev.serialization.SerializationUtil;
 6  
 7 public class SerializationProxyTest {
 8  
 9     public static void main(String[] args) {
10         String fileName = "data.ser";
11  
12         Data data = new Data("Pankaj");
13  
14         try {
15             SerializationUtil.serialize(data, fileName);
16         } catch (IOException e) {
17             e.printStackTrace();
18         }
19  
20         try {
21             Data newData = (Data) SerializationUtil.deserialize(fileName);
22             System.out.println(newData);
23         } catch (ClassNotFoundException | IOException e) {
24             e.printStackTrace();
25         }
26     }
27  
28 }

 

运行以上测试程序,可以得到以下输出。

1 Data{data=Pankaj

如果你打开data.ser文件,可以看到DataProxy对象已经被作为流存入了文件中。

这就是Java序列化的所有内容,看上去很简单但我们应当谨慎地使用它,通常来说,最好不要依赖于默认实现。你可以从上面的链接中下载项目,玩一玩,这能让你学到更多。

 

 


本文参考以下内容:

原文链接: journaldev 翻译: ImportNew.com - Justin Wu
译文链接: http://www.importnew.com/14465.html

转载于:https://www.cnblogs.com/ixenos/p/5832736.html

你可能感兴趣的:(java,数据库)