欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  IT编程

java序列化,看这篇就够了

程序员文章站 2022-04-28 15:29:03
一、序列化的含义、意义及使用场景二、序列化实现的方式1、Serializable1.1 普通序列化1.2 成员是引用的序列化1.3 同一对象序列化多次的机制1.4 java序列化算法潜在的问题1.5 可选的自定义序列化2、Externalizable:强制自定义序列化3、两种序列化对比三、序列化版本 ......

1、serializable2、externalizable:强制自定义序列化三、序列化版本号serialversionuid

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

  • 序列化:将对象写入到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 serializable {
      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"))) {
              //将对象序列化到文件s
              person person = new person("9龙", 23);
              oos.writeobject(person);
          } catch (exception e) {
              e.printstacktrace();
          }
      }
    }
  1. 反序列化步骤:
  • 步骤一:创建一个objectinputstream输入流;

  • 步骤二:调用objectinputstream对象的readobject()得到序列化的对象。

    我们将上面序列化到person.txt的person对象反序列化回来

    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 brady = (person) ois.readobject();
              system.out.println(brady);
          } catch (exception e) {
              e.printstacktrace();
          }
      }
    }
    //输出结果
    //person{name='9龙', age=23}

    waht???? 输出告诉我们,反序列化并不会调用构造方法。反序列的对象是由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);
        }
    }
}
java序列化,看这篇就够了

我们看到程序直接报错,因为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();
        }
    }
}
//输出结果
//false
//true
//true
//true
//true

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

  • java序列化算法
  1. 所有保存到磁盘的对象都有一个序列化编码号

  2. 当程序试图序列化一个对象时,会先检查此对象是否已经序列化过,只有此对象从未(在此虚拟机)被序列化过,才会将此对象序列化为字节序列输出。

  3. 如果此对象已经序列化过,则直接输出编号即可。

    图示上述序列化过程。

java序列化,看这篇就够了
1.4 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("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();
       }
    }

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

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

    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修饰。

2、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("brady", 23));
            experson ep = (experson) ois.readobject();
            system.out.println(ep);
        }
    }
}
//输出结果
//ydarb
//brady
//experson{name='brady', age=23}

注意:externalizable接口不同于serializable接口,实现此接口必须实现接口中的两个方法实现自定义序列化,这是强制性的;特别之处是必须提供pulic的无参构造器,因为在反序列化的时候需要反射创建对象。

3、两种序列化对比

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

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

三、序列化版本号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异常。

java序列化,看这篇就够了

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

什么情况下需要修改serialversionuid呢?分三种情况。

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

四、总结

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