深入理解序列化

问题：

• 序列化是为了作甚
  1.数据持久化(少)
  2.网络传输对象(多)
  远程调用RMI和远程过程调用RPC都依赖于序列化

• 序列化一般怎么用

第一种

继承serializable接口即可，serializable为标记接口，没有任何方法，但如果一个待序列化对象不实现该接口，将抛出NotSerializableException异常
String，Array，Enum，基本数据类型都可序列化。
跨进程怎么使用序列化，要求就是具有相同的对象class文件，相同指对象的功能和类路径都必须一致。serialVersionUID也一致。

第二种
实现Externalizable接口，该接口是Serializable的子接口

public interface Externalizable extends java.io.Serializable {
    // 序列化
    void writeExternal(ObjectOutput out) throws IOException;
    // 反序列化
    void readExternal(ObjectInput in) throws IOException, ClassNotFoundException;
}

如果序列化时实现该接口，则需要自主控制所有序列化细节。也就是说，该接口是一个正常的接口，使用时遵循JAVA语法即可。作为标记接口的Serializable反序列化时不会调用构造方法，而实现该接口反序列时则需要调用类的无参构造方法，然后调用readExternal()方法。

class User implements Externalizable {
    private static final long serialVersionUID = 42L;

    private String name;
    private transient String password;

    public User() {}
    
    @Override
    public void writeExternal(ObjectOutput out) throws IOException {
        out.writeUTF(name);
        out.writeUTF(encrypt(password));
    }
    
    @Override
    public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
        this.name = in.readUTF();
        String encryptStr = in.readUTF();
        System.out.println(encryptStr);
        this.password = decrypt(encryptStr);
    }
}

• 什么情况下会序列化，什么情况下不会序列化，我怎么用实践证明它是否序列化。
  transient，static 为什么不行，继承关系，子类继承serializable父类未继承serializable的情况，父类继承serializable子类未继承serializable的情况呢，以下代码

怎么看是否序列化 ，上代码

class BaseBean {
    public String property1 = "property1";
    public String property2 = "property2";

 //无参构造,如没有无参构造,子类反序列化会失败
//    public BaseBean(){
//
//    }

}

class TestBean extends BaseBean implements Serializable {

    public static final int serialVersionUID = 1;

    public transient  String desc = "transient";
    public static String prostatic = "static";
}

public class Test2 {
    public static void main(String[] args) {
        TestBean testBean = new TestBean();
       // testBean.property2 = "22222";   即时定义了为“2222”，如果父类未Serializable继承接口，则返回的还是初始化的值“property2”
        System.out.println(testBean);
        serialization(testBean, "/Users/xxx/Desktop/testBean.ser");
        System.out.println("序列化成功");
        TestBean deserialization = deserialization("/Users/xxx/Desktop/testBean.ser");
        System.out.println("反序列化成功");
        System.out.println(deserialization);
    }

    public static void serialization(TestBean src, String target) {
        FileOutputStream fos = null;
        ObjectOutputStream oos = null;
        try {
            fos = new FileOutputStream(target);
            oos = new ObjectOutputStream(fos);
            oos.writeObject(src);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                oos.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    public static TestBean deserialization (String target){
        FileInputStream fis = null;
        ObjectInputStream ois = null;
        try {
            fis = new FileInputStream(target);
            ois = new ObjectInputStream(fis);
            Object o = ois.readObject();
            return (TestBean) o;
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }finally {
            try {
                ois.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

}

问题：请问上图哪些序列化了哪些没有序列化。

**********输出：******************

TestBean{desc='transient', property1='property1', property2='property2'}
序列化成功
反序列化成功
TestBean{desc='null', property1='property1', property2='property2'}

*****如果BaseBean没有无参构造，输出：******

TestBean{desc='transient', property1='property1', property2='property2'}
序列化成功
java.io.InvalidClassException: TestBean; no valid constructor
    at java.io.ObjectStreamClass$ExceptionInfo.newInvalidClassException(ObjectStreamClass.java:169)
    at java.io.ObjectStreamClass.checkDeserialize(ObjectStreamClass.java:885)
    at java.io.ObjectInputStream.readOrdinaryObject(ObjectInputStream.java:2099)
    at java.io.ObjectInputStream.readObject0(ObjectInputStream.java:1624)
    at java.io.ObjectInputStream.readObject(ObjectInputStream.java:464)
    at java.io.ObjectInputStream.readObject(ObjectInputStream.java:422)
    at Test2.deserialization(Test2.java:94)
    at Test2.main(Test2.java:65)
反序列化成功
null

• 继承
  当一个父类实现序列化，子类自动实现序列化，不需要显式实现Serializable接口。当一个子类实现序列化，而父类没有实现序列化。序列化正常，但反序列化时抛出异常。
  解决办法：父类不实现Serializable接口，但提供一个无参构造方法。此时，子类中的字段可以恢复为序列化前的值，但父类中的字段依然为初始化默认值。

• 静态
  JAVA序列化保存的是对象的状态，而静态变量不是对象的状态而是类的状态，所以序列化不保存静态变量。

• transient
  在不希望被序列化的字段前添加transient关键字，序列化时将忽略该字段。直接输出为null