JAVA序列化

1.序列化概述
   简单来说序列化就是一种用来处理对象流的机制，所谓对象流也就是将对象的内容进行流化，流的概念这里不用多说(就是I/O)，我们可以对流化后的对象进行读写操作，也可将流化后的对象传输于网络之间(注：要想将对象传输于网络必须进行流化)！在对对象流进行读写操作时会引发一些问题，而序列化机制正是用来解决这些问题的！

不序列化出现的问题：
   如上所述，读写对象会有什么问题呢？比如：我要将对象写入一个磁盘文件而后再将其读出来会有什么问题吗？别急，其中一个最大的问题就是对象引用！举个例子来说：假如我有两个类，分别是A和B，B类中含有一个指向A类对象的引用，现在我们对两个类进行实例化{ A a = new A(); B b = new B(); }，这时在内存中实际上分配了两个空间，一个存储对象a，一个存储对象b，接下来我们想将它们写入到磁盘的一个文件中去，就在写入文件时出现了问题！因为对象b包含对对象a的引用，所以系统会自动的将a的数据复制一份到b中，这样的话当我们从文件中恢复对象时(也就是重新加载到内存中)时，内存分配了三个空间，而对象a同时在内存中存在两份，想一想后果吧，如果我想修改对象a的数据的话，那不是还要搜索它的每一份拷贝来达到对象数据的一致性，这不是我们所希望的！

以下序列化机制的解决方案：
   1.保存到磁盘的所有对象都获得一个序列号(1, 2, 3等等)
   2.当要保存一个对象时，先检查该对象是否被保存了。
   3.如果以前保存过，只需写入"与已经保存的具有序列号x的对象相同"的标记，否则，保存该对象

通过以上的步骤序列化机制解决了对象引用的问题！

2.序列化的实现
   如果想让一个类可被序列化，那么这个类必须实现Serializable接口，这个接口本身没有任何方法和属性，它的作用只是为了标示一个类可以被序列化，这一个特性好像在Java里用的比较多，比如克隆也是采用了相同的机制。
   因此，如果我们想创建一个可以被序列化的类，我们可以像下面的代码一样做。
import java.io.Serializable;
public class SerialClass implements Serializable
{
   private static final long serialVersionUID = -190734710746841476L;
   private String c;
   public int a;
   public String b;

public int getA(){return a;}
public String getB(){return b;}
public void setA(int a){this.a = a;}
public void setB(String b){this.b = b;}
public String getC(){return c; }
public void setC(String c){this.c = c; }
}
   从上面的例子我们可以看到，除了需要实现Serialzable接口外，一个可序列化的类和一个普通类没有什么大的区别。不过我们还是有一些特别的东西需要注意的。
属性 serialVersionUID
   这个属性是一个私有的静态final属性，一般刚接触序列化的人会忽略这个属性，因为这个属性不是必须的。这个属性主要是为了保证一个可序列化类在不同的 Java编译器中，能保证相同的版本号，这样保证当这个类在不同的JVM中进行序列化与反序列化时不会出现InvalidClassException异常。
属性与序列化
   那么我们再考虑另一个问题，是不是一个类实现了Serializable之后就可以看成是可序列化的类呢？答案是不行，实际上一个类是否可序列化还需要看这个类的属性，在Java规范中，一个类是否能序列化，不但取决于这个类是否实现Serializable接口，还取决于这个类中的属性是否可序列化。在上面的例子里，一共有三个属性，两个是String对象，一个是int类型的属性，实际上，String类是可序列化的（继承了Serializable 接口且它的属性都是可序列化的），而像int这样的基本数据类型在Java中被看成是可序列化的，因此我们可以确认上面的这个类是一个可序列化的类。那么现在我们已经创建了一个可序列化类，接下去的问题是怎么使用这个类，对它进行序列化与反序列化操作？
ObjectOutputStream 和 ObjectInputStream类
   Jdk提供了两个IO流类进行序列化和反序列化操作，其中ObjectOutputStream中的writeObject方法对一个对象进行序列化工作；而ObjectInputStrem中的readObject方法则负责发序列化的操作。下面的例子完整的显示了一个类的序列化和反序列化操作。
package serialtest;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;

public class TestClass
{
public static void main(String[] args) throws Exception
{
SerialClass s = new SerialClass();
s.setA(10);
s.setB("hello");
s.setC("world");
//创建ObjectOutputStream对象，准备序列化对象s
ObjectOutputStream oos = new ObjectOutputStream(
new FileOutputStream("abc"));
//调用writeObject将对象进行序列化，存储在文件abc中。
oos.writeObjectMoon;
oos.flush();
oos.close();

//创建ObjectInputStream对象，准备从文件abc中反序列化SerialClass对象
ObjectInputStream ois = new ObjectInputStream(
new FileInputStream("abc"));
//调用readObject将存储在文件abc中的字节流反序列化为SerialClass对象。
s = (SerialClass) ois.readObject();
System.out.println(s.getA());
System.out.println(s.getB());
System.out.println(s.getC());
}
}
执行程序，最后的结果应该是：
10
Hello
World
好了，序列化的基础知识就讲到这里。接下来我们看看继承对于序列化的影响。

二、继承对序列化的影响
我们现在把上面的例子做点变换，变成如下的形式。
1）首先创建一个Interface。
package serialtest;
public interface SuperInterface
{
public int getA();
public String getB();
public void setA(int a);
public void setB(String b);
}
2）创建一个抽象类实现SuperInterface接口，注意，这个类没有实现Serializable接口。
package serialtest;
public abstract class AbsSuperClass implements SuperInterface
{
public int a;
public String b;
public int getA() {return a;}
public String getB(){return b; }
public void setA(int a) {this.a = a;}
public void setB(String b) {this.b = b;}
}
3）SerialClass类继承了AbSuperClass，同时它也实现了Serializable接口。
package serialtest;
import java.io.Serializable;

public class SerialClass extends AbsSuperClass implements Serializable
{
private static final long serialVersionUID = -190734710746841476L;
private String c;
public String getC(){return c; }
public void setC(String c) {this.c = c;}
}
这时候我们在运行Test，将会发现结果和第一节的例子不一样了，这时候结果将变成：
0
null
world
而导致这个结果的原因就在AbSuperClass上，因为AbSuperClass没有实现Serializable接口，所以它不可被序列化；但 SerialClass由于实现了Serializable接口而成为一个可序列化的类，这时候，属性c因为是SerialClass的类所以c的值在序列化时将被保存，而属性a和b是从AbSuperClass中继承而来，他们因为AbSuperClass的缘故而导致了它们的值不能在序列化是被保存。
关于这一点，我在Java文档中也得到了证实，在Java doc中明确指出，如果一个类继承了一个非Serializable类时，如果想在序列化中保存父类的属性，则需要实现额外的代码显式地存储父类的属性值。
最后再回到本文的初衷，诚然，这篇文章是以对象的序列化为主的，但最后我又要回到一个比较古老的话题上，那就是在软件开发的时候，继承到底该用到什么一种程度？毕竟，滥用继承对整个系统的影响将是深远的



Another Example:

package com;

import java.io.*;
import java.util.*;

class Data implements Serializable { // 实现序列话接口
/**
* 需要序列化的类
*/
private static final long serialVersionUID = 1L;

private int n;

private String str;

public Data(int n, String str) {
this.n = n;
this.str = str;
}

public String toString() {
return Integer.toString(n) + ":" + str;
}
}

public class Test implements Serializable {
/**
* 测试例子
*/
private static final long serialVersionUID = 1L;

public static void main(String[] args) throws ClassNotFoundException,
IOException { // 序列话读入和写入Object可能会有这两个异常
// 将你要序列化的object，保留到一个文件中
Random rand = new Random();
Data data = new Data(rand.nextInt(10), Double.toString(rand.nextDouble())); // 构建你需要序列话的Object
System.out.println("Original=" + data);
ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream(
"example")); // 准备写入的文件
out.writeObject(data);
out.flush();
out.close(); // 执行到这里你可以看见worm.out这个文件
// 以下的代码读出你刚刚写入Object
ObjectInputStream in = new ObjectInputStream(new FileInputStream(
"example")); // 读你刚刚写入的文件
Data d2 = (Data) in.readObject(); // 重新构建你刚刚写入的Object
System.out.println("Current=" + d2);
}
}

参考文献
1.Java序列化. surendaxiao/blog/item/f8cd69d2491fcfd5a9ec9a30.html
2.JAVA序列化. %BF%C6%D1%A7%CA%C0%BD%E7/blog/item/2a571bd846e3a03332fa1c25.html