序列化（Serialization）
为什么要序列化？
概括来说是为了JVM和JVM之间的对象(数据)传输
系列化的目的就是能在网络上传输对象，否则就无法实现面向对象的分布式计算。比如你的客户端要调用服务器上的一个方法获得一个产品对象，比如方法为：public Product findProduct(int product_id);
注意该方法返回一个Product对象，如果没有系列化技术，客户端就收不到返回的对象Product。而序列化的实现就是把对象变成一个可在网络上传输的字节流。
序列化的概念和代码:
序列化（Serialization）也叫串行化，是Java内置的持久化Java对象的机制。只要某个类实现了java.io.Serializable接口，就能够使用java.io.ObjectOutputStream将该类对象以二进制字节码的形式写到硬盘上，并能使用java.io.ObjectInputStream将该对象从硬盘上还原。这样，即使重启了机器，该Java对象也能够从硬盘上恢复。
对应简单的应用，可以使用序列化实现对Java对象的持久化。序列化的对象一般为普通的Java Bean。
例如下面的Person类，为一个普通的Java Bean，Person类只有了两个属性name和hobby代码如下：
Person.java
package com.fengmanfei.intro;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.List;
public class Person implements Serializable {
private static final long serialVersionUID = -3067867193032937191L;
private String name;//姓名
private List<String> hobby = new ArrayList<String>();//爱好
//获得爱好的getter方法
public List<String> getHobby() {
return hobby;
}
//设置爱好的setter方法
public void setHobby(List<String> hobby) {
this.hobby = hobby;
}
//获得姓名的getter方法
public String getName() {
return name;
}
//设置姓名的setter方法
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return "姓名: " + name + ", 爱好: " + hobby;
}
}
将一个普通Java类使其可序列化，要注意以下几个方面。
l 类一定要实现Serializable接口，并声明一个private static final的long类型的serialVersionUID属性，如代码中加粗部分所示。
l 类所有属性也需要是可序列化的。Person类中，属性name为String类型，属性hobby为ArrayList类型。String和ArrayList都是实现了Serializable接口，也是可序列化的。
l 这样，可序列化的类可以通过ObjectOutput类中的writeObject方法和readObject保存和读取。
下面是编写一个简单的对象序列化与还原程序，当输入“save”后，然后依次输入人员，最后保存；当输入“load”后，然后输入人员名称，自动将匹配的人员查找出来，并且显示其信息。该程序运行后，效果如图所示。
该程序的源代码如下所示。
Console.java
package com.fengmanfei.intro;
import java.io.*;
import java.util.Arrays;
public class Console {
// 当前文件夹
public static File directory = new File(System.getProperty("user.dir"));
// 控制台输入
public static String systemRead() throws IOException {
BufferedReader reader = new BufferedReader(new InputStreamReader(
System.in));
return reader.readLine();
}
// 将 person 对象持久化到硬盘上
public static void persist(Person person) throws IOException {
File file = new File(directory, person.getName() + ".dat");
ObjectOutput output = new ObjectOutputStream(new FileOutputStream(file));
//保存对象
output.writeObject(person);
output.close();
System.out.println("文件保存在：" + file);
}
// 将 person 对象从硬盘上恢复
public static Person load(String name) throws Exception {
File file = new File(directory, name + ".dat");
if (!file.exists())
return null;
ObjectInput ins = new ObjectInputStream(new FileInputStream(file));
//读取对象
return (Person) ins.readObject();
}
public static void main(String[] args) throws Exception {
System.out.println("人员信息管理系统. ");
System.out.println("1. 输入''save''开始录入人员信息. ");
System.out.println("2. 输入''load''开始查询人员信息. ");
System.out.println("3. 输入''exit''退出系统. ");
System.out.print("请输入(回车结束输入): ");
//获取用户输入信息
String menu = systemRead();
//如果输入的为save，则继续输入人员的姓名、爱好
if ("save".equalsIg否reCase(menu)) {
System.out.print("请输入要录入的人员姓名: ");
//获得输入人员的姓名
String name = systemRead();
System.out.print("请输入''" + name + "''的爱好，用'',''隔开：");
//获得输入人员的爱好
String hobbies = systemRead();
//创建人员对象
Person person = new Person();
person.setName(name);
person.setHobby(Arrays.asList(hobbies.split(",")));
//持久化人员对象
persist(person);
//如果输入的为load，则继续查找人员的姓名，然后根据姓名查询该人员的信息
} else if ("load".equalsIg否reCase(menu)) {
System.out.print("请输入要查找的人员姓名：");
//获得输入人员的姓名
String name = systemRead();
//根据姓名查询人员，并返回人员相关信息
Person person = load(name);
if (person == null)
System.out.println("没有此人信息。");
else
System.out.println("查询结果: " + person);
//如果输入的为exit，则退出程序
} else if ("exit".equalsIg否reCase(menu)) {
System.out.println("再见. ");
System.exit(0);
//否则，提示错误信息
} else {
System.out.println("无效输入: " + menu);
}
System.out.println();
// 继续执行main主函数
main(null);
}
}
在实际的应用中，Tomcat的会话（session）中使用的就是序列化技术。当Tomcat关闭的时候，Tomcat会把session中的Java对象通过序列化保存到硬盘上，这样，重启Tomcat时又会把这些对象还原并重新放回session中。因此，保存在session中的对象最好实现Serializable接口。
虽然序列化使用起来快速、高效，能够直接持续化Java对象，但是缺陷也很明显，比如说不能进行复杂查询，可序列化的类结构、serialVersionUID值都不能发生改变（否则恢复时会出错）等。