devbox
weixin_40725706
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Java基础汇总（十二）——序列化和反序列化_java反序列化哪些类型

作者：weixin_40725706 | 2024-04-26 19:59:21

赞

踩

java反序列化哪些类型

 一、序列化和反序列化

1.定义

序列化 (Serialization)：将对象的状态信息转换为可以存储或传输的形式的过程（一般将一个对象存储至一个储存媒介，如档案或是记亿体缓冲等）

反序列化：将字节对象或XML编码格式还原成完全相等的对象

        在网络传输过程中，对象的状态信息可以以字节或是XML格式存储或传输，而字节的或XML编码格式可以还原完全相等的对象。

2.作用

        在Java中通过多种方式创建出的对象都是存在于JVM的堆内存中，只有JVM处于运行状态的时候，这些对象才可能存在。一旦JVM停止运行，这些对象的状态也就随之而丢失，所以为实现对象的持久化，提出了Java对象序列化的功能。

        即通过对象序列化，可以把对象的状态保存为字节数组，并且可以在有需要的时候将这个字节数组通过反序列化的方式再转换成对象。

  • 将数据持久化，防止一直存储在内存当中，消耗内存资源
  • 序列化后的对象便于网络运输和传播

        对象序列化可以很容易的在JVM中的活动对象和字节数组（流）之间进行转换

        在Java中，对象的序列化与反序列化被广泛应用到RMI(远程方法调用)及网络传输中

        对象序列化保存的是对象的状态而非类的状态，所以静态变量（static修饰的变量）不能被序列化存储，因为静态变量是类的状态

3.相关接口及类

  • java.io.Serializable
  • java.io.Externalizable
  • ObjectOutput
  • ObjectInput
  • ObjectOutputStream
  • ObjectInputStream

java.io.Serializable 接口

        类通过实现 java.io.Serializable 接口以启用其序列化功能，即未实现此接口的类将无法使其任何状态序列化或反序列化

        对一个对象进行序列化时，如果遇到不支持 Serializable 接口的对象，将抛出NotSerializableException

        Serializable序列化接口没有方法或字段，仅用于标识可序列化的语义

  • 可序列化类的所有子类型本身都是可序列化的
  • 如果要序列化的类有父类，要想同时将在父类中定义过的变量持久化下来，那么父类也应该集成java.io.Serializable接口

例1（实现了java.io.Serializable接口的类）：

  1. public class 序列化和反序列化 {
  2. ​//注意，内部类不能进行序列化，因为它依赖于外部类 
  3. @Test 
  4. public void test() throws IOException { 
  5. A a = new A(); 
  6. a.i = 1; 
  7. a.s = "a"; 
  8. FileOutputStream fileOutputStream = null; 
  9. FileInputStream fileInputStream = null; 
  10. try { 
  11. //将obj写入文件 
  12. fileOutputStream = new FileOutputStream("temp"); 
  13. ObjectOutputStream objectOutputStream = new ObjectOutputStream(fileOutputStream);
  14. objectOutputStream.writeObject(a); 
  15. fileOutputStream.close();
  16.  //通过文件读取obj 
  17. fileInputStream = new FileInputStream("temp"); 
  18. ObjectInputStream objectInputStream = new ObjectInputStream(fileInputStream); 
  19. A a2 = (A) objectInputStream.readObject(); 
  20. fileInputStream.close(); 
  21. System.out.println(a2.i); 
  22. System.out.println(a2.s); 
  23. //打印结果和序列化之前相同
  24. } catch (IOException e)
  25. { e.printStackTrace(); 
  26. } catch (ClassNotFoundException e) 
  27. { e.printStackTrace(); } } }
  28.  
  29. class A implements Serializable {
  30.  
  31.     int i;
  32.     String s;
  33. }

java.io.Externalizable接口

除Serializable 之外，java中还提供了另一个序列化接口Externalizable

Serializable 接口和Externalizable接口的区别：

  • Externalizable继承了Serializable，该接口中定义了两个抽象方法：writeExternal()与readExternal()
  • 使用Externalizable接口来进行序列化与反序列化时，需要重写writeExternal()与readExternal()方法
  • 实现Externalizable接口的类必须要提供一个public的无参的构造器（因为Externalizable进行序列化时，会调用被序列化类的无参构造器去创建一个新的对象，然后再将被保存对象的字段的值分别填充到新对象中）

例2（Externalizable接口）：

  1. class B implements Externalizable {
  2.     //必须要有公开无参构造函数。否则报错
  3.     public B() {
  4.  
  5.     }
  6.     int i;
  7.     String s;
  8.     @Override
  9.     public void writeExternal(ObjectOutput out) throws IOException {
  10.  
  11.     }
  12.  
  13.     @Override
  14.     public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
  15.  
  16.     }
  17. }
  18.  
  19. @Test
  20.     public void test2() throws IOException, ClassNotFoundException {
  21.         B b = new B();
  22.         b.i = 1;
  23.         b.s = "a";
  24.         //将obj写入文件
  25.         FileOutputStream fileOutputStream = new FileOutputStream("temp");
  26.         ObjectOutputStream objectOutputStream = new ObjectOutputStream(fileOutputStream);
  27.         objectOutputStream.writeObject(b);
  28.         fileOutputStream.close();
  29.         //通过文件读取obj
  30.         FileInputStream fileInputStream = new FileInputStream("temp");
  31.         ObjectInputStream objectInputStream = new ObjectInputStream(fileInputStream);
  32.         B b2 = (B) objectInputStream.readObject();
  33.         fileInputStream.close();
  34.         System.out.println(b2.i);
  35.         System.out.println(b2.s);
  36.         //打印结果为0和null，即初始值，没有被赋值
  37.         //0
  38.         //null
  39.     }

4.序列化ID

        虚拟机是否允许反序列化，不仅取决于类路径和功能代码是否一致，一个非常重要的一点是两个类的序列化 ID 是否一致（就是 private static final long serialVersionUID = 1L）

例3（序列化ID）：

  1. package com.inout; 
  2.  
  3. import java.io.Serializable; 
  4.  
  5. public class A implements Serializable { 
  6.  
  7.     private static final long serialVersionUID = 1L; 
  8.  
  9.     private String name; 
  10.     
  11.     public String getName() 
  12.     { 
  13.         return name; 
  14.     } 
  15.     
  16.     public void setName(String name) 
  17.     { 
  18.         this.name = name; 
  19.     } 
  20. } 
  21.  
  22. package com.inout; 
  23.  
  24. import java.io.Serializable; 
  25.  
  26. public class A implements Serializable { 
  27.  
  28.     private static final long serialVersionUID = 2L; 
  29.     
  30.     private String name; 
  31.     
  32.     public String getName() 
  33.     { 
  34.         return name; 
  35.     } 
  36.     
  37.     public void setName(String name) 
  38.     { 
  39.         this.name = name; 
  40.     } 
  41. }

        在上述代码中，虽然两个类的路径和功能代码完全一致，但是序列化 ID 不同，他们无法相互序列化和反序列化

5.静态变量不参与序列化（因为其为类的状态）

例4：

  1. public class Test implements Serializable {
  2.  
  3.     private static final long serialVersionUID = 1L;
  4.  
  5.     public static int staticVar = 5;
  6.  
  7.     public static void main(String[] args) {
  8.         try {
  9.             //初始时staticVar为5
  10.             ObjectOutputStream out = new ObjectOutputStream(
  11.                     new FileOutputStream("result.obj"));
  12.             out.writeObject(new Test());
  13.             out.close();
  14.  
  15.             //序列化后修改为10
  16.             Test.staticVar = 10;
  17.  
  18.             ObjectInputStream oin = new ObjectInputStream(new FileInputStream(
  19.                     "result.obj"));
  20.             Test t = (Test) oin.readObject();
  21.             oin.close();
  22.              
  23.             //再读取，通过t.staticVar打印新的值
  24.             System.out.println(t.staticVar);
  25.              
  26.         } catch (FileNotFoundException e) {
  27.             e.printStackTrace();
  28.         } catch (IOException e) {
  29.             e.printStackTrace();
  30.         } catch (ClassNotFoundException e) {
  31.             e.printStackTrace();
  32.         }
  33.     }
  34. }
  35.  
  36. //staticVar输出为10而非5
  37. //因为其为静态变量，在序列化时并未被保存

6.ArrayList的序列化

例5（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. }
  8.  
  9. //ArrayList实现了java.io.Serializable接口
  10. //可以对它进行序列化及反序列化

        ArrayList实现了java.io.Serializable接口,可以对它进行序列化及反序列化。但是其中数组elementData（用来保存列表中的元素的）是transient的，正常不应该被序列化保存下来。

例6（ArrayList的结果能通过序列化和反序列化把List中的元素保留下来）：

  1. public class ArrayList的序列化 {
  2.     public static void main(String[] args) throws IOException, ClassNotFoundException {
  3.         ArrayList list = new ArrayList();
  4.         list.add("a");
  5.         list.add("b");
  6.         ObjectOutputStream objectOutputStream = new ObjectOutputStream(new FileOutputStream("arr"));
  7.         objectOutputStream.writeObject(list);
  8.         objectOutputStream.close();
  9.         ObjectInputStream objectInputStream = new ObjectInputStream(new FileInputStream("arr"));
  10.         ArrayList list1 = (ArrayList) objectInputStream.readObject();
  11.         objectInputStream.close();
  12.         System.out.println(Arrays.toString(list.toArray()));
  13.         //序列化成功，里面的元素保持不变。
  14.     }

        在ArrayList中定义了writeObject和readObject方法。在序列化过程中因为其定义了writeObject 和 readObject 方法，虚拟机会试图调用对象类里的 writeObject 和 readObject 方法，进行用户自定义的序列化和反序列化（用户自定义的 writeObject 和 readObject 方法可以允许用户控制序列化的过程，比如可以在序列化的过程中动态改变序列化的数值）

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

例7（ArrayList中writeObject 和 readObject 方法）：

  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
  10.  
  11.         if (size > 0) {
  12.             // be like clone(), allocate array based upon size not capacity
  13.             ensureCapacityInternal(size);
  14.  
  15.             Object[] a = elementData;
  16.             // Read in all elements in the proper order.
  17.             for (int i=0; i<size; i++) {
  18.                 a[i] = s.readObject();
  19.             }
  20.         }
  21.     }
  22.  
  23.  
  24.  
  25.  
  26. private void writeObject(java.io.ObjectOutputStream s)​ 
  27.         throws java.io.IOException{​ 
  28.         // Write out element count, and any hidden stuff​ 
  29.         int expectedModCount = modCount;​ 
  30.         s.defaultWriteObject();​
  31.         // Write out size as capacity for behavioural compatibility with clone()           
  32.         s.writeInt(size);
  33.         // Write out all elements in the proper order.
  34.         for (int i=0; i<size; i++) {
  35.             s.writeObject(elementData[i]);
  36.         }
  37.  
  38.         if (modCount != expectedModCount) {
  39.             throw new ConcurrentModificationException();
  40.         }
  41.     }

为什么ArrayList要通过重写writeObject 和 readObject 方法来实现序列化呢？

  • 为什么数组elementData是transient的

ArrayList实际上是动态数组，每次在放满以后自动增长设定的长度值，如果数组自动增长长度设为100，而实际只放了一个元素，那就会序列化99个null元素。

        为了保证在序列化的时候不会将这么多null同时进行序列化，ArrayList把元素数组设置为transient

  • 为什么要重写writeObject 和 readObject 方法

   前面说过，为了防止一个包含大量空对象的数组被序列化，为了优化存储，所以，ArrayList使用transient来声明elementData。

         但是，作为一个集合，在序列化过程中还必须保证其中的元素可以被持久化下来，所以，通过重写writeObject 和 readObject方法的方式把其中的元素保留下来。

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

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

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

  • 通过在被序列化的类中增加writeObject 和 readObject方法

  • 会通过反射的方式调用ObjectOutputStream的writeObject方法和ObjectInputStream的readObject方法

详解： 

 ObjectOutputStream的writeObject的调用栈：

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

例8（invokeWriteObject代码段）：

  1. void invokeWriteObject(Object obj, ObjectOutputStream out)
  2.         throws IOException, UnsupportedOperationException
  3.     {
  4.         if (writeObjectMethod != null) {
  5.             try {
  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方法的关键

8.Serializable接口如何实现行序列化与反序列化

        Serializable是一个空的接口，却能够实现序列化与反序列化。

        因为在进行序列化操作时，writeObject0（ObjectOutputStream的writeObject的调用栈中一层）会判断要被序列化的类是否是Enum、Array和Serializable类型，如果三者都不是则直接抛出NotSerializableException

详解：

ObjectOutputStream的writeObject的调用栈：

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

writeObject0方法中的部分代码： 

  1. if (obj instanceof String) {
  2.                 writeString((String) obj, unshared);
  3.             } else if (cl.isArray()) {
  4.                 writeArray(obj, desc, unshared);
  5.             } else if (obj instanceof Enum) {
  6.                 writeEnum((Enum<?>) obj, desc, unshared);
  7.             } else if (obj instanceof Serializable) {
  8.                 writeOrdinaryObject(obj, desc, unshared);
  9.             } else {
  10.                 if (extendedDebugInfo) {
  11.                     throw new NotSerializableException(
  12.                         cl.getName() + "\n" + debugInfoStack.toString());
  13.                 } else {
  14.                     throw new NotSerializableException(cl.getName());
  15.                 }
  16.             }

9.总结

  • 如果一个类想被序列化，需要实现Serializable接口，否则将抛出NotSerializableException异常。这是因为，在序列化操作过程中会对类型进行检查，要求被序列化的类必须属于Enum、Array和Serializable类型其中的任何一种。
  • 通过ObjectOutputStream和ObjectInputStream对对象进行序列化及反序列化
  • 虚拟机是否允许反序列化，不仅取决于类路径和功能代码是否一致，一个非常重要的点是两个类的序列化 ID 是否一致（即private static final long serialVersionUID）

        序列化 ID 在 Eclipse 下提供了两种生成策略，一个是固定的 1L，一个是随机生成一个不重复的 long 类型数据（实际上是使用 JDK 工具生成），在这里有一个建议，如果没有特殊需求，就是用默认的 1L 就可以，这样可以确保代码一致时反序列化成功。随机生成的序列化 ID 有什么作用呢？有些时候，通过改变序列化 ID 可以用来限制某些用户的使用。

  • 序列化并不保存静态变量。
  • 要想将父类对象也序列化，就需要让父类也实现Serializable 接口。
  • Transient 关键字的作用是控制变量的序列化，在变量声明前加上该关键字，可以阻止该变量被序列化到文件中，在被反序列化后，transient 变量的值被设为初始值，如 int 型的是 0，对象型的是 null。
  • 服务器端给客户端发送序列化对象数据，对象中有一些数据是敏感的，比如密码字符串等，希望对该密码字段在序列化时，进行加密，而客户端如果拥有解密的密钥，只有在客户端进行反序列化时，才可以对密码进行读取，这样可以一定程度保证序列化对象的数据安全。
  • 在类中增加writeObject 和 readObject 方法可以实现自定义序列化策略。

参考文章

Java-Tutorial/22、序列化和反序列化.md at master · h2pl/Java-Tutorial · GitHub

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/weixin_40725706/article/detail/492859
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号