对象序列化是讲对象持久化的一种方式，这种方式使得对象可以永久存储于本地硬盘，并可以在网络中传输对象信息（如果目的地有相应的类字节码的话）。java中，将对象持久化有两种方式，序列化与XML读写，这篇博客主要描述对象序列化。
Serializable接口与transient关键字
Serizlizable是一个标签接口，这个接口没有任何方法需要实现，只要一个类implements Serializable，那么这个类就是可序列化的，以后可以根据序列化文件恢复这个类对象。
transient是一个关键字，被transient修饰的成员变量不会被序列化，保证了成员变量的隐私性。
反序列化是通过字节序列恢复对象，不会调用类的构造方法。
public class Person implements Serializable
{
private String name;
private int age;
public Person()
{
this("",0);
System.out.println("I'm constructor");
}
public Person(String name,int age)
{
System.out.println("I'm constructor too");
this.name = name;
this.age = age;
}
@Override
public String toString()
{
return name+" "+age;
}
}import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
public class Test
{
public static void main(String[] args) throws IOException, ClassNotFoundException
{
Person p = new Person("asd",2);
System.out.println(p); //asd 2
ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("person.dat"));
out.writeObject(p);
out.close();
ObjectInputStream in = new ObjectInputStream(new FileInputStream("person.dat"));
Person pX = (Person)in.readObject();//不会调用构造方法
System.out.println(pX); //asd 0,age被transient修饰了
}
}Serializable的特殊实现
Serializable是一个标签接口，你只需要implements Serializable而不需要实现任何方法。但是神奇的是，如果你implements Serializable后，添加两个方法（writeObject（）和readObject（）），你就可以控制序列化。
- defaultWriteObject(),defaultReadObject()连个方法就是默认的序列化函数，加入你在writeObject（）方法中调用defaultWriteObject（）方法，就会序列化所有没有被transient修饰的成员变量。
- 如果你序列化transient关键字修饰的成员变量，transient关键字失效，被修饰的成员变量也会被序列化
- 成员变量序列化与反序列化顺序相同
- 不会调用构造函数
import java.io.Externalizable;
import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectInputStream;
import java.io.ObjectOutput;
import java.io.ObjectOutputStream;
import java.io.Serializable;
public class Person implements Serializable
{
private String name;
private transient int age;
public Person()
{
this("",0);
System.out.println("I'm constructor");
}
public Person(String name,int age)
{
this.name = name;
this.age = age;
}
@Override
public String toString()
{
return name+" "+age;
}
private void writeObject(ObjectOutputStream out) throws IOException
{
out.defaultWriteObject(); //默认序列化，序列化所有没有被transient修饰的成员变量
out.writeInt(age); //显示序列化，transient失效，age任然被序列化
}
private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException
{
in.defaultReadObject(); //默认反序列化
this.age = in.readInt();
}
}import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
public class Test
{
public static void main(String[] args) throws IOException, ClassNotFoundException
{
Person p = new Person("asd",2);
System.out.println(p);
ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("person.dat"));
out.writeObject(p);
out.close();
ObjectInputStream in = new ObjectInputStream(new FileInputStream("person.dat"));
Person pX = (Person)in.readObject();
System.out.println(pX);
}
}serialVersionUID作用
相信用过eclipse的朋友们都会看过这么一个异常，”The serializable class Person does not declare a static final serialVersionUID field of type long”
,就是一个class Person没有声明long 类型的serialVersionUID成员变量。之所以要声明这么一个成员变量，是为了验证版本是否一致，当serialVersionUID相同则认为版本一致，进行序列化/反序列化操作。具体请看下面，随便安利一下这个网站。
http://swiftlet.net/archives/1268
Externalizable
实现Externalizable接口是另一种实现对象序列化的方式，他比Serializable接口更灵活，由你自己确定哪些成员变量需要序列化。他与Serializable接口最大的不同就是他会调用默认构造函数，如果序列化的类没有公共的默认构造函数的话，就会报错。
- 实现readExternal()与writeExternal()方法
- 成员变量序列化顺序必须相同，比如你的序列化顺序是name、age、high，那么你的反序列化顺序也必须是name、age、high
- 一定要有公共的默认构造函数（反序列化时会调用）
- 如果你序列化transient关键字修饰的成员变量，transient关键字失效
import java.io.Externalizable;
import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectInputStream;
import java.io.ObjectOutput;
import java.io.ObjectOutputStream;
import java.io.Serializable;
public class Person implements Externalizable
{
private String name;
private transient int age;//失效,具体得看接口的实现
public Person()
{
this("",0);//即使在默认构造函数中调用别的构造函数，也不会影响
System.out.println("I'm constructor");
}
public Person(String name,int age)
{
this.name = name;
this.age = age;
}
@Override
public String toString()
{
return name+" "+age;
}
@Override
public void writeExternal(ObjectOutput out) throws IOException
{
out.writeObject(name);
out.writeInt(age);
}
@Override
public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException
{
//反序列化顺序与序列化顺序相同
name = (String)in.readObject();
age = in.readInt();
}
}
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
public class Test
{
public static void main(String[] args) throws IOException, ClassNotFoundException
{
Person p = new Person("asd",2);
System.out.println(p);
ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("person.dat"));
out.writeObject(p);
out.close();
ObjectInputStream in = new ObjectInputStream(new FileInputStream("person.dat"));
Person pX = (Person)in.readObject();//调用默认构造函数
System.out.println(pX);
}
}当序列化一个具有类成员变量的对象时
当成员变量用static修饰时，这个成员变量就成为类成员变量，这个变量的拥有者就是这个类了,当你序列化一个具有类成员变量的对象时，对象的类成员变量其实就不受控制了，最终的结果其实等于反序列那一刻，类成员变量的值而不是序列化时类成员变量的值。
import java.io.Externalizable;
import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectInputStream;
import java.io.ObjectOutput;
import java.io.ObjectOutputStream;
import java.io.Serializable;
public class Person implements Serializable
{
public static int ID = 1; //类成员变量ID
private String name;
private int age;
public Person()
{
this("",0);
System.out.println("I'm constructor");
}
public Person(String name,int age)
{
this.name = name;
this.age = age;
}
@Override
public String toString()
{
return ID +" "+name+" "+age;
}
}
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
public class Test
{
public static void main(String[] args) throws IOException, ClassNotFoundException
{
Person p = new Person("asd",2);
System.out.println(p);
ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("person.dat"));
out.writeObject(p); //序列化对象时，ID=1
out.close();
Person.ID = 2; //修改ID值，会影响下面反序列化ID的值
ObjectInputStream in = new ObjectInputStream(new FileInputStream("person.dat"));
Person pX = (Person)in.readObject(); //序列化对象时，ID=2
System.out.println(pX);
}
}如果你想要保存类成员变量信息，那你就要显示序列化与反序列类成员变量了。
在Person.java中添加两个方法
public void serialize(ObjectOutput out) throws IOException
{
out.writeInt(ID);
}
public void deserizlize(ObjectInput in) throws IOException
{
ID = in.readInt();
}在Test.java中显示调用上述两个方法
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
public class Test
{
public static void main(String[] args) throws IOException, ClassNotFoundException
{
Person p = new Person("asd",2);
System.out.println(p);
ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("person.dat"));
out.writeObject(p);
p.serialize(out); //显示调用序列化
out.close();
Person.ID = 2;
ObjectInputStream in = new ObjectInputStream(new FileInputStream("person.dat"));
Person pX = (Person)in.readObject(); //显示调用反序列化
p.deserizlize(in);
System.out.println(pX);
}
}最后，对象序列化有一个致命的缺陷，就是我这个对象是用java序列化的，那你想要获取我这个对象，你就也得用java来反序列化从而获取我这个对象，这相比XML就有些不足了，因为XML不受平台于语言的限制。
以上（by the way ,今天剪的头真难看！！！）
Referer
-《think in java》
扫一扫
2313
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
