Java 之 Serializable 序列化和反序列化的概念及详细解释

朴灿烈づ我的快乐病毒、 2022-05-18 10:39 36阅读 0赞

## 一、序列化和反序列化的概念 ##

**       把对象转换为字节序列的过程称为对象的序列化**。  
　　**把字节序列恢复为对象的过程称为对象的反序列化**。  
　　对象的序列化主要有两种用途：  
　　1） 把对象的字节序列永久地保存到硬盘上，通常存放在一个文件中；  
　　2） 在网络上传送对象的字节序列。

在很多应用中，需要对某些对象进行序列化，让它们离开内存空间，入住物理硬盘，以便长期保存。比如最常见的是Web服务器中的Session对象，当有 10万用户并发访问，就有可能出现10万个Session对象，内存可能吃不消，于是Web容器就会把一些seesion先序列化到硬盘中，等要用了，再把保存在硬盘中的对象还原到内存中。

当两个进程在进行远程通信时，彼此可以发送各种类型的数据。无论是何种类型的数据，都会以二进制序列的形式在网络上传送。发送方需要把这个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()方法读取对象。

## 三、代码分析 ##

**对象序列化和反序列范例：**

**上面这些理论都比较简单，下面实际代码看看这个序列化到底能干啥，以及会产生的bug问题。**

package com.lxk.model;
     
    import java.io.Serializable;
     
    /**
     * @author lxk on 2017/11/1
     */
    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 + '\'' +
                    '}';
        }
    }

注意下，注释的代码，是一会儿要各种情况下使用的。

下面就是main方法啦

package com.lxk.test;
         
        import com.lxk.model.FlyPig;
         
        import java.io.*;
         
        /**
         * 序列化测试
         *
         * @author lxk on 2017/11/1
         */
        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;
            }
        }

对上面的2个操作文件流的类的简单说明

ObjectOutputStream代表对象输出流：

它的writeObject(Object obj)方法可对参数指定的obj对象进行序列化，把得到的字节序列写到一个目标输出流中。

ObjectInputStream代表对象输入流：

它的readObject()方法从一个源输入流中读取字节序列，再把它们反序列化为一个对象，并将其返回。

具体怎么看运行情况。

**第一种：**上来就这些代码，不动，直接run，看效果。

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

![70][]

从运行结果上看：

1，他实现了对象的序列化和反序列化。

2，transient 修饰的属性，是不会被序列化的。我设置的奥迪四个圈的车不见啦，成了null。

3，你先别着急说，这个静态变量AGE也被序列化啦。这个得另测。

**第二种：**为了验证这个**静态的属性能不能被序列化和反序列化**，可如下操作。

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

这个完了之后，意思也就是说，你先序列化个对象到文件了。这个对象是带静态变量的static。

现在修改flyPig类里面的AGE的值，给改成26吧。

然后，看下图里面的运行代码和执行结果。

![70 1][]

可以看到，刚刚序列化的269，没有读出来。而是刚刚修改的26，如果可以的话，应该是覆盖这个26，是269才对。

所以，得出结论，这个静态static的属性，他不序列化。

**第三种：示范这个 serialVersionUID 的作用和用法**

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

抛异常：NotSerializableException

![70 2][]

这个太暴力啦，不推荐这么干。

然后就是，还和上面的操作差不多，先是单独执行序列化方法。生成文件。  
然后，打开属性 addTip ，这之后，再次执行反序列化方法，看现象。

![70 3][]

抛异常：InvalidClassException 详情如下。

InvalidClassException: com.lxk.model.FlyPig;  
local class incompatible:  
stream classdesc serialVersionUID = -3983502914954951240,  
local class serialVersionUID = 7565838717623951575

解释一下：

因为我再model里面是没有明确的给这个 serialVersionUID 赋值，但是，Java会自动的给我赋值的，

这个值跟这个model的属性相关计算出来的。

我保存的时候，也就是我序列化的时候，那时候还没有这个addTip属性呢，

所以，自动生成的serialVersionUID 这个值，

在我反序列化的时候Java自动生成的这个serialVersionUID值是不同的，他就抛异常啦。

（你还可以反过来，带ID去序列化，然后，没ID去反序列化。也是同样的问题。）

再来一次，就是先序列化，这个时候，把 private static final long serialVersionUID = 1L; 这行代码的注释打开。那个addTip属性先注释掉

序列化之后，再把这个属性打开，再反序列化。看看什么情况。

![70 4][]

这个时候，代码执行OK，一切正常。good。

**这个现象对我们有什么意义：**

老铁，这个意义比较大，首先，你要是不知道这个序列化是干啥的，万一他真的如开头所讲的那样存数据库啦，socket传输啦，rmi传输啦。虽然我也不知道这是干啥的。你就给model bean 实现了个这个接口，你没写这个 serialVersionUID 那么在后来扩展的时候，可能就会出现不认识旧数据的bug，那不就炸啦吗。回忆一下上面的这个出错情况。想想都可怕，这个锅谁来背？

所以，有这么个理论，就是在**实现这个Serializable 接口的时候，一定要给这个 serialVersionUID 赋值**，就是这么个问题。

这也就解释了，我们刚刚开始编码的时候，实现了这个接口之后，为啥eclipse编辑器要黄色警告，需要添加个这个ID的值。而且还是一长串你都不知道怎么来的数字。

下面解释**这个 serialVersionUID 的值到底怎么设置才OK**。

首先，你可以不用自己去赋值，Java会给你赋值，但是，这个就会出现上面的bug，很不安全，所以，还得自己手动的来。

那么，我该怎么赋值，eclipse可能会自动给你赋值个一长串数字。这个是没必要的。

可以简单的赋值个 **1L**，这就可以啦。。这样可以确保代码一致时反序列化成功。

不同的serialVersionUID的值，会影响到反序列化，也就是数据的读取，你写1L，注意L大些。计算机是不区分大小写的，但是，作为观众的我们，是要区分1和L的l，所以说，这个值，闲的没事不要乱动，不然一个版本升级，旧数据就不兼容了，你还不知道问题在哪。。。

**下面是摘自 jdk api 文档里面关于接口 Serializable 的描述**  
类通过实现 java.io.Serializable 接口以启用其序列化功能。  
未实现此接口的类将无法使其任何状态序列化或反序列化。  
可序列化类的所有子类型本身都是可序列化的。因为实现接口也是间接的等同于继承。  
序列化接口没有方法或字段，仅用于标识可序列化的语义。  
  
**关于 serialVersionUID 的描述**  
序列化运行时使用一个称为 serialVersionUID 的版本号与每个可序列化类相关联，该序列号在反序列化过程中用于验证序列化对象的发送者和接收者是否为该对象加载了与序列化兼容的类。如果接收者加载的该对象的类的 serialVersionUID 与对应的发送者的类的版本号不同，则反序列化将会导致 InvalidClassException。可序列化类可以通过声明名为 "serialVersionUID" 的字段（该字段必须是静态 (static)、最终 (final) 的 long 型字段）显式声明其自己的 serialVersionUID：  
  
如果可序列化类未显式声明 serialVersionUID，则序列化运行时将基于该类的各个方面计算该类的默认 serialVersionUID 值，如“Java(TM) 对象序列化规范”中所述。不过，强烈建议 所有可序列化类都显式声明 serialVersionUID 值，原因是计算默认的 serialVersionUID 对类的详细信息具有较高的敏感性，根据编译器实现的不同可能千差万别，这样在反序列化过程中可能会导致意外的 InvalidClassException。因此，为保证 serialVersionUID 值跨不同 java 编译器实现的一致性，序列化类必须声明一个明确的 serialVersionUID 值。还强烈建议使用 private 修饰符显示声明 serialVersionUID（如果可能），原因是这种声明仅应用于直接声明类 -- serialVersionUID 字段作为继承成员没有用处。数组类不能声明一个明确的 serialVersionUID，因此它们总是具有默认的计算值，但是数组类没有匹配 serialVersionUID 值的要求。

本文连接：[Java 之 Serializable 序列化和反序列化的概念及详细解释][Java _ Serializable]

[70]: /images/20220518/6d3a5e69321d47c39c0c33b780bb1a09.png
[70 1]: /images/20220518/bc499447a75e4b718a283c965c48c26b.png
[70 2]: /images/20220518/f6a9ce57d45441dfa0dd3c6e03b29472.png
[70 3]: /images/20220518/c81d0d8723e0497ebb01b458c925372e.png
[70 4]: /images/20220518/feb649418d3a4b7a818e9eee202fb7b6.png
[Java _ Serializable]: http://www.lingshu.xin/article/62357631.html