what
把Java对象转换为字节序列的过程,-----------> 序列化
把字节序列恢复为Java对象的过程,-----------> 反序列化
Why
我们知道，Java对象是运行在JVM的堆内存中的，如果JVM停止后，对象也就不复存在了。
如果想在JVM停止后，把这些对象保存到磁盘或者通过网络传输到另一远程机器，怎么办呢？------------------------------------就要把这些对象转化为字节数组，这个过程就是序列化 .
作用
序列化使得对象可以脱离程序运行而独立存在，它主要有两种用途：
序列化机制可以让对象地保存到磁盘上，减轻内存压力的同时，也起了持久化的作用；
比如 Web服务器中的Session对象，当有 10+万用户并发访问的，就有可能出现10万个Session对象，内存可能消化不良，于是Web容器就会把一些seesion先序列化到硬盘中，等要用了，再把保存在硬盘中的对象还原到内存中 【仅举例，实际工作中并不会这么干】
序列化机制让Java对象在网络中传输变得更加容易
在使用Dubbo远程调用服务框架时，需要把传输的Java对象实现Serializable接口，即让Java对象序列化，因为这样才能让对象在网络上传输。
常用API
java.io.Serializable
Serializable接口是一个标记接口，没有方法或字段。一旦实现了此接口，就标志该类的对象就是可序列化的。
public interface Serializable { }
java.io.Externalizable
Externalizable继承了Serializable接口，还定义了两个抽象方法：writeExternal()和readExternal()，如果开发人员使用Externalizable来实现序列化和反序列化，需要重写writeExternal()和readExternal()方法
public interface Externalizable extends java.io.Serializable { void writeExternal(ObjectOutput out) throws IOException; void readExternal(ObjectInput in) throws IOException, ClassNotFoundException; }
java.io.ObjectOutputStream
表示对象输出流，它的writeObject(Object obj)方法可以对指定obj对象参数进行序列化，再把得到的字节序列写到一个目标输出流中。
java.io.ObjectInputStream
表示对象输入流，它的readObject()方法，从输入流中读取到字节序列，反序列化成为一个对象，最后将其返回。
Code
实现Serializable接口
import java.io.Serializable; /** * @author 小工匠 * @version 1.0 * @description: TODO * @date 2021/9/12 19:07 * @mark: show me the code , change the world */ public class Artisan implements Serializable { private Integer age; private String name; public Integer getAge() { return age; } public void setAge(Integer age) { this.age = age; } public String getName() { return name; } public void setName(String name) { this.name = name; } }
ObjectOutputStream#writeObject 实现序列化
把Artisan对象 (必须实现Serializable 接口)设置值后，写入一个文件，即序列化
import java.io.FileOutputStream; import java.io.IOException; import java.io.ObjectOutputStream; /** * @author 小工匠 * @version 1.0 * @description: TODO * @date 2021/9/12 19:08 * @mark: show me the code , change the world */ public class Test { public static void main(String[] args) throws IOException { ObjectOutputStream objectOutputStream = new ObjectOutputStream(new FileOutputStream("D:\\artisan.out")); Artisan artisan = new Artisan(); artisan.setAge(18); artisan.setName("artisan"); objectOutputStream.writeObject(artisan); objectOutputStream.flush(); objectOutputStream.close(); } }
ObjectInputStream#readObject方法实现反序列化
再把test.out文件读取出来，反序列化为Student对象
import java.io.FileInputStream; import java.io.IOException; import java.io.ObjectInputStream; /** * @author 小工匠 * @version 1.0 * @description: TODO * @date 2021/9/12 19:09 * @mark: show me the code , change the world */ public class Test2 { public static void main(String[] args) throws IOException, ClassNotFoundException { ObjectInputStream objectInputStream = new ObjectInputStream(new FileInputStream("D:\\artisan.out")); Artisan art = (Artisan) objectInputStream.readObject(); System.out.println("name="+art.getName()); } }
序列化底层实现分析
Serializable接口，只是一个空的接口，没有方法或字段，为什么这么神奇，实现了它就可以让对象序列化了？
为了验证Serializable的作用，写个ArtisanNoSerial对象，去掉实现Serializable接口，看序列化过程怎样吧~
堆栈信息看一下
ObjectOutputStream 在序列化的时候，会判断被序列化的Object是哪一种类型，String array enum 还是 Serializable，如果都不是的话，抛出 NotSerializableException异常。所以 Serializable真的只是一个标志，一个序列化标志 。
writeObject（Object）
序列化的方法就是writeObject, debug下
writeObject直接调用的就是writeObject0（）方法
public final void writeObject(Object obj) throws IOException { ...... writeObject0(obj, false); ...... }
private void writeObject0(Object obj, boolean unshared) throws IOException { ...... //String类型 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); //Serializable实现序列化接口 } 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()); } } ......
writeObject0 主要实现是对象的不同类型，调用不同的方法写入序列化数据，这里面如果对象实现了Serializable接口，就调用writeOrdinaryObject()方法~
private void writeOrdinaryObject(Object obj, ObjectStreamClass desc, boolean unshared) throws IOException { ...... //调用ObjectStreamClass的写入方法 writeClassDesc(desc, false); // 判断是否实现了Externalizable接口 if (desc.isExternalizable() && !desc.isProxy()) { writeExternalData((Externalizable) obj); } else { //写入序列化数据 writeSerialData(obj, desc); } ..... }
writeSerialData（）实现的就是写入被序列化对象的字段数据
private void writeSerialData(Object obj, ObjectStreamClass desc) throws IOException { for (int i = 0; i < slots.length; i++) { if (slotDesc.hasWriteObjectMethod()) { //如果被序列化的对象自定义实现了writeObject()方法，则执行这个代码块 slotDesc.invokeWriteObject(obj, this); } else { // 调用默认的方法写入实例数据 defaultWriteFields(obj, slotDesc); } } }
defaultWriteFields（）方法，获取类的基本数据类型数据，直接写入底层字节容器；获取类的obj类型数据，循环递归调用writeObject0()方法，写入数据~
private void defaultWriteFields(Object obj, ObjectStreamClass desc) throws IOException { // 获取类的基本数据类型数据，保存到primVals字节数组 desc.getPrimFieldValues(obj, primVals); //primVals的基本类型数据写到底层字节容器 bout.write(primVals, 0, primDataSize, false); // 获取对应类的所有字段对象 ObjectStreamField[] fields = desc.getFields(false); Object[] objVals = new Object[desc.getNumObjFields()]; int numPrimFields = fields.length - objVals.length; // 获取类的obj类型数据，保存到objVals字节数组 desc.getObjFieldValues(obj, objVals); //对所有Object类型的字段,循环 for (int i = 0; i < objVals.length; i++) { ...... //递归调用writeObject0()方法，写入对应的数据 writeObject0(objVals[i], fields[numPrimFields + i].isUnshared()); ...... } }
FAQ
- static静态变量和transient 修饰的字段是不会被序列化的
- serialVersionUID问题
JAVA序列化的机制是通过判断类的serialVersionUID来验证版本是否一致的。在进行反序列化时，JVM会把传来的字节流中的serialVersionUID和本地相应实体类的serialVersionUID进行比较，如果相同，反序列化成功，如果不相同，就抛出InvalidClassException异常
如果确实需要修改某个类类，又想反序列化成功，怎么办呢？可以手动指定serialVersionUID的值，一般可以设置为1L或者，或者让我们的编辑器IDE生成
- 如果某个序列化类的成员变量是对象类型，则该对象类型的类必须实现序列化
- 子类实现了序列化，父类没有实现序列化，父类中的字段丢失问题
