Java -- 序列化(Serializable)

一、前言

1. 什么是序列化
   (a) 序列化是Java提供的一种机制。通过该机制，一个对象可以被表示为一个字节序列，并存储到磁盘文件中。
   (b) 将序列化的对象写入文件后，通过反序列化可以将这个对象从文件中读取出来。
2. 为什么要序列化
   对象、文件、数据有许多不同的格式，很难统一传输与保存。序列化后就可以将上述数据转换为字节流，统一起来，这样方便传输。使用时，再将其反序列化，这样对象是对象，文件是文件。

二、序列化过程

1. 被序列化的类需要继承Serializable接口，并且设置serialVersionUID。
   我们新建一个User类，主要设置/获取用户id、name、age几个属性，代码如下：

   package com.example.test;
   
   import java.io.Serializable;
   
   public class User implements Serializable {
       private static final long serialVersionUID = 1L;
   
       private int id;
       private String name;
       private int age;
   
       public void setId(int id) {
           this.id = id;
       }
   
       public int getId() {
           return id;
       }
   
       public void setName(String name) {
           this.name = name;
       }
   
       public String  getName() {
           return name;
       }
   
       public void setAge(int age) {
           this.age = age;
       }
   
       public int getAge() {
           return age;
       }
   
   }
   
   

2. 序列化过程
   (1) 首先定义文件存储位置：

   private static String file = "D:\\Serializable";
   

   (2) 实现writeUser方法

       private static void writeUser() {
   
           User user = new User();
           user.setId(10);
           user.setName("Jerry");
           user.setAge(20);
   
           try {
               ObjectOutputStream outputStream = new ObjectOutputStream(new FileOutputStream(new File(file)));
               outputStream.writeObject(user);
               outputStream.close();
   
               System.out.println("Serializable success");
           } catch (IOException e) {
               e.printStackTrace();
               System.out.println("Error writeUser: " + e);
           }
       }
   

   (3) 实现readUser方法

       private static void readUser() {
           User user = null;
   
           try {
               ObjectInputStream inputStream = new ObjectInputStream(new FileInputStream(new File(file)));
   
               user = (User) inputStream.readObject();
   
               System.out.println("Deserializable success");
   
               System.out.println("User ID: " + user.getId() + "\nUser Name: " + user.getName() + "\nUser Age: " + user.getAge());
           } catch (IOException | ClassNotFoundException e) {
               e.printStackTrace();
               System.out.println("Error readUser: " + e);
           }
       }
   

   (4) 完善main方法

       public static void main(String[] args) {
           writeUser();
           readUser();
       }
   

   (5) 打印

   Serializable success
   Deserializable success
   User ID: 10
   User Name: Jerry
   User Age: 20
   

   这样，一个序列化/反序列化演示完成。

三、总结

1. 被序列化的类需要继承Serializable接口。
2. Java建议用户定义serialVersionUID数值，且在网络传输中，serialVersionUID不一致，会导致反序列化不成功。
3. 静态变量不能被序列化，因为序列化保存的是对象的状态，静态变量属于类的状态。
4. 当一个父类实现序列化，子类自动实现序列化，不需要显式实现Serializable接口。一个子类实现了 Serializable 接口，它的父类都没有实现 Serializable 接口，要想将父类对象也序列化，就需要让父类也实现Serializable 接口。

四、参考文章

1. Serializable 1
2. Serializable 2
3. 官方文档