深入分析序列化和反序列化原理，终于知道serialVersionUID到底有什么用了(1)

e.printStackTrace();

}

}

if (null != socket){

try {

socket.close();

} catch (IOException e) {

e.printStackTrace();

}

}

}

}

}

接下来我们先启动socket服务端，然后再启动socket客户端，这时候客户端就会连接上服务端进行通讯数据传输。

运行时却发现，报错了，提示我们没有序列化：

这时候我们把类SocketUser改一下,实现序列化接口：

public class SocketUser implements Serializable{

再次运行，发现这时候服务端可以正常输出我们传入的SocketUser对象了：

所以我们可以知道，当我们在远程通信的时候，必须要序列化数据才能正常传输，那么到底什么是序列化，什么又是反序列化呢？

什么是序列化和反序列化

========================================================================

• 序列化：是把对象的状态信息转化为可存储或传输的形式过程，也就是把对象转化为字节序列的过程称为对象的序列化。

• 反序列化：是序列化的逆向过程，把字节数组反序列化为对象，把字节序列恢复为对象的过程称为对象的反序列化。

为什么需要序列化

=====================================================================

序列化的本质是为了进行网络数据传输，而数据又只能够以二进制的形式在网络中进行传输，所以我们就需要把对象转为二进制的形式，也就是需要序列化这么一个过程，而因为二进制形式对我们使用者来说是不方便的，所以就需要有一个反序列化的过程，将数据重新还原。

序列化的方式

===================================================================

序列化的方式有很多种，比如Java自带的序列化方式，json序列化，xml序列化等。

Java序列化

---

文中开始的例子就是Java自带的序列化，其中SocketClient是序列化过程，SocketServer就是反序列化过程。

serialVersionUID的作用

当我们在实现序列化接口Serializable时候，可以手动生成一个serialVersionUID，有两种表现形式：

private static final long serialVersionUID = -2426545572670767992L;

private static final long serialVersionUID = 1L;

那么这两种形式有什么区别？serialVersionUID 又到底有什么用呢？为了说明这两个问题，我们还是先来看一个例子：

SocketUser沿用上面的类，但是不要添加serialVersionUID属性

package com.zwx.serialize;

import com.alibaba.fastjson.JSONObject;

import com.zwx.serialize.demo.SocketUser;

import java.io.*;

public class TestJavaSerialize {

public static void main(String[] args) {

//代码片段A：序列化

SocketUser socketUser = new SocketUser(“1”,“张三”);

serialize(socketUser);

//代码片段B：反序列化

// SocketUser socketUser2 = deSerialize();

// System.out.println(JSONObject.toJSONString(socketUser2));

}

static void serialize(SocketUser user){

try {

ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream(new File(“G:\user”)));

out.writeObject(user);

} catch (IOException e) {

e.printStackTrace();

}

}

static SocketUser deSerialize(){

try {

ObjectInputStream in = new ObjectInputStream(new FileInputStream(new File(“G:\user”)));

return (SocketUser) in.readObject();

}catch (Exception e){

e.printStackTrace();

}

return null;

}

}

上面的例子中，我们把创建好的SocketUser对象初始化到了本地文件中，然后先不要反序列化，我们在SocketUser类中自动生成serialVersionUID = -2426545572670767992L;

然后把上面的代码片段A注释掉，把代码片段B打开注释，运行，发现反序列化成功，这个没有问题。好，那我们把serialVersionUID = -2426545572670767992L;换成serialVersionUID =1L，再去运行，这时候发现报错了:

这是因为如果我们没有生成serialVersionUID的话，那么当序列化的时候，会自动在序列化对象中自动生成serialVersionUID，而如果我们没有修改过类中的方法和属性，这个值是不会变的，所以我们序列化之后再去生成serialVersionUID，因为算法一直，所以两边的UID依然是相同的，但是我们改成了1L就不行了，会导致UID不相等，无法反序列化，当然，如果我们手动修改serialVersionUID值，也会导致匹配不上，或者说我们修改了类的属性和方法之后再去重新生成，也会导致匹配不上而无法反序列化。

serialVersionUID的两种表现形式

serialVersionUID默认有两种表现方式：

• 一种是根据类名、接口名、成员方法及属性等来生成一个 64 位的哈希字段。

比如：private static final long serialVersionUID = -2426545572670767992L;。

• 另一种就是1L。

比如private static final long serialVersionUID = 1L;

如果我们没有手动生成serialVersionUID，则系统会默认采用第一种方式生成，如果我们此时又手动采用了第二种方式生成serialVersionUID，那么反序列化的时候就会发现两边的UID匹配不上，导致反序列化失败。

Transient关键字

Transient 关键字的作用是控制变量的序列化，在变量声明前加上该关键字，可以阻止该变量被序列化到文件中，在被反序列化后，transient 变量的值被设为初始值，如 int 型的是 0，对象型的是null。

如我们把上面的name属性加上transient 关键字之后再去序列化,：

private transient String name;

然后反序列化可以看到name=null：

不过，我们有办法可以绕开transient 关键字，从而使得transient 关键字失效。这就是下面的两个方法：writeObject和readObject的作用了。

writeObject和readObject

我们把上面的SocketUser类进行一下改写：

package com.zwx.serialize.demo;

import java.io.IOException;

import java.io.Serializable;

public class SocketUser implements Serializable{

public SocketUser(String id, String name) {

this.id = id;

this.name = name;

}

private String id;

private transient String name;

private void writeObject(java.io.ObjectOutputStream s) throws IOException {

s.defaultWriteObject();

s.writeObject(name);

}

private void readObject(java.io.ObjectInputStream s) throws IOException, ClassNotFoundException {

s.defaultReadObject();

name=(String)s.readObject();

}

public String getId() {

return id;

}

public void setId(String id) {

this.id = id;

}

public String getName() {

return name;

}

public void setName(String name) {

this.name = name;

}

}

然后再去序列化和反序列化，发现name属性已经可以被反序列化出来了：

Java序列化特点

• 1、Java序列化只是针对对象的状态进行保存，至于对象中的方法，序列化不关心。

• 2、当一个父类实现了序列化，那么子类会自动实现序列化，不需要显示实现序列化接口 。

• 3、当一个对象的实例变量引用了其他对象，序列化这个对象的时候会自动把引用的对象也进行序列化（实现深度克隆）。

• 4、当某个字段被申明为transient后，默认的序列化机制会忽略这个字段。

• 5、被申明为transient 的字段，如果需要序列化，可以添加两个私有方法：writeObject 和 readObject 。

Java序列化的缺点

如果会用Java序列化会有两个缺点：

• 不能跨语言。序列化本身就是为了数据传输，那么不能跨语言，就说明通信的对方也必须是Java语言才行，这一点就造成了很大的局限性。

• 序列化之后数据比较大。远程通信数据包越小效率就越高，所以序列化之后的二进制流越小，性能越高。

我们针对Java序列化之后的数据包大小来个测试：

定义一个序列化接口(方便后面其他序列化方式共用)：

package com.zwx.serialize;

public interface ISerializer {

byte[] serialize(T obj);

T deserialize(byte[] data,Class clazz);

}

新建一个Java序列化类实现ISerializer接口：

package com.zwx.serialize;

import java.io.ByteArrayInputStream;

import java.io.ByteArrayOutputStream;

import java.io.ObjectInputStream;

import java.io.ObjectOutputStream;

public class JavaSerialize implements ISerializer{

@Override

public byte[] serialize(T obj) {

ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();

try {

ObjectOutputStream objectOutputStream = new ObjectOutputStream(byteArrayOutputStream);

objectOutputStream.writeObject(obj);

return byteArrayOutputStream.toByteArray();

}catch (Exception e){

e.printStackTrace();

}

return null;

}

@Override

public T deserialize(byte[] data, Class clazz) {

ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(data);

try {

ObjectInputStream objectInputStream = new ObjectInputStream(byteArrayInputStream);

return (T)objectInputStream.readObject();

}catch (Exception e){

e.printStackTrace();

}

return null;

}

}

最后新建一个测试类来测试一下Java序列化之后的字节大小：

package com.zwx.serialize;

import com.zwx.serialize.demo.SocketUser;

public class TestSerialize {

public static void main(String[] args) {

SocketUser socketUser = new SocketUser(“1”,“张三丰”);

//Java序列化

JavaSerialize javaSerialize = new JavaSerialize();

byte[] byteArr = javaSerialize.serialize(socketUser);

System.out.println(byteArr.length);//108

}

}

输出之后大小为108，先记住这个数字，我们再来看看其他序列化方式在序列化之后的字节大小。

XML序列化

---

引入XML序列化依赖：

com.thoughtworks.xstream

xstream

1.4.10

新建一个XML序列化类实现ISerializer接口：

package com.zwx.serialize;

import com.thoughtworks.xstream.XStream;

import com.thoughtworks.xstream.io.xml.DomDriver;

public class XMLSerializer implements ISerializer {

XStream xStream=new XStream(new DomDriver());

@Override

public byte[] serialize(T obj) {

return xStream.toXML(obj).getBytes();

}

@Override

public T deserialize(byte[] data, Class clazz) {

return (T)xStream.fromXML(new String(data));

}

}

最后在之前的测试类中测试一下XML序列化的大小为110：

//XML序列化

XMLSerializer xmlSerializer = new XMLSerializer();

System.out.println(xmlSerializer.serialize(socketUser).length);//110

JSON序列化

---

JSON（JavaScript Object Notation）是一种轻量级的数据交换格式，相对于XML来说，JSON 的字节流更小，而且可读性也非常好。现在JSON数据格式在企业运用是最普遍的 JSON序列化常用的开源工具有很多，如：Jackson，FastJson，GSON。

下面以FastJson来举例：

新建一个FastJson序列化类实现ISerializer接口：

package com.zwx.serialize;

import com.alibaba.fastjson.JSON;

public class FastJsonSerialize implements ISerializer {

@Override

public byte[] serialize(T obj) {

return JSON.toJSONString(obj).getBytes();

}

@Override

public T deserialize(byte[] data, Class clazz) {

return (T)JSON.parseObject(new String(data),clazz);

}

}

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数Java工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则几千的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Java开发知识点，真正体系化！

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！

如果你觉得这些内容对你有帮助，可以扫码获取！！（备注Java获取）

写在最后

作为一名即将求职的程序员，面对一个可能跟近些年非常不同的 2019 年，你的就业机会和风口会出现在哪里？在这种新环境下，工作应该选择大厂还是小公司？已有几年工作经验的老兵，又应该如何保持和提升自身竞争力，转被动为主动？

就目前大环境来看，跳槽成功的难度比往年高很多。一个明显的感受：今年的面试，无论一面还是二面，都很考验Java程序员的技术功底。

最近我整理了一份复习用的面试题及面试高频的考点题及技术点梳理成一份“Java经典面试问题（含答案解析）.pdf和一份网上搜集的“Java程序员面试笔试真题库.pdf”（实际上比预期多花了不少精力），包含分布式架构、高可扩展、高性能、高并发、Jvm性能调优、Spring，MyBatis，Nginx源码分析，Redis，ActiveMQ、Mycat、Netty、Kafka、Mysql、Zookeeper、Tomcat、Docker、Dubbo、Nginx等多个知识点高级进阶干货！

由于篇幅有限，为了方便大家观看，这里以图片的形式给大家展示部分的目录和答案截图！

Java经典面试问题（含答案解析）

阿里巴巴技术笔试心得

《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取！
在哪里？在这种新环境下，工作应该选择大厂还是小公司？已有几年工作经验的老兵，又应该如何保持和提升自身竞争力，转被动为主动？

就目前大环境来看，跳槽成功的难度比往年高很多。一个明显的感受：今年的面试，无论一面还是二面，都很考验Java程序员的技术功底。

最近我整理了一份复习用的面试题及面试高频的考点题及技术点梳理成一份“Java经典面试问题（含答案解析）.pdf和一份网上搜集的“Java程序员面试笔试真题库.pdf”（实际上比预期多花了不少精力），包含分布式架构、高可扩展、高性能、高并发、Jvm性能调优、Spring，MyBatis，Nginx源码分析，Redis，ActiveMQ、Mycat、Netty、Kafka、Mysql、Zookeeper、Tomcat、Docker、Dubbo、Nginx等多个知识点高级进阶干货！

由于篇幅有限，为了方便大家观看，这里以图片的形式给大家展示部分的目录和答案截图！
[外链图片转存中…(img-seLUOOj0-1713747203116)]

Java经典面试问题（含答案解析）

[外链图片转存中…(img-BNXsSlCz-1713747203116)]

阿里巴巴技术笔试心得

[外链图片转存中…(img-hWcJHXxd-1713747203116)]

《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取！