Java序列化详解

绝地灬酷狼 2021-12-10 14:17 137阅读 0赞

转载自[https://mp.weixin.qq.com/s?\_\_biz=MzU2MzYzNTc2OA==&mid=2247483681&idx=1&sn=8784dfc4d33e3ef7c0a77a74c1598d7b&chksm=fc567276cb21fb60f48d4f13eaf6cd57ea5981b554281779a9e6bfc2f87407ee58914906ac3b&mpshare=1&scene=1&srcid=&key=cc7d6364edc5eb3e0b3de9e60f7f330c77369d86f1ed0b2747bab982d5d1454e401d9580dbf14f82f02c090ebf06a9f502df33f67bcb698759662cf31f0f74f4faa00650b95bca26075ba9eb7696671b&ascene=1&uin=ODI5ODM4ODI1&devicetype=Windows%2010&version=62060833&lang=zh\_CN&pass\_ticket=6i2Zvg5ibYNpXt%2bSFhtH%2bGtSKThvxgPP7ygap4M2hCcdDn4daqlWBaFwAObXWQ15][https_mp.weixin.qq.com_s_biz_MzU2MzYzNTc2OA_mid_2247483681_idx_1_sn_8784dfc4d33e3ef7c0a77a74c1598d7b_chksm_fc567276cb21fb60f48d4f13eaf6cd57ea5981b554281779a9e6bfc2f87407ee58914906ac3b_mpshare_1_scene_1_srcid_key_cc7d6364edc5eb3e0b3de9e60f7f330c77369d86f1ed0b2747bab982d5d1454e401d9580dbf14f82f02c090ebf06a9f502df33f67bcb698759662cf31f0f74f4faa00650b95bca26075ba9eb7696671b_ascene_1_uin_ODI5ODM4ODI1_devicetype_Windows_2010_version_62060833_lang_zh_CN_pass_ticket_6i2Zvg5ibYNpXt_2bSFhtH_2bGtSKThvxgPP7ygap4M2hCcdDn4daqlWBaFwAObXWQ15]

--------------------

**目录**

1 什么是序列化和反序列化？

2 市面上的几种序列化方式

3 为什么需要序列化和反序列化?

4 Java原生序列化实现

5 关于serialVersionUID

6 序列化机制算法

7 如何实现选择序列化?

7.1 transient

7.2 writeObject()方法 与 readObject()方法

7.3 Externalizable接口

8 单例模式的序列化

9 反序列化漏洞

10 序列化对象注意事项

--------------------

# **1 什么是序列化和反序列化？** #

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

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

--------------------

# **2 市面上的几种序列化方式** #

1. 利用Java自带的序列化功能（实现Serializable接口）。一般是需要加密传输时才用这种方式。此方式会将数据序列化成**字节流。**缺点是**性能一般**，且**不支持跨语言**。

2.**Json序列化**。将对象包装成**JSON字符串**（**字符流**）

**Json序列化工具**有**Jackson**、**FastJson**或者GJson，它们各有**优**缺点：

*  **JackSon**：Map、List的转换可能会出现问题。转复杂类型的Bean时，转换的Json格式不是标准的Json格式。适合处理 **大文本Json**。
 *  **FastJosn**：速度最快。将复杂类型的Bean转换成Json可能会有问题：引用类型如果没有引用被出错。适合对性能有要求的场景。
 *  **GJson**：功能最全，可以将复杂的Bean和Json字符串进行互转。性能上面比FastJson有所差距。适合处理**小文本Json**，和对于数据正确性有要求的场景。
 *

3. protoBuf工具、Hession序列化(转为**二进制流**)

性能好，效率高，字节数很小，网络传输节省IO。但**二进制格式可读性差**。

--------------------

# **3 为什么需要序列化和反序列化?** #

之所以需要序列化和反序列化，主要是因为**Java对象是在JVM中生成的，是内存中的数据**。如果需要把**对象的字节序列**远程传输或保存到硬盘上时，你就需要**将Java对象转换成二进制流**。 这个转换过程就是序列化**。**

假如别人传给你一个二进制流数据，当你想要恢复成内存中的对象时，你就需要反序列化 。

Java平台允许我们在内存中创建可复用的Java对象，但只有当JVM（Java虚拟机）处于运行时，这些对象才可能存在，也就是**这些对象的生命周期 不会比JVM的生命周期更长**。但在现实应用中，就可能要求**在JVM停止运行之后**能够保存指定的对象(**持久化对象**)，并在将来**重新读取被保存的对象**。

网络通信时，无论是何种类型的数据，都会转成**字节序列**的形式在网络上传送。发送方需要把这个Java对象**转换为字节序列**，**才能在网络上传送**；接收方则需要把字节序列再恢复为Java对象。

--------------------

# **4 Java原生序列化实现** #

实现了如下两个接口之一的类的对象才能被序列化：

> 1.  **Serializable 　　** 
> 2.  **Externalizable**

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

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

注：使用**writeObject()** 和**readObject()**方法的对象**必须已经被序列化**

--------------------

# **5 关于serialVersionUID** #

如果serialVersionUID**没有显式生成**，**系统就会自动生成一个**。此时，如果**在序列化后，**我们**将该类代码作了改动**（包括类名、接口名、方法、属性），那么**系统在反序列化时**会重新生成一个**新的serialVersionUID。**然后去和**已经序列化的对象**进行比较，就会报**序列号版本不一致**的错误。为了避免这种问题， 一般系统都会要求实现Serialiable接口的类**显式的声明一个serialVersionUID**。

所以**显式定义serialVersionUID**有如下两种用途：

1.  **希望**类的不同版本对序列化兼容时，需要确保类的不同版本具有相同的serialVersionUID；
2.  **不希望**类的不同版本对序列化兼容时，需要确保类的不同版本具有不同的serialVersionUID。

--------------------

# **6 序列化机制算法** #

1.  **所有保存到磁盘中的对象，**都有一个**序列化编号** 。
2.  当程序试图序列化一个对象时，程序先检查**该对象是否已经被序列化过**。如果从未被序列化过，系统就会将该对象转换成字节序列并输出；如果**已经序列化过**，将直接输出一个**序列化编号**。

**示例：**

**要被序列化的对象**对应的类的代码：

/* 实现了Serializable接口  */
    public class Person implements Serializable {  
        private String name = null;  
        private Integer age = null;   
        
        public Person(){
            System.out.println("无参构造");
        }
    
        public Person(String name, Integer age) {  
            this.name = name;  
            this.age = age;  
        }  
    
        //getter setter方法省略...
        @Override 
        public String toString() {  
            return "[" + name + ", " + age+"]";  
        }

下面MySerilizable 是一个简单的序列化程序，它先将一个Person对象保存到**文件person.txt**中，然后再从该文件中读出被存储的Person对象，并打印该对象。

public class MySerilizable {
        public static void main(String[] args) throws Exception { 
            File file = new File("person.txt");  
            //序列化持久化对象
            ObjectOutputStream out = 
                new ObjectOutputStream(new FileOutputStream(file)); 
            Person person = new Person("Peter", 27);  
            out.writeObject(person);  
            out.close();  
    
            //反序列化，并得到对象
            ObjectInputStream in = 
                new ObjectInputStream(new FileInputStream(file));  
            // 没有强制转换到Person类型  
            Object newPerson = in.readObject(); 
            in.close();  
            System.out.println(newPerson);  
        }  
    }

输出结果：

> \[Peter, 27\]

> 结果没有打印“无参构造”，说明反序列化机制**无需通过构造器**来初始Java对象。
> 
> 没有调整构造方法，却能反序列化生成Java对象，这是怎么做到的呢？实际上反序列化时，是通过**调用native方法**给类的成员变量赋值的。

**结论： 　**

1） 反序列化读取的**仅仅是Java对象的数据**，而**不是Java类**。所以在反序列化时**必须提供该Java对象所属类的class文件**（这里是**Person.class**），否则会引发**ClassNotFoundException异常**。

2）当重新读取被保存的Person对象时，并没有调用Person的任何构造器，说明反序列化机制**无须通过构造器**来初始化对象。

--------------------

# **7 如何实现选择序列化?** #

## 7.1 transient ##

当对某个对象进行序列化时，系统会自动**将该对象的所有属性**依次进行序列化，如果某个属性 引用到别的一个对象，则**被引用的对象** 也会被序列化。如果**被引用的对象的属性** 又引用了其他对象，则**这个被引用的对象**又会被序列化。这就是**递归序列化**。

有时候，我们并不希望出现 递归序列化，或是希望某个存敏感信息（如银行密码）的属性不被序列化，我们就可通过**transient关键字**修饰该属性，来阻止该属性被序列化。

将上面的Person类的age属性用**transient**修饰：

transient private Integer age = null;

再去执行MySerilizable的结果为：

> \[Peter, null\] // 反序列化时没有值，说明**age字段 未被序列化**

## 7.2 writeObject()方法 与 readObject()方法 ##

使用transient关键字阻止序列化虽然简单方便，但被它修饰的属性被完全隔离在序列化机制之外，导致了**在反序列化时无法获取该属性的值**，而通过**在需要序列化的对象的Java类里** 加入**writeObject()方法**与**readObject()方法**，就可以控制如何序列化各属性，甚至完全不序列化某些属性（此时就跟transient一样）。

如果我们想要上面的**Person类里的name属性**，在序列化后存在文件里，不让别人知道具体是什么（加密）。我们就可在**Person类**里，加如下代码：

//自定义序列化
     private void writeObject(ObjectOutputStream out) 
         throws IOException {   
        // 将当前类的非静态和非瞬态字段写入此流。  
        //如果不写，如果还有其他字段，则不会被“序列化”  
        // out.defaultWriteObject();  
            
        out.writeObject(new StringBuffer(name).reverse());
        //将name简单加密（即反转），这样别人就不知道是怎么回事，
        // 当然实际应用不可能这样加密。
        out.writeInt(age);  
     }  
    
    
    
    //反序列化
     private void readObject(ObjectInputStream in) 
         throws IOException, ClassNotFoundException {  
        // 从此流读取当前类的非静态和非瞬态字段。
        //如果不写，其他字段就不能被“反序列化”
        //in.defaultReadObject();
        
        //解密:即简单的反转
        name = ((StringBuffer)in.readObject()).reverse().toString();  
        age = in.readInt();  
     }

详细的**自定义序列化与反序列化**可参见ObjectOutputStream 和ObjectInputStream 类的JDK文档。

## 7.3 Externalizable接口 ##

Externalizable接口 与Serializable 接口类似，只是Externalizable接口 需要**强制自定义序列化**。

要序列化对象的代码：

public class Teacher implements Externalizable{
        private String name;
        private Integer age;
        //setter、getter方法省略
        
        public Teacher(){
            System.out.println("无参构造");
        }
    
        public Teacher(String name,Integer age){
            System.out.println("有参构造");
            this.name = name;
            this.age = age;
        }   
    
        @Override
        public void writeExternal(ObjectOutput out) 
              throws IOException {
             //将name简单加密
            out.writeObject(new StringBuffer(name).reverse());
            //out.writeInt(age);  //注掉这句后，age属性将不能被序化
        }
    
        @Override
        public void readExternal(ObjectInput in) 
              throws IOException, ClassNotFoundException {
            name = ((StringBuffer) in.readObject()).reverse().toString();
            //age = in.readInt();  
        }
        
        @Override 
        public String toString() {  
            return "[" + name + ", " + age+ "]";  
        } 
    }

主函数代码改为：

public class MySerilizable {
        public static void main(String[] args) throws Exception {  
            File file = new File("person.txt");  
    
            //序列化持久化对象
            ObjectOutputStream out = 
                new ObjectOutputStream(new FileOutputStream(file)); 
            Teacher person = new Teacher("Peter", 27);  
            out.writeObject(person);  
            out.close();  
    
            //反序列化，并得到对象
            ObjectInputStream in = 
                new ObjectInputStream(new FileInputStream(file));  
            // 没有强制转换到Person类型  
            Object newPerson = in.readObject(); 
            in.close();  
            System.out.println(newPerson);  
        }  
    }

打印结果：

>     有参构造无参构造         //与Serializable 不同的是，还调用了无参构造[Peter, null]   //age未被序列化，所以未取到值

--------------------

# **8 单例模式的序列化** #

当我们使用Singleton模式时，应该是期望某个类的实例应该是唯一的。但如果该类是可序列化的，那么情况可能略有不同。对前面使用的Person类进行修改，使其实现Singleton模式，如下所示：

public class Person implements Serializable {  
        /* 通过静态内部类来实现单例模式 */
        private static class InstanceHolder { 
            private static final Person instatnce = 
                new Person("John", 31, "男");  
        }  
    
        public static Person getInstance() {  
            return InstanceHolder.instatnce;  
        }  
    
        private String name = null;  
        private Integer age = null;  
        private String gender = null;  
    
        private Person() {  
            System.out.println("必须私有化的无参构造");  
        }  
    
        private Person(String name, Integer age, String gender) { 
            System.out.println("有参构造");  
            this.name = name;  
            this.age = age;  
            this.gender = gender;  
        }  
        ...  
    }

同时要修改MySerilizable 应用，使得能够保存/获取上述单例对象，并进行对象相等性比较，如下代码所示：

public class MySerilizable {  
        public static void main(String[] args) throws Exception {  
            File file = new File("person.txt");  
            ObjectOutputStream out = 
                new ObjectOutputStream(new FileOutputStream(file)); 
            out.writeObject(Person.getInstance()); // 保存单例对象  
            out.close();  
    
            ObjectInputStream in = 
                new ObjectInputStream(new FileInputStream(file)); 
            Object newPerson = in.readObject();  
            in.close();  
            System.out.println(newPerson);  
             // 将获取的对象与Person类中的单例对象进行相等性比较  
            System.out.println(Person.getInstance() == newPerson);//若为false，说明地址不一样了
        }  
    }

打印结果：

> 有参构造
> 
> `[John, 31, 男]`
> 
> `false //说明不是同一个对象`

从上面结果能发现，序列化、反序列化之后生成的对象，和之前不再是同一个对象了。

其实是可以这样解释的：Java有**4种创建对象的方式**（**new**、**newInstance()**、**clone()**以及这里的**readObject()方法**）。readObject()方法就是**相当于新建了一个对象**，所以上面引用的会是不同的对象。

--------------------

# **9 反序列化漏洞** #

黑客会可以在你反序列化的数据里，加上恶意代码；当你反序列化时，就**执行这段恶意代码**。

像这种情况，就需要我们将拿到手的数据进行**校验**，如签名等。

--------------------

# **10 序列化对象注意事项** #

1.对象的**类名**、**属性**都会被序列化；而**方法**、**static属性**（静态属性）、**transient属性**（即瞬态属性）都不会被序列化（这也就是第4条注意事项的原因）

2.虽然加static也能让某个属性不被序列化，但static不是这么用的。

3.要序列化的对象的引用属性 也必须是可序列化的，否则该对象不可序列化，除非以transient关键字修饰该属性使其不用序列化。

4.反序列化对象时，必须要有**序列化对象生成的class文件**。（很多没有被序列化的数据，需要从class文件获取）

5.当通过文件、网络来读取序列化后的对象时，必须按实际的写入顺序读取。

[https_mp.weixin.qq.com_s_biz_MzU2MzYzNTc2OA_mid_2247483681_idx_1_sn_8784dfc4d33e3ef7c0a77a74c1598d7b_chksm_fc567276cb21fb60f48d4f13eaf6cd57ea5981b554281779a9e6bfc2f87407ee58914906ac3b_mpshare_1_scene_1_srcid_key_cc7d6364edc5eb3e0b3de9e60f7f330c77369d86f1ed0b2747bab982d5d1454e401d9580dbf14f82f02c090ebf06a9f502df33f67bcb698759662cf31f0f74f4faa00650b95bca26075ba9eb7696671b_ascene_1_uin_ODI5ODM4ODI1_devicetype_Windows_2010_version_62060833_lang_zh_CN_pass_ticket_6i2Zvg5ibYNpXt_2bSFhtH_2bGtSKThvxgPP7ygap4M2hCcdDn4daqlWBaFwAObXWQ15]: https://mp.weixin.qq.com/s?__biz=MzU2MzYzNTc2OA==&mid=2247483681&idx=1&sn=8784dfc4d33e3ef7c0a77a74c1598d7b&chksm=fc567276cb21fb60f48d4f13eaf6cd57ea5981b554281779a9e6bfc2f87407ee58914906ac3b&mpshare=1&scene=1&srcid=&key=cc7d6364edc5eb3e0b3de9e60f7f330c77369d86f1ed0b2747bab982d5d1454e401d9580dbf14f82f02c090ebf06a9f502df33f67bcb698759662cf31f0f74f4faa00650b95bca26075ba9eb7696671b&ascene=1&uin=ODI5ODM4ODI1&devicetype=Windows%2010&version=62060833&lang=zh_CN&pass_ticket=6i2Zvg5ibYNpXt%2BSFhtH%2BGtSKThvxgPP7ygap4M2hCcdDn4daqlWBaFwAObXWQ15