Java -- 序列化(Serializable)

不念不忘少年蓝@ 2022-11-16 01:35 166阅读 0赞

### 一、前言 ###

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.  [官方文档][Link 1]

[Serializable 1]: https://blog.csdn.net/u011568312/article/details/57611440
[Serializable 2]: https://baijiahao.baidu.com/s?id=1633305649182361563&wfr=spider&for=pc
[Link 1]: https://docs.oracle.com/javase/8/docs/api/java/io/Serializable.html