关于Serializable的一篇笔记

矫情吗；* 2023-09-25 20:25 51阅读 0赞

最近在学习代码规范的时候POJO中用到了VO, DTO, entity这些东西, 然后发现实体类的代码中都会有 implements serializable 这段代码, 然后来网上学学这段代码的用处, 发现很多人都是和我一样接触到代码规范来进行的记录  
![在这里插入图片描述][d26f4596ef724ed5ab1232fb70657bb1.png]  
在程序中为了能直接以 Java 对象的形式进行保存(持久化保存, 序列化就是保存, 反序列化就是读取)，然后再重新得到该 Java 对象，这就需要**序列化能力**。序列化其实可以看成是一种机制，按照一定的格式将 Java 对象的某状态转成介质可接受的形式，以方便存储或传输。其实想想就大致清楚基本流程，序列化时将 Java 对象相关的类信息、属性及属性值等等保存起来，反序列化时再根据这些信息构建出 Java 对象。而过程可能涉及到其他对象的引用，所以这里引用的对象的相关信息也要参与序列化。

> 注: Serializable主要作用将类的实例持久化保存，序列化就是保存，反序列化就是读取。保存也不一定保存在本地，也可以保存到远方。类一定要实现Serializable才可以(也可以是Externalizable 接口)

**序列化的作用?**

*  提供一种简单又可扩展的对象保存恢复机制。
 *  对于远程调用，能方便对对象进行编码和解码，就像实现对象直接传输。
 *  可以将对象持久化到介质中，就像实现对象直接存储。
 *  允许对象自定义外部存储的格式。

**什么时候要进行序列化?**  
在存储时需要序列化，这是肯定的。大家知道的是序列化是将对象进行流化存储，我们有时候感觉自己在项目中并没有进行序列化操作，也一样是存进去了，那么对象需要经过序列化才能存储的说法，似乎从这儿就给阉割了。事实究竟是怎样的呢？

首先看我们常用的数据类型类声明：  
`public final class String implements java.io.Serializable, Comparable<String>, CharSequence`  
`public class Date implements java.io.Serializable, Cloneable, Comparable`

而像其他int、long、boolean类型等，都是基本数据类型，*数据库里面有与之对应的数据结构*。从上面的类声明来看，我们以为的没有进行序列化，其实是在声明的各个不同变量的时候，由具体的数据类型帮助我们实现了序列化操作。

到这儿的时候，就又有一个问题，既然实体类的变量都已经帮助我们实现了序列化，为什么我们仍然要显示的让类实现serializable接口呢？

注意以上的说法：首先，序列化的目的有两个，

1.  第一个是便于存储，
2.  第二个是便于传输。

我们一般的实体类不需要程序员再次实现序列化的时候，请想两个问题：第一：存储媒体里面，是否是有其相对应的数据结构？第二：这个实体类，是否需要远程传输（或者两个不同系统甚至是分布式模块之间的调用）？

如果有人打开过Serializable接口的源码，就会发现，这个接口其实是个**空接口**，那么这个序列化操作，到底是由谁去实现了呢？其实，看一下接口的注释说明就知道，当我们让实体类实现Serializable接口时，其实是在告诉JVM此类可被序列化，可被默认的序列化机制序列化。

public interface Serializable {
        
    }

然后来写代码实践一下看看Serializable是如何序列化Java对象的.创建一个类SClass（序列化类），增加name和age两个属性，并创建Getter和Setter方法。

public class SClass {
        
        private String name;
        private Integer age;
    
        public String getName() {
        
            return name;
        }
    
        public void setName(String name) {
        
            this.name = name;
        }
    
        public Integer getAge() {
        
            return age;
        }
    
        public void setAge(Integer age) {
        
            this.age = age;
        }
    }

再创建一个测试类，通过ObjectOutputStream将一个SClass对象写入文件中，这个实际上就是一种序列化的过程；再通过ObjectInputSream将SClass对象读取出来，这个实际上就是一个反序列化的过程。

public class Test {
        
        public static void main(String[] args) {
        
            // 初始化
            SClass sclass = new SClass();
            sclass.setName("王二");
            sclass.setAge(18);
            System.out.println(sclass);
            // 把对象写到文件中
            try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("file"));){
        
                oos.writeObject(sclass);
            } catch (IOException e) {
        
                e.printStackTrace();
            }
            // 从文件中读出对象
            try (ObjectInputStream ois = new ObjectInputStream(new FileInputStream(new File("file")));){
        
                SClass sclass1 = (SClass) ois.readObject();
                System.out.println(sclass1);
            } catch (IOException | ClassNotFoundException e) {
        
                e.printStackTrace();
            }
        }
    }

运行一下会发现出现报错, 这是由于SClass没有实现Serializable接口，所以系统会报错。  
![在这里插入图片描述][5072b2fd15cd4b9a9d3b8ee1b2609368.png]  
顺着堆栈信息，我们来看一下 ObjectOutputStream 的 writeObject0() 方法。其部分源码如下：

if (obj instanceof String) {
        
        writeString((String) obj, unshared);
    } else if (cl.isArray()) {
        
        writeArray(obj, desc, unshared);
    } else if (obj instanceof Enum) {
        
        writeEnum((Enum<?>) obj, desc, unshared);
    } else if (obj instanceof Serializable) {
        
        writeOrdinaryObject(obj, desc, unshared);
    } else {
        
        if (extendedDebugInfo) {
        
            throw new NotSerializableException(
                cl.getName() + "\n" + debugInfoStack.toString());
        } else {
        
            throw new NotSerializableException(cl.getName());
        }
    }

这段代码的意思是，`ObjectOutPutStream` 在序列化的时候，会判断对象的类型，如果不是字符串、数组、枚举、Serializable的湖锕，会抛出`NotSerializableException` 。  
但是，如果SClass实现了`Serializable`接口的话，就可以被序列化和反序列化了。

具体是**怎么序列化**的呢？  
以`ObjectOutputStream`为例，它在序列化的时候会依次调用

> writeObject()→writeObject0()→writeOrdinaryObject()→writeSerialData()→invokeWriteObject()→`defaultWriteFields()`

`defaultWriteFields方法`为真正将对象序列化的接口。

那怎么**反序列化**呢？  
以 `ObjectInputStream` 为例，它在反序列化的时候会依次调用

> readObject()→readObject0()→readOrdinaryObject()→readSerialData()→`defaultReadFields()`

`defaultReadFields方法`为真正将对象反序列化的接口

所以Serializable接口仅仅是起到了标识的作用，告诉程序，他可以被序列化。

补充:  
1.static 和 transient 修饰的字段是不会被序列化的。  
因为序列化保存的是对象的状态，而 static 修饰的字段属于类的状态，因此可以证明序列化并不保存 static 修饰的字段。  
transient 的中文字义为“临时的”（论英语的重要性），它可以阻止字段被序列化到文件中，在被反序列化后，transient 字段的值被设为初始值，比如 int 型的初始值为 0，对象型的初始值为 null。

2.除了 Serializable 之外，Java 还提供了一个序列化接口 Externalizable（念起来有点拗口）。

3.`serialVersionUID` 被称为序列化 ID，它是决定 Java 对象**能否反序列化成功的重要因子**。在反序列化时，Java 虚拟机会把字节流中的 `serialVersionUID`与被序列化类中的`serialVersionUID` 进行比较，如果相同则可以进行反序列化，否则就会抛出序列化版本不一致的异常。

我的其他文章:  
[关于serialVersionUID的作用解释说明][serialVersionUID]

参看文章(侵删):  
[https://www.cnblogs.com/tentacion/p/11356174.html][https_www.cnblogs.com_tentacion_p_11356174.html]  
[Java中Serializable接口的作用是什么][Java_Serializable]  
[谈谈实现Serializable接口的作用和必要性][Serializable]

[d26f4596ef724ed5ab1232fb70657bb1.png]: https://img-blog.csdnimg.cn/d26f4596ef724ed5ab1232fb70657bb1.png
[5072b2fd15cd4b9a9d3b8ee1b2609368.png]: https://img-blog.csdnimg.cn/5072b2fd15cd4b9a9d3b8ee1b2609368.png
[serialVersionUID]: https://blog.csdn.net/mfysss/article/details/129233277?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522168010397516800226580803%2522%252C%2522scm%2522%253A%252220140713.130102334.pc%255Fblog.%2522%257D&request_id=168010397516800226580803&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2~blog~first_rank_ecpm_v1~rank_v31_ecpm-1-129233277-null-null.blog_rank_default&utm_term=Serializable&spm=1018.2226.3001.4450
[https_www.cnblogs.com_tentacion_p_11356174.html]: https://www.cnblogs.com/tentacion/p/11356174.html
[Java_Serializable]: https://www.yisu.com/zixun/574439.html
[Serializable]: https://www.jianshu.com/p/4935a87976e5