对于Serializable的理解
Last Edited: Apr 04, 2019 2:53 PM
Tags: java
开始
序列化：把Java对象转换为字节序列的过程。
反序列化：把字节序列恢复为Java对象的过程。
序列化的解释
在Java中，我们可以通过多种方式来创建对象，并且只要对象没有被回收我们都可以复用该对象，但是，我们创建出来的这些**Java对象都是存在于JVM的堆内存中的。**只有JVM处于运行状态的时候，这些对象才可能存在，一单JVM停止运行，这些对象的状态也就随之丢失了。
但是在真是的应用场景中，我们需要将这些对象持久化下来，并且能够在需要的时候把对象重新读取出来。Java对象序列化就可以帮助我们实现该功能。
测试
这样说的话我们可能不怎么会理解，我们直接上手代码。现在我们有一个需求就是把一个对象保存到文件中，我们现在简单的测试一下。
创建一个最简单的Student类
public class Student {
private int id;
public Student(int id) {
this.id = id;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
@Override
public String toString() {
return "Student{" +
"id=" + id +
'}';
}
}
接下来创建一个类用于输出对象到文件中。
@Test
public void main() throws Exception{
Student student = new Student(1);
FileOutputStream fos = new FileOutputStream("out.txt");
ObjectOutputStream oos = new ObjectOutputStream(fos);
oos.writeObject(student);
oos.close();
}
测试结果是什么呢，直接运行的话系统会直接报 java.io.NotSerializableException
哪我们现在实现 serializable接口重新试试看，将Student类修改为
public class Student implements Serializable {
private int id;
public Student(int id) {
this.id = id;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
@Override
public String toString() {
return "Student{" +
"id=" + id +
'}';
}
}
结果当然没有问题啦，成功的执行了，那么下面我们从文件中获取对象试试看。
@Test
public void main1() throws Exception{
ObjectInputStream ois =
new ObjectInputStream(
new FileInputStream(new File("out.txt")));
Student student = (Student)ois.readObject();
ois.close();
System.out.println(student);
}
程序并不会报错，完整的输出了 Student{id=1}
在这之前，我们一直没有把 serialVersionUID 这个参数加入在程序中，现在我们在Student类中加入
private static final long serialVersionUID = 1L;
重新运行main1 主函数试试看（这里其实用到的还是没有吧serialVersionUID参数加入Student类之前，用main函数生成的out.txt文件）
程序会报
java.io.InvalidClassException: com.liuyanzhao.blog.test.SerializableTest.Student; local class incompatible: stream classdesc serialVersionUID = -1350335207596260519, local class serialVersionUID = 1
从上面可以看出，当我们没有定义serialVersionUID参数的时候，系统自动帮我们生成serialVersionUID 。当我们手动给serialVersionUID赋值1L之后，再重新去读取之前那个对象，serialVersionUID不同，程序报错。
我们仔细想一想，在报错信息中，已经把系统给我们自动定义的serialVersionUID给出来了，我们不就直接可以把 报错信息中的stream classdesc serialVersionUID = -1350335207596260519 弄到我们的Student类里面去。
话不多说，我们直接测试，我们把Student中的 private static final long serialVersionUID = 1L;改为
private static final long serialVersionUID = -1350335207596260519L;
执行，main1主函数，果然，跟我们想的一样，程序成功的执行了。
根据上面的实验结果我们可以总结出来三个特点
- 要想把一个对象写入文件，我们需要实现Serializable接口
- 当没有定义serialVersionUID的时候，系统会自动给我们创建
- 只有当serialVersionUID一致的时候，才能成功的从文件中读取之前保存到对象
静态变量序列化
在理解上面的测试之后，我们开始一些进阶的测试，静态变量的序列化，我们修改Student中的代码如下
public class Student implements Serializable {
private static final long serialVersionUID = -1350335207596260519L;
private int id;
private static String name;
public Student(int id) {
this.id = id;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public static String getName() {
return name;
}
public static void setName(String name) {
Student.name = name;
}
@Override
public String toString() {
return "Student{" +
"id=" + id +
" name = " + getName() + '}';
}
}
在上面的代码中，我们添加一个静态的name变量，并重构了toString方法，接下来就用main2主函数测试
@Test
public void main2() throws Exception{
Student student = new Student(1);
Student.setName("XXX");
System.out.println(student);
FileOutputStream fos = new FileOutputStream("out.txt");
ObjectOutputStream oos = new ObjectOutputStream(fos);
oos.writeObject(student);
oos.close();
}
运行上面的代码将对象写入到文件中之后，在次运行main1主函数读取在文件中的对象，结果如下
Student{id=1 name = null}
可以看出，静态变量并未被写入文件。贴上一段复制过来的文本
串行化只能保存对象的非静态成员交量，不能保存任何的成员方法和静态的成员变量，而且串行化保存的只是变量的值，对于变量的任何修饰符都不能保存。
如果把Student类中的name定义为static类型的话，试图重构，就不能得到原来的值，只能得到null。说明对静态成员变量值是不保存的。这其实比较容易理解，序列化保存的是对象的状态，静态变量属于类的状态，因此 序列化并不保存静态变量。
transient关键字
简单来说，当某些变量不想被写入文件，同是又不适合使用static关键字声明，那么此时就需要用transient关键字来声明该变量。例如，把Student类中的静态变量name改为
private transient String name;
接下来重复之前的测试方法给对象赋值，把对象写入文件，从文件中读取对象，可以得到跟static关键字定义的name一样的结果。
在被反序列化后，transient 变量的值被设为初始值，如 int 型的是 0，对象型的是 null。
注：对于某些类型的属性，其状态是瞬时的，这样的属性是无法保存其状态的。例如一个线程属性或需要访问IO、本地资源、网络资源等的属性，对于这些字段，我们必须用transient关键字标明，否则编译器将报措。
序列化中的继承问题
我觉得就只有一个重点，
- 当一个父类实现序列化，子类自动实现序列化，不需要显式实现Serializable接口。
通过上面的一些测试，我们大概知道了Serializable接口的作用，接下来就是序列化的用途
序列化的用途
- 想把的内存中的对象状态保存到一个文件中或者数据库中时候
- 想把对象通过网络进行传播的时候
结语
上面的仅仅是我自己的理解，里面并没用用太多的专业词汇，因为我也不懂，嘿嘿，
参考文章
https://blog.csdn.net/u011568312/article/details/57611440
一些更好的理解
一个对象序列化的接口，一个类只有实现了Serializable接口，它的对象才是可序列化的。因此如果要序列化某些类的对象，这些类就必须实现Serializable接口。而实际上，Serializable是一个空接口，没有什么具体内容，它的目的只是简单的标识一个类的对象可以被序列化。
什么情况下需要序列化
a）当你想把的内存中的对象写入到硬盘的时候；
b）当你想用套接字在网络上传送对象的时候；
c）当你想通过RMI传输对象的时候；
再稍微解释一下:a)比如说你的内存不够用了，那计算机就要将内存里面的一部分对象暂时的保存到硬盘中，等到要用的时候再读入到内存中，硬盘的那部分存储空间就是所谓的虚拟内存。在比如过你要将某个特定的对象保存到文件中，我隔几天在把它拿出来用，那么这时候就要实现Serializable接口；
b)在进行java的Socket编程的时候，你有时候可能要传输某一类的对象，那么也就要实现Serializable接口；最常见的你传输一个字符串，它是JDK里面的类，也实现了Serializable接口，所以可以在网络上传输。
c)如果要通过远程的方法调用（RMI）去调用一个远程对象的方法，如在计算机A中调用另一台计算机B的对象的方法，那么你需要通过JNDI服务获取计算机B目标对象的引用，将对象从B传送到A，就需要实现序列化接口。