一、为什么要序列化
java允许我们在内存中创建可复用的对象，当JVM正常运行时，这些对象才存在，这些对象的生命周期不会比JVM的生命周期更长。当我们需要永久化保存这些对象时，就需要使用序列化来将对象转化成二进制信息存储起来，方便随时调用。
二、java如何实现序列化
java实现序列化的方式很简单，只需要将序列化的类实现Serializable接口即可；不实现Serializable接口的类在调用writeObject()方式时会报错NotSerializableException；具体的原因看writeObject()源码：
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);
} 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());
}
}
在进行序列化操作时，会判断要被序列化的类是否是Enum、Array和Serializable类型，如果不是则直接抛出NotSerializableException。
三、通过Serializable实现序列化需要注意的几个问题
1.序列化 ID 的问题
虚拟机是否允许反序列化，不仅取决于类路径和功能代码是否一致，一个非常重要的一点是两个类的序列化 ID 是否一致；
public class Man implements Serializable {
private static final long serialVersionUID = 1L;
private String name;
private int age;
private String address;
public static int height = 185;
transient private String hobby;
//省略getter(),setter()方法
}
写个main()方法测试一下：
Man man = new Man();
man.setName("ymz");
man.setAddress("屋子科");
man.setAge(18);
File file = new File("test01.txt");
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(file));
oos.writeObject(man);
oos.flush();
oos.close();
在系列化之后改变Man类的序列化ID，
private static final long serialVersionUID = 2L;
然后反序列化，看结果:
//改变序列ID之后再读取会报错
ObjectInputStream ois = new ObjectInputStream(new FileInputStream("test01.txt"));
Man man = (Man)ois.readObject();
ois.close();
System.out.println(man.getName());
具体的报错信息：
Exception in thread "main" java.io.InvalidClassException: cn.ymz.serialization.Man; local class incompatible: stream classdesc serialVersionUID = 1, local class serialVersionUID = 2
at java.io.ObjectStreamClass.initNonProxy(ObjectStreamClass.java:621)
at java.io.ObjectInputStream.readNonProxyDesc(ObjectInputStream.java:1623)
at java.io.ObjectInputStream.readClassDesc(ObjectInputStream.java:1518)
at java.io.ObjectInputStream.readOrdinaryObject(ObjectInputStream.java:1774)
at java.io.ObjectInputStream.readObject0(ObjectInputStream.java:1351)
at java.io.ObjectInputStream.readObject(ObjectInputStream.java:371)
at cn.ymz.serialization.TestSeria01.main(TestSeria01.java:23)
2.静态变量的序列化
直接看代码：
//先写入文件,当前height的值是185
Man man = new Man();
man.setName("ymz");
man.setAddress("屋子科");
man.setAge(18);
File file = new File("test02.txt");
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(file));
oos.writeObject(man);
oos.flush();
oos.close();
//改变height的值
Man.height = 100;
ObjectInputStream ois = new ObjectInputStream(new FileInputStream("test02.txt"));
Man man2 = (Man)ois.readObject();
ois.close();
System.out.println(man2.getHeight());
height的初始值是185，在序列化之后，改变height的值，看结果会是多少：
100
height的值变了！说明读取的不是文件中的内容，读的是JVM中Man类的height属性；序列化并不保存静态变量。
3.transient关键字的作用
Man man = new Man();
man.setName("ymz");
man.setAddress("屋子科");
man.setAge(18);
man.setHobby("eat");
File file = new File("test03.txt");
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(file));
oos.writeObject(man);
oos.flush();
oos.close();
//读取被transient修饰的属性
ObjectInputStream ois = new ObjectInputStream(new FileInputStream("test03.txt"));
Man man2 = (Man)ois.readObject();
ois.close();
System.out.println(man2.getHobby());
输出的结果为：null;
被transient修饰的属性不会被序列化，在反序列化的时候会给该属性一个默认值，int默认给0，string默认给null。
4.重写writeObject()与readObject()方法可以实现对某些属性的特殊处理
重写writeObject()与readObject()方法后，ObjectOutputStream会通过反射调用类中重写的方法：
private void writeObject(ObjectOutputStream oos){
try {
ObjectOutputStream.PutField putFields = oos.putFields();
System.out.println("原地址："+address);
address = "****"+address+"****";
putFields.put("address",address);
System.out.println("加密后的地址："+address);
oos.writeFields();
} catch (Exception e) {
e.printStackTrace();
}
}
private void readObject(ObjectInputStream ois){
try {
ObjectInputStream.GetField getField = ois.readFields();
Object obj = getField.get("address","");
System.out.println("加密后获取到的地址："+obj);
obj = String.valueOf(obj).replace("*","");
System.out.println("解密后的地址："+obj);
address = obj.toString();
} catch (Exception e) {
e.printStackTrace();
}
}
测试一下：
Man man = new Man();
man.setAddress("屋子科");
File file = new File("test04.txt");
ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(file));
oos.writeObject(man);
oos.flush();
oos.close();
ObjectInputStream ois = new ObjectInputStream(new FileInputStream("test04.txt"));
Man man2 = (Man)ois.readObject();
ois.close();
System.out.println(man2.getAddress());
输出结果为：
原地址：屋子科
加密后的地址：****屋子科****
加密后获取到的地址：****屋子科****
解密后的地址：屋子科
屋子科
5.序列化存储规则
将一个类连续两次写入同一个文件，看文件的大小变化；再连续读取两次，看是否得到同一个对象：
ObjectOutputStream out = new ObjectOutputStream(
new FileOutputStream("result.obj"));
Man test = new Man();
//试图将对象两次写入文件
out.writeObject(test);
out.flush();
System.out.println(new File("result.obj").length());
out.writeObject(test);
out.close();
System.out.println(new File("result.obj").length());
ObjectInputStream oin = new ObjectInputStream(new FileInputStream(
"result.obj"));
//从文件依次读出两个文件
Man t1 = (Man) oin.readObject();
Man t2 = (Man) oin.readObject();
oin.close();
//判断两个引用是否指向同一个对象
System.out.println(t1 == t2);
结果如下：
100
105
true
Java 序列化机制为了节省磁盘空间，具有特定的存储规则，当写入文件的为同一对象时，并不会再将对象的内容进行存储，而只是再次存储一份引用，上面增加的 5 字节的存储空间就是新增引用和一些控制信息的空间。反序列化时，恢复引用关系，使得 t1 和 t2 指向唯一的对象，二者相等，输出 true。该存储规则极大的节省了存储空间。
6.序列化特性分析
在连续两次序列化同一对象中间，改变对象的属性值，然后看对象的值是否被改写：
ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("result.obj"));
Man man = new Man();
man.setAge(1);
out.writeObject(man);
out.flush();
man.setAge(2);
out.writeObject(man);
out.close();
ObjectInputStream oin = new ObjectInputStream(new FileInputStream("result.obj"));
Man t1 = (Man) oin.readObject();
Man t2 = (Man) oin.readObject();
System.out.println(t1.getAge());
System.out.println(t2.getAge());
输出结果为：
1
1
结果两个输出的都是 1。
原因就是第一次写入对象以后，第二次再试图写的时候，虚拟机根据引用关系知道已经有一个相同对象已经写入文件，因此只保存第二次写的引用，所以读取时，都是第一次保存的对象。
