对象流（序列化机制）详解

一、理解对象流及序列化机制

1.对象流作用

用于存储和读取基本数据类型数据或对象的处理流。它的强大之处就是可以把Java中的对象写入到文件源中（序列化），也能把对象从文件源中还原回来（反序列化）

2.序列化机制理解

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

序列化：用ObjectOutputStream类保存基本类型数据或对象的机制
反序列化：用ObjectInputStream类读取基本类型数据或对象的机制

注意：ObjectOutputStream和ObjectInputStream不能序列化static和transient修饰的成员变量

3.序列化机制的好处

可将任何实现了Serializable接口的对象转化为字节数据，使其在保存和传输时可被还原

4.序列化注意事项

首先，如果需要让某个对象支持序列化机制，则必须让对象所属的类及其属性是可
序列化的，为了让某个类是可序列化的，该类必须实现如下两个接口之一。

1. Serializable（主要实现这个接口）
2. Externalizable

否则，会抛出NotSerializableException异常

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

/*
用来表明类的不同版本间的兼容性。
简言之，其目的是以序列化对象进行版本控制，有关各版本反序列化时是否兼容。
如果类没有显示定义这个静态常量，它的值是Java运行时环境根据类的内部细节自
动生成的。若类的实例变量做了修改，serialVersionUID 可能发生变化。故建议，
显式声明。
*/
private static final long serialVersionUID;

二、操作步骤

1.使用对象流序列化操作

1. 创建节点输出流（FileOutputStream）
2. 创建对象流（ObjectOutputStream）
3. 调用 ObjectOutputStream 对象的 writeObject(对象) 方法输出可序列化对象
4. 注意写出一次，操作flush()一次
5. 关闭流

代码展示：

public class ObjectTest {
    @Test
    public void test(){
        ObjectOutputStream oos = null;
        try {
            //1.创建节点流(文件流)
            FileOutputStream fos = new FileOutputStream("object.txt");
            //2.创建对象流,实现序列化操作
            oos = new ObjectOutputStream(fos);
            //3.调用 ObjectOutputStream 对象的 writeObject(对象) 方法输出可序列化对象
            oos.writeObject(new String("对象流很简单！"));
            //4.注意写出一次，操作flush()一次
            oos.flush();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (oos != null){
                //5.关闭流
                try {
                    oos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

注意：输出序列化对象后，需要进行反序列化操作才能得到内容！否则就是乱码！

2.使用对象流反序列化操作

1. 创建节点输出流（FileInputStream）
2. 创建对象流（ObjectInputStream）
3. 调用 ObjectOutputStream 对象的 readObject() 方法输出可序列化对象
4. 关闭流

代码展示：

public class ObjectTest {
    @Test
    public void test2(){
        ObjectInputStream ois = null;
        try {
            //1.创建节点输入流(FileInputStream)
            FileInputStream fis = new FileInputStream("object.txt");
            //2. 创建对象流（ObjectInputStream）
            ois = new ObjectInputStream(fis);
            //3.调用 ObjectOutputStream 对象的 readObject() 方法输出可序列化对象
            Object obj = ois.readObject();
            String str = (String) obj;
            System.out.println(str);
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } finally {
            //4.关闭流
            try {
                ois.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

强调：如果某个类的属性不是基本数据类型或 String 类型，而是另一个
引用类型，那么这个引用类型必须是可序列化的，否则拥有该类型的
Field 的类也不能序列化

假设我们想要通过对象流输出自定义的对象（Person）

代码展示：

/*
我们必须将自定义的对象，实现Serializable接口，
否则该对象不能进行序列化操作！
 */
public class Person  implements Serializable{
	//序列化版本标识符的静态变量
    private static final long serialVersionUID = 12321312331231L;

    private String name;
    private int age;

    public Person() {
    }

    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 class PersonTest {
    @Test
    public void test(){
        ObjectOutputStream oos = null;
        try {
            //1.创建节点流
            FileOutputStream fos = new FileOutputStream("Person.txt");
            //2.创建对象流
            oos = new ObjectOutputStream(fos);
            //3.调用方法，进行序列化操作
            oos.writeObject(new Person("Xuzhibin",20));
            //4.刷新
            oos.flush();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (oos != null){
                //5.关闭
                try {
                    oos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    @Test
    public void test1(){
        ObjectInputStream ois = null;
        try {
            //1.创建节点流
            FileInputStream fis = new FileInputStream("Person.txt");
            //2.创建对象流
            ois = new ObjectInputStream(fis);
            //3.调用方法进行反序列化操作
            Object obj = ois.readObject();
            Person p = (Person) obj;
            System.out.println(p);
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } finally {
            //4.关闭流
            try {
                ois.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

先运行序列化操作，再运行非序列化操作，得到结果如下，大功告成！：