Java序列化

最新推荐文章于 2024-07-15 21:55:17 发布

阅读量220

点赞数

文章标签： java

原文链接：https://www.cnblogs.com/9dragon/

版权

Java序列化与反序列化

文章目录

Java序列化与反序列化
一、序列化的含义、意义及使用场景
二、序列化的实现的方式

一、序列化的含义、意义及使用场景

序列化: 将对象写入到IO流中.
反序列化: 从IO流中恢复对象.
意义:序列化机制将实现序列化的Java对象转换为位字节序列, 这些字节序列化保存在磁盘上,或通过网络传输,以达到以后恢复成原来的对象。序列化机制使得对象可以脱离程序的运行而独立存在。
使用场景: 所有可在网络上传输的对象必须是可序列化的,比如 RMI(remote method invoke,即远程方法调用),传入的参数或返回的对象都是可序列化的,否则会出错;所有需要保存在磁盘的Java 对象都必须是可序列化的。通常建议: 程序创建的每个JavaBean类都实现Serializeable接口。

二、序列化的实现的方式

如果需要将某个对象保存到磁盘上或者通过网络传输,那么这个类应该实现Serializable接口或者Externalizable接口之一。

1.Serializable

1.1 普通序列化

Serializable 接口是一个标记接口,不用实现任何方法。一旦实现了此接口,该类的对象就是可序列化的。
1.序列化步骤:

步骤一: 创建一个ObjectOutputStream 输出流;
步骤二:调用ObjectOutputStream对象的writeObject 输出可序列化对象。

public class Person implements Seriablizable{
 private String name;
 private  int age;
 public Person (String name,int age){
 this.name = name;
 this.age = age;
 }
 @Override
 public String toString(){
  return "Person{" + "name='" +name +'\'' +
  ",age=" + age + '}';
     }
   }
 public class WriteObject{
  public static void main(String[] args){
  try{//创建一个ObjectOutputStream输出流.
    ObjectOutputStream oos = new ObjectOutputStream(
    new FileOutputStream("object.txt");
    Person pserson = new Person("JJ",23);
    oos.writeObject(person);
    }catch(Exception e){
    e.printStackTrace();
        }
       }
     }

2.反序列化:

步骤1:创建一个ObjectInputStream 输入流;
步骤2:调用ObjectInputStream 对象的readObject()得到序列化的对象。
我们将上面序列化到person.tex的person对象反序列化回来.

public class ReadObject{
public static void main(String[] args){
  try{
    ObjectInputStream ois = new ObjectInputStream(new 
    FileInputStream("person.txt))){
    Person brady  = (Person) ois.readObject();
    System.out.println(brady);
    }catch(Exception e){
     e.printStackTrace();
        }
      }
    }
   }

输出结果 Person{name=‘jj’, age=23};
输出告诉我们,反序列化并不会调用构造方法,反序列的对象是由JVM 自己生成的生成的对象,不通过构造方法生成。

1.2成员是引用的序列化

如果一个可序列化的类的成员变量不是基本类型,也不是String类型,那这个引用也必须是可序列化的;否则,会导致此类不能序列化。
看例子:新建一个Teacher类.将Person去掉实现Serializable接口代码。

   public class Person{
    //省略相关属性与方法
}
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("teacher.txt"))) {
            Person person = new Person("路飞", 20);
            Teacher teacher = new Teacher("雷利", person);
            oos.writeObject(teacher);
        }
    }

在这里插入图片描述
我们看到程序直接报错,因为Person 类的对象是不可序列化的,这导致了Teacher 的对象不可序列化

1.3 同一对象序列化多次的机制

同一个对象序列化多次,会将这个对象序列化多次吗? 答案是否定的。

public class WriteTeacher {
    public static void main(String[] args) throws Exception {
        try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("teacher.txt"))) {
            Person person = new Person("路飞", 20);
            Teacher t1 = new Teacher("雷利", person);
            Teacher t2 = new Teacher("红发香克斯", person);
            //依次将4个对象写入输入流
            oos.writeObject(t1);
            oos.writeObject(t2);
            oos.writeObject(person);
            oos.writeObject(t2);
        }
    }
}

依次将t1、t2、person、t2 对象序列化到文件teacher.txt中。

注意: 反序列化的顺序与序列化时的顺序一致。

public class ReadTeacher {
    public static void main(String[] args) {
        try (ObjectInputStream ois = new ObjectInputStream(new FileInputStream("teacher.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();
        }
    }
}
输出结果:
t1==t2?false
t1.getPerson()==p true
t2.getPerson()==p true
t2==t3  true
t1.getPerson==t2.getPerson true

从输出结果可以看出,Java 序列化同一对象,并不会将此对象序列化多次得到多个对象.

.Java序列化算法
1. 所有保存到磁盘的对象都有一个序列化编码号
2.当程序试图序列化一个对象时,会先检查此对象是否已经序列化过,只有此对象从未(在此虚拟
机)序列化过,才会将此对象序列化位字节序列化输出。
3.如果此对象已经序列化过,则直接输出编号即可。

图示所示序列化过程：
在这里插入图片描述

1.4Java序列化算法潜在的问题.

由于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("9龙", 23);
            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='9龙', age=23}
//Person{name='海贼王', age=23}
//true
//true

1.5可选的自定义序列化

1.有些时候，我们有这样的需求，某些属性不需要序列化。使用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("9龙", 23);
           person.setHeight(185);
           System.out.println(person);
           oos.writeObject(person);
           Person p1 = (Person)ios.readObject();
           System.out.println(p1);
       }
   }
}
//输出结果
//Person{name='9龙', age=23', singlehood=true', height=185cm}
//Person{name='null', age=0', singlehood=false', height=185cm}

从输出我们看到，使用transient修饰的属性，java序列化时，会忽略掉此字段，所以反序列化出的对象，被transient修饰的属性是默认值。对于引用类型，值是null；基本类型，值是0；boolean类型，值是false。

2.使用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();
   }
}

1.6.更彻底的自定义序列化

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("9龙", 23);
          oos.writeObject(person);
          ArrayList list = (ArrayList)ios.readObject();
          System.out.println(list);
      }
  }
}
//输出结果
//[9龙, 23]

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("9龙", 23);
            oos.writeObject(person);
            HashMap map = (HashMap)ios.readObject();
            System.out.println(map);
        }
    }
}
//输出结果
//{brady=23}

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

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

1.7序列化版本号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。如果只是新增了实例变量，则反序列化回来新增的是默认值；如果减少了实例变量，反序列化时会忽略掉减少的实例变量。

三总结

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

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Java序列化

Java序列化与反序列化文章目录Java序列化与反序列化一、序列化的含义、意义及使用场景二、序列化的实现的方式1.Serializable1.1 普通序列化1.2成员是引用的序列化1.3 同一对象序列化多次的机制1.4Java序列化算法潜在的问题.1.5可选的自定义序列化1.6.更彻底的自定义序列化1.7序列化版本号serialVersionUID三总结一、序列化的含义、意义及使用场景序列化: 将对象写入到IO流中.反序列化: 从IO流中恢复对象.意义:序列化机制将实现序列化的Java对
复制链接

扫一扫