java序列化反序列化，serialVersionUID你不能不知道的知识点

最新推荐文章于 2024-05-09 10:00:00 发布

IT悍将阿瑞

最新推荐文章于 2024-05-09 10:00:00 发布

阅读量627

点赞数

分类专栏： java 文章标签： java 编程语言

原文链接：https://blog.csdn.net/zhuzicc/article/details/106398554

版权

java 专栏收录该内容

123 篇文章 0 订阅

订阅专栏

在这里插入图片描述
来源：https://blog.csdn.net/zhuzicc/article/details/106398554

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

一、实现Serializable接口的作用

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

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

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

import java.io.Serializable;
public class Person implements Serializable {
    private String name;
<span class="token keyword">private</span> Integer age<span class="token punctuation">;</span>

//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盘可以看到序列化后的文件：
定义一个消息消费者类（Producer）将磁盘上的文件反序列化后获取数据：

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

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

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

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

生产者Person类：:

public class Person implements Serializable {
    private String name;
<span class="token keyword">private</span> Integer age<span class="token punctuation">;</span>

<span class="token keyword">private</span> String sex<span class="token punctuation">;</span>

//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;
<span class="token keyword">private</span> Integer age<span class="token punctuation">;</span>

//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不能把数据流转换为实例对象：
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;
<span class="token keyword">private</span> String name<span class="token punctuation">;</span>

<span class="token keyword">private</span> Integer age<span class="token punctuation">;</span>

<span class="token keyword">private</span> String sex<span class="token punctuation">;</span>

<span class="token comment">//setter/getter省略...</span>

}

生产代码：

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 {
	//添加serialVersionUID 
    private static final long serialVersionUID = 7111078431122519129L;
<span class="token keyword">private</span> String name<span class="token punctuation">;</span>

<span class="token keyword">private</span> Integer age<span class="token punctuation">;</span>

<span class="token comment">//setter/getter省略...</span>

}

消费者代码：

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

看消费者运行结果（这里的生产者Person中有sex属性，消费者Person中没有sex属性）：

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

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

生产者Person类：

public class Person implements Serializable {
    private static final long serialVersionUID = 7111078431122519129L;
<span class="token keyword">private</span> String name<span class="token punctuation">;</span>

//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;
<span class="token keyword">private</span> String name<span class="token punctuation">;</span>

<span class="token keyword">private</span> Integer age<span class="token punctuation">;</span>

<span class="token keyword">private</span> String sex<span class="token punctuation">;</span>

//setter/getter省略…

消费者代码：

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

反序列化操作成功，运行结果，age变量和sex变量在消费者端反序列化后被自动赋值为null：
从示例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字段，也不会带来太多的工作量，但它却可以在关键时候发挥异乎寻常的作用。

-END-

如果你是刚开始学习java，或者刚开始从事java行业，有很多的问题都可以关注微信公众号： java学长，一个致力于打造免费指导学习java高薪就业的公益平台！点赞、关注 哦，不定期分享程序员的骚操作和强势浪漫！

IT悍将阿瑞

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
java序列化反序列化，serialVersionUID你不能不知道的知识点

来源：https://blog.csdn.net/zhuzicc/article/details/106398554 在实际项目开发中，肯定在实体类中见到过.
复制链接

扫一扫