java 序列化 父子类

环境

java：1.7+

前言

今天读了这篇文章，一篇译文：
我下面的讲解就是基于这篇文章
Java序列化示例教程

到了晚上又看到了这么一篇文章：
Java 序列化的高级认识
中的对敏感字段加密

突然对其中某段代码产生了兴趣；现在记录下

---

回顾

我先记录下我今天看到的知识，看看我记住多少！

1、序列化本质其实就是 对象 –> 二进制，目的为了存储或者网络传输
2、序列化分为自动和手动；也就是实现两个不同的接口。
3、用户或者说开发者可以重写某些方法来控制序列化的过程
4、可以使用transient修饰符来控制某些字段不被序列化。但是这只适用于自动的
5、序列化代理模式能使序列化的安全性达到极高

疑惑一

ois.defaultReadObject();
oos.defaultWriteObject();

上面的作用是什么？

这是我在看继承那章节的代码时遇到的！我这里贴出完整代码：

首先假设，有这么一个父类

public class SuperClass {

    private int id;
    private String value;

    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getValue() {
        return value;
    }
    public void setValue(String value) {
        this.value = value;
    }

}

现在我们写个子类继承上面父类：

public class SubClass extends SuperClass implements Serializable, ObjectInputValidation{

    private static final long serialVersionUID = -1322322139926390329L;

    private String name;

    public String getName() {
        return name;
    }

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

    @Override
    public String toString(){
        return "SubClass{id="+getId()+",value="+getValue()+",name="+getName()+"}";
    }

    //adding helper method for serialization to save/initialize super class state
    private void readObject(ObjectInputStream ois) throws ClassNotFoundException, IOException{
        ois.defaultReadObject();

        //notice the order of read and write should be same
        setId(ois.readInt());
        setValue((String) ois.readObject());

    }

    private void writeObject(ObjectOutputStream oos) throws IOException{
        oos.defaultWriteObject();

        oos.writeInt(getId());
        oos.writeObject(getValue());
    }

    @Override
    public void validateObject() throws InvalidObjectException {
        //validate the object here
        if(name == null || "".equals(name)) throw new InvalidObjectException("name can't be null or empty");
        if(getId() <=0) throw new InvalidObjectException("ID can't be negative or zero");
    }

}

测试代码：

public class InheritanceSerializationTest {

    public static void main(String[] args) {
        String fileName = "subclass.ser";

        SubClass subClass = new SubClass();
        subClass.setId(10);
        subClass.setValue("Data");
        subClass.setName("Pankaj");

        try {
            SerializationUtil.serialize(subClass, fileName);
        } catch (IOException e) {
            e.printStackTrace();
            return;
        }

        try {
            SubClass subNew = (SubClass) SerializationUtil.deserialize(fileName);
            System.out.println("SubClass read = "+subNew);
        } catch (ClassNotFoundException | IOException e) {
            e.printStackTrace();
        }
    }

}

结果为：

SubClass read = SubClass{id=10,value=Data,name=Pankaj}

此时我把下面代码注释掉：

//readObject方法中
ois.defaultReadObject();
//writeObject方法中
oos.defaultWriteObject();

其结果就变成了：

SubClass read = SubClass{id=10,value=Data,name=null}

这里可以猜测出，其作用：
因为子类是实现了序列化接口的，并且又重写了readObject()和writeObject()方法。
那么在序列化或者反序列化时，就会走这两个方法，（并且不会再走ObjectInputStream和ObjectOutputStream中的相应的方法）。那么defaultWriteObject()和defaultReadObject()其实就是没重写时的默认方法。或者说，虽然我重写了，又不想改任何东西，那么就直接调这两个方法就可以了！

说白了，就是序列化的默认方法，对上面的子类而已，其默认只会序列化name这个字段，其从父类继承过来的，并不会序列化，所以你可以再重写的方法中手动处理，使其可以序列化。

后来我又做了个测试，既然子类就是要序列化name字段，我手动处理不也可以吗？
答案是肯定的：

private void readObject(ObjectInputStream ois) throws ClassNotFoundException, IOException {
//      ois.defaultReadObject();
    setName(ois.readUTF());
    setId(ois.readInt());
    setValue(ois.readObject().toString());
}

private void writeObject(ObjectOutputStream oos) throws IOException{
    oos.writeUTF(getName());//
    oos.writeInt(getId());
    oos.writeObject(getValue());
}

也就是调用writeUTF和readUTF方法。这两个方法是以utf-8方式保存字符串。

readResolve与writeReplace作用或者说区别

这个是我在看最后一个例子时，注意到的；

最后一个例子是配合起来用，使序列化达到极高的安全状态。

writeReplace：这个用于序列化；java的序列化机制保证在序列化某个对象之前，先调用该对象的writeReplace()方法，如果该方法返回另一个java对象，则系统转为序列化另一个对象。

系统在序列化某个对象之前，会先调用该对象的writeReplace()和writeObject()两个方法，系统总是先调用被序列化对象的writeReplace()方法，如果该方法返回另一个对象，系统将再次调用另一个对象的writeReplace()方法，直到该方法不再返回另一个对象为止，程序最后将调用该对象的writeObject()方法来保存该对象的状态。

readResolve：用于反序列化；一般用于在序列化类中实现单例模式；

这个方法会紧挨着readObject()之后被调用，该方法的返回值将会代替原来反序列化的对象，而原来readObject()反序列化的对象将会立即丢弃。

readObject()方法在序列化单例类，枚举类时尤其有用。

个人觉得，其就是为了解决反序列化的单例问题而存在的。

我对最后一个例子做了个小测试：

private void readObject(ObjectInputStream ois) throws ClassNotFoundException, IOException{
//          ois.defaultReadObject();
    String oo = ois.readObject().toString();
    System.out.println(oo);
    if(oo.startsWith(PREFIX) && oo.endsWith(SUFFIX)){
        Data a = new Data("1");
a.setData( oo.substring(3, oo.length() -4));
    }
}

/*private Object readResolve() throws InvalidObjectException {
    if(dataProxy.startsWith(PREFIX) && dataProxy.endsWith(SUFFIX)){
    return new Data(dataProxy.substring(3, dataProxy.length() -4));
    }else throw new InvalidObjectException("data corrupted");
}*/

上面注释掉的代码是其原来的代码；

我是改为重写readObject方法，但是报错了：

java.lang.ClassCastException: serializable.Data$DataProxy cannot be cast to serializable.Data

当然这个错，很明了，毕竟序列化保存在文件里的是代理类对象，那么反序列化得到的当然是代理类对象了；此时将其强转为Data，当然就错了；而我重写的那个方法，由于无法改变返回的对象，自然是没起到什么作用！所以需要使用readResolve方法来替换掉原来反序列化的对象（DataProxy）。

当然假设我们不强转的话，只得到代理类的话，还是OK的：
将测试代码修改下：

public static void main(String[] args) throws IOException, ClassNotFoundException {
   String fileName = "data.ser";

   Data data = new Data("Pankaj");

   SerializationUtil.serialize(data, fileName);

   Object newData =  SerializationUtil.deserialize(fileName);
System.out.println(newData);
}

其结果为：

ABCPankajDEFG
serializable.Data$DataProxy@119d7047

总结

目前大概是了解了写序列化的步骤；
之前还想着自己重写个类似功能的jar包出来。
现在看来，我之前的想法过于简单；

参考地址：

黑马程序员——————> 自定义序列化

readResolve()方法与序列化

Serializable：writeReplace

Java序列化示例教程