Java对象序列化

1、Java序列化概述

Java 提供了一种对象序列化的机制，该机制中，一个对象可以被表示为一个字节序列，该字节序列包括该对象的数据、有关对象的类型的信息和存储在对象中数据的类型。

将序列化对象写入文件之后，可以从文件中读取出来，并且对它进行反序列化，也就是说，对象的类型信息、对象的数据，还有对象中的数据类型可以用来在内存中新建对象。

整个过程都是 Java 虚拟机（JVM）独立的，也就是说，在一个平台上序列化的对象可以在另一个完全不同的平台上反序列化该对象。

序列化机制：

对象序列化机制允许把内存中的Java对象转换成平台无关的二进制流，从而允许把这种二进制流持久地保存在磁盘上，或通过网络将这种二进制流传输到另一个网络节点。当其它程序获取了这种二进制流，就可以恢复成原来的Java对象(反序列化)。

序列化的实现

序列化好处在于可将任何实现了Serializable接口的对象转化为字节数据，使其在保存和传输时可被还原
序列化是 RMI（Remote Method Invoke – 远程方法调用）过程的参数和返回值都必须实现的机制，而 RMI 是 JavaEE 的基础。因此序列化机制是 JavaEE 平台的基础
如果需要让某个对象支持序列化机制，则必须让对象所属的类及其属性是可序列化的
- 为了让某个类是可序列化的，该类必须实现如下两个接口之一。否则，会抛出NotSerializableException异常
  - Serializable
  - Externalizable

序列化特点

凡是实现Serializable接口的类都有一个表示序列化版本标识符的静态变量：

private static final long serialVersionUID;
serialVersionUID用来表明类的不同版本间的兼容性。简言之，其目的是以序列化对象进行版本控制，有关各版本反序列化时是否兼容。
如果类没有显示定义这个静态常量，它的值是Java运行时环境根据类的内部细节自动生成的。但是若类的实例变量做了修改，serialVersionUID 可能发生变化。故建议， 显式声明。
简单来说，Java的序列化机制是通过在运行时判断类的serialVersionUID来验证版本一致性的。在进行反序列化时，JVM会把传来的字节流中的 serialVersionUID与本地相应实体类的serialVersionUID进行比较，如果相同就认为是一致的，可以进行反序列化，否则就会出现序列化版本不一致的异常InvalidCastException

序列化的实现

ObjectInputStream和OjbectOutputSteam

这两个实现类是用于存储和读取基本数据类型数据或对象的处理流。它的强大之处就是可以把Java中的对象写入到数据源中，也能把对象从数据源中还原回来。
序列化：用ObjectOutputStream类保存基本类型数据或对象的机制
反序列化：用ObjectInputStream类读取基本类型数据或对象的机制
ObjectOutputStream和ObjectInputStream不能序列化static和transient修饰的成员变量

2、序列化过程

若某个类实现了 Serializable 接口，该类的对象就是可序列化的

创建一个 ObjectOutputStream 对象流
调用 ObjectOutputStream 对象的 writeObject(object obj) 方法输出可序列化对象
注意写出一次，操作flush()一次

强调：如果某个类的属性不是基本数据类型或 String 类型，而是另一个引用类型，那么这个引用类型必须是可序列化的，否则拥有该类型的 Field 的类也不能序列化。【基本数据类型包装类或 String 类型已经实现了 Serializable 接口，所以是可以序列化的】

使用ObjectOutputStream实现

序列化即将内存中的java对象保存到磁盘中或通过网络传输出去
String实现了 Serializable 接口，所以可以实例化，所以可以将String对象序列化之后保存在磁盘中

@Test  
public void testObjectOutputStream(){  
    ObjectOutputStream oos = null;  
    try {  
        //1.  处理流要包含节点流
        oos = new ObjectOutputStream(new FileOutputStream("object.dat"));  
        //2.  把字符串给他序列化起来保存在文件object.dat文件中
        oos.writeObject(new String("我爱北京天安门"));  
        oos.flush();//刷新操作    
    } catch (IOException e) {  
        e.printStackTrace();  
    } finally {  
        if(oos != null){  
            try {  
                oos.close();  
            } catch (IOException e) {  
                e.printStackTrace();  
            } 
        }
    }
}
复制代码

文件中的内容为：

乱码：
复制代码

3、反序列化

反序列化：将磁盘文件中的对象还原为内存中的一个java对象

创建一个 ObjectInputStream
调用 readObject() 方法读取流中的对象，它的返回值为Object，因此，你需要将它转换成合适的数据类型。

public final Object readObject() throws IOException, 
                                 ClassNotFoundException
复制代码

使用ObjectInputStream来实现

第2步序列化过程中，我们将字符串对象序列化的保存在了文件中，因为这个文件里面内容是乱码，必须经过反序列化才能把它读取出来

@Test  
public void testObjectInputStream(){  
    ObjectInputStream ois = null;  
    try {  
        ois = new ObjectInputStream(new FileInputStream("object.dat"));  
        //将对象读取出来
        Object obj = ois.readObject();  
        String str = (String) obj; //强转
        System.out.println(str);    
    } catch (IOException e) {  
        e.printStackTrace();  
    } catch (ClassNotFoundException e) {  
        e.printStackTrace();  
    } finally {  
        if(ois != null){  
            try {  
                ois.close();  
            } catch (IOException e) {  
                e.printStackTrace();  
            }  
        } 
    }
}
复制代码

反序列化之后的输出结果

我爱北京天安门
复制代码

这里要注意以下要点：

readObject() 方法中的 try/catch代码块尝试捕获 ClassNotFoundException 异常。对于 JVM 可以反序列化对象，它必须是能够找到字节码的类。如果JVM在反序列化对象的过程中找不到该类，则抛出一个 ClassNotFoundException 异常。

注意，readObject() 方法的返回值被转化成 Employee 引用。

当对象被序列化时，属性 SSN 的值为 111222333，但是因为该属性是短暂的，该值没有被发送到输出流。所以反序列化后 Employee 对象的 SSN 属性为 0。

4、自定义类实现序列化和反序列化

4.1、自定义类序列化概述

自定义类需要满足如下的要求，方可序列化

需要实现接口：Serialiable
当前类提供一个全局常量：serialVersionUID
除了当前Person类需要实现Serializable接口之外，还必须保证其内部所有属性也必须是可序列化的
ObjectOutputStream和ObjectInputStream不能序列化static和transient修饰的成员变量

如果某个类的属性不是基本数据类型或 String 类型，而是另一个引用类型或内部类，那么这个引用类型必须是可序列化的，否则拥有该类型的 Field 的类也不能序列化。默认情况下，基本数据类型可序列化，我们的string是自动实现了Serializable接口，所以才满足序列化条件的

public final class String
    implements java.io.Serializable, Comparable<String>, CharSequence {
    /** The value is used for character storage. */
    private final char value[];

    /** Cache the hash code for the string */
    private int hash; // Default to 0

    /** use serialVersionUID from JDK 1.0.2 for interoperability */
    private static final long serialVersionUID = -6849794470754667710L;
复制代码

4.2、实例

自定义Person类

public class Person implements Serializable {
    public static final long serialVersionUID=24324234L;
    private String name;
    private int age;
 
    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
 
    public String getName() {
        return name;
    }
 
    public void setName(String name) {
        this.name = name;
    }
 
    public int getAge() {
        return age;
    }
 
    public void setAge(int age) {
        this.age = age;
    }
 
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
}
复制代码

序列化和反序列化操作

public class ObjectInputOutputStream {
    /*
    序列化过程：将内存中的java对象保存到磁盘中或通过网络传输出去
    使用ObjectOutPutStream实现
     */
    @Test
    public void test(){
        ObjectOutputStream oos=null;
        try {
            //1.
            oos=new ObjectOutputStream(new FileOutputStream(new File("object.bat")));
            oos.writeObject(new Person("Tom",23));//添加person数据
            oos.flush();//刷新操作
        }
        catch (IOException e){
            e.printStackTrace();
        }
        finally {
            if(oos!=null){
                try {
                    //3.
                    oos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
    @Test
    /*
    反序列化：将磁盘文件中的对象还原为内存中的一个Java对象
    使用ObjectInputStream
     */
    public void test1(){
        ObjectInputStream ois=null;
        try {
            ois=new ObjectInputStream(new FileInputStream(new File("object.bat")));
            Object o1 = ois.readObject();
            Person p=(Person) o1;
            System.out.println(p);
        }
        catch (IOException | ClassNotFoundException e){
            e.printStackTrace();
        }
        finally {
            if (ois!=null){
                try {
                    ois.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}
复制代码

当对象被序列化时，属性 age 的值为23，但是因为该属性是短暂的，该值没有被发送到输出流。所以反序列化后 Person对象的 age属性为 0。

5、java.io.Serializable接口的理解

谈谈你对java.io.Serializable接口的理解，我们知道它用于序列化，是空方法接口，还有其它认识吗？

public interface Serializable {
}
复制代码

实现了Serializable接口的对象，可将它们转换成一系列字节，并可在以后完全恢复回原来的样子。这一过程亦可通过网络进行。这意味着序列化机制能自动补偿操作系统间的差异。换句话说，可以先在Windows机器上创建一个对象，对其序列化，然后通过网络发给一台Unix机器，然后在那里准确无误地重新“装配”。不必关心数据在不同机器上如何表示，也不必关心字节的顺序或者其他任何细节。

由于大部分作为参数的类如String、Integer等都实现了 java.io.Serializable的接口，也可以利用多态的性质，作为参数使接口更灵活。

文章版权归作者所有，未经允许请勿转载。

THE END

后端