java 序列化机制深度解析

Posted StubbornAnt

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了java 序列化机制深度解析相关的知识,希望对你有一定的参考价值。

概要

  • 序列化机制允许将实现序列化的Java对象转换为字节序列,这些字节序列可以被保存在磁盘上或通过网络传输,以备以后重新恢复原来的对象,序列化机制使得对象可以脱离程序的运行而独立存在
  • 可序列化的类包括:实现了Serializable的类,数组,枚举,String类也是可序列化对象
  • 由于序列化保存的是对象的状态,因此不会保存类的静态变量
    -通过ObjectOutputStream和ObjectInputStream对对象进行序列化及反序列化
  • 虚拟机是否允许反序列化,不仅取决于类路径和功能代码是否一致,一个非常重要的一点是两个类的序列化 ID 是否一致(就是 private static final long serialVersionUID)
  • Transient 关键字的作用是控制变量的序列化,在变量声明前加上该关键字,可以阻止该变量被序列化到文件中
  • 反序列化对象时必须有序列化对象的class文件
  • 通过文件、网络来读取序列化的对象时,必须按实际写入顺序读取;

不被序列化的内容

  • 静态变量不会被序列化
  • transient类型成员变量不会被序列化

可序列化的类型

  • 实现Serializable接口的类
  • String类
  • java基本类型
  • Enum 枚举类型
  • 数组类型
public class Demo 
    public static void main(String[] args) throws Exception 
        ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("tempFile"));
        ObjectInputStream in = new ObjectInputStream(new FileInputStream("tempFile"));
        out.writeObject("hello world");
        out.writeObject(new int[]1, 2, 3);
        out.writeObject(Color.BLACK);
        out.writeObject(new Data(1, "one"));
        out.writeObject(new Integer(1));
        System.out.println(in.readObject());
        System.out.println(Arrays.toString((int[]) (in.readObject())));
        System.out.println((Color) in.readObject());
        Data data = (Data) in.readObject();
        System.out.println(data);
        System.out.println(in.readObject());
    

enum Color 
    BLACK, RED

class Data implements Serializable 
    int x;
    String s;
    public Data(int x, String s) 
        this.x = x;
        this.s = s;
    
    @Override
    public String toString() 
        return x + "    " + s;
    

/* 结果:hello world
[1, 2, 3]
BLACK
1    one
1 
*/

递归序列化

  • 当某个对象进行序列化的时候,系统会自动把该对象的所有Field依次进行序列化
  • 如果某个Field引用到另一个对象,则被引用的对象也会被序列化
  • 如果被引用的对象的Field也引用了其它对象,则被引用的对象也会被序列化。可序列化的类的成员变量也必须是可序列化的,否则在序列化过程中抛出异常
public class Demo 
    public static void main(String[] args) throws Exception 
        ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("tempFile"));
        ObjectInputStream in = new ObjectInputStream(new FileInputStream("tempFile"));
        out.writeObject(new Data(1, "one"));
        Data data = (Data) in.readObject();
        System.out.println(data);
    
  
class Data implements Serializable 
    int x;
    String s;
    SubData subdata = new SubData(1);
    public Data(int x, String s) 
        this.x = x;
        this.s = s;
    
    @Override
    public String toString() 
        return x + "    " + s + subdata.x;
    

class SubData 
    int x;
    public SubData(int x) 
        this.x = x;
    
  

定制序列化

在序列化过程中,如果被序列化的类中定义了writeObject 和 readObject 方法,虚拟机会试图调用对象类里的 writeObject 和 readObject 方法,进行用户自定义的序列化和反序列化。如果没有这样的方法,则默认调用是 ObjectOutputStream 的 defaultWriteObject 方法以及 ObjectInputStream 的 defaultReadObject 方法。用户自定义的 writeObject 和 readObject 方法可以允许用户控制序列化的过程,比如可以在序列化的过程中动态改变序列化的数值。

实例 ArrayList的序列化

  • ArrayList实现了Serializable接口默认会将类中所有对象都出到输出流中去
  • ArrayList用来保存元素的数组被声明为transient,也就是不会被序列化
  • ArrayList重写了writeObject与ReadObject方法,对于数组元素,只输出实例元素,不会输出因为扩容而导致的数组末尾的null值,提高了序列化的效率
    private void writeObject(java.io.ObjectOutputStream s)
        throws java.io.IOException
        // Write out element count, and any hidden stuff
        int expectedModCount = modCount;
        s.defaultWriteObject();
        // Write out size as capacity for behavioural compatibility with clone()
        s.writeInt(size);
        // Write out all elements in the proper order.
        for (int i=0; i<size; i++) 
            s.writeObject(elementData[i]);
        
        if (modCount != expectedModCount) 
            throw new ConcurrentModificationException();
        
      
    private void readObject(java.io.ObjectInputStream s)
        throws java.io.IOException, ClassNotFoundException 
        elementData = EMPTY_ELEMENTDATA;
        // Read in size, and any hidden stuff
        s.defaultReadObject();
        // Read in capacity
        s.readInt(); // ignored
        if (size > 0) 
            // be like clone(), allocate array based upon size not capacity
            ensureCapacityInternal(size);
            Object[] a = elementData;
            // Read in all elements in the proper order.
            for (int i=0; i<size; i++) 
                a[i] = s.readObject();
            
        
      

替换序列化对象

wirteReplace():只要该方法存在,由序列化机制调用,在序列化对象时将该对象替换成其它对象;


public class Person4 implements Serializable 
    private String name;
    private int age;
    public Person4(String name, int age) 
        super();
        this.name = name;
        this.age = age;
    
    public String getName() 
        return name;
    
    public void setName(String name) 
        this.name = name;
    
    public int getAge() 
        return age;
    
    public void setAge(int age) 
        this.age = age;
    
    private Object writeReplace() throws ObjectStreamException 
        ArrayList<Object> list = new ArrayList<Object>();
        list.add(name);
        list.add(age);
        return list;
    
    public static void main(String[] args) 
        try 
            ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("replace.txt"));
            ObjectInputStream ooi = new ObjectInputStream(new FileInputStream("replace.txt"));
            Person4 per = new Person4("孙悟空", 500);
            // 系统将per对象转换成字节序列并输出
            oos.writeObject(per);
            // 反序列化读取得到的是ArrayList
            ArrayList list = (ArrayList) ooi.readObject();
            System.out.println(list.toString());
         catch (FileNotFoundException e) 
            e.printStackTrace();
         catch (IOException e) 
            e.printStackTrace();
         catch (ClassNotFoundException e) 
            e.printStackTrace();
        
    
  

序列化机制深入分析

  • 首先序列化与反序列化是通过ObjectOutputStream和ObjectInputStream的writeObject和readObject方法实现的
  • Serializable是一个空的标志接口,序列化的机制在于ObjectOutputStream的writeObject方法中,下面的代码可以看出可序列化的类型包含String,数组,枚举,以及实现了Serializable的类
            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());
                
              
  • 实现了Serializable接口的类的序列化的方法调用过程 writeObject ---> writeObject0 --->writeOrdinaryObject--->writeSerialData
  • 序列化类中存在WriteObject方法时,writeSerialData方法会通过反射机制来调用WriteObject方法
if (slotDesc.hasWriteObjectMethod()) 
            ...
                    slotDesc.invokeWriteObject(obj, this);  

serialVersonUID

序列化版本兼容

反序列化Java对象时,必须提供该对象的class文件,随着项目的升级,系统的class文件也会升级。如果保持两个class文件兼容性:
- Java的序列化机制允许为序列化类提供一个private static final的serialVersonUID值,该Field值用于标识该Java类的序列化版本;
- 最好在每个要序列化的类中加入private static final long serialVersionUID这个Field,具体数值自己定义。这样,即使对象被序列化之后,它所对应的类修改了,该对象也依然可以被正确反序列化;

如果不显示定义serialVersionUID值:
- 该Field值将由JVM根据类的相关信息计算,而修改后的类计算结果与修改前的类计算结果往往不同,从而造成对象的反序列化因为类版本的不兼容失败;
- 不利于程序在不同的JVM之间移植,因为不同的编译器计算该Field的值计算策略可能不同,从而造成虽然类完全没有改变,但是因为JVM不同,也会出现序列化版本不兼容而无法正确反序列化的现象;

多次序列化同一对象

- 当程序视图序列化一个对象时,程序将先检查该对象是否已经被序列化过,只有该对象从未(在本次虚拟机)中序列化过,系统才会将该对象转换成字节序列并输出; 
- 如果某个对象已经序列化过,程序将只是直接输出一个序列化编号,而不是再次重新序列化该对象,因此当重复序列化同一个对象时即便变量域已经改变,反序列化时还是只会保存第一个序列化对象的状态
```java
public class SerializaMutable 
    public static void main(String[] args) 
        try 
            // 创建一个ObjectOutputStream对象
            ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("mutable.txt"));
            // 创建一个ObjectInputStream对象
            ObjectInputStream ois = new ObjectInputStream(new FileInputStream("mutable.txt"));
            Person per = new Person("孙悟空", 500);
            // 系统将per对象转换成字节序列并输出
            oos.writeObject(per);
            per.setName("猪八戒");
            // 系统只是输出序列化编号,所以改变后的name不会被序列化
            oos.writeObject(per);
            Person p1 = (Person) ois.readObject();
            Person p2 = (Person) ois.readObject();
            // 下面输出true,即反序列化后p1等于p2
            System.out.println(p1 == p2);
            // 下面依然看到输出“孙悟空”,即改变后的Field没有被序列化
            System.out.println(p2.getName());
         catch (FileNotFoundException e) 
            e.printStackTrace();
         catch (IOException e) 
            e.printStackTrace();
         catch (ClassNotFoundException e) 
            e.printStackTrace();
        
    

class Person implements Serializable 
    String name;
    int age;
    public Person(String name, int age) 
        this.name = name;
        this.age = age;
    
    public String getName() 
        return name;
    
    public void setName(String name) 
        this.name = name;
    
 
/*
结果:
true
孙悟空  
*/ 




<div class="se-preview-section-delimiter"></div>

Externalizable 序列化机制

  • 自定义序列化的成员变量
  • void readExternal(ObjectInput in):实现反序列化,调用DataInput(ObjectInput的父接口)的方法来恢复基本类型的Field值,调用ObjectInput的readObject()方法来恢复引用类型的Field值;
  • void writeExternal(ObjectOutput out):实现序列化,调用DataOutput(ObjectOutput的父接口)的方法来保存基本类型的Field值,调用ObjectOutput的writeObject()方法来保存引用类型的Field值;
public class Person5 implements Externalizable 
    private String name;
    private int age;
    // 必须提供无参数的构造函数,否则报java.io.InvalidClassException
    public Person5() 
        super();
    
    // 注意此处没有提供无参数的构造器
    public Person5(String name, int age) 
        super();
        System.out.println("有参数的构造器");
        this.name = name;
        this.age = age;
    
    public String getName() 
        return name;
    
    public void setName(String name) 
        this.name = name;
    
    public int getAge() 
        return age;
    
    public void setAge(int age) 
        this.age = age;
    
    @Override
    public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException 
        // 将去读的字符串反转后赋值给name Field
        this.name = ((StringBuffer) in.readObject()).reverse().toString();
        this.age = in.readInt();
    
    @Override
    public void writeExternal(ObjectOutput out) throws IOException 
        // 将name Field值反转后写入二进制流
        out.writeObject(new StringBuffer(name).reverse());
        out.writeInt(age);
    
    public static void main(String[] args) 
        try 
            ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("external.txt"));
            ObjectInputStream ois = new ObjectInputStream(new FileInputStream("external.txt"));
            Person5 per = new Person5("孙悟空", 500);
            oos.writeObject(per);
            Person5 p = (Person5) ois.readObject();
            System.out.println(p.getName() + ":" + p.getAge());
         catch (FileNotFoundException e) 
            e.printStackTrace();
         catch (IOException e) 
            e.printStackTrace();
         catch (ClassNotFoundException e) 
            e.printStackTrace();
        
    
  

序列化机制对比

  • 实现Serializable接口:
    • 系统自动存储必要的信息;
    • Java内建支持,抑郁实现,只需要实现该接口即可,无需任何代码支持;
      性能略差;
  • 实现Externalizable接口:
    • 程序员决定存储那些信息;
    • 仅仅提供两个空方法,实现该接口必须为两个空方法提供实现;
    • 性能略好

以上是关于java 序列化机制深度解析的主要内容,如果未能解决你的问题,请参考以下文章

java 序列化机制深度解析

Flink 源码解析 —— 深度解析 Flink 序列化机制

深度解析java接口回调机制

深度解析Java线程池的异常处理机制

Java笔记八,深度解析Java线程池的异常处理机制

深度解析Java线程池的异常处理机制 #3