java基础知识回顾之javaIO类--java序列化和反序列化

/**
 *
 * 一：理解序列化反序列化及其应用
 * 序列化：把堆内存的对象转化成字节流的过程。
 * 反序列化：把字节流序列恢复重构成对象的过程。
 * 对象的序列化的用途：1.把对象的字节序列持久化，保存到硬盘上，通常是文件当中。
 *               2.将对象变成字节流在网络上传输
 * 在很多应用当中，需要对某些对象进行序列化，让他们离开堆内存空间，持久化到硬盘上，以便长期保存。
 * 比如最常见的web服务器中的Session对象，当有10万个用户并发访问，就有可能出现10万个Session对象，
 * 内存吃不消，于是web容器就会把一些Session对象序列化到硬盘上，等要用了在把硬盘中字节序列读到内存中。
 * 而不需要重新创建对象。
 *
 * 再比如，分布式系统在进行网络传输，当两个进程在进行远程通信的时候，在网络上彼此可以发送
 * 各种类型的数据，无论是何种类型的数据都会以二进制的形式在网络上传输。这就用到序列化，将java对象转化成字节序列
 * ，才能在网络上传送，接受方可以把字节序列在恢复为java对象
 *
 * 二、JDK类库中的序列化API
 *
　　java.io.ObjectOutputStream代表对象输出流，它的writeObject(Object obj)方法可对参数指定的obj对象进行序列化，把得到的字节序列写到一个目标输出流中。
　　java.io.ObjectInputStream代表对象输入流，它的readObject()方法从一个源输入流中读取字节序列，再把它们反序列化为一个对象，并将其返回。
　　只有实现了Serializable和Externalizable接口的类的对象才能被序列化。Externalizable接口继承自 Serializable接口，实现Externalizable接口的类完全由自身来控制序列化的行为，而仅实现Serializable接口的类可以 采用默认的序列化方式 。
　　对象序列化包括如下步骤：
　　1） 创建一个对象输出流，它可以包装一个其他类型的目标输出流，如文件输出流；
　　2） 通过对象输出流的writeObject()方法写对象。

　　对象反序列化的步骤如下：
　　1） 创建一个对象输入流，它可以包装一个其他类型的源输入流，如文件输入流；
　　2） 通过对象输入流的readObject()方法读取对象。
 *
 */

import java.io.Serializable;

public class Person1 implements Serializable{

    /**
     * Serializable:用于给被序列化的类加入ID号，用于判断类和对象是否是同一个版本号
     */
    private static final long serialVersionUID = 1L;
    private String name;
    private  int age;

    public Person1(String name, int age) {
        super();
        this.name = name;
        this.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 class ObjectStreamDemo {

    /**
     * @param args
     * @throws IOException
     * @throws ClassNotFoundException
     */
    public static void main(String[] args) throws IOException, ClassNotFoundException {

        writeObj();//对象序列化
        readObj();//反序列化
    }
    /**
     * 反序列化
     * @throws IOException
     * @throws ClassNotFoundException
     * 对象的反序列化，Person.class文件和obj.object才能实现反序列化
     */
    public static void readObj() throws IOException, ClassNotFoundException {

        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("lp.object"));
        //对象的反序列化。
        Person1 p = (Person1)ois.readObject();
        Person1 p1 = (Person1)ois.readObject();
        System.out.println(p.getName()+":"+p.getAge());
        System.out.println(p1.getName()+":"+p1.getAge());
        ois.close();

    }
    /**
     * 持久化对象到文件上，如果对象没有实现Serializable接口，就不能被序列化
     * 把堆内存的对象生命周期延长，存放到硬盘上进行持久化，不需要解析，下次我们需要对象，不需要new，直接从硬盘上读重构对象
     * @throws IOException
     * @throws IOException
     */
    public static void writeObj() throws IOException, IOException {

        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("lp.object"));
        //对象序列化。  被序列化的对象必须实现Serializable接口。
        oos.writeObject(new Person1("小强",30));
        oos.writeObject(new Person1("lp",40));

        oos.close();
    }

}

输出结果为：小强:30

lp:40

序列化后在项下面生成了lp.object文件，而反序列化是读取lp.object文件重构了对象。

serialVersionUID的作用：是用于给被序列化的类加入ID号，用于判断类和对象是否是同一个版本号。

假设我们一开始没有在Person类中没有添加这个版本号，系统默认的序列化运行时会根据类名，接口名，属性名，方法名等等(该类的各个方面)生成一个默认的serialVersionUID序列化版本号来唯一标识此类。加入我们没有加入serialVersionUID，代码如下：

public class Person1 implements Serializable/*标记接口*/ {

    private String name;
    private  int age;

    public Person1(String name, int age) {
        super();
        this.name = name;
        this.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;
    }

}

我们调用上面的代码中writeObj()方法，对要序列化的对象进行序列化，然后调用readObj()反序列化，输出结果为：

小强:30
lp:40

好的，我们在对Person类做一个小小的修改，把private int age的名字变为public int age，其它的都不改变。调用readObj（）反序列化，发现，程序报错了：

Exception in thread "main" java.io.InvalidClassException: 无效的类错误

com.lp.io.p2.bean.Person1; local class incompatible: stream classdesc serialVersionUID = -4619097973205016437, local class serialVersionUID = -7230327405276836859

出现了两个serialVersionUID 序列号，而且不一样，我们只修改了那么一点，为什么反序列化会报错呢？

通过看API发现，默认的 serialVersionUID 对类的详细信息具有较高的敏感性，根据编译器的不同可能会千差万别，即使我们在要序列化的类中多加一个空格可能导致serialVersionUID版本号截然不同，编译器会重新生成一个版本号。由于序列版本号是标识序列化类的ID,由于修改前和修改后生成的序列化ID不同，所以java虚拟机认为加载的class有问题，所以报类无效的错误。所以当要改动要序列化的类的时候，最好显示的申明serialVersionUID值，这样当你对这个Person类有小小的改动的时候，只要serialVersionUID值没有改变，就不会抛出以上的异常。

最后总结：要序列化的类必须实现Serializable接口，只有实现了这个接口才能被序列化，反序列化。在序列化的类中最好显示的申明serialVersionUID值。