Java Entity实体中serialVersionUID的作用

水深无声 2023-10-10 11:12 43阅读 0赞

> 在实际项目开发中，肯定在实体类中见到过serialVersionUID所声明的常量，有没有想过这个serialVersionUID有什么作用呢？

#### 目录 ####

*   *  一、实现Serializable接口的作用
     *  二、序列化与反序列化代码示例
     *  三、生产者与消费者中实体属性不一致
     *   *  1.不声明serializableUID，生产者成员变量(有sex变量)>消费者成员变量(无sex变量)
         *  2.声明serializableUID，生产者成员变量(有sex变量)>消费者成员变量(无sex变量)
         *  3.声明serializableUID，生产者成员变量(无age变量、sex变量)<消费者成员变量(有age变量、sex变量)

### 一、实现Serializable接口的作用 ###

类实现Serializable接口的目的是为了对象可持久化，比如网络传输或本地存储，为系统的分布和异构部署提供先决条件支持。若没有序列化，现在熟悉的远程调用、对象数据库都不可能存在；

### 二、序列化与反序列化代码示例 ###

*  首先通过一个简单的代码示例JavaBean实现Serializable接口；

import java.io.Serializable;
    public class Person implements Serializable {
        
        private String name;
    
    	private Integer age;
    
       //setter/getter省略...
    }

*  定义一个消息生产者类（Producer）将Person类序列化到本地存储/读取：

public class Producer {
        
        public static void main(String[] args) {
        
            Person p = new Person();
            p.setName("张三");
            p.setAge(21);
            // 序列化，保存到磁盘上
            SerializationUtils.writeObject(p);
        }
    }

*  工具类SerializationUtils对一个类进行序列化和反序列化，并存储到硬盘上（模拟网络传输），代码如下：

import java.io.FileInputStream;
    import java.io.FileNotFoundException;
    import java.io.FileOutputStream;
    import java.io.IOException;
    import java.io.ObjectInputStream;
    import java.io.ObjectOutputStream;
    import java.io.Serializable;
    
    public class SerializationUtils {
        
        private static String FILE_NAME = "d:/obj.bin";
        //序列化
        public static void writeObject(Serializable s) {
        
            try {
        
                ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(FILE_NAME));
                oos.writeObject(s);
                oos.close();
            } catch (FileNotFoundException e) {
        
                e.printStackTrace();
            } catch (IOException e) {
        
                e.printStackTrace();
            }
        }
        //反序列化
        public static Object readObject() {
        
            Object obj = null;
            try {
        
                ObjectInputStream input = new ObjectInputStream(new FileInputStream(FILE_NAME));
                obj=input.readObject();
                input.close();
            } catch (FileNotFoundException e) {
        
                e.printStackTrace();
            } catch (IOException e) {
        
                e.printStackTrace();
            } catch (ClassNotFoundException e) {
        
                e.printStackTrace();
            }
            return obj;
        }
    }

*  序列化存储操作后，在d盘可以看到序列化后的文件：  
    ![在这里插入图片描述][20200528105223885.png]
 *  定义一个消息消费者类（Producer）将磁盘上的文件**反序列化**后获取数据：

public class Customer {
        
        public static void main(String[] args) {
        
            //反序列化
            Person p=(Person) SerializationUtils.readObject();
            System.out.println(p.getName());
        }
    }

*  这是一个反序列化的过程，也就是对象数据流转换为一个实例的过程，其运行后的输出结果为 “张三，21”，这就是序列化和反序列化的示例：  
    ![在这里插入图片描述][2020052811012981.png]
 *  思考一个问题，如果**消息生产者**和**消息消费者**（Person类）的中成员变量属性有差异，比如：在分布式部署应用中，一个应用中的消息生产者中的Person类添加一个性别属性，而另一个应用中的消费者没有增加性别属性。消息发送通过中间件广播方式发消息的情况，漏掉一两个订阅者也是很正常的。在这种情况下会发生什么？

### 三、生产者与消费者中实体属性不一致 ###

#### 1.不声明serializableUID，生产者成员变量(有sex变量)>消费者成员变量(无sex变量) ####

*  生产者Person类：:

public class Person implements Serializable {
        
        private String name;
    
        private Integer age;
    
        private String sex;
    
       //setter/getter省略...
    }

*  生产者代码：

public class Producer {
        
        public static void main(String[] args) {
        
            Person p = new Person();
            p.setName("张三");
            p.setAge(21);
            p.setSex("男");
            // 序列化，保存到磁盘上
            SerializationUtils.writeObject(p);
        }
    }

*  消费者Person类:

public class Person implements Serializable {
        
    	private String name;
    
        private Integer age;
    
       //setter/getter省略...
     }

*  消费者代码:

public class Customer {
        
        public static void main(String[] args) {
        
            //反序列化
            Person p = (Person) SerializationUtils.readObject();
            System.out.println(p.getName() + " , " + p.getAge());
        }
    }

*  结果报了一个InalidClassException异常，原因是序列化和反序列化所对应的类版本发生了变化，JVM不能把数据流转换为实例对象：  
    ![在这里插入图片描述][20200528111521315.png]
 *  JVM是根据SerializableUID来判断一个类的版本，SerializableUID也叫做流标识符（Stream Unique Identifier），即类的版本定义的，它可以**显示声明**也可以**隐式声明**。  
    1. 隐示声明：编译器在编译的时候生成。生成依据通过包名、类名、继承关系、非私有的方法和属性，以及参数、返回值等诸多因子算出来的，极度复杂，基本上计算出来的这个值是唯一的。  
    2. 显示声明格式如下（可以避免对象的不一致导致反序列化报错）：

private static final long serialVersionUID = 7111078431122519129L;

*  serialVersionUID的作用：JVM在反序列化时，会比较数据流中的serialVersionUID与消费者类的serialVersionUID是否相同，如果相同，则认为类没有改变，反序列化成功；如果不相同，JVM就会抛出InviladClassException异常。这是一个非常好的校验机制，可以保证一个对象即使在网络或磁盘中“滚过”一次，仍能做到“出淤泥而不染”，完美的实现了类的一致性。
 *  但是，有时候我们需要一点特例场景，例如我的类改变不大，JVM是否可以把以前的对象反序列化回来？就是依据显示声明的serialVersionUID，向JVM撒谎说"类版本没有变化"，如此编写的类就实现了**向上兼容**。

#### 2.声明serializableUID，生产者成员变量(有sex变量)>消费者成员变量(无sex变量) ####

修改一下示例代码，在**生产者**和**消费者**的Person类中同时添加private static final long serialVersionUID = 7111078431122519129L;

*  生产者Person类 ：

public class Person implements Serializable {
        
    	//添加serialVersionUID 
        private static final long serialVersionUID = 7111078431122519129L;
    
        private String name;
    
        private Integer age;
    
        private String sex;
    
    	//setter/getter省略...
     }

*  生产代码：

*  消费者Person类：

*  消费者代码：

*  看消费者运行结果（这里的生产者Person中**有**sex属性，消费者Person中**没有**sex属性）：  
    ![在这里插入图片描述][20200528134934250.png]

#### 3.声明serializableUID，生产者成员变量(无age变量、sex变量)<消费者成员变量(有age变量、sex变量) ####

一起来看看，当生产者成员变量(无age变量、sex变量)<消费者成员变量(有age变量、sex变量)时，会出现什么情况：

*  生产者Person类：

public class Person implements Serializable {
        
        private static final long serialVersionUID = 7111078431122519129L;
    
        private String name;
        
    //setter/getter省略...
    }

*  生产者代码：

public class Producer {
        
        public static void main(String[] args) {
        
            Person p = new Person();
            p.setName("张三");
            // 序列化，保存到磁盘上
            SerializationUtils.writeObject(p);
        }
    }

*  消费者Person类：

public class Person implements Serializable {
        
        private static final long serialVersionUID = 7111078431122519129L;
    
        private String name;
    
        private Integer age;
    
        private String sex;
        
    //setter/getter省略...

*  消费者代码：

*  **反序列化操作成功**，运行结果，age变量和sex变量在消费者端反序列化后被**自动赋值为null**：  
    ![在这里插入图片描述][20200528154255195.png]
 *  从示例2、示例3结果可以看出，声明了serialVersionUID后，消费者程序并没有在抛出InalidClassException异常，而是可以正常完成反序列化操作，只是没有接收到sex属性值或自动填充不存在的值。刚开始生产者和消费者持有的Person类一致，都是V1.0，某天生产者的Person类变更了，增加了一个“性别”属性，升级为V2.0，由于种种原因（比如程序员疏忽，升级时间窗口不同等）消费端的Person类还是V1.0版本，添加的代码为 priavte String sex;以及对应的setter和getter方法。此时虽然生产者和消费者对应的类版本不同，但是显示声明的serialVersionUID相同，**这时的反序列化是可运行的！！！ 所带来的业务问题**就是**消费端不能读取**到新增的业务属性(**sex属性**而已)。通过此例，反序列化也实现了版本向上兼容的功能，使用V1.0版本的应用访问了一个V2.0的对象，这无疑提高了代码的健壮性。所以在编写序列化类代码时随手添加一个serialVersionUID字段，也不会带来太多的工作量，但它却可以在关键时候发挥异乎寻常的作用。

[20200528105223885.png]: https://img-blog.csdnimg.cn/20200528105223885.png
[2020052811012981.png]: https://img-blog.csdnimg.cn/2020052811012981.png
[20200528111521315.png]: https://img-blog.csdnimg.cn/20200528111521315.png
[20200528134934250.png]: https://img-blog.csdnimg.cn/20200528134934250.png
[20200528154255195.png]: https://img-blog.csdnimg.cn/20200528154255195.png