序列化与反序列化

liubo525

已于 2022-03-14 15:18:21 修改

阅读量375

点赞数 1

分类专栏： Java 文章标签： java

于 2021-11-04 09:23:24 首次发布

本文链接：https://blog.csdn.net/weixin_42607437/article/details/114718451

版权

Java 专栏收录该内容

28 篇文章 0 订阅

订阅专栏

序列化与反序列化

	序列化	反序列化
定义	对象---->IO字节流	IO字节流---->对象
作用	1)对象可以保存在磁盘上。使对象可以脱离程序的运行而独立存在 2)便于网络传输。如RMI（远程方法调用）	恢复成原来的对象
数据格式	json/xml	json/xml

对象的序列化:把对象转换为字节流的过程。可以将其保存到磁盘文件中或通过网络发送到任何其他程序。

对象的反序列化：把字节流恢复为对象的过程。字节流是与平台无关的，在一个平台上序列化的对象可以在不同的平台上反序列化。

对象的序列化主要有两种用途：

1）把对象的字节序列永久地保存到硬盘上，通常存放在一个文件中；

2）在网络上传送对象的字节序列。

在很多应用中，需要对某些对象进行序列化，让它们离开内存空间，入住物理硬盘，以便长期保存。比如最常见的是Web服务器中的Session对象，当有 10万用户并发访问，就有可能出现10万个Session对象，内存可能吃不消，于是Web容器就会把一些seesion先序列化到硬盘中，等要用了，再把保存在硬盘中的对象还原到内存中。

当两个进程在进行远程通信时，彼此可以发送各种类型的数据。无论是何种类型的数据，都会以二进制序列的形式在网络上传送。发送方需要把这个Java对象转换为字节序列，才能在网络上传送；接收方则需要把字节序列再恢复为Java对象。

实现方式

ObjectOutputStream代表对象输出流，它的writeObject(Object obj)方法可对参数指定的obj对象进行序列化，把得到的字节序列写到一个目标输出流中。

ObjectInputStream代表对象输入流，它的readObject()方法从一个源输入流中读取字节序列，再把它们反序列化为一个对象，并将其返回。

只有实现了Serializable和Externalizable接口的类的对象才能被序列化。Externalizable接口继承自 Serializable接口，实现Externalizable接口的类完全由自身来控制序列化的行为，而仅实现Serializable接口的类可以采用默认的序列化方式。

对象序列化包括如下步骤：

1）创建一个对象输出流，它可以包装一个其他类型的目标输出流，如文件输出流；

2）通过对象输出流的writeObject()方法写对象。

对象反序列化的步骤如下：

1）创建一个对象输入流，它可以包装一个其他类型的源输入流，如文件输入流；

2）通过对象输入流的readObject()方法读取对象。

serialVersionUID: 字面意思上是序列化的版本号，凡是实现Serializable接口的类都有一个表示序列化版本标识符的静态变量

Serializeable

属性=（基本数据结构+String）& 全部序列化

/**
 *序列化类
 */
public class Person implements Serializable {
  private String name;
  private int age;
  //不提供无参构造器
  public Person(String name, int age) {
      this.name = name;
      this.age = age;
  }
}

/**
 *普通序列化
 */
public class WriteObject {
  public static void main(String[] args) {
      try (
          //创建一个ObjectOutputStream输出流
           ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("person.txt"))) {
          //将对象序列化到文件
          Person person = new Person("我", 1111);
          oos.writeObject(person);
      } catch (Exception e) {
          e.printStackTrace();
      }
  }
}

/**
 * 反序列化类
 */
public class Person implements Serializable {
  private String name;
  private int age;
  //不提供无参构造器
  public Person(String name, int age) {
      System.out.println("反序列化，你调用我了吗？");
      this.name = name;
      this.age = age;
  }

  @Override
  public String toString() {
      return "Person{" +
              "name='" + name + '\'' +
              ", age=" + age +
              '}';
  }
}

public class ReadObject {
  public static void main(String[] args) {
      try (
          //创建一个ObjectInputStream输入流
           ObjectInputStream ois = new ObjectInputStream(new FileInputStream("person.txt"))
      ){
          Person obj = (Person) ois.readObject();
          System.out.println(obj);
      } catch (Exception e) {
          e.printStackTrace();
      }
  }
}
//输出结果
//Person{name='我', age=1111}
//从输出的结果看，反序列化并不会调用构造方法。反序列的对象是由JVM自己生成的对象，不通过构造方法生成。

属性=（基本+引用）数据结构&全部序列化

/**
 *序列化类
 */
public class Person implements Serializable {
  private String name;
  private int age;
  //不提供无参构造器
  public Person(String name, int age) {
      this.name = name;
      this.age = age;
  }
}

/**
 *普通序列化
 */
public class WriteObject {
  public static void main(String[] args) {
      try (
          //创建一个ObjectOutputStream输出流
           ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("person.txt"))) {
          //将对象序列化到文件
          Person person = new Person("我", 1111);
          oos.writeObject(person);
      } catch (Exception e) {
          e.printStackTrace();
      }
  }
}

如果一个可序列化的类的成员不是基本类型，也不是String类型，那这个引用类型也必须是可序列化的；否则，会导致此类不能序列化。

public class Person{
  private String name;
  private int age;
  //不提供无参构造器
  public Person(String name, int age) {
      this.name = name;
      this.age = age;
  }
}

public class Teacher implements Serializable {

    private String name;
    private Person person;

    public Teacher(String name, Person person) {
        this.name = name;
        this.person = person;
    }

     public static void main(String[] args) throws Exception {
        try(
            ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("person.txt"))
       ) {
            Person person = new Person("我", 1111);
            Teacher teacher = new Teacher("马云", 8888);
            oos.writeObject(teacher);
        }
    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-LBk7DE5G-1615573317339)(…\java\img\成员是引用的序列化.jpg)]

我们看到程序直接报错，因为Person类的对象是不可序列化的，这导致了Teacher的对象不可序列化。

解决方案，Person类实现序列化接口

属性=部分序列化

有些时候，我们有这样的需求，某些属性不需要序列化。

transient

使用transient关键字选择不需要序列化的字段。

public class Person implements Serializable {
   //不需要序列化名字与年龄
   private transient String name;
   private transient int age;
   private int height;
   private transient boolean singlehood;
   public Person(String name, int age) {
       this.name = name;
       this.age = age;
   }
   //省略get,set方法
}

public class TransientTest {
   public static void main(String[] args) throws Exception {
       try (
           ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("person.txt"));
            ObjectInputStream ios = new ObjectInputStream(new FileInputStream("person.txt"))
       ) {
           Person person = new Person("我", 1111);
           person.setHeight(185);
           System.out.println(person);
           oos.writeObject(person);
           Person p1 = (Person)ios.readObject();
           System.out.println(p1);
       }
   }
}
//输出结果
//Person{name='我', age=1111', singlehood=true', height=185cm}
//Person{name='null', age=0', singlehood=false', height=185cm}
/**
从输出我们看到，使用transient修饰的属性，java序列化时，会忽略掉此字段，所以反序列化出的对象，被transient修饰的属性是默认值。对于引用类型，值是null；基本类型，值是0；boolean类型，值是false。
*/

重写writeObject()与readObject()方法

使用transient虽然简单，但将此属性完全隔离在了序列化之外。java提供了**可选的自定义序列化。**可以进行控制序列化的方式，或者对序列化数据进行编码加密等。

private void writeObject(java.io.ObjectOutputStream out) throws IOException；
private void readObject(java.io.ObjectIutputStream in) throws IOException,ClassNotFoundException;
private void readObjectNoData() throws ObjectStreamException;

通过重写writeObject与readObject方法，可以自己选择哪些属性需要序列化，哪些属性不需要。如果writeObject使用某种规则序列化，则相应的readObject需要相反的规则反序列化，以便能正确反序列化出对象。这里展示对名字进行反转加密。

public class Person implements Serializable {
   private String name;
   private int age;
   //省略构造方法，get及set方法

   private void writeObject(ObjectOutputStream out) throws IOException {
       //将名字反转写入二进制流
       out.writeObject(new StringBuffer(this.name).reverse());
       out.writeInt(age);
   }

   private void readObject(ObjectInputStream ins) throws IOException,ClassNotFoundException{
       //将读出的字符串反转恢复回来
       this.name = ((StringBuffer)ins.readObject()).reverse().toString();
       this.age = ins.readInt();
   }
}

当序列化流不完整时，readObjectNoData()方法可以用来正确地初始化反序列化的对象。例如，使用不同类接收反序列化对象，或者序列化流被篡改时，系统都会调用readObjectNoData()方法来初始化反序列化的对象。

更彻底的自定义序列化

ANY-ACCESS-MODIFIER Object writeReplace() throws ObjectStreamException;
ANY-ACCESS-MODIFIER Object readResolve() throws ObjectStreamException;

writeReplace：在序列化时，会先调用此方法，再调用writeObject方法。此方法可将任意对象代替目标序列化对象

public class Person implements Serializable {
  private String name;
  private int age;
  //省略构造方法，get及set方法

  private Object writeReplace() throws ObjectStreamException {
      ArrayList<Object> list = new ArrayList<>(2);
      list.add(this.name);
      list.add(this.age);
      return list;
  }

   public static void main(String[] args) throws Exception {
      try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("person.txt"));
           ObjectInputStream ios = new ObjectInputStream(new FileInputStream("person.txt"))) {
          Person person = new Person("我", 1111);
          oos.writeObject(person);
          ArrayList list = (ArrayList)ios.readObject();
          System.out.println(list);
      }
  }
}
//输出结果
//[我, 1111]

readResolve：反序列化时替换反序列化出的对象，反序列化出来的对象被立即丢弃。此方法在readeObject后调用。

public class Person implements Serializable {
    private String name;
    private int age;
    //省略构造方法，get及set方法
     private Object readResolve() throws ObjectStreamException{
        return new ("brady", 23);
    }
    public static void main(String[] args) throws Exception {
        try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("person.txt"));
             ObjectInputStream ios = new ObjectInputStream(new FileInputStream("person.txt"))) {
            Person person = new Person("我", 1111);
            oos.writeObject(person);
            HashMap map = (HashMap)ios.readObject();
            System.out.println(map);
        }
    }
}
//输出结果
//{brady=23}

readResolve常用来反序列单例类，保证单例类的唯一性。

注意：readResolve与writeReplace的访问修饰符可以是private、protected、public，如果父类重写了这两个方法，子类都需要根据自身需求重写，这显然不是一个好的设计。通常建议对于final修饰的类重写readResolve方法没有问题；否则，重写readResolve使用private修饰。

Externalizable

Externalizable，强制自定义序列化。

通过实现Externalizable接口,必须实现writeExternal、readExternal方法。

public interface Externalizable extends java.io.Serializable {
     void writeExternal(ObjectOutput out) throws IOException;
     void readExternal(ObjectInput in) throws IOException, ClassNotFoundException;
}
public class ExPerson implements Externalizable {

    private String name;
    private int age;
    //必须加上pulic无参构造器
    public ExPerson() {
    }

    public ExPerson(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public void writeExternal(ObjectOutput out) throws IOException {
        //将name反转后写入二进制流
        StringBuffer reverse = new StringBuffer(name).reverse();
        System.out.println(reverse.toString());
        out.writeObject(reverse);
        out.writeInt(age);
    }

    @Override
    public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
        //将读取的字符串反转后赋值给name实例变量
        this.name = ((StringBuffer) in.readObject()).reverse().toString();
        System.out.println(name);
        this.age = in.readInt();
    }

    public static void main(String[] args) throws IOException, ClassNotFoundException {
        try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("ExPerson.txt"));
             ObjectInputStream ois = new ObjectInputStream(new FileInputStream("ExPerson.txt"))) {
            oos.writeObject(new ExPerson("我", 1111));
            ExPerson ep = (ExPerson) ois.readObject();
            System.out.println(ep);
        }
    }
}
//输出结果
//ydarb
//brady
//ExPerson{name='我', age=1111}

注：必须提供pulic的无参构造器，因为在反序列化的时候需要反射创建对象。

serialVersionUID

为了提高serialVersionUID的独立性和确定性，建议在一个可序列化类中显示的定义serialVersionUID，为它赋予明确的值。

显式地定义serialVersionUID有两种用途：

1、在某些场合，希望类的不同版本对序列化兼容，因此需要确保类的不同版本具有相同的serialVersionUID；

2、在某些场合，不希望类的不同版本对序列化兼容，因此需要确保类的不同版本具有不同的serialVersionUID。

serialVersionUID序列化版本号

我们知道，反序列化必须拥有class文件，但随着项目的升级，class文件也会升级，序列化怎么保证升级前后的兼容性呢？

java序列化提供了一个private static final long serialVersionUID 的序列化版本号，只有版本号相同，即使更改了序列化属性，对象也可以正确被反序列化回来。

public class Person implements Serializable {
    //序列化版本号
    private static final long serialVersionUID = 1111013L;
    private String name;
    private int age;
    //省略构造方法及get,set
}

如果反序列化使用的class的版本号与序列化时使用的不一致，反序列化会报InvalidClassException异常。

序列化版本号可自由指定，如果不指定，JVM会根据类信息自己计算一个版本号，这样随着class的升级，就无法正确反序列化；不指定版本号另一个明显隐患是，不利于jvm间的移植，可能class文件没有更改，但不同jvm可能计算的规则不一样，这样也会导致无法反序列化。

什么情况下需要修改serialVersionUID呢？分三种情况。

如果只是修改了方法，反序列化不容影响，则无需修改版本号；
如果只是修改了静态变量，瞬态变量（transient修饰的变量），反序列化不受影响，无需修改版本号；
如果修改了非瞬态变量，则可能导致反序列化失败。**如果新类中实例变量的类型与序列化时类的类型不一致，则会反序列化失败，这时候需要更改serialVersionUID。**如果只是新增了实例变量，则反序列化回来新增的是默认值；如果减少了实例变量，反序列化时会忽略掉减少的实例变量。

常见问题

同一对象序列化多次机制

同一对象序列化多次，会将这个对象序列化多次吗？

答案是否定的。

public class Person{
  private String name;
  private int age;
  //不提供无参构造器
  public Person(String name, int age) {
      this.name = name;
      this.age = age;
  }
}
public class WriteTeacher {
    public static void main(String[] args) throws Exception {
        try (
            ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("person.txt"))
        ) {
            Person person = new Person("我", 1111);
            Teacher t1 = new Teacher("马云", person);
            Teacher t2 = new Teacher("于谦", person);
            //依次将4个对象通过输入流写到文件person.txt文件中。
            oos.writeObject(t1);
            oos.writeObject(t2);
            oos.writeObject(person);
            oos.writeObject(t2);
        }
    }
}

public class ReadTeacher {
    public static void main(String[] args) {
        try (
            ObjectInputStream ois = new ObjectInputStream(new FileInputStream("xxx.txt"))
        ) {
            //注意:反序列化的顺序与序列化时的顺序一致
            Teacher t1 = (Teacher) ois.readObject();
            Teacher t2 = (Teacher) ois.readObject();
            Person p = (Person) ois.readObject();
            Teacher t3 = (Teacher) ois.readObject();
            System.out.println(t1 == t2);
            System.out.println(t1.getPerson() == p);
            System.out.println(t2.getPerson() == p);
            System.out.println(t2 == t3);
            System.out.println(t1.getPerson() == t2.getPerson());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
//输出结果
//false
//true
//true
//true
/**
*从输出结果可以看出，Java序列化同一对象，并不会将此对象序列化多次得到多个对象。
*/

java序列化算法

Java序列化算法

所有保存到磁盘的对象都有一个序列化编码号
当程序试图序列化一个对象时，会先检查此对象是否已经序列化过，只有此对象从未（在此虚拟机）被序列化过，才会将此对象序列化为字节序列输出。
如果此对象已经序列化过，则直接输出编号即可。

由于java序利化算法不会重复序列化同一个对象，只会记录已序列化对象的编号。如果序列化一个可变对象（对象内的内容可更改）后，更改了对象内容，再次序列化，并不会再次将此对象转换为字节序列，而只是保存序列化编号。

public class WriteObject {
    public static void main(String[] args) {
        try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("person.txt"));
             ObjectInputStream ios = new ObjectInputStream(new FileInputStream("person.txt"))) {
            //第一次序列化person
            Person person = new Person("我", 1111);
            oos.writeObject(person);
            System.out.println(person);

            //修改name
            person.setName("海贼王");
            System.out.println(person);
            //第二次序列化person
            oos.writeObject(person);

            //依次反序列化出p1、p2
            Person p1 = (Person) ios.readObject();
            Person p2 = (Person) ios.readObject();
            System.out.println(p1 == p2);
            System.out.println(p1.getName().equals(p2.getName()));
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
//输出结果
//Person{name='我', age=1111}
//Person{name='海贼王', age=1111}
//true
//true

总结

所有需要网络传输的对象都需要实现序列化接口，通过建议所有的javaBean都实现Serializable接口。
对象的类名、实例变量（包括基本类型，数组，对其他对象的引用）都会被序列化；方法、类变量、transient实例变量都不会被序列化。
如果想让某个变量不被序列化，使用transient修饰。
序列化对象的引用类型成员变量，也必须是可序列化的，否则，会报错。
反序列化时必须有序列化对象的class文件。
当通过文件、网络来读取序列化后的对象时，必须按照实际写入的顺序读取。
单例类序列化，需要重写readResolve()方法；否则会破坏单例原则。
同一对象序列化多次，只有第一次序列化为二进制流，以后都只是保存序列化编号，不会重复序列化。
建议所有可序列化的类加上serialVersionUID 版本号，方便项目升级。

| 实现Serializable接口                                         | 实现Externalizable接口   |
| :----------------------------------------------------------- | :----------------------- |
| 系统自动存储必要的信息                                       | 程序员决定存储哪些信息   |
| Java内建支持，易于实现，只需要实现该接口即可，无需任何代码支持 | 必须实现接口内的两个方法 |
| 性能略差                                                     | 性能略好                 |

**虽然Externalizable接口带来了一定的性能提升，但变成复杂度也提高了，所以一般通过实现Serializable接口进行序列化。**