序列化与反序列化

1 序列化和反序列化的概念

• 序列化：把对象转换为字节序列的过程称为对象的序列化。

• 反序列化：把字节序列恢复为对象的过程称为对象的反序列化。

  
  
  image

2 什么情况下需要序列化

• 当你想把的内存中的对象状态保存到一个文件中或者数据库中时候；
• 当你想用套接字在网络上传送对象的时候(rpc dubo)；
• 当你想通过RMI传输对象的时候；

3 如何实现序列化

3.1 怎么实现序列化

• 实现Serializable接口即可

• 实现这个Serializable 接口的时候，一定要给这个 serialVersionUID 赋值

3.2 序列化，反序列测试代码

• 序列化，反序列测试代码

public class FlyPig implements Serializable {
    //private static final long serialVersionUID = 1L;
    private static String AGE = "269";
    private String name;
    private String color;
    transient private String car;

    //private String addTip;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }

    public String getCar() {
        return car;
    }

    public void setCar(String car) {
        this.car = car;
    }

    //public String getAddTip() {
    //    return addTip;
    //}
    //
    //public void setAddTip(String addTip) {
    //    this.addTip = addTip;
    //}

    @Override
    public String toString() {
        return "FlyPig{" +
                "name='" + name + '\'' +
                ", color='" + color + '\'' +
                ", car='" + car + '\'' +
                ", AGE='" + AGE + '\'' +
                //", addTip='" + addTip + '\'' +
                '}';
    }
}
public class SerializableTest {  
    public static void main(String[] args) throws Exception {  
        serializeFlyPig();  
        FlyPig flyPig = deserializeFlyPig();  
        System.out.println(flyPig.toString());  
    }    
    /** 
     * 序列化 
     */  
    private static void serializeFlyPig() throws IOException {  
        FlyPig flyPig = new FlyPig();  
        flyPig.setColor("black");  
        flyPig.setName("naruto");  
        flyPig.setCar("0000");  
        // ObjectOutputStream 对象输出流，将 flyPig 对象存储到E盘的 flyPig.txt 文件中，完成对 flyPig 对象的序列化操作  
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(new File("d:/flyPig.txt")));  
        oos.writeObject(flyPig);  
        System.out.println("FlyPig 对象序列化成功！");  
        oos.close();  
    }  
    /** 
     * 反序列化 
     */  
    private static FlyPig deserializeFlyPig() throws Exception {  
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream(new File("d:/flyPig.txt")));  
        FlyPig person = (FlyPig) ois.readObject();  
        System.out.println("FlyPig 对象反序列化成功！");  
        return person;  
    }  
}  

实际运行结果，他会在 d:/flyPig.txt 生成个文件

FlyPig 对象序列化成功！
FlyPig 对象反序列化成功！
FlyPig{name='naruto', color='black', car='null', AGE='269'}

从运行结果上看：

1，他实现了对象的序列化和反序列化。
2，transient 修饰的属性，是不会被序列化的。我设置的奥迪四个圈的车不见啦，成了null。my god。
3，你先别着急说，这个静态变量AGE也被序列化啦。这个得另测。

3.3 验证静态的属性能不能被序列化和反序列化

private static String AGE = "26";

public static void main(String[] args) throws Exception {  
    //serializeFlyPig();  
    FlyPig flyPig = deserializeFlyPig();  
    System.out.println(flyPig.toString());  
} 

这个完了之后，意思也就是说，你先序列化个对象到文件了。这个对象是带静态变量的static。
现在修改flyPig类里面的AGE的值，给改成26吧。
然后，看下图里面的运行代码和执行结果。

FlyPig 对象反序列化成功！
FlyPig{name='naruto', color='black', car='null', AGE='26'}

• 可以看到，刚刚序列化的269，没有读出来。而是刚刚修改的26，如果可以的话，应该是覆盖这个26，是269才对。
• 所以，得出结论，这个静态static的属性，他不序列化。

3.4 示范serialVersionUID 的作用和用法

• 最暴力的改法，直接把model的类实现的这个接口去掉。然后执行后面的序列化和反序列化的方法。直接报错。
• 抛异常：NotSerializableException（序列化异常）

Exception in thread "main" java.io.NotSerializableException: com.doordu.soa.service.web.FlyPig
    at java.io.ObjectOutputStream.writeObject0(Unknown Source)
    at java.io.ObjectOutputStream.writeObject(Unknown Source)
    at com.doordu.soa.service.web.SerializableTest.serializeFlyPig(SerializableTest.java:26)
    at com.doordu.soa.service.web.SerializableTest.main(SerializableTest.java:12)

• 抛异常：InvalidClassException(反序列化异常)详情如下。

Exception in thread "main" java.io.InvalidClassException: com.doordu.soa.service.web.FlyPig; class invalid for deserialization
    at java.io.ObjectStreamClass$ExceptionInfo.newInvalidClassException(Unknown Source)
    at java.io.ObjectStreamClass.checkDeserialize(Unknown Source)
    at java.io.ObjectInputStream.readOrdinaryObject(Unknown Source)
    at java.io.ObjectInputStream.readObject0(Unknown Source)
    at java.io.ObjectInputStream.readObject(Unknown Source)
    at com.doordu.soa.service.web.SerializableTest.deserializeFlyPig(SerializableTest.java:35)
    at com.doordu.soa.service.web.SerializableTest.main(SerializableTest.java:13)

解释一下：*

因为我再model里面是没有明确的给这个 serialVersionUID 赋值，但是，Java会自动的给我赋值的，这个值跟这个model的属性相关计算出来的。我保存的时候，也就是我序列化的时候，那时候还没有这个addTip属性呢，
所以，自动生成的serialVersionUID 这个值，
在我反序列化的时候Java自动生成的这个serialVersionUID值是不同的，他就抛异常啦。

4 jdk api 文档里面关于接口 Serializable 的描述

• 类通过实现 java.io.Serializable 接口以启用其序列化功能。
• 未实现此接口的类将无法使其任何状态序列化或反序列化。
• 可序列化类的所有子类型本身都是可序列化的。因为实现接口也是间接的等同于继承。
• 序列化接口没有方法或字段，仅用于标识可序列化的语义。

5 关于serialVersionUID 的描述

• 序列化运行时使用一个称为 serialVersionUID 的版本号与每个可序列化类相关联，该序列号在反序列化过程中用于验证序列化对象的发送者和接收者是否为该对象加载了与序列化兼容的类。
• 如果接收者加载的该对象的类的 serialVersionUID 与对应的发送者的类的版本号不同，则反序列化将会导致 InvalidClassException。可序列化类可以通过声明名为
• “serialVersionUID” 的字段（该字段必须是静态 (static)、最终 (final) 的 long 型字段）显式声明其自己的 serialVersionUID：
• 如果可序列化类未显式声明 serialVersionUID，则序列化运行时将基于该类的各个方面计算该类的默认 serialVersionUID 值，如“Java(TM) 对象序列化规范”中所述。

不过，强烈建议 所有可序列化类都显式声明 serialVersionUID 值，原因是计算默认的 serialVersionUID 对类的详细信息具有较高的敏感性，根据编译器实现的不同可能千差万别，这样在反序列化过程中可能会导致意外的 InvalidClassException。因此，为保证 serialVersionUID 值跨不同 java 编译器实现的一致性，序列化类必须声明一个明确的 serialVersionUID 值。还强烈建议使用 private 修饰符显示声明
serialVersionUID（如果可能），原因是这种声明仅应用于直接声明类 – serialVersionUID 字段作为继承成员没有用处。数组类不能声明一个明确的 serialVersionUID，因此它们总是具有默认的计算值，但是数组类没有匹配 serialVersionUID 值的要求。