序列化是一种对象持久化的手段。普遍用在网络传输，RMI（远程方法调用），对象保存到本地等。
序列化的含义，意义和使用场景
- 序列化：将对象写入到IO流中
- 反序列化：从IO流中恢复对象
- 意义：序列化机制可以把对象转化为位字节序列，这些字节序列可以保存在磁盘上面，或是进行网络传输，然后使用反序列化，以达到以后恢复称原对象。序列化的机制可以使对象可以脱离程序的运行，而独立的存在。
- 使用的场景：所有在网络上面传输的对象，必须是可以序列化的。比如RMI（remote method invoke 远程方法调用），传入的参数和返回的结构都是可序列化的。所有需要保存到磁盘的对象都要实现序列化。通常建议创建的javaBean类都实现Serializable接口。
序列化的实现方式
java序列化的实现方式主要实现Serializable接口或者是Externalizable接口
一 普通序列化实现Serializable接口
Serializable接口是一个标志接口，不用实现任何的方法。实现接口的对象就是可以序列化的。
1.1序列化
- 创建一个ObjectOutputStream流
- 调用ObjectOuputStream流来输出序列化对象
\\java bean
public class Book implements Serializable{
private String name;
private int age;
public Book(String name,int age){
this.name=name;
this.age=age;
}
@Override
public String toString() {
return "Book{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
\\测试方法
public static void test1() {
//使用try-close的方式来关闭流
try (ObjectOutputStream objectOutputStream = new ObjectOutputStream(
new FileOutputStream("D:\\tmp\\abc.txt"))) {
Book asdf = new Book("asdf", 10);
objectOutputStream.writeObject(asdf);
\\冲刷出流，将所有返回的缓冲的数据强制发送到目的地
objectOutputStream.flush();
} catch (IOException e) {
e.printStackTrace();
}
}
1.2 反序列化
- 创建一个ObjectInputStream
- 调用ObjectInputStream对象的readObject方法
public static void test2() {
//使用try-close关闭流
try (ObjectInputStream in=new ObjectInputStream(new FileInputStream("D:\\tmp\\abc.txt"))){
Book book = (Book) in.readObject();
Book book1 = (Book) in.readObject();
System.out.println(book);
} catch (Exception e) {
e.printStackTrace();
}
}
1.3 注意点
ObjectInputStream和ObjectOutPutStream都是有两个构造器的，一个是无参构造器但是proteced的，另外一个是有参构造器，参数是流，ObjectInputStream和ObjectOutputStream一般用于java的序列化的，把对象传入IO流里面，反序列化是把对象从IO流里面读取出来，所以，测试指的就是这个IO流。
// ObjectOutputStream构造器
public ObjectOutputStream(OutputStream out) throws IOException {
verifySubclass();
bout = new BlockDataOutputStream(out);
handles = new HandleTable(10, (float) 3.00);
subs = new ReplaceTable(10, (float) 3.00);
enableOverride = false;
writeStreamHeader();
bout.setBlockDataMode(true);
if (extendedDebugInfo) {
debugInfoStack = new DebugTraceInfoStack();
} else {
debugInfoStack = null;
}
}
//ObjectInputStream构造器
public ObjectInputStream(InputStream in) throws IOException {
verifySubclass();
bin = new BlockDataInputStream(in);
handles = new HandleTable(10);
vlist = new ValidationList();
serialFilter = ObjectInputFilter.Config.getSerialFilter();
enableOverride = false;
readStreamHeader();
bin.setBlockDataMode(true);
}
1.4 属性是引用的序列化
如果一个实现了Serializable的接口的类里面的属性是自定义的引用类型的话，必须也要实现Serializable接口，否则这个类无法序列化。
public class Title {
private String title;
public Title(String title){
this.title=title;
}
@Override
public String toString() {
return "Title{" +
"title='" + title + '\'' +
'}';
}
}
public class Book implements Serializable{
private String name;
private int age;
private Title title;
public Book(String name, int age, Title title){
this.name=name;
this.age=age;
this.title=title;
}
@Override
public String toString() {
return "Book{" +
"name='" + name + '\'' +
", age=" + age +
", title=" + title +
'}';
}
}
报错
java.io.NotSerializableException: com.zhi.ref.Title
at java.io.ObjectOutputStream.writeObject0(ObjectOutputStream.java:1184)
at java.io.ObjectOutputStream.defaultWriteFields(ObjectOutputStream.java:1548)
at java.io.ObjectOutputStream.writeSerialData(ObjectOutputStream.java:1509)
at java.io.ObjectOutputStream.writeOrdinaryObject(ObjectOutputStream.java:1432)
at java.io.ObjectOutputStream.writeObject0(ObjectOutputStream.java:1178)
我们看程序是因为Title的不可以序列化，导致了Book的序列化失败。
1.5 同一个对象序列化多次，对象只会被序列化一次，并且在反序列化的时候，也并不会创建多个对象，任然只会创建一个对象。
一个对象被序列化多次，其实底层只是对这对象序列化了异常
public static void main(String[] args) {
test1();
test2();
}
public static void test2() {
//使用try-close关闭流
try (ObjectInputStream in = new ObjectInputStream(new FileInputStream("D:\\tmp\\abc.txt"))) {
Book book1 = (Book) in.readObject();
Book book2 = (Book) in.readObject();
Title title = (Title) in.readObject();
System.out.println(book1==book2);
System.out.println(book1.getTitle()==title);
System.out.println(book1.getTitle()==title);
} catch (Exception e) {
e.printStackTrace();
}
}
public static void test1() {
//使用try-close的方式来关闭流
try (ObjectOutputStream objectOutputStream = new ObjectOutputStream(
new FileOutputStream("D:\\tmp\\abc.txt"))) {
final Title title = new Title("1111");
Book book1 = new Book("asdf", 10, title);
Book book2 = new Book("asdfddddd", 20, title);
objectOutputStream.writeObject(book1);
objectOutputStream.writeObject(book2);
objectOutputStream.writeObject(title);
objectOutputStream.flush();
} catch (IOException e) {
e.printStackTrace();
}
}
结果
false
true
true
true
由此可得，当一个对象被序列化多次，并不会将此对象序列化多次得到多个对象，反序列化的时候，任然只会有一个对象。
java序列化算法
- 所有保存到磁盘的对象都有一个序列化编码
- 当程序试图序列化一个对象到磁盘，首先会检查这个对象是否已经序列化过，只有这个对象从未被当前的虚拟机序列化过，才会将次对象序列称直接输出
- 当已经序列化过了，就会直接返回序列化编号的。
java序列化算法潜在问题
由于java序列化算法不会重复的序列化同一个对象，当在次序列化的时候，就会只记录序列化的编号，当对象的内容改变，在次的序列化任然不会再次的序列化，还是保存序列化编号
1.6 可选自定义序列化
有的时候，对象中有些属性是不用序列化的，比如密码等，这个时候，我们就可以使用transient关键字，在虚拟机序列化对象的时候，这个属性就不会序列化到指定的目的地里面。
将age使用transient进行一个序列化
输出结果如下：
age是默认值0，如果是对引用类型的使用transient，直接就会是null
Book{name='asdf', age=0, title=Title{title='1111'}}
虽然，使用trnasient简单，但是将这个属性完全的隔离在序列化之外。java提供了可选的自定义序列化，可以进行进行序列化的控制，或对序列化的数据进行编码和加密。
private void writeObject(java.io.ObjectOutputStream out) throws IOException；
private void readObject(java.io.ObjectIutputStream in) throws IOException,ClassNotFoundException;
private void readObjectNoData() throws ObjectStreamException;
代码
private void readObject(ObjectInputStream inputStream) throws Exception{
this.name=inputStream.readObject().toString();
this.age=inputStream.readInt();
}
//对你想要操作的属性进行编码或者是加密
private void writeObject(ObjectOutputStream outputStream) throws IOException{
outputStream.writeObject(name);
outputStream.writeInt(age+100);
}
readObjectNoData方法是在当数据流不完整的时候，或是不同的类接收反序列化的对象的时候，或者是序列化流被篡改的时候，系统都会调用readObjectNoData来进反序列化对象，一般是用不到的。
使用这个中重写以上三个方法的方式可以解决上面被transient关键字修饰的完全屏蔽序列化的这个弊端。
下面有一种更加彻底的序列化方式
Object writeReplace() throws ObjectStreamException;
Object readResolve() throws ObjectStreamException;
writeReplace方法：在序列化的时，会调用这个方法，在调用writeObject方法，这个方法的优点是可以用任意的对象来替代序列化对象。
Externalizable序列化方式
通过实现Externalizable接口，必须实现writeExternal、readExternal方法。
public interface Externalizable extends java.io.Serializable {
void writeExternal(ObjectOutput out) throws IOException;
void readExternal(ObjectInput in) throws IOException, ClassNotFoundException;
}
public class ExPerson implements Externalizable {
private String name;
private int age;
//注意，必须加上pulic无参构造器
public ExPerson() {}
public ExPerson(String name, int age) {
this.name = name;
this.age = age;
}
@Override
public void writeExternal(ObjectOutput out) throws IOException {
//将name反转后写入二进制流
StringBuffer reverse = new StringBuffer(name).reverse();
System.out.println(reverse.toString());
out.writeObject(reverse);
out.writeInt(age);
}
@Override
public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
//将读取的字符串反转后赋值给name实例变量
this.name = ((StringBuffer) in.readObject()).reverse().toString();
System.out.println(name);
this.age = in.readInt();
}
public static void main(String[] args) throws IOException, ClassNotFoundException {
try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("ExPerson.txt"));
ObjectInputStream ois = new ObjectInputStream(new FileInputStream("ExPerson.txt"))) {
oos.writeObject(new ExPerson("brady", 23));
ExPerson ep = (ExPerson) ois.readObject();
System.out.println(ep);
}
}
}
注意：Externalizable接口不同于Serializable接口，实现此接口必须实现接口中的两个方法实现自定义序列化，这是强制性的；特别之处是必须提供pulic的无参构造器，因为在反序列化的时候需要反射创建对象。
这里和Serializable不一样，Serializable接口是不需要提供无参构造器的，因为直接由虚拟机来创建对象的。不通过构造方法。
Externalizable是通过反射来创建对象的。
三、序列化版本号serialVersionUID
我们知道，反序列化必须拥有class文件，但随着项目的升级，class文件也会升级，序列化怎么保证升级前后的兼容性呢？
java序列化提供了一个private static final long serialVersionUID 的序列化版本号，只有版本号相同，即使更改了序列化属性，对象也可以正确被反序列化回来。
如果反序列化使用的class的版本号与序列化时使用的不一致，反序列化会报InvalidClassException异常。
序列化版本号可自由指定，如果不指定，JVM会根据类信息自己计算一个版本号，这样随着class的升级，就无法正确反序列化；不指定版本号另一个明显隐患是，不利于jvm间的移植，可能class文件没有更改，但不同jvm可能计算的规则不一样，这样也会导致无法反序列化。
什么情况下需要修改serialVersionUID呢？分三种情况。
如果只是修改了方法，反序列化不容影响，则无需修改版本号；
如果只是修改了静态变量，瞬态变量（transient修饰的变量），反序列化不受影响，无需修改版本号；
-如果修改了非瞬态变量，则可能导致反序列化失败。如果新类中实例变量的类型
-序列化时类的类型不一致，则会反序列化失败，这时候需要更改serialVersionUID
-如果只是新增了实例变量，则反序列化回来新增的是默认值；如果减少了实例变量，反序列化时会忽略掉减少的实例变量。
参考 https://juejin.im/post/5ce3cdc8e51d45777b1a3cdf
https://www.cnblogs.com/lanxuezaipiao/p/3369962.html
