Java中的序列化及其transient关键字

1、常用的两种序列化方式

实现Serializable接口
实现Externalizable接口，重写writeExternal和readExternal方法

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

2、序列化控制

当我们对序列化进行控制时，可能某个特定子对象不想让Java序列化机制自动保存与恢复。如果子对象表示的是我们不希望将其序列化的敏感信息（如密码），通常会面临这种情况。即使对象中的这些信息是private属性，一经序列化处理，人们就可以通过读取文件或者拦截网络传输的方式来访问到它。有两种办法可以防止对象的敏感部分被序列化：

一旦变量被transient修饰，变量将不再是对象持久化的一部分，该变量内容在序列化后无法获得访问。
transient关键字只能修饰变量，而不能修饰方法和类。注意，本地变量是不能被transient关键字修饰的。变量如果是用户自定义类变量，则该类需要实现Serializable接口。
被transient关键字修饰的变量不再能被序列化，一个静态变量不管是否被transient修饰，均不能被序列化。

举个栗子

public class LoggingInfo implements Serializable {

    private Date loggingDate = new Date();
    private String uid;
    private transient String pwd;

    public LoggingInfo(String user, String password) {
        uid = user;
        pwd = password;
    }

    @Override
    public String toString() {
        return "LoggingInfo{" +
                "loggingDate=" + loggingDate.toString() +
                ", uid='" + uid + '\'' +
                ", pwd='" + pwd + '\'' +
                '}';
    }

}

public static void main(String[] args) {

        LoggingInfo logInfo = new LoggingInfo("MIKE", "MECHANICS");
        System.out.println(logInfo.toString());
        try {
            ObjectOutputStream o = new ObjectOutputStream(new FileOutputStream("logInfo.out"));
            o.writeObject(logInfo);
            o.close();
        } catch (Exception e) {
            e.printStackTrace();
        }

        try {
            ObjectInputStream in = new ObjectInputStream(new FileInputStream("logInfo.out"));
            LoggingInfo logInfo2 = (LoggingInfo) in.readObject();
            System.out.println(logInfo2.toString());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

输出结果：

LoggingInfo{loggingDate=Sun Feb 25 10:44:29 CST 2018, uid='MIKE', pwd='MECHANICS'}
LoggingInfo{loggingDate=Sun Feb 25 10:44:29 CST 2018, uid='MIKE', pwd='null'}

可以看到被transient修饰的pwd反序列化为null。

3、实现Externalizable接口

public class LoggingInfo implements Externalizable {

    private Date loggingDate = new Date();
    private String uid;
    private transient String pwd;

    public LoggingInfo(String user, String password) {
        uid = user;
        pwd = password;
    }

    @Override
    public String toString() {
        return "LoggingInfo{" +
                "loggingDate=" + loggingDate.toString() +
                ", uid='" + uid + '\'' +
                ", pwd='" + pwd + '\'' +
                '}';
    }

    @Override
    public void writeExternal(ObjectOutput out) throws IOException {
        out.writeObject(loggingDate);
        out.writeUTF(uid);
        out.writeUTF(pwd);
    }

    @Override
    public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
        loggingDate = (Date) in.readObject();
        uid = in.readUTF();
        pwd = in.readUTF();
    }
}

其他不变，运行后发现报错：

LoggingInfo{loggingDate=Sun Feb 25 11:25:54 CST 2018, uid='MIKE', pwd='MECHANICS'}
java.io.InvalidClassException: com.justin.practice.entity.LoggingInfo; no valid constructor
at java.io.ObjectStreamClass$ExceptionInfo.newInvalidClassException(ObjectStreamClass.java:150)
atjava.io.ObjectStreamClass.checkDeserialize(ObjectStreamClass.java:790)
at java.io.ObjectInputStream.readOrdinaryObject(ObjectInputStream.java:1782)
at java.io.ObjectInputStream.readObject0(ObjectInputStream.java:1353)
at java.io.ObjectInputStream.readObject(ObjectInputStream.java:373)
at com.justin.practice.Main.main(Main.java:31)

在LoggingInfo中增加无参公共构造函数后运行结果如下：

LoggingInfo{loggingDate=Sun Feb 25 11:29:56 CST 2018, uid='MIKE', pwd='MECHANICS'}
LoggingInfo{loggingDate=Sun Feb 25 11:29:56 CST 2018, uid='MIKE', pwd='MECHANICS'}

可以看到输出结果不受transient的控制。

- 注意事项：

1、对Serializable对象反序列化时，由于Serializable对象完全以它存储的二进制位为基础来构造，因此并不会调用任何构造函数，因此Serializable类无需默认构造函数，但是当Serializable类的父类没有实现Serializable接口时，反序列化过程会调用父类的默认构造函数，因此该父类必需有默认构造函数，否则会抛异常。
2、对Externalizable对象反序列化时，会先调用类的不带参数的构造方法，这是有别于默认反序列方式的。如果把类的不带参数的构造方法删除，或者把该构造方法的访问权限设置为private、默认或protected级别，会抛出java.io.InvalidException: no valid constructor异常，因此Externalizable对象必须有默认构造函数，而且必需是public的。

Java transient关键字使用小记