Java对象序列化

Java对象序列化

1、什么是序列化

Java序列化是指把Java对象转换为字节序列的过程；而反序列化是指把字节序列恢复为Java对象的过程。从而实现网络传输、本地存储等需求；

• 一般Java对象的生命周期比Java虚拟机短，而实际开发中如果需要JVM停止后能够继续持有对象，则需要用到序列化技术将对象持久化到磁盘或数据库；

• 在多个项目进行RPC（Remote Procedure Call）调用时，需要在网络上传输JavaBean对象，而网络上只允许二进制形式的数据进行传输，这时则需要用到序列化技术；

2、如何实现序列化

将被序列化的类实现Serializable或Externalizable接口即可；在实现Serializable接口的默认情况下，Java会自动将非transient(短暂的，临时的)关键字修饰的属性序列化到指定文件中去；

3、Serializable接口示例

//JavaBean
  public class StudentBean implements Serializable{
      
      private String code;
      private String name ;
      private Integer age ;
      private List<Score> scores  ;
      // get/set/toString ...
  ​
  }
  public class Score implements Serializable {
      
      private Integer code ;
      private String name;
      private Integer score ;
      // get/set/toString ...
  }
  //SerializableUtils
  public class SerializableUtils {
      
      /**
       * 序列化
       * 
       * @param obj   实现了Serializable接口的类
       * @param fileName 文件输出路径
       * @throws IOException
       */
      public static void serialize(Object obj, String fileName)
              throws IOException {
   
          FileOutputStream fos = new FileOutputStream(fileName);
          BufferedOutputStream bos = new BufferedOutputStream(fos);
          ObjectOutputStream oos = new ObjectOutputStream(bos);
          oos.writeObject(obj);
          oos.close();
      }
      
      /**
       * 反序列化
       * 
       * @param fileName  反序列化时读取的文件路径
       * @return
       * @throws IOException
       * @throws ClassNotFoundException
       */
      public static Object deserialize(String fileName) throws IOException, ClassNotFoundException {
          FileInputStream fis = new FileInputStream(fileName);
          BufferedInputStream bis = new BufferedInputStream(fis);
          ObjectInputStream ois = new ObjectInputStream(bis);
          Object obj = ois.readObject();
          ois.close();
          return obj;
      }
  }
  // TestClass
  public class MyTest {
  ​
      private StudentBean stu;
  ​
      @Before
      public void before() {
          stu = new StudentBean();
          stu.setAge(18);
          stu.setCode("101");
          stu.setName("张三");
          Score s1 = new Score(101, "高等数学", 100);
          Score s2 = new Score(102, "计算机", 100);
          Score s3 = new Score(103, "大学物理", 100);
          List<Score> list = new ArrayList<Score>();
          list.add(s1);
          list.add(s2);
          list.add(s3);
          stu.setScores(list);
      }
  ​
      @Test
      public void Test() throws IOException, ClassNotFoundException {
          // 序列化
          SerializableUtils.serialize(stu, "student.txt");
  ​
          // 反序列化
          StudentBean student = (StudentBean) SerializableUtils.deserialize("student.txt");
          System.out.println(student.getName());
          for (Score s : student.getScores()) {
              System.out.println(s);
          }
      }
  }

4、serialVersionUID

• 实现Serializable接口之后可选择添加一个serialVersionUID 属性作为该类的一个序列化版本号，该编码可选择自动生成或者自定义编辑，其主要作用是为当前类添加一个版本标识，UID不变则认为类的内容没变。反序列化时会判断UID是否未发生变化，若序列化后修改了此UID值，则会导致反序列化失败 ，抛出InvalidClassException异常；

• 不指定版本号另一个明显隐患是，不利于jvm间的移植，可能class文件没有更改，但不同jvm可能计算的规则不一样，这样也会导致无法反序列化；

5、Externalizable接口示例

Externalizable(可外部化的)继承自Serializable，须手动实现writeExternal以及readExternal方法；

//修改StudentBean
  public class StudentBean implements Externalizable{
  ​
      private String code;
      private String name ;
      private Integer age ;
      private List<Score> scores  ;
  ​
      /*
       * 自定义序列化规则
       */
      @Override
      public void writeExternal(ObjectOutput out) throws IOException {
          out.writeObject(code);
          out.writeObject(name);
          out.writeInt(age);
          out.writeObject(scores);
      }
  ​
      /*
       * 自定义反序列化规则
       */
      @Override
      public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
          
          code = (String)in.readObject();
          name = (String)in.readObject();
          age = in.readInt();
          scores = (List<Score>)in.readObject();
      }
      // get/set/toString
  }

6、部分属性序列化

6.1 transient关键字

transient关键字，在实现Serializable接口情况下，只需要对不需要序列化的属性使用transient关键字进行修饰即可实现在序列化时忽略该字段；

  private transient String code

6.2 添加writeObject和readObject方法

添加writeObject和readObject方法，在实现Serializable接口的情况下添加如下两个方法，自定义选择序列化哪些字段，但注意若该字段没有参加序列化，则反序列化时亦不能参与；

defaultWriteObject()会执行默认序列化操作即序列化所有非static、transient属性；transient关键字修饰的属性可以用writeObject()方式实现序列化；

原理：调用ObjectOutputStream中writeObject方法时会检查序列化对象是否实现了自己的writeObject方法，如果是则跳过常规序列化转流程转而调用writerObject方法实现序列化readObject同理；

      private Integer code ;
      private transient String name;
      private Integer score ;
  ​
      //序列化
      private void writeObject(ObjectOutputStream oos) throws IOException {
          oos.defaultWriteObject();
          oos.writeObject(name);
      }
      //反序列化
      private void readObject(ObjectInputStream ois) throws IOException, ClassNotFoundException {
          ois.defaultReadObject();
          name = (String)ois.readObject();
      }

6.3 修改writeExternal和readExternal方法

修改writeExternal和readExternal方法，原理同上，且序列化与反序列化属性须一致；

/*
       * 自定义序列化规则
       */
      @Override
      public void writeExternal(ObjectOutput out) throws IOException {
          //out.writeObject(code);
          out.writeObject(name);
          out.writeInt(age);
          out.writeObject(scores);
      }
  ​
      /*
       * 自定义反序列化规则
       */
      @Override
      public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
          
          //code = (String)in.readObject();
          name = (String)in.readObject();
          age = in.readInt();
          scores = (List<Score>)in.readObject();
      }

7、总结

• Serializable是标识接口，没有需要实现的方法；Externalizable必须实现writeExternal和readExternal方法；

• Serializable不需要有空构造，但Externalizable若含有参构造则必须有无参构造函数；

• Serializable有两种实现方式，默认方式下自动序列化非static、transient关键字修饰的属性；

• Serializable默认方式下使用反射实现序列化，性能稍弱，对属性顺序无要求；Externalizable要求属性的序列化与反序列化顺序一致，否则抛出 java.io.OptionalDataException 异常；

• 所有需要网络传输的对象都需要实现序列化接口，通过建议所有的javaBean都实现Serializable接口；

• 同一对象序列化多次，只有第一次序列化为二进制流，以后都只是保存序列化编号，不会重复序列化；

• 建议所有可序列化的类加上serialVersionUID 版本号，方便项目升级、维护；

• 序列化可以实现深拷贝；

8、预告：Redis中的序列化