Java平台允许我们在内存中创建可复用的Java对象,但一般情况下,只有当JVM处于运行时,这些对象才可能存在,即,这些对象的生命周期不会比JVM的生命周期更长。
但在现实应用中,就可能要求在JVM停止运行之后能够保存(持久化)指定的对象,并在将来重新读取被保存的对象。Java对象序列化就能够帮助我们实现该功能。使用Java对象序列化,在保存对象时,会把其状态保存为一组字节,在未来,再将这些字节组装成对象。
必须注意地是,对象序列化保存的是对象的”状态”,即它的成员变量。由此可知,对象序列化不会关注类中的静态变量。
Demo:
public static void main(String[] args) throws Exception {
// 对象序列化输出
ObjectOutputStream objOut = new ObjectOutputStream(new FileOutputStream("F:\\1.txt"));
Man kole = new Man();
kole.setName("kole");
objOut.writeObject(kole);
objOut.close();
// 对象序列化输入
ObjectInputStream objIn = new ObjectInputStream(new FileInputStream("F:\\1.txt"));
Object newMan = objIn.readObject();
if (newMan instanceof Man){
System.out.println(((Man)newMan).getName());
}
objIn.close();
}
// 可被序列化的对象
public class Man implements Serializable{
private String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
为什么一个类要实现Serializable接口?
// ObjectOutputStream源码
//..
if (obj instanceof String) {
writeString((String) obj, unshared);
} else if (cl.isArray()) {
writeArray(obj, desc, unshared);
} else if (obj instanceof Enum) {
writeEnum((Enum) obj, desc, unshared);
} else if (obj instanceof Serializable) {
writeOrdinaryObject(obj, desc, unshared);
} else {
// 非String、数组、枚举、序列化对象直接报错
if (extendedDebugInfo) {
throw new NotSerializableException(
cl.getName() + "\n" + debugInfoStack.toString());
} else {
throw new NotSerializableException(cl.getName());
}
}
//..
transient
当某个字段被声明为transient后,默认序列化机制就会忽略该字段。
public class Man implements Serializable
{
// ..
// 此字段将不会被序列化
private transient double money;
// ..
}
writeObject()&readObject()
声明为transitive的字段不一定无法将其序列化, 可通过writeObject()与readObject()方法实现自序列化而跳过transitive关键字;
public class Man implements Serializable{
private String name;
private transient double money;
// 只要添加writeObject和readObject方法即可
private void writeObject(ObjectOutputStream out) throws IOException {
out.defaultWriteObject();
out.writeDouble(this.money);
}
private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
in.defaultReadObject();
this.money = in.readDouble();
}
// get()、set()...
}
why?
// 如果自己实现writeObject; 就根据自己的方法实现
// 因此自己的方法中需要实现默认writeObject的方法。
if (slotDesc.hasWriteObjectMethod()) {
PutFieldImpl oldPut = curPut;
curPut = null;
SerialCallbackContext oldContext = curContext;
if (extendedDebugInfo) {
debugInfoStack.push(
"custom writeObject data (class \"" +
slotDesc.getName() + "\")");
}
try {
curContext = new SerialCallbackContext(obj, slotDesc);
bout.setBlockDataMode(true);
// 调用自定义的writeObject方法
slotDesc.invokeWriteObject(obj, this);
bout.setBlockDataMode(false);
bout.writeByte(TC_ENDBLOCKDATA);
} finally {
curContext.setUsed();
curContext = oldContext;
if (extendedDebugInfo) {
debugInfoStack.pop();
}
}
curPut = oldPut;
} else {
// 调用默认的写方法
defaultWriteFields(obj, slotDesc);
}
Externalizable
无论是使用transient关键字,还是使用writeObject()和readObject()方法,其实都是基于Serializable接口的序列化。
JDK中提供了另一个序列化接口–Externalizable实现该接口之后,之前基于Serializable接口的序列化机制就将失效。
public class Man implements Externalizable {
private String name;
private transient double money;
// 需要构造函数(没有报错no valid constructor)
public Man(){
}
@Override
public void writeExternal(ObjectOutput out) throws IOException {
out.writeDouble(this.money);
}
@Override
public void readExternal(ObjectInput in) throws IOException,
ClassNotFoundException {
this.money = in.readDouble();
}
}
// Externalizable 继承于Serializable
public interface Externalizable extends java.io.Serializable
// ..
// 如果实现Externalizable则走自定义的方法
if (desc.isExternalizable() && !desc.isProxy()) {
// 自定义序列化
// 内部调用writeExternal(this);
writeExternalData((Externalizable) obj);
} else {
// 系统实现的序列化
writeSerialData(obj, desc);
}
readResolve()
当序列化的对象是单例模式时, 可通过readResolve方法返回一个对象, 而替换序列化读取的对象。
public class Man implements Serializable {
private static Man singleThiz = null;
private String name;
private transient double money;
private Man() {
}
// 实现读取结果方法
private Object readResolve() throws ObjectStreamException {
return Man.getInstance();
}
public static Man getInstance() {
if (Man.singleThiz == null) {
synchronized (Man.class) {
if (Man.singleThiz == null) {
Man.singleThiz = new Man();
}
}
}
return Man.singleThiz;
}
}
// 是否存在ReadResolveMethod方法
if (obj != null &&
handles.lookupException(passHandle) == null &&
desc.hasReadResolveMethod()){
// 获得readResolve得到的方法
Object rep = desc.invokeReadResolve(obj);
if (unshared && rep.getClass().isArray()) {
rep = cloneArray(rep);
}
// 生成的obj对象与readResolve方法返回不同,进行替换
if (rep != obj) {
handles.setObject(passHandle, obj = rep);
}
}
无论是实现Serializable接口,或是Externalizable接口,当从I/O流中读取对象时,readResolve()方法都会被调用到。实际上就是用readResolve()中返回的对象直接替换在反序列化过程中创建的对象。