简单说就是为了保存在内存中的各种对象的状态（也就是实例变量，不是方法），并且可以把保存的对象状态再读出来。虽然你可以用你自己的各种各样的方法来保 存object states，但是Java给你提供一种应该比你自己好的保存对象状态的机制，那就是序列化。
2、什么情况下需要序列化
a）当你想把的内存中的对象状态保存到一个文件中或者数据库中时候；
b）当你想用套接字在网络上传送对象的时候；
c）当你想通过RMI传输对象的时候；
3、当对一个对象实现序列化时，究竟发生了什么？
在没有序列化前，每个保存在堆（Heap）中的对象都有相应的状态（state），即实例变量（instance ariable）比如：
java 代码
Foo myFoo = new Foo();
myFoo .setWidth(37);
myFoo.setHeight(70);
当 通过下面的代码序列化之后，MyFoo对象中的width和Height实例变量的值（37，70）都被保存到foo.ser文件中，这样以后又可以把它 从文件中读出来，重新在堆中创建原来的对象。当然保存时候不仅仅是保存对象的实例变量的值，JVM还要保存一些小量信息，比如类的类型等以便恢复原来的对 象。
java 代码
FileOutputStream fs = new FileOutputStream("foo.ser");
ObjectOutputStream os = new ObjectOutputStream(fs);
os.writeObject(myFoo);
4、实现序列化（保存到一个文件）的步骤
a、Make a FileOutputStream
java 代码
FileOutputStream fs = new FileOutputStream(“foo.ser”);
b、Make a ObjectOutputStream
java 代码
ObjectOutputStream os = new ObjectOutputStream(fs);
c、write the object
java 代码
os.writeObject(myObject1);
os.writeObject(myObject2);
os.writeObject(myObject3);
d、 close the ObjectOutputStream
java 代码
os.close();
===========================================
Bean Serializable Interface 的接口让 BEAN 可以串行化，将其变成一个可保存为以后使用的二进制流。当一个BEAN被系列化到磁盘上或者其他任何地方，其状态被保存起来，其中的属性值也不会改变。在BEAN的规范中，JSP并没有要求BEAN实现Serializable接口。但是，如果您希望自己控制您所创建的组件的serialization进程，或者您想serialize并不是标准组件扩展的组件，您必须了解serialization and deserialization的细节。
有几个原因你会把 BEAN 冷藏起来以备后用。 有些服务器通过将所有的SESSION 数据（包括BEAN）写入磁盘来支持任意长的SESSION生命期，即使服务器停机也不会丢失。当服务器重新启动后，串行化的数据被恢复。同样的理由，在重负载的站点上支持服务器分簇的环境中，许多服务器通过串行化来复制SESSION。如果你的BEAN不支持串行化，服务器就不能正确地保存和传输类。
通过同样的策略，你可以选择将BEAN保存在磁盘上或者数据库中，以备后用。例如，也许可以将客户的购物车实现为一个BEAN，在访问期间将其保存在数据库中。
如果BEAN需要特殊的复杂的初始设置，可以将BEAN设置好后串行化保存在磁盘上。这个BEAN的“快照”可以用在任何需要的地方，包括在$#@60;jsp:useBean$#@62;中用beanName属性的调用。
$#@60;jsp:useBean$#@62;标签中的beanName属性，用来实例化一个串行化的BEAN，而不是用来从一个类创建一个全新的实例。如果BEAN还没有创建，beanName属性传给java.beans.Bean.instantiate()方法，由类装载器对类进行实例化。它首先假定存在一个串行化的BEAN（带有扩展名.ser），然后会将其激活。如果这个操作失败，它就会实例化一个新的实例。
下面简单介绍一下这个接口：
对象能包含其它的对象，而这其它的对象又可以包含另外的对象。JAVA serialization能够自动的处理嵌套的对象。对于一个对象的简单的域，writeObject()直接将值写入流。而，当遇到一个对象域时，writeObject()被再次调用，如果这个对象内嵌另一个对象，那么，writeObject() 又被调用，直到对象能被直接写入流为止。程序员所需要做的是将对象传入ObjectOutputStream 的writeObject() 方法，剩下的将又系统自动完成。下面的例子创建了一个调用mine对象的PersonalData对象。代码实现的是将一个串和mine 对象输出到一个流，并存入一个文件：
public class PersonalData implements Serializable {
public int id
public int yearOfBirth;
public float yearlySalary;
}
PersonalData mine = new PersonalData(101, 1956, 46500.00);
FileOutputStream outstream = new FileOutputStream("PersonalData.ser");
ObjectOutputStream out = new ObjectOutputStream(outstream);
out.writeObject("My personal data"); //将一个串写入流
out.writeObject(mine); //将这个对象写入流
out.close(); // 清空并关闭流
...一个FileOutputStream对象被创建且传到一个ObjectOutputStream。当out.writeObject() 被调用，这个串和mine 对象被objects are serializ顺序加入一个存入文件PersonalData.ser的字节对列。
您应该注意上述类是实现的java.io.Serializable接口。因为它并未指定要实现的方法，所以Serializable被称为"tagging interface" ，但是它仅仅"tags"它自己的对象是一个特殊的类型。任一个您希望serialize的对象都应该实现这个接口。这是必须的。否则，用到流技术时将根本不工作。例如，如果您试着去serialize 一个没有实现这个接口的对象，一个 NotSerializableException将产生。
类通过实现 java.io.Serializable 接口以启用其序列化功能。未实现此接口的类将无法使其任何状态序列化或反序列化。可序列化类的所有子类型本身都是可序列化的。序列化接口没有方法或字段，仅用于标识可序列化的语义。
Java的"对象序列化"能让你将一个实现了Serializable接口的对象转换成一组byte，这样日后要用这个对象时候，你就能把这些byte数据恢复出来，并据此重新构建那个对象了。
要想序列化对象，你必须先创建一个OutputStream，然后把它嵌进ObjectOutputStream。这时，你就能用writeObject( )方法把对象写入OutputStream了。
writeObject 方法负责写入特定类的对象的状态，以便相应的 readObject 方法可以还原它。通过调用 out.defaultWriteObject 可以调用保存 Object 的字段的默认机制。该方法本身不需要涉及属于其超类或子类的状态。状态是通过使用 writeObject 方法或使用 DataOutput 支持的用于基本数据类型的方法将各个字段写入 ObjectOutputStream 来保存的。
读的时候，你得把InputStream嵌到ObjectInputStream里面，然后再调用readObject( )方法。不过这样读出来的，只是一个Object的reference，因此在用之前，还得先下传。readObject 方法负责从流中读取并还原类字段。它可以调用 in.defaultReadObject 来调用默认机制，以还原对象的非静态和非瞬态字段。
defaultReadObject 方法使用 流中的信息来分配流中通过当前对象中相应命名字段 保存的对象的字段。这用于处理类发展后需要添加新字段的情形。该方法本身不需要涉及属于其超类或子类的状态。状态是通过使用 writeObject 方法或使用 DataOutput 支持的用于基本数据类型的方法将各个字段写入 ObjectOutputStream 来保存的。
package com.itm.test;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
public class Simulator {
/*****************************************************
*
*
我们可以看到，读取到的对象与保存的对象状态一样。这里有几点需要说明一下：
1、 基本类型 的数据可以直接序列化
2、 对象要被序列化，它的类必须要实现Serializable接口;如果一个类中有引用类型的实例变量，这个引用类型也要实现Serializable接口。
比如上面 的例子中，Student类中有一个Book类型 的实例就是，要想让Student的对象成功序列化，那么Book也必须要实现Serializable接口。
3、 我们看这个语句：
ObjectOutputStreamout = newObjectOutputStream(new FileOutputStream("seria"));
我们知道 FileOutputStream类有一个带有两个参数的重载Constructor——FileOutputStream(String,boolean),
其第二个参数如果为true且String代表的文件存在，那么将把新的内容写到原来文件的末尾而非重写这个文件，
这里我们不能用这个版本的构造函数，
也就是说我们必须重写这个文件，否则在读取这个文件反序列化的过程中就会抛出异常。
导致只有我们第一次写到这个文件中的对象可以被反序列化，之后程序就会出错。
下面的问题是如果 我们上面 用到的Book类没有实现Serializable接口，但是我们还想序列化Student类的对象 ，怎么办。
Java为我们提供了transient这个关键字。
如果一个变量被声明成transient，那么 在序列化的过程 中，这个变量是会被无视的。我们还是通过对上面的代码进行小的修改来说明 这个问题。
新的Book类不实现Serializable接口
*
* @param args
*/
public static void main(String[] args) {
new Simulator().go();
}
private void go(){
Student student = new Student(new Book(2011),"小海");
try {
ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("seria"));
out.writeObject(student); // 向seria文件中 写入。
System.out.println("将要写入内容");
out.close();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
try {
ObjectInputStream in = new ObjectInputStream(new FileInputStream("seria"));
Student studentRead = (Student) in.readObject();
System.out.println("Object 在这里 读取~~");
System.out.println(studentRead);
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (ClassNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
(2), 因为我们要序列化Student类的对象，所以我们必须实现Serializable接口，然而Book是Student的一个实例变量，它的类没有实现Serializable接口，所以为了顺序完成序列化，我们把这个实例变量声明为transient以在序列化的过程中跳过它。
=======================================
可以看到，student对象被成功的序列化了。因为序列化过程中跳过了Book实例，所以当恢复对象状态的时候 ，它被赋予了默认值null，这也就意味着我们不能使用它。那如果Book类没有实现Serializable接口，但我们还想对它的状态进行保存，这可以实现 吗？答案是肯定的。
Java针对这种情况有一种特殊的机制—— 一组私有（回调）方法（这个我们马上在代码中看到），可以在要被序列化的类中实现它们，在序列化和的序列化的过程中它们会被自动调用。所以在这组方法中我们可以调用ObjectOutputStream/ObjectInputStream的一些有用方法来实现对象状态的保存。
package com.itm.test;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
public class Student implements Serializable{
private transient Book book;
private String name;
public Student(Book book,String name){
super();
this.book = book;
this.name = name;
}
public Book getBook() {
return book;
}
public void setBook(Book book) {
this.book = book;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
//下面这两个方法就是那组特殊的私有方法，它们会在序列化、反序列化的过程 中被自动调用
//我们必须保证方法的签名和下面的两个方法完全相同
// （1）序列化。
private void writeObject(ObjectOutputStream out){
try {
//这个方法会把这当前中非静态变量和非transient变量写到流中
//因为我们要保存Book的状态，所以我们还要想办法把其状态写入流中
out.defaultWriteObject();
//在这里我们就把name写到了流中。
out.writeInt(book.getIsbn()); //ObjectOutputStream中提供了写基本类型数据的方法
//out.close();//注意，这句千万不能有，否刚将直接导致写入失败
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
// （2）反序列化。
private void readObject(ObjectInputStream in){
try {
//和defaultWriteObject()方法相对应，默认的反序列化方法，会从流中读取
//非静态变量和非transient变量
in.defaultReadObject();
int isbn = in.readInt(); //用这个方法来读取一个int型值，这里我们是读取书号 。
book = new Book(isbn); //这里我们就通过读取的 保存的状态构造 了一个和原来一样的Book对象
// in.close(); 注意：也不可以要。
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (ClassNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
public String toString(){
return "Student -------> book =" +book+ ",name=" +name+ "--> ";
}
}
第2个问题：
Object是每个类的超类，但是它没有实现 Serializable接口，但是我们照样在序列化对象，所以说明一个类要序列化，它的父类不一定要实现Serializable接口。但是在父类中定义 的状态能被正确 的保存以及读取吗？
第3个问题：
如果将一个对象写入某文件（比如是a），那么之后对这个对象进行一些修改，然后把修改的对象再写入文件a，那么文件a中会包含该对象的两个 版本吗？
事与愿违啊，它输出了三个kevin，这证明 我们对student名字的修改并没有被写入。原因是序列化输出过程跟踪写入流的对象，试图将同一个对象写入流时，不会导致该对象被复制，而只是将一个句柄写入流，该句柄指向流中相同对象的第一个对象出现的位置。
那我们如何来避免这种情况 ，让它输出三个人名呢，方法是在writeObject()之前调用out.reset()方法，这个方法的作用是清除流中保存的写入对象的记录。
请见：http://blog.csdn.net/moreevan/article/details/6698529 这位仁兄。
1532
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
