Java的序列化与反序列化

1 什么是序列化
序列化就是将对象转化为字节流，反序列化就是将字节流转化为对象。

2 如何实现序列化
在Java中，要想实现类的序列化和反序列化，只要让这个类实现java.io.Serializable即可。比如下面的代码：
Employee类

    import java.io.Serializable;
    import java.math.BigDecimal;
    
    public class Employee implements Serializable {
        private  static final long serialVersionUID =2020061201007L;
        private  String name;
        private  Integer age;
        private  String gender;
        private  String mobile;
        private  String address;
        private  BigDecimal salary;
        private  String department;
    
        public Employee(){}
    
        @Override
        public String toString() {
            return "Employee{" +
                    "name='" + name + '\'' +
                    ", age=" + age +
                    ", gender='" + gender + '\'' +
                    ", mobile='" + mobile + '\'' +
                    ", address='" + address + '\'' +
                    ", salary=" + salary +
                    ", department='" + department + '\'' +
                    '}';
        }
    
        public Employee(String name, Integer age, String gender, String mobile, String  address, BigDecimal salary, String deparment) {
            this.name = name;
            this.age = age;
            this.gender = gender;
            this.mobile = mobile;
            this.address = address;
            this.salary = salary;
            this.department = deparment;
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public Integer getAge() {
            return age;
        }
    
        public void setAge(Integer age) {
            this.age = age;
        }
    
        public String getGender() {
            return gender;
        }
    
        public void setGender(String gender) {
            this.gender = gender;
        }
    
        public String getMobile() {
            return mobile;
        }
    
        public void setMobile(String mobile) {
            this.mobile = mobile;
        }
    
        public String getAddress() {
            return address;
        }
    
        public void setAddress(String address) {
            this.address = address;
        }
    
        public BigDecimal getSalary() {
            return salary;
        }
    
        public void setSalary(BigDecimal salary) {
            this.salary = salary;
        }
    
        public String getDepartment() {
            return department;
        }
    
        public void setDepartment(String deparment) {
            this.department = deparment;
        }
    }

Test类

    import java.io.*;
    import java.math.BigDecimal;
    
    public class Test {
        public static void main(String[] args) throws IOException, ClassNotFoundException {
            ObjectOutputStream oos =new ObjectOutputStream(new FileOutputStream("file/employee.txt"));
            Employee employee=new Employee();
            employee.setName("宋蔚然");
            employee.setAddress("江苏南京");
            employee.setAge(20);
            employee.setDepartment("英语");
            employee.setGender("女");
            employee.setMobile("18011445566");
            employee.setSalary(new BigDecimal(10000000.00));
            oos.writeObject(employee);
            oos.flush();
            oos.close();
            ObjectInputStream ois=new ObjectInputStream(new FileInputStream("file/employee.txt"));
            Employee e=(Employee) ois.readObject();
            ois.close();
            System.out.println(e);
        }
    }

employee.txt文件中内容如下：

程序运行结果如下：

    Employee{name='宋蔚然', age=20, gender='女', mobile='18011445566', address='江苏南京', salary=10000000, department='英语'}

代码分析：
声明实现了Serializable接口后，保存/读取Employee对象就可以使用ObjectOutputStream/ObjectInputStream流了。ObjectOutputStream是OutputStream的子类，但实现了Object-Output接口。ObjectOutput是DataOutput的子接口，增加了一个方法：

    public void writeObject（Object obj） throws IOException

这个方法能够将对象obj转化为字节，写到流中。

ObjectInputStream是InputStream的子类，它实现了ObjectInput接口。ObjectInput是DataInput的子接口，增加了一个方法：

    public Object readObject（） throws ClassNotFoundException，IOException

这个方法能够从流中读取字节，转化为一个对象。

使用这两个流，就能将对象转换成字节流（序列化）以及读取字节流转化成一个对象。

3 序列化的注意事项
1）如果类的字段表示的就是类的逻辑信息，如上面的Employee类，那就可以使用默认序列化机制，只要声明实现Serializable接口即可。
2）否则的话，如LinkedList，那就可以使用transient关键字，实现writeObject和readObject自定义序列化过程。
3）Java的序列化机制可以自动处理如引用同一个对象、循环引用等情况。
4）序列化时，如果对象没有实现Serializable，在调用writeObject时NotSerializableException异常。
5）在解析字节流时，对于引用到的类型信息，会动态加载，如果找不到类，会抛出ClassNotFoundException。