JAVA序列化Serializable及Externalizable区别详解

序列化简介

Java 的对象序列化将那些实现 Serializable 接口的对象转换成一个字节序列,并能在之后将这个字节序列完全恢复为原来的对象。
这就意味着 Java 对象在网络上的传输可以不依赖于当前计算机的操作系统,就可以将对象进行传递,这也是Java跨平台的一种体现。

Java 对象的序列化主要支持两种特性:

1、Java的远程方法调用(Remote Method Invocation RMI);

2、对于 JavaBean 来说,序列化也是必须的。

要序列化一个对象,需要创建一个 OutputStream 对象,然后将其封装在 ObjectOutputStream 对象中,再调用 writeObject() 方法就可以完成对象的序列化(也是在这一步进行序列化);反序列化(将一个序列还原为一个对象)就是该过程的反过程:创建一个 InputStream 对象,将其封装在 ObjectInputStream 对象中,使用 readObject() 方法将序列反序列化为对象,当然这是一个Object类型的对象,需要向下转型为我们需要的类型(如果该类型不在本地,会导致反序列化失败,ClassNotFoundException )。

先说结论

序列化有以下方式:

1、实现 Serializable 接口:

2、实现 Externalizable 接口,并重写 writeExternal() readExternal() 方法;

3、(即下文中的 Externalizable 的替代方式进行序列化)如果不想实现Externalizable 接口,又想按照自己的规则进行序列化,可以实现 Serializable 接口,并在该类中添加(添加,不是覆盖、实现)名为 writeExternal() readExternal() 方法,且这两个方法必须为下面这两个准确的方法签名:

private void writeObject(ObjectOutputStream stream) throws IOException;
private void readObject(ObjectInputStream stream) throws IOException,ClassNotFoundException;

一、三种方式完成序列化

1、实现 Serializable 接口序列化

这种方式最为常用且常见,只需要对需要序列化的类实现 Serializable 即可,对于不希望进行序列化的,可以使用 transient 关键词进行修饰(即瞬时变量)。
这种方式序列化的特征:

1、 Serializable 接口仅仅是一个标记接口,不包含任何方法;

2、对于Serializable对象来说,对象完全以它存储的二进制位为基础来构造,(反序列化)不会调用构造器。

2、实现 Externalizable 接口序列化

这种方式可以实现序列化的完全自定义:所有成员变量是否序列化都需要在 writeExternal()、readExternal()
方法中写出;且可以完全自定义序列化方式(在 writerExternal()、readExternal()方法中)。当然,实现 Externalizable 接口必须要重写这两个方法。
这种方式序列化的特征:

1、必须重写 writerExternal()、readExternal()两个方法,并在两个方法中写出所有需要序列化的成员变量;

2、对于 Externalizable对象来说,必须要有无参public构造器,不然会报出 InvalidClassException 异常。

3、 Externalizable 的替代方式进行序列化

让 ObjectOutputStream 和 ObjectInputStream 对象的 writeObject() 方法和 readObject() 方法调用我们编写的这两个方法。
如果想在这种方式中也调用原有默认提供的方式,可以在 writeObject() 中调用: s.defaultWriteObject();,在 readObject() 中调用 s.defaultReadObject();。 这部分代码可以查看 ArrayList 源码。

二、测试代码

1、 Serializable 对象反序列化,不调用任何构造器

Serializable 对象反序列化不调用任何构造器,包括默认构造器,整个对象都是从 InputStream 中取得数据恢复过来的

主测试类 Dogs

public class Dogs {
  public static void main(String[] args) throws Exception {
    // 创建对象
    System.out.println("--- 创建对象 ---");
    Dog1 d1 = new Dog1("pidan",4.0);
    Dog2 d2 = new Dog2("duanwu","black");
    // 序列化
    System.out.println("--- 序列化 ---");
    ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("D:/dogs.out"));
    oos.writeObject(d1);
    oos.writeObject(d2);
    System.out.println("--- 反序列化 ---");
    // 反序列化 不会调用任何构造器
    ObjectInputStream ois = new ObjectInputStream(new FileInputStream("d:/dogs.out"));
    Dog1 o1 = (Dog1) ois.readObject();
    Dog2 o2 = (Dog2) ois.readObject();
    System.out.println("反序列化 o1 : " + o1);
    System.out.println("反序列化 o2 : " + o2);
  }
}

Serializable 对象 Dog1 Dog2 类

class Dog1 implements Serializable {
  private static final long serialVersionUID = -7101743601344663182L;

  private String name;
  private Double weight;

  public Dog1(String name, Double weight) {
    System.out.println("Dog1 构造器运行 ---");
    this.name = name;
    this.weight = weight;
    System.out.println("Dog1 : " + this);
  }

  // 省略get、set、toString方法
}

public class Dog2 implements Serializable {

  private static final long serialVersionUID = -5462607652670703938L;

  private String name;
  private String color;

  public Dog2(String name, String color) {
    System.out.println("Dog2 构造器运行 ---");
    this.name = name;
    this.color = color;
    System.out.println("Dogs2 : " + this);
  }

  // 省略get、set、toString方法
}

运行结果:

--- 创建对象 ---
Dog1 构造器运行 ---
Dog1 : Dog1{name='pidan', weight=4.0}
Dog2 构造器运行 ---
Dogs2 : Dog2{name='duanwu', color='black'}
--- 序列化 ---
--- 反序列化 ---
反序列化 o1 : Dog1{name='pidan', weight=4.0}
反序列化 o2 : Dog2{name='duanwu', color='black'}

再最后取出对象时,完全没有调用到其任何构造器。

2、无参构造器对 Externalizable 对象序列化的影响

主测试代码:

public class Persons {
  public static void main(String[] args) throws Exception {
    // 创建对象
    System.out.println("Init Objects");
    Person1 p1 = new Person1();
    Person2 p2 = new Person2();
    // 存储在磁盘上
    ObjectOutputStream os = new ObjectOutputStream(new FileOutputStream("d:/person.out"));
    os.writeObject(p1);
    os.writeObject(p2);
    os.flush();
    os.close();
    // 取出
    ObjectInputStream is = new ObjectInputStream(new FileInputStream("d:/person.out"));
    System.out.println("取出p1: ");
    p1 = (Person1) is.readObject();
    p2 = (Person2) is.readObject();
  }
}

Externalizable 对象:Perion1 Persion2

public class Person1 implements Externalizable {

  public Person1(){
    System.out.println("Person1 构造器---");
  }

  @Override
  public void writeExternal(ObjectOutput out) throws IOException {
    System.out.println("Person1 writeExternal ---");
  }

  @Override
  public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
    System.out.println("Person1 readExternal ---");
  }
}
class Person2 implements Externalizable{

  // 注意不是public
  Person2(){
    System.out.println("Person2 构造器 ---");
  }
  @Override
  public void writeExternal(ObjectOutput out) throws IOException {
    System.out.println("Person2 writeExternal ---");
  }

  @Override
  public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
    System.out.println("Person2 readExternal ---");
  }
}

Person2 默认构造器不是 public 的运行结果:

Init Objects
Person1 构造器---
Person2 构造器 ---
Person1 writeExternal ---
Person2 writeExternal ---
取出p1:
Person1 构造器---
Person1 readExternal ---
Exception in thread "main" java.io.InvalidClassException: ...serializableAndexternalizable.Person2; no valid constructor
	at java.io.ObjectStreamClass$ExceptionInfo.newInvalidClassException(ObjectStreamClass.java:169)
	at java.io.ObjectStreamClass.checkDeserialize(ObjectStreamClass.java:874)
	at java.io.ObjectInputStream.readOrdinaryObject(ObjectInputStream.java:2043)
	at java.io.ObjectInputStream.readObject0(ObjectInputStream.java:1573)
	at java.io.ObjectInputStream.readObject(ObjectInputStream.java:431)
	at ...serializableAndexternalizable.Persons.main(Persons.java:29)

Process finished with exit code 1

将 Person2 构造器改为 public 后:

Init Objects
Person1 构造器---
Person2 构造器 ---
Person1 writeExternal ---
Person2 writeExternal ---
取出p1:
Person1 构造器---
Person1 readExternal ---
Person2 构造器 ---
Person2 readExternal ---

3、使用 Externalizable 对象实现序列化

主测试类 Cats :

public class Cats {
  public static void main(String[] args) throws Exception {
    // 初始化对象
    System.out.println("--- 初始化对象 ---");
    Person person = new Person("01", "老王", 30);
    Cat2 cat = new Cat2("fugui", person);
    // 序列化
    System.out.println("--- 序列化对象 ---");
    ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("d:/cats.out"));
    oos.writeObject(cat);
    System.out.println("--- 反序列化对象 ---");
    ObjectInputStream ois = new ObjectInputStream(new FileInputStream("d:/cats.out"));
    cat = (Cat2) ois.readObject();
    System.out.println("--- 反序列化对象后 ---");
    System.out.println("cat : " + cat);
  }
}

Externalizable 对象: Cat2 ;Serializable 对象:Person :

public class Person implements Serializable {
  private static final long serialVersionUID = -822166081906894628L;
  private transient String id;
  private String name;
  private int age;

  public Person() {
    System.out.println("--- Person 无参构造器 ---");
  }

  public Person(String id, String name, int age) {
    System.out.println("--- Person 无参构造器 ---");
    this.id = id;
    this.name = name;
    this.age = age;
    System.out.println("Person : " + this);
  }

  // 省略get、set、toString方法
}

class Cat2 implements Externalizable {
  private static final long serialVersionUID = 1102930161606017855L;
  private String name;
  private Person minion;

  public Cat2() {
    System.out.println("Cat2 无参构造器 --->");
  }

  public Cat2(String name, Person minion) {
    System.out.println("Cat2 有参构造器 --->");
    this.name = name;
    this.minion = minion;
    System.out.println("Cat2 : " + this);
  }

  // 省略get、set、toString方法

  @Override
  public void writeExternal(ObjectOutput out) throws IOException {
    System.out.println("--- Cat2:writeExternal ---");
    // code1
    out.writeObject(this.minion);
    out.writeObject(this.name);
  }

  @Override
  public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
    System.out.println("--- Cat2:readExternal ---");
    // code2
    this.minion = (Person) in.readObject();
    this.name = (String) in.readObject();
  }
}

运行结果:

可以注意到Person的成员变量id在使用了 transient 关键词修饰后,就不再序列化该字段了。

--- 初始化对象 ---
--- Person 无参构造器 ---
Person : Person{id='01', name='老王', age=30}
Cat2 有参构造器 --->
Cat2 : Cat2{name='fugui', minion=Person{id='01', name='老王', age=30}}
--- 序列化对象 ---
--- Cat2:writeExternal ---
--- 反序列化对象 ---
Cat2 无参构造器 --->
--- Cat2:readExternal ---
--- 反序列化对象后 ---
cat : Cat2{name='fugui', minion=Person{id='null', name='老王', age=30}}

如果将Cat2类中标注的 code1 与 code2 代码下面的两行代码均注释掉,就不再可以序列化及反序列化了:
注释掉后的运行结果:

--- 初始化对象 ---
--- Person 无参构造器 ---
Person : Person{id='01', name='老王', age=30}
Cat2 有参构造器 --->
Cat2 : Cat2{name='fugui', minion=Person{id='01', name='老王', age=30}}
--- 序列化对象 ---
--- Cat2:writeExternal ---
--- 反序列化对象 ---
Cat2 无参构造器 --->
--- Cat2:readExternal ---
--- 反序列化对象后 ---
cat : Cat2{name='null', minion=null}

4、使用 Externalizable 对象替代方式实现序列化

替代方式就是实现 Serializable 接口,并且添加 writeObject(),readObject() 两个方法注意这两个方法必须有准确的方法特征签名,在这两个方法中编写自定义方式实现序列化和反序列化。

class Mouse implements Serializable {
  private static final long serialVersionUID = -3278535893876444138L;
  private String name;
  private int i;

  public Mouse() {
    System.out.println("Mouse 无参构造器 ---");
  }

  public Mouse(String name, int i) {
    System.out.println("Mouse 有参构造器 ---");
    this.name = name;
    this.i = i;
    System.out.println("Mouse : " + this);
  }

  // 方法特征签名必须完全一致
  private void writeObject(ObjectOutputStream stream) throws IOException {
//    stream.defaultWriteObject();// 可以选择执行默认的writeObject()
    System.out.println("--- 这是自定义的writeExternal方法 ---");
    stream.writeObject(this.name);
    stream.writeInt(this.i);
  }

  // 方法特征签名必须完全一致
  private void readObject(ObjectInputStream stream) throws IOException,ClassNotFoundException {
//    stream.defaultReadObject(); // 可以选择执行默认的readObject()
    System.out.println("--- 这是自定义的readExternal方法 ---");
    this.name = (String)stream.readObject();
    this.i = stream.readInt();
  }

  // 省略get、set、toString方法
}

主测试类:

public class Mouses {
  public static void main(String[] args) throws Exception {
    // 创建对象
    System.out.println("--- 创建对象 ---");
    Mouse m1 = new Mouse("zhizhi", 2);
    // 序列化
    System.out.println("--- 序列化 ---");
    ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("D:/mouse.out"));
    oos.writeObject(m1);
    // 反序列化
    System.out.println("--- 反序列化 ---");
    ObjectInputStream ois = new ObjectInputStream(new FileInputStream("d:/mouse.out"));
    // 反序列化结果
    System.out.println("--- 反序列化结果 ---");
    m1 = (Mouse) ois.readObject();
    System.out.println(" zhizhi : " + m1);
  }
}

运行结果

--- 创建对象 ---
Mouse 有参构造器 ---
Mouse : Mouse{name='zhizhi', i=2}
--- 序列化 ---
--- 这是自定义的writeExternal方法 ---
--- 反序列化 ---
--- 反序列化结果 ---
--- 这是自定义的readExternal方法 ---
zhizhi : Mouse{name='zhizhi', i=2}

以上就是本文的全部内容,希望对大家的学习有所帮助,也希望大家多多支持我们。

(0)

相关推荐

  • 深入理解Java原生的序列化机制

    概念 一个对象如果想在硬盘上存储,一定就需要借助于一定的数据格式.这种把对象转换为硬盘存储的格式的过程就叫做对象的序列化,同样地,将这些文件再反向转换为程序中对象的操作就叫做反序列化 一些复杂的解决方案可能是将对象转换为json字符串的方式,这种方式的优点是易读,但是效率还是太低,所以Java的序列化的解决方案是将对象转换为一个二进制流的形式,来实现数据的持久化,本篇文章将会来详细讲解序列化的实现和原理 实现 准备 我们这里有一个普通的对象,要注意的是这个类和其中用到的所有对象都需要实现序列化接

  • JAVA序列化和反序列化的底层实现原理解析

    一.基本概念 1.什么是序列化和反序列化 (1)Java序列化是指把Java对象转换为字节序列的过程,而Java反序列化是指把字节序列恢复为Java对象的过程: (2)**序列化:**对象序列化的最主要的用处就是在传递和保存对象的时候,保证对象的完整性和可传递性.序列化是把对象转换成有序字节流,以便在网络上传输或者保存在本地文件中.序列化后的字节流保存了Java对象的状态以及相关的描述信息.序列化机制的核心作用就是对象状态的保存与重建. (3)**反序列化:**客户端从文件中或网络上获得序列化后

  • java 序列化对象 serializable 读写数据的实例

    序列化对象: 复制代码 代码如下: package com.chen.seriaizable; import java.io.Serializable;import java.util.List; @SuppressWarnings("serial")public class Student implements Serializable{ private String name; private String id; private int age; private List<

  • Java对象序列化操作详解

    本文实例讲述了Java对象序列化操作.分享给大家供大家参考,具体如下: 当两个进程在进行远程通信时,彼此可以发送各种类型的数据.无论是何种类型的数据,都会以二进制序列的形式在网络上传送.发送方需要把这个Java对象转换为字节序列,才能在网络上传送:接收方则需要把字节序列再恢复为Java对象. 只能将支持 java.io.Serializable 接口的对象写入流中.每个 serializable 对象的类都被编码,编码内容包括类名和类签名.对象的字段值和数组值,以及从初始对象中引用的其他所有对象

  • 解决Spring Boot和Feign中使用Java 8时间日期API(LocalDate等)的序列化问题

    LocalDate . LocalTime . LocalDateTime 是Java 8开始提供的时间日期API,主要用来优化Java 8以前对于时间日期的处理操作.然而,我们在使用Spring Boot或使用Spring Cloud Feign的时候,往往会发现使用请求参数或返回结果中有 LocalDate . LocalTime . LocalDateTime 的时候会发生各种问题.本文我们就来说说这种情况下出现的问题,以及如何解决. 问题现象 先来看看症状.比如下面的例子: @Sprin

  • 详解java中的深拷贝和浅拷贝(clone()方法的重写、使用序列化实现真正的深拷贝)

    1.序列化实现 public class CloneUtils { @SuppressWarnings("unchecked") public static <T extends Serializable> T clone(T object){ T cloneObj = null; try { ByteArrayOutputStream out = new ByteArrayOutputStream(); ObjectOutputStream obs = new Objec

  • java中Serializable接口作用详解

    本文为大家解析java中Serializable接口的作用,具体内容如下 1.(serializable)主要支持对象的回复,所以可以用来保存当前的程序系统状态,远程方法调用RMI(远程机器必须含有必要的.class文件,否则将掷出classNotFound   Exception),但是因为它将对象数据自动全部保存,你根本无法插手,因此对于一些敏感字段(如:password)存在安全问题.但相应有很多解决的方法,例如可以在敏感字段的声明中使用transient关键字,或者去继承external

  • JAVA基于SnakeYAML实现解析与序列化YAML

    这篇文章主要介绍了JAVA基于SnakeYAML实现解析与序列化YAML,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下 1.概述 本文,我们将学习如何使用SnakeYAML库将 YAML文档转换为Java对象,以及JAVA对象如何序列化为YAML文档. 2.项目设置 要在项目中使用SnakeYAML,需要添加Maven依赖项(可在此处找到最新版本): <dependency> <groupId>org.yaml</group

  • java 中序列化NotSerializableException问题解决办法

    java 中序列化NotSerializableException问题解决办法 前言: 某项目中,要将某个自定义类MMessage对象,通过ObjectOutputStream和ObjectInputStream传递,该MMessage的特征描述: 1 该类未继承Serializable接口: 2 其父类Message的父类继承了Serializable接口: 3 其父类中有一个字段类型为Java.io.ByteArrayOutputStream类型: 经测试发现,MMessage类序列化过程中

  • JAVA序列化Serializable及Externalizable区别详解

    序列化简介 Java 的对象序列化将那些实现 Serializable 接口的对象转换成一个字节序列,并能在之后将这个字节序列完全恢复为原来的对象. 这就意味着 Java 对象在网络上的传输可以不依赖于当前计算机的操作系统,就可以将对象进行传递,这也是Java跨平台的一种体现. Java 对象的序列化主要支持两种特性: 1.Java的远程方法调用(Remote Method Invocation RMI): 2.对于 JavaBean 来说,序列化也是必须的. 要序列化一个对象,需要创建一个 O

  • Java中 % 与Math.floorMod() 区别详解

    %为取余(rem),Math.floorMod()为取模(mod) 取余取模有什么区别呢? 对于整型数a,b来说,取模运算或者取余运算的方法都是: 1.求 整数商: c = a/b; 2.计算模或者余数: r = a - c*b. 区别是: 取余运算在计算商值向0方向舍弃小数位 取模运算在计算商值向负无穷方向舍弃小数位 比如a=4,b=-3时,a/b = -1.3333... 此时,取余c=1,取模c=-2 (%在不同语言中有不同的意义,比如Java或者c/c++中%为取余,python中%则为

  • java 序列化与反序列化的实例详解

     1.Java序列化与反序列化 Java序列化是指把Java对象转换为字节序列的过程:而Java反序列化是指把字节序列恢复为Java对象的过程.  2.为什么需要序列化与反序列化 我们知道,当两个进程进行远程通信时,可以相互发送各种类型的数据,包括文本.图片.音频.视频等, 而这些数据都会以二进制序列的形式在网络上传送.那么当两个Java进程进行通信时,能否实现进程间的对象传送呢?答案是可以的.如何做到呢?这就需要Java序列化与反序列化了.换句话说,一方面,发送方需要把这个Java对象转换为字

  • java中“==“和equals()的区别详解

    今天我们探讨一下Java中"=="与equals()的区别 ==:关系运算符 在基本数据类型中比较两个值的内容是否相等       在引用类型型中比较的是两个对象的地址是否相等 equals()是Object类中的方法 1.基本数据类型无法使用equals()方法 2.在引用类型中若是没有重写Object类时,则默认使用Object类的equals方法,则仍然 利用"=="比较两个对象的内存地址,若是重写Object类的equals方法,则调用子类重写后    的方

  • Java 接口和抽象类的区别详解

    什么是抽象类和接口? 区别在哪里? 不同的编程语言对接口和抽象类的定义方式可能有些差别,但是差别并不大.本文使用 Java 语言. 抽象类 下面我们通过一个例子来看一个典型的抽象类的使用场景. Logger 是一个记录日志的抽象类,FileLogger 和 MessageQueueLogger 继承Logger,分别实现两种不同的日志记录方式: 记录日志到文件中 记录日志到消息队列中 FileLogger 和 MessageQueuLogger 两个子类复用了父类 Logger 中的name.e

  • java HashMap和HashTable的区别详解

    HashMap和HashTable,这二者的区别经常被别人问起,今天在此总结一下. (一)继承的历史不同 public class Hashtable extends Dictionary implements Map public class HashMap extends AbstractMap implements Map Hashtable是继承自Dictionary类的,而HashMap则是Java 1.2引进的Map接口的一个实现. (二)安全性不同 HashMap是非synchro

  • Java枚举与.net枚举区别详解

    通过一段时间的项目实践,发现java中的枚举与.net中的枚举有很大的差别,初期造成了我对java中的枚举一些错误理解及部分有缺陷的应用,其实追其原因还是因为我会习惯性的认为java的枚举在作用以及定义上与.net应该是差不多的,毕竟两者都是高级语言,语言上也有很多相似之处.这就是老师傅常说的新手好教,老兵不好教的原因,新手脑子一片空白不会有任何干扰,老兵总会以自己曾经的某些经验与新知识做对比. 习惯性观点一:枚举的定义应该与.net相同,比如在.net中我们可以这样定义枚举. public e

  • java基础之 “==”与“equals”区别详解

    对于初学java的人来说,在面对数值比较的时候,我们大多数会采用 "=="的方式来进行比较,但是java中给我们提供了equals()方法,这时候很多人就会忽略这两种方式的区别,在学习中产生了很多错误,本文将详细区分equals和 == 两种方式的区别. "==" 解读 对于基本类型和引用类型,==的作用效果是不同的,对于 基本类型 来说,比较的是值是否相同,对于 引用类型 来说,比较的是引用是否相同. 代码示例: public static void main(S

  • java  HashMap和HashTable的区别详解

    HashMap和HashTable,这二者的区别经常被别人问起,今天在此总结一下. (一)继承的历史不同 public class Hashtable extends Dictionary implements Map public class HashMap extends AbstractMap implements Map Hashtable是继承自Dictionary类的,而HashMap则是Java 1.2引进的Map接口的一个实现. (二)安全性不同 HashMap是非synchro

  • java ArrayList和Vector的区别详解

     ArrayList和Vector的区别 相同点: 1.ArrayList和Vector都是继承了相同的父类和实现了相同的接口 2.底层都是数组实现的 3.初始默认长度都为10. 不同点: 1.同步性: Vector中的public方法多数添加了synchronized关键字,以确保方法同步,也即是Vector线程安全,ArrayList线程不安全. 2.扩容不同 内部属性不同,这可能是导致扩容方式不同的原因所在. ArrayList有两个属性,存储数据的数组elementData,和存储记录数

随机推荐