Java的序列化与反序列化

前言

Java的序列化与反序列化是Java中比较重要的一个知识,本文将总结一下,怎么使用序列化功能以及经常遇到的一些问题的解答.

什么是Java的序列化

JDK提供给我们的,可以将某一个对象转化为二进制字节流保存,并从字节流恢复对象的一种技术.

我们可以再网络传输对象,或者持久化对象时使用这项技术.

怎么进行序列化与反序列化

Java中通过继承Serializable接口来获得序列化与反序列化的能力,使用ObjectInputStream和ObjectOutputStream来进行具体的对象序列化读写.

示例如下:

package daily;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
import java.util.ArrayList;

/**
 * created by huyanshi on 2019/1/29
 */
public class SerializTest implements Serializable {

  private static int staticValue = 10;

  private int value;

  SerializTest(int value) {
    this.value = value;
  }

  public static void main(String[] args) {
    try {
      //初始化
      SerializTest test = new SerializTest(100);
      //序列化
      ObjectOutputStream oos = new ObjectOutputStream(
          new FileOutputStream("/Users/pfliu/Desktop/serialized.ser"));
      System.out.println(test.value);
      System.out.println(SerializTest.staticValue);
      oos.writeObject(test);

      SerializTest.staticValue = 250;

      //反序列话
      ObjectInputStream ois = new ObjectInputStream(
          new FileInputStream("/Users/pfliu/Desktop/serialized.ser"));
      SerializTest test1 = (SerializTest) ois.readObject();
      System.out.println(test1.value);
      System.out.println(SerializTest.staticValue);


    } catch (Exception e) {
      System.out.println("error");
    }
  }
}

在上面的代码中,我们new了一个对象,并将其进行了序列化与反序列化,并在序列化之前和反序列化之后打印了对象的值,结果为值相同.同时,在桌面上生成了Serialized.set文件.

为什么必须要实现Serializable接口?

点开该接口的源码,我们可以发现,这是一个空的接口,即没有任何的定义,那么它是怎么使用的呢?

在序列化的过程中,我们会调用ObjectOutputStream的writeObject方法,该方法,该方法调用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());
    }
}

可以看到,对传入的对象进行了几次判断,分别判断传入对象是否为:String,Array,Enum,Serializable.

什么意思呢?就是JDK规定了,只有字符串,数组,枚举,Serializable四种对象才允许序列化,其他的都会抛出NotSerializableException异常.

而这四种中,前面三种都是内定的,只有最后一种是留给程序员的序列化通道,因此我们想要序列化某一个类,必须实现Serializable接口.

序列化ID是干什么用的?

在看一些开源框架的代码时,发现他们的类都会有private static final long serialVersionUID = 8683452581122892189L;这个属性,这是用来干什么的呢?

序列化和反序列化的匹配是怎么匹配的?总不能随便来的吧,A类序列化后的二进制文件,B类能从哪里读出一个对象来嘛?

不能,类的路径以及功能代码必须完全相同,而序列化ID也是用来补充这一判断的.

试想一下,你在服务里new了一个对象,并将其序列化使用网络传输,那么收到这个二进制流的人都能序列化吗?不是的,他必须在自己的服务中有同样的类路径,同样的类定义,同时,他的类中定义的序列化ID必须与你的一致才可以.算是一定程度上的安全性保证吧.

当然,日常开发中我们使用默认生成的1L即可.

静态变量的序列化

我在上面的代码中,定义了一个静态变量,他也能被序列化吗?

在序列化之后,对静态变量重新赋值,那么两次打印的值相等吗?

打印结果是:

10
250

为什么呢?这个问题其实比较简单,静态变量是属于类的,而我们是序列化了对象,因此不包含类的静态变量是正常的.

transient 关键字

transient 关键字用于在序列化时,忽略某一个字段,在反序列化后该字段为初始值,比如int=0,对象引用为null.

ArrayList 的序列化

看了这么多理论知识,我们来看一下常用类ArrayList是怎么序列化的吧.

ArrayList实现了Serializable自然不必多说,其中用来保存数据的属性定义为:

/**
 * The array buffer into which the elements of the ArrayList are stored.
 * The capacity of the ArrayList is the length of this array buffer. Any
 * empty ArrayList with elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA
 * will be expanded to DEFAULT_CAPACITY when the first element is added.
 */
transient Object[] elementData; // non-private to simplify nested class access

为什么会定义为transient呢?我序列化一个ArrayList,你不给我存储内部的值?我要你个空壳子干啥!我摔!

稳住,我们可以实际测试一下,会发现在序列化及反序列化的过程中,是保留了list中的值的.

为什么要定义为transient呢?怎么做到仍然保留数据的呢?

第一个问题

ArrayList内部是使用数组实现的,虽然他是动态数组,但是也是数组.

也就是说,当你定义了长度为100的Arraylist,只放入了一个对象,剩下的99个就为空了.

序列化的时候有必要将这99个空也记录下来吗?没有.因此定义为了transient.

第二个问题

在序列化的过程中,虚拟机会试图调用被序列化类的writeObject和readObject方法,调用不到才会去执行默认的这两个方法,也就是对应的输入输出流中的方法.

在ArrayList中有如下代码:

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();
    }
}

/**
 * Reconstitute the <tt>ArrayList</tt> instance from a stream (that is,
 * deserialize it).
 */
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
        int capacity = calculateCapacity(elementData, size);
        SharedSecrets.getJavaOISAccess().checkArray(s, Object[].class, 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();
        }
    }
}

可以在代码中看到,ArrayList自定义的序列化方法,没有序列化99个空值,只序列化了有意义的值.

总结

1.java的序列化需要实现Serializable接口,之后使用ObjectOutputStream及ObjectInputStream进行读写.

2.必须实现Serializable是因为JDK中进行了检查,不属于那四个类就会抛异常且不允许序列化.

3.序列化ID可以起到验证是不是同一个类的作用,当然是在两个类的代码完全一样的基础上.

4.transient关键字可以忽略一些字段,使其不参与序列化.

5.静态变量是不会序列化的,因为序列化的是对象,而静态变量属于类.

6.可以参考ArrayList的实现方法实现自己的自定义序列化,在这个自定义的过程中,可以做许多事情,比如对某些字段加密(常用于密码字段).

参考链接

https://www.ibm.com/developerworks/cn/java/j-lo-serial/index.html
https://www.hollischuang.com/archives/1140

联系我

最后，欢迎关注我的个人公众号【 呼延十 】，会不定期更新很多后端工程师的学习笔记。
也欢迎直接公众号私信或者邮箱联系我，一定知无不言，言无不尽。

完.

ChangeLog

2019-01-28 完成

以上皆为个人所思所得，如有错误欢迎评论区指正。

欢迎转载，烦请署名并保留原文链接。

联系邮箱：huyanshi2580@gmail.com

更多学习笔记见个人博客——>呼延十