Java序列化Serializable和Externalizable

纸上得来终觉浅，绝知此事要躬行
--陆游 问渠那得清如许，为有源头活水来 --朱熹

什么是Java序列化？为什么出现Java序列化？怎样实现Java序列化？
一、什么是Java序列化
Java序列化是指把Java对象转换为字节序列的过程；而Java反序列化是指把字节序列恢复为Java对象的过程。

二、为什么出现Java序列化
两个进程之间进行通信时，需要传输各种信息，比如文本，图像，声音等等，这些信息是通过二进制流的形式进行传输的。
那么进程之间是不是也可以传递对象数据呢？答案是可以的。Java的序列化和反序列化就是将Java对象转化为字节序列，并
在网络上进行传输，反序列化将获得的字节序列数据生成对象。

三、怎样实现Java序列化

1）、对象的输入输出：ObjectInputStream，ObjectOutputStream。
2）、对象要实现Serializable或者Externalizable接口，否则会抛出异常。

注意：在Serializable中声明为static和transient类型的成员数据不能被序列化。

实现Serializable接口的序列化和反序列化示例程序：

public class Student implements Serializable
{
private String name;
private char sex;
public Student()
{

}
public Student(String name,char sex)
{
this.name = name;
this.sex = sex;
}

public void setName(String name)
{
this.name = name;
}

public void setSex(char sex)
{
this.sex = sex;
}

public String getName()
{
return this.name;
}

public char getSex()
{
return this.sex;
}

}

public class UseStudent
{
public static void main(String[] args)
{
Student st = new Student("Tom",'M');
File file = new File("O:\\Java\\com\\jieke\\io\\student.txt");
try
{
file.createNewFile();
}
catch(IOException e)
{
e.printStackTrace();
}
try
{
//Student对象序列化过程
FileOutputStream fos = new FileOutputStream(file);
ObjectOutputStream oos = new ObjectOutputStream(fos);
oos.writeObject(st);
oos.flush();
oos.close();
fos.close();

//Student对象反序列化过程
FileInputStream fis = new FileInputStream(file);
ObjectInputStream ois = new ObjectInputStream(fis);
Student st1 = (Student) ois.readObject();
System.out.println("name = " + st1.getName());
System.out.println("sex = " + st1.getSex());
ois.close();
fis.close();
}
catch(ClassNotFoundException e)
{
e.printStackTrace();
}
catch (IOException e)
{
e.printStackTrace();
}
}
}

使用Externalizable接口进行序列化，必须要重写writeExternal（ObjectOutput
output）和readExternal（ObjectInput input）方法
使用该接口的序列化方法需要我们来实现，因此可以对static和transient数据进行序列化。

public class Person implements Externalizable {
private static final long serialVersionUID = -842029427676826563L;
public static String name;
private int age;
private transient int workDay = 5;
private String fClub;
public Person() {
System.out.println("none-arg constructor");
}
public Person(int age, String fClub) {
this.age = age;
this.fClub = fClub;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public int getWorkDay() {
return workDay;
}
public void setWorkDay(int workDay) {
this.workDay = workDay;
}
public String getfClub() {
return fClub;
}
public void setfClub(String fClub) {
this.fClub = fClub;
}
private void writeObject(ObjectOutputStream out) throws IOException {
out.defaultWriteObject();//执行默认的序列化机制
out.writeInt(workDay);
System.out.println("正在进行序列持久化");
}
private void readObject(ObjectInputStream in) throws IOException,
ClassNotFoundException {
in.defaultReadObject();
workDay = in.readInt();
System.out.println("读取持久化对象");
}
@Override
public void readExternal(ObjectInput arg0) throws IOException,
ClassNotFoundException {
// TODO Auto-generated method stub
}
@Override
public void writeExternal(ObjectOutput arg0) throws IOException {
// TODO Auto-generated method stub
}
}
public class Hello {
public static void main(String[] args) {
Person person = new Person(26, "Juventus");
person.setWorkDay(7);
try {
FileOutputStream fs = new FileOutputStream("foo.ser");
ObjectOutputStream os = new ObjectOutputStream(fs);
os.writeObject(person);
os.close();
Person.name = "Alex";
FileInputStream in = new FileInputStream("foo.ser");
ObjectInputStream s = new ObjectInputStream(in);
Person p = (Person) s.readObject();
System.out.println("name==" + Person.name + " age==" + p.getAge()
+ " workDay==" + p.getWorkDay() + " fClub==" + p.getfClub());
} catch (Exception e) {
e.printStackTrace();
}
}
}

当然还有很多开源的序列化和反序列化的库，可以在实际的工程中进行使用。