Java 序列化对象序列化和反序列化

时间 2019-11-29

标签 java 序列对象栏目 Java 繁體版

原文原文链接

Java 序列化对象序列化和反序列化

@author ixenosjava

对象序列化是什么

一、对象序列化就是把一个对象的状态转化成一个字节流。数组

　　咱们能够把这样的字节流存储为一个文件，做为对这个对象的复制（深拷贝）；在一些分布式应用中，咱们还能够把对象的字节流发送到网络上的其余计算机。安全

　　反序列化是把流结构的对象恢复为其原有形式服务器

二、Java平台容许咱们在内存中建立可复用的Java对象，但通常状况下，只有当JVM处于运行时，这些对象才可能存在，即，这些对象的生命周期不会比JVM的生命周期更长。但在现实应用中，就可能要求在JVM中止运行以后可以保存(持久化)指定的对象，并在未来从新读取被保存的对象。Java对象序列化就可以帮助咱们实现该功能。网络

三、使用Java对象序列化，在保存对象时，会把其状态保存为一组字节，在将来，再将这些字节组装成对象。必须注意地是，对象序列化保存的是对象的”状态”，即它的成员变量。由此可知，对象序列化不会关注类中的静态变量。dom

　　由于静态变量是类在加载-连接-初始化的阶段就分配空间和初始化了的，更不用说在编译期初始化的静态常量了。分布式

四、除了在持久化对象时会用到对象序列化以外，当使用RMI(远程方法调用)，或在网络中传递对象时，都会用到对象序列化。Java序列化API为处理对象序列化提供了一个标准机制，该API简单易用。ide

序列化及反序列化相关知识

一、在Java中，只要一个类实现了java.io.Serializable接口，那么它就能够被序列化。优化

二、经过ObjectOutputStream和ObjectInputStream对对象进行序列化及反序列化this

三、虚拟机是否容许反序列化，不只取决于类路径和功能代码是否一致，一个很是重要的一点是两个类的序列化 ID 是否一致（就是 private static final long serialVersionUID）

四、序列化并不保存静态变量。

五、要想将父类对象也序列化，就须要让父类也实现Serializable 接口。

六、Transient 关键字的做用是控制变量的序列化，在变量声明前加上该关键字，能够阻止该变量被序列化到文件中，在被反序列化后，transient 变量的值被设为初始值，如 int 型的是 0，对象型的是 null。

七、服务器端给客户端发送序列化对象数据，对象中有一些数据是敏感的，好比密码字符串等，但愿对该密码字段在序列化时，进行加密，而客户端若是拥有解密的密钥，只有在客户端进行反序列化时，才能够对密码进行读取，这样能够必定程度保证序列化对象的数据安全。

使用JDK序列化对象须要的准备工做

　　1.对象的类应当实现Serializable接口。这是一个标记接口，跟Cloneable接口同样性质。

　　2.须要一个序列化编号 private static final long serialVersionUID ，做为标识检验，以防止冗余引用的状况下重复生成同一对象。

　　3.使用ObjectOutputStream的writeObject方法将对象信息转化成字节码，写进流中。

简要示例

将对象写入文件输出流中

 1 import java.io.FileNotFoundException;
 2 import java.io.FileOutputStream;
 3 import java.io.IOException;
 4 import java.io.ObjectOutputStream;
 5 import java.io.Serializable;
 6 
 7 /**
 8  * 将对象序列化，写入文件输出流中
 9  * 
10  * @author ixenos
11  *
12  */
13 public class JDKObjSerial {
14     
15     public static void main(String[] args) {
16         Person p = new Person(12, "ixenos", 170.0);
17         try {
18             ObjectOutputStream oo = new ObjectOutputStream(
19                     new FileOutputStream("serialObj.txt"));
20             oo.writeObject(p);
21             oo.close();
22             
23             
24         } catch (FileNotFoundException e) {
25             e.printStackTrace();
26         } catch (IOException e) {
27             e.printStackTrace();
28         }
29     }
30 
31 }
32 
33 class Person implements Serializable{
34 
35     private static final long serialVersionUID = 1L;
36     private transient int age;
37     private String name;
38     private double length;
39     public int getAge() {
40         return age;
41     }
42     public void setAge(int age) {
43         this.age = age;
44     }
45     public String getName() {
46         return name;
47     }
48     public void setName(String name) {
49         this.name = name;
50     }
51     public double getLength() {
52         return length;
53     }
54     public void setLength(double length) {
55         this.length = length;
56     }
57     
58     public Person(){
59         
60     }
61     public Person(int age, String name, double length) {
62         super();
63         this.age = age;
64         this.name = name;
65         this.length = length;
66     }
67     
68     
69     @Override
70     public String toString() {
71         return "Person [age=" + age + ", name=" + name + ", length=" + length + "]";
72     }
73     /**
74      * 
75      */
76     
77 }

从文件输入流中反序列化对象

 1 import java.io.FileNotFoundException;
 2 import java.io.FileInputStream;
 3 import java.io.IOException;
 4 import java.io.ObjectInputStream;
 5 
 6 
 7 /**
 8  * 从文件输入流中反序列化对象
 9  * 
10  * @author ixenos
11  *
12  */
13 public class JDKObjSerial1 {
14 
15     public static void main(String[] args) {
16         
17         try {
18             ObjectInputStream oi = new ObjectInputStream(
19                     new FileInputStream("serialObj.txt"));
20             Person per = (Person)oi.readObject();
21             System.out.println(per);
22             oi.close();
23             
24             
25         } catch (FileNotFoundException e) {
26             e.printStackTrace();
27         } catch (IOException e) {
28             e.printStackTrace();
29         } catch (ClassNotFoundException e) {
30             e.printStackTrace();
31         }
32         
33         
34     }
35 
36 }

ArrayList的序列化示例 [ 转载 ]

在介绍ArrayList序列化以前，先来考虑一个问题：

如何自定义的序列化和反序列化策略

带着这个问题，咱们来看java.util.ArrayList的源码

1 public class ArrayList<E> extends AbstractList<E>
2         implements List<E>, RandomAccess, Cloneable, java.io.Serializable
3 {
4     private static final long serialVersionUID = 8683452581122892189L;
5     transient Object[] elementData; // non-private to simplify nested class access
6     private int size;
7 }

笔者省略了其余成员变量，从上面的代码中能够知道ArrayList实现了java.io.Serializable接口，那么咱们就能够对它进行序列化及反序列化。由于elementData是transient的，因此咱们认为这个成员变量不会被序列化而保留下来。

咱们写一个Demo，验证一下咱们的想法：

 1 public static void main(String[] args) throws IOException, ClassNotFoundException {
 2         List<String> stringList = new ArrayList<String>();
 3         stringList.add("hello");
 4         stringList.add("world");
 5         stringList.add("hollis");
 6         stringList.add("chuang");
 7         System.out.println("init StringList" + stringList);
 8         ObjectOutputStream objectOutputStream = new ObjectOutputStream(new FileOutputStream("stringlist"));
 9         objectOutputStream.writeObject(stringList);
10  
11         IOUtils.close(objectOutputStream);
12         File file = new File("stringlist");
13         ObjectInputStream objectInputStream = new ObjectInputStream(new FileInputStream(file));
14         List<String> newStringList = (List<String>)objectInputStream.readObject();
15         IOUtils.close(objectInputStream);
16         if(file.exists()){
17             file.delete();
18         }
19         System.out.println("new StringList" + newStringList);
20     }
21 //init StringList[hello, world, hollis, chuang]
22 //new StringList[hello, world, hollis, chuang]

了解ArrayList的人都知道，ArrayList底层是经过数组实现的。那么数组elementData其实就是用来保存列表中的元素的。经过该属性的声明方式咱们知道，他是没法经过序列化持久化下来的。那么为何code 4的结果却经过序列化和反序列化把List中的元素保留下来了呢？

writeObject和readObject方法

在ArrayList中定义了两个方法： writeObject和readObject。

这里先给出结论:

在序列化过程当中，若是被序列化的类中定义了writeObject 和 readObject 方法，虚拟机会试图调用对象类里的 writeObject 和 readObject 方法，进行用户自定义的序列化和反序列化。

若是没有这样的方法，则默认调用是 ObjectOutputStream 的 defaultWriteObject 方法以及 ObjectInputStream 的 defaultReadObject 方法。

用户自定义的 writeObject 和 readObject 方法能够容许用户控制序列化的过程，好比能够在序列化的过程当中动态改变序列化的数值。

来看一下ArrayList中这两个方法的具体实现：

　　反序列化：

 1 private void readObject(java.io.ObjectInputStream s)
 2         throws java.io.IOException, ClassNotFoundException {
 3         elementData = EMPTY_ELEMENTDATA;
 4  
 5         // Read in size, and any hidden stuff
 6         s.defaultReadObject();
 7  
 8         // Read in capacity
 9         s.readInt(); // ignored 得到size值
10  
11         if (size > 0) {
12             // be like clone(), 分配存储空间，指定大小为size
13             ensureCapacityInternal(size); 
14  　　　　　　//
15             Object[] a = elementData;
16             //将writeObject单独序列化的数组成员反序列化
17             for (int i=0; i<size; i++) {
18                 a[i] = s.readObject(); 
19             }
20         }
21     }

　　序列化：

 1 private void writeObject(java.io.ObjectOutputStream s)
 2         throws java.io.IOException{
 3         // 先调用默认的方法将通常的变量值写到对象输出流中
 4         int expectedModCount = modCount;
 5         s.defaultWriteObject();
 6  
 7         // 将运行时实际的size写到对象输出流中，由于数组的size是运行时变化的
 8         s.writeInt(size);
 9  
10         // 将内部数组存储的对象按数组遍历的顺序写到对象输出流中
11         for (int i=0; i<size; i++) {
12             s.writeObject(elementData[i]);
13         }
14  　　　　
15         if (modCount != expectedModCount) {
16             throw new ConcurrentModificationException();
17         }
18     }

那么为何ArrayList要用这种方式来实现序列化呢？

why transient

ArrayList其实是动态数组，每次在放满之后自动增加设定的长度值，若是数组自动增加长度设为100，而实际只放了一个元素，那就会序列化99个null元素。为了保证在序列化的时候不会将这么多null同时进行序列化，ArrayList把元素数组设置为transient。

why writeObject and readObject

前面说过，为了防止一个包含大量空对象的数组被序列化，为了优化存储，因此，ArrayList使用transient来声明elementData。可是，做为一个集合，在序列化过程当中还必须保证其中的元素能够被持久化下来，因此，经过重写writeObject 和 readObject方法的方式把其中的元素保留下来。

writeObject方法把elementData数组中的元素遍历的保存到输出流（ObjectOutputStream）中。

readObject方法从输入流（ObjectInputStream）中读出对象并保存赋值到elementData数组中。

至此，咱们先试着来回答刚刚提出的问题：

如何自定义的序列化和反序列化策略

答：能够经过在被序列化的类中增长writeObject 和 readObject方法。那么问题又来了：

虽然ArrayList中写了writeObject 和 readObject 方法，可是这两个方法并无显示的被调用啊。

那么若是一个类中包含writeObject 和 readObject 方法，那么这两个方法是怎么被调用的呢?

ObjectOutputStream

从code 4中，咱们能够看出，对象的序列化过程经过ObjectOutputStream和ObjectInputputStream来实现的，那么带着刚刚的问题，咱们来分析一下ArrayList中的writeObject 和 readObject 方法究竟是如何被调用的呢？

为了节省篇幅，这里给出ObjectOutputStream的writeObject的调用栈：

writeObject ---> writeObject0 --->writeOrdinaryObject--->writeSerialData--->invokeWriteObject(调用被序列化类的writeObject方法)

这里看一下invokeWriteObject：

 1 void invokeWriteObject(Object obj, ObjectOutputStream out)
 2         throws IOException, UnsupportedOperationException
 3     {
 4         if (writeObjectMethod != null) {
 5             try { // 在这里反射调用被序列化的类的readObject方法  6                 writeObjectMethod.invoke(obj, new Object[]{ out });
 7             } catch (InvocationTargetException ex) {
 8                 Throwable th = ex.getTargetException();
 9                 if (th instanceof IOException) {
10                     throw (IOException) th;
11                 } else {
12                     throwMiscException(th);
13                 }
14             } catch (IllegalAccessException ex) {
15                 // should not occur, as access checks have been suppressed
16                 throw new InternalError(ex);
17             }
18         } else {
19             throw new UnsupportedOperationException();
20         }
21     }

其中writeObjectMethod.invoke(obj, new Object[]{ out });是关键，经过反射的方式调用writeObjectMethod方法。

官方是这么解释这个writeObjectMethod的：

class-defined writeObject method, or null if none

在咱们的例子中，这个方法就是咱们在ArrayList中定义的writeObject方法。经过反射的方式被调用了。

至此，咱们先试着来回答刚刚提出的问题：

若是一个类中包含writeObject 和 readObject 方法，那么这两个方法是怎么被调用的?

答：在使用ObjectOutputStream的writeObject方法和ObjectInputStream的readObject方法时，会经过反射的方式调用。

至此，咱们已经介绍完了ArrayList的序列化方式。那么，不知道有没有人提出这样的疑问：

Serializable明明就是一个空的接口，它是怎么保证只有实现了该接口的方法才能进行序列化与反序列化的呢？

Serializable接口的定义：

1 public interface Serializable {
2 }

读者能够尝试把code 1中的继承Serializable的代码去掉，再执行code 2，会抛出java.io.NotSerializableException。

其实这个问题也很好回答，咱们再回到刚刚ObjectOutputStream的writeObject的调用栈：

writeObject ---> writeObject0 --->writeOrdinaryObject--->writeSerialData--->invokeWriteObject

writeObject0方法中有这么一段代码：

 
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 {
               if (extendedDebugInfo) {
                   throw new NotSerializableException(
                       cl.getName() + "\n" + debugInfoStack.toString());
               } else {
                   throw new NotSerializableException(cl.getName());
               }
           } 
  

在进行序列化操做时，会判断要被序列化的类是不是Enum、Array和Serializable类型，若是不是则直接抛出NotSerializableException。

总结

一、若是一个类想被序列化，须要实现Serializable接口。不然将抛出NotSerializableException异常，这是由于，在序列化操做过程当中会对类型进行检查，要求被序列化的类必须属于Enum、Array和Serializable类型其中的任何一种。

二、在变量声明前加上transient关键字，能够阻止该变量被序列化到文件中。

三、在类中增长writeObject 和 readObject 方法能够实现自定义序列化策略

Java 序列化 对象序列化和反序列化

Java 序列化 对象序列化和反序列化

对象序列化是什么

序列化及反序列化相关知识

使用JDK序列化对象须要的准备工做

简要示例

ArrayList的序列化示例 [ 转载 ]

writeObject和readObject方法

why transient

why writeObject and readObject

ObjectOutputStream

总结

Java 序列化对象序列化和反序列化

Java 序列化对象序列化和反序列化