序列化最基本使用

public class A implements Serializable{
    private static final long serialVersionUID = 9175036933185692367L;
    private final String name;
    private String Id;
    public A(String name,String Id){
        this.name = name;
        this.Id = Id;
    }    public void methodA(){
        System.out.println("My name is zazalu" + Id);
    }
}

class B{
    public static void main(String[] args) throws IOException {
        //将A序列化
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(new File("test.txt")));
        A a = new A("zazaluA","123456");
        oos.writeObject(a);
    }
}

class C{
    //将A反序列化
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream(new File("test.txt")));
        A a = (A) ois.readObject();
        a.methodA();    //输出My name is zazalu123456
    }
}

以上就是最基本的序列化使用方式，不多说。接下来来思考Serializable到底在底层发生了什么

其实，上面的代码其实隐式调用了2个方法

private void writeObject(java.io.ObjectOutputStream out) throws IOException;
private void readObject(java.io.ObjectInputStream in) throws IOException, ClassNotFoundException;

接下来我们来演示下，将这两个方法在A类中重写

private void readObject(ObjectInputStream in){
    System.out.println("调用了readObject");
}
private void writeObject(java.io.ObjectOutputStream out){
    System.out.println("调用了writeObject");
}

然后我们在此运行下，控制台输出就变成了这样：

Paste_Image.png

可见，这两个方法都被调用了。

那么接下来我们就要学习这两个方法到底可以做什么？

首先我们先了解下下面两个方法

in.defaultReadObject(); 
out.defaultWriteObject(); //in和out是对象输入输出流的两个实例

这两个方法其实是对象流读写对象的默认的底层调用方法。
当我们使用out.writeObject()和in.readObject()的时候，就会默认去调用

in.defaultReadObject(); 
out.defaultWriteObject();

这两个方法是会把允许序列化的属性和方法进行序列化和反序列化(被transient关键字修饰的属性方法是不会被默认序列化的)

既然

in.defaultReadObject(); 
out.defaultWriteObject();

这两个是默认的方法，那么看来我们可以自定义序列化过程
如何自定义序列化，其实方法有很多
主要是使用

private void readObject(ObjectInputStream in){
    System.out.println("只反序列化Id属性");
    out.writeObject(Id);
}
private void writeObject(java.io.ObjectOutputStream out){
    System.out.println("只序列化Id属性");
    this.Id = in.readObject();
}

在序列化的类中重写这两个方法进行自定义序列化！上述写法就只序列化了一个Id属性，而name属性没有序列化！

但是我们这样自定义序列化是很粗糙的，因为我们没有处理很多细节方法的问题，比如NotActiveException我们就没有做处理。所以我们最好是

in.defaultReadObject(); 
out.defaultWriteObject();

让这两个方法被调用。所以我们可以如此实现
1.先将所有属性方法哟哦那个transient关键字修饰
2.将你想要序列化的字段用out.writeObject()和in.readObject()来实现
3.在最后调用in.defaultReadObject(); 和in.defaultReadObject(); 来保证细节处理正常

private void readObject(ObjectInputStream in){
    System.out.println("只反序列化Id属性");
    out.writeObject(Id);
    in.defaultReadObject();  
}
private void writeObject(java.io.ObjectOutputStream out){
    System.out.println("只序列化Id属性");
    this.Id = in.readObject();
    in.defaultReadObject(); 
}

序列化安全问题

1.首先，序列化出来的字节流，可以进行分析，从而给攻击者暴露了所有的信息，解决方法：在序列化时对字段进行加密，反序列化的时候再进行解密
2.其次，攻击者可以伪造字节流，然后通过反序列化获取珍贵的信息。
比如（Period是一个类，有start和end这两个Date属性）

ByteArrayOutputStream bos = new ByteArrayOutputStream();  
ObjectOutputStream oos = new ObjectOutputStream(/*new FileOutputStream(new File("D:/obj.data"))*/bos);  
oos.writeObject(new Period(new Date(), new Date()));  
/*
伪造一个字节流，这个字节流以一个有效的Period实例所产生的字节流作为开始，然后附加上两个额外的引用，指向Period实例中的两个内部私有Date域，攻击者通过引用攻击内部域
*/          
byte[] ref = {0x71, 0 , 0x7e, 0, 5};  
bos.write(ref);  
ref[4] = 4;  
bos.write(ref);  
          
ObjectInputStream ois = new ObjectInputStream(/*new FileInputStream(new File("D:/obj.data"))*/new ByteArrayInputStream(bos.toByteArray()));  
period = (Period)ois.readObject();  
start = (Date)ois.readObject();  //获取到了Period里的start属性引用
end = (Date)ois.readObject();  //获取到了Period里的end属性引用

......
//获取到的end属性，我们可以修改，因为是对象类型，所以period里的end属性也发生了变化！这实在是太恶毒了
end.setYear(78);

解决办法：使用保护性拷贝！

private void readObject(java.io.ObjectInputStream in)

 throws IOException, ClassNotFoundException{

 in.defaultReadObject();

 start = new Date(start.getTime());

 end = new Date(end.getTime()); //重新创建start和end对象引用

 }

可是这办法因为二次修改了属性的引用，所以无法和final字段配合使用，更多时候我们会希望属性是final的，这样就不会被轻易修改了。

加强解决办法：使用序列化代理