Java 中的 Serializable 与 transient

由于种种原因，简书等第三方平台博客不再保证能够同步更新，欢迎移步 GitHub：https://github.com/kingcos/Perspective/。谢谢！

注：
由于目前个人对 Java 的理解应用仅限于皮毛，故若有不妥，望及时告知，会及时修正。

  • Info:
  • JDK 1.8
  • Eclipse EE neon

前言

Java 中的 transient 是有关对象序列化的关键字，之前学习中并没有注意，并且没有实际使用。但是这次希望可以总结一下，来了解 Java 的这个特点，故记录于此。

作用

序列化（Serializable）是指把 Java 对象字节序列的过程，就是说将原本保存在内存中的对象，保存到硬盘（或数据库等）中。当需要使用时，再反序列化恢复到内存中使用。在我查到的资料中，通过网络传递对象或是RMI（Remote Method Invocation远程方法调用）都会用到对象序列化。transient 译为短暂的，在这里即不被持久化。有一些敏感数据是不适合被传输，因此需要加上 transient 关键字，即可避免序列化。

Demo

实体类：Account.java

import java.io.Serializable;

// 参与序列化只需要实现 Serializable 接口即可
public class Account implements Serializable {
    // Java 的序列化机制通过判断以下 ID 来进行版本比对，本处使用默认
    private static final long serialVersionUID = 1L;
    
    private Long accountId;
    private String username;
    // transient 修饰：
    private transient String password;
    private transient double balance;
    
    public static int staticVar;
    
    public Account(Long accountId, String username, String password, double balance) {
        super();
        this.accountId = accountId;
        this.username = username;
        this.password = password;
        this.balance = balance;
    }

    public String toString() {
        return "Account [accountId=" + accountId + ", username=" + username + ", password=" + password + ", balance="
                + balance + "]";
    }
    
}

测试类：TestTransient.java

import java.io.*;

public class Demo01 {

    public static void main(String[] args) {
        // 此处需要改为你要存入的地址，注意 Win 下地址中的 \ 需要转义
        String src = "/Users/kingcos/Desktop/demo.object";
        Account kingcos = new Account(62278888L, "kingcos", "123456", 1000.0);
        Account.staticVar = 11;
        System.out.println("序列化之前：");
        System.out.println(kingcos);
        System.out.println("staticVar = " + Account.staticVar);
        
        write(kingcos, src);
        Account.staticVar = 22;
        Account newKingcos = read(src);
        System.out.println("序列化之后：");
        System.out.println(newKingcos);
        System.out.println("staticVar = " + Account.staticVar);
    }
    
    static void write(Account acc, String src) {
        OutputStream os = null;
        ObjectOutputStream oos = null;
        try {
            os = new FileOutputStream(src);
            oos = new ObjectOutputStream(os);
            // 写入
            oos.writeObject(acc);
            
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                oos.flush();
                oos.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
    
    static Account read(String src) {
        Account acc = null;
        InputStream is = null;
        ObjectInputStream ois = null;
        try {
            is = new FileInputStream(src);
            ois = new ObjectInputStream(is);
            // 读取
            acc = (Account) ois.readObject();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } finally {
            try {
                ois.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return acc;
    }
}

// Console:
// 序列化之前：
// Account [accountId=62278888, username=kingcos, password=123456, balance=1000.0]
// staticVar = 11
// 序列化之后：
// Account [accountId=62278888, username=kingcos, password=null, balance=0.0]

总结

序列化

  • 序列化前后的对象内容一样，地址不同，属于深拷贝（deep copy）

serialVersionUID

  • 序列化时系统会把当前类的 serialVersionUID 写入序列化的文件中（也可能是其他的中介），当反序列化的时候系统会去检测文件中的 serialVersionUID，看它是否和当前类的 serialVersionUID 一致，如果一致就说明序列化的类的版本和当前类的版本是相同的，这个时候可以成功反序列化，否则就说明当前类和序列化的类相比发生了某些变化
  • Eclipse 可以根据类名，接口名，方法和属性等来生成一个 64 位的哈希字段，也可添加默认的 1L
  • 当序列化后，对对象进行修改，再进行反序列化所出现的情形，可以查看参考资料中的讲解

静态变量

  • 静态变量是相对于类的，而非对象，因此其也无法参与到序列化中。上面的 Demo 中，我们在写入对象后对静态变量进行修改。而再次读取对象时，该变量的值为我们所修改过的。即序列化会忽略静态变量

其它

  • 当一个父类实现序列化，子类自动实现序列化，不需要显式实现 Serializable 接口
  • 仅实现 Serializable 接口而无其它处理，即为默认序列化机制。在此机制下序列化对象时，不仅会序列化其本身，也会对该其引用的其它对象也进行序列化，同样，这些其它对象引用的另外对象也将被序列化，以此类推。因此有时序列化开销可能较大
  • transient 关键字只能修饰属性（变量），不能修饰方法和类
  • 属性如果也是对象，则该对象对应的类需要实现 Serializable 接口

Externalizable

Externalizable
Externalizable 接口内部实现了 Serializable 接口，但是为其扩展了两个方法，writerExternal() 方法在序列化时被自动调用，可以在其中控制序列化内容，readExternal() 方法在反序列化时被自动调用，可以在其中控制反序列化的内容。如果留空，（反）序列化行为将不会保存或读取任何一个字段，所以 transient 关键字也失效。因此我们可以对（反）序列化进行控制，详见下面的 Demo。
注意：
使用 Externalizable 进行序列化时，当读取对象时，会调用被序列化类的无参构造方法去创建一个新的对象，然后再将被保存对象的字段的值分别填充到新对象中。因此，实现 Externalizable 接口的类必须要提供一个无参的构造器，且它的访问权限为 public。

Demo

该 Demo 基于上处改编

实体类：Account.java

import java.io.Externalizable;
import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectOutput;

// Externalizable 接口内部也实现了 Serializable
public class Account implements Externalizable {
    // Java 的序列化机制通过判断以下 ID 来进行版本比对，本处使用默认
    private static final long serialVersionUID = 1L;
    
    private Long accountId;
    private String username;
    // transient 修饰：
    private transient String password;
    private transient double balance;
    
    public static int staticVar;
    
    public Account() {
        super();
        System.out.println("调用了 无参构造方法");
    }
    
    public Account(Long accountId, String username, String password, double balance) {
        super();
        this.accountId = accountId;
        this.username = username;
        this.password = password;
        this.balance = balance;
    }

    @Override
    public String toString() {
        return "Account [accountId=" + accountId + ", username=" + username + ", password=" + password + ", balance="
                + balance + "]";
    }

    @Override
    public void writeExternal(ObjectOutput out) throws IOException {
        System.out.println("调用 writeExternal");
        out.writeLong(accountId);
        out.writeObject(password);
        out.writeDouble(balance);
    }

    @Override
    public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
        System.out.println("调用 readExternal");
        accountId = in.readLong();
        // 对象类型需要强制类型转换
        password = (String) in.readObject();
        balance = in.readDouble();
    }
    
}

测试类：TextExternalizable.java

import java.io.*;

public class TextExternalizable {

    public static void main(String[] args) {
        // 此处需要改为你要存入的地址，注意 Win 下地址中的 \ 需要转义
        String src = "/Users/kingcos/Desktop/demo.object";
        Account kingcos = new Account(62278888L, "kingcos", "123456", 1000.0);
        Account.staticVar = 11;
        System.out.println("序列化之前：");
        System.out.println(kingcos);
        System.out.println("staticVar = " + Account.staticVar);
        
        write(kingcos, src);
        Account.staticVar = 22;
        Account newKingcos = read(src);
        System.out.println("序列化之后：");
        System.out.println(newKingcos);
        System.out.println("staticVar = " + Account.staticVar);
    }
    
    static void write(Account acc, String src) {
        OutputStream os = null;
        ObjectOutputStream oos = null;
        try {
            os = new FileOutputStream(src);
            oos = new ObjectOutputStream(os);
            // 写入
            oos.writeObject(acc);
            
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                oos.flush();
                oos.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
    
    static Account read(String src) {
        Account acc = null;
        InputStream is = null;
        ObjectInputStream ois = null;
        try {
            is = new FileInputStream(src);
            ois = new ObjectInputStream(is);
            // 读取
            acc = (Account) ois.readObject();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } finally {
            try {
                ois.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return acc;
    }
}

// Console:
// 序列化之前：
// Account [accountId=62278888, username=kingcos, password=123456, balance=1000.0]
// staticVar = 11
// 调用 writeExternal
// 调用了 无参构造方法
// 调用 readExternal
// 序列化之后：
// Account [accountId=62278888, username=null, password=123456, balance=1000.0]
// staticVar = 22

参考资料

本人博客：https://maimieng.com

最后编辑于 ：
©著作权归作者所有,转载或内容合作请联系作者
平台声明：文章内容（如有图片或视频亦包括在内）由作者上传并发布，文章内容仅代表作者本人观点，简书系信息发布平台，仅提供信息存储服务。

推荐阅读更多精彩内容

  • 序列化和反序列化
    JAVA序列化机制的深入研究 对象序列化的最主要的用处就是在传递,和保存对象(object)的时候,保证对象的完整...
    时待吾阅读 13,748评论 0赞 24
  • 对象的序列化与反序列化
    官方文档理解 要使类的成员变量可以序列化和反序列化，必须实现Serializable接口。任何可序列化类的子类都是...
    狮_子歌歌阅读 7,128评论 1赞 3
  • java序列化与反序列化
    原帖地址：原帖个人网站地址：个人网站简书对markdown的支持太完美了，我竟然可以直接Ctrl C/V过来。 定...
    ryderchan阅读 9,193评论 1赞 9
  • 接纳父母一一还给自己一个不一样的我
    当我进入冥想，父母来到我面前时，首先看到母亲，当与母亲对视时，我觉得：愧对母亲的养育之恩！同时看到母亲对我的担心，...
    王泽华wzh阅读 2,415评论 0赞 0
  • 未知的下一秒
    人总是沉浸在幻想中， 祈祷着明天更美好， 期盼着美梦能够成真， 岂知人生无常世事难料！ 奋力拼搏也好， 碌碌无为也...
    十六心域阅读 3,226评论 0赞 0