Javatransient关键字怎么用？手把手教你字段排除小技巧

想要轻松掌握Java序列化中的字段排除技巧吗？本文将深入解析Java中的`transient`关键字，助你理解其在阻止字段序列化中的关键作用。`transient`关键字常用于保护敏感信息如密码，避免其被持久化；也可用于排除计算型字段，减少数据大小，优化性能。文章还将对比`transient`与`static`的区别，并介绍如何通过实现`Externalizable`接口自定义序列化逻辑，实现更精细的字段控制，例如加密或压缩。务必注意，实现`Externalizable`接口的类需要提供无参构造函数。掌握`transient`，让你的Java序列化更安全、高效！

transient关键字在Java中的作用是阻止某些字段被序列化。具体原因包括：1. 安全敏感信息如密码、密钥等不应被保存；2. 计算型字段可通过其他字段重新计算，无需存储；3. 排除字段可减少数据大小，提高性能。此外，static字段本身不会被序列化，因其属于类而非对象。若需更精细控制，可通过实现Externalizable接口自定义序列化逻辑，如加密或压缩字段，并注意必须提供无参构造函数用于反序列化。

transient关键字在Java中，简单来说，就是告诉JVM，这个字段我不希望被序列化。

解析字段排除

transient关键字的主要作用是阻止对象的某些字段在序列化过程中被保存。这在很多场景下都很有用，比如：

• 安全敏感信息： 密码、密钥等敏感信息不应该被序列化到磁盘或者网络中。
• 计算型字段： 某些字段的值可以通过其他字段计算得到，不需要保存，在反序列化后重新计算即可。
• 优化性能： 排除不必要的字段可以减少序列化和反序列化的大小，提高性能。

为什么需要transient？

序列化是Java中一种将对象转换为字节流的过程，以便可以存储到磁盘或通过网络传输。默认情况下，一个对象的所有非静态字段都会被序列化。但有些字段可能包含敏感信息，或者在反序列化后重新计算即可，没有必要进行序列化。这时候，transient就派上用场了。

举个例子，假设你有一个User类：

import java.io.Serializable;

public class User implements Serializable {

    private String username;
    private transient String password;
    private int age;

    public User(String username, String password, int age) {
        this.username = username;
        this.password = password;
        this.age = age;
    }

    public String getUsername() {
        return username;
    }

    public String getPassword() {
        return password;
    }

    public int getAge() {
        return age;
    }

    @Override
    public String toString() {
        return "User{" +
                "username='" + username + '\'' +
                ", password='" + password + '\'' +
                ", age=" + age +
                '}';
    }
}

在这个例子中，password字段被声明为transient。这意味着，当User对象被序列化时，password字段的值不会被保存。反序列化后，password字段的值将是null（对于对象类型）或者类型的默认值（比如0对于int类型）。

transient和static的区别是什么？

static字段属于类，而不是对象。序列化只针对对象的状态，所以static字段无论是否被声明为transient，都不会被序列化。简单来说，序列化关注的是对象实例，而static字段属于类级别，因此不在序列化的考虑范围内。

如何自定义序列化过程？

除了使用transient，你还可以通过实现Externalizable接口来完全控制序列化和反序列化的过程。Externalizable接口继承自Serializable接口，但它提供了writeExternal()和readExternal()方法，允许你自定义序列化和反序列化的逻辑。这给了你更大的灵活性，可以决定哪些字段需要序列化，以及如何序列化它们。

例如：

import java.io.*;

public class ExternalizableUser implements Externalizable {

    private String username;
    private String password;
    private int age;

    public ExternalizableUser() {
        // 必须提供一个无参构造函数
    }

    public ExternalizableUser(String username, String password, int age) {
        this.username = username;
        this.password = password;
        this.age = age;
    }

    public String getUsername() {
        return username;
    }

    public String getPassword() {
        return password;
    }

    public int getAge() {
        return age;
    }

    @Override
    public void writeExternal(ObjectOutput out) throws IOException {
        // 自定义序列化逻辑
        out.writeObject(username);
        // 可以对密码进行加密后再序列化
        out.writeObject(encrypt(password));
        out.writeInt(age);
    }

    @Override
    public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
        // 自定义反序列化逻辑
        username = (String) in.readObject();
        // 解密密码
        password = decrypt((String) in.readObject());
        age = in.readInt();
    }

    private String encrypt(String password) {
        // 简单的加密示例
        return new StringBuilder(password).reverse().toString();
    }

    private String decrypt(String encryptedPassword) {
        // 简单的解密示例
        return new StringBuilder(encryptedPassword).reverse().toString();
    }

    @Override
    public String toString() {
        return "ExternalizableUser{" +
                "username='" + username + '\'' +
                ", password='" + password + '\'' +
                ", age=" + age +
                '}';
    }
}

在这个例子中，writeExternal()方法定义了如何序列化对象，readExternal()方法定义了如何反序列化对象。你可以根据需要对字段进行加密、压缩等处理。注意，实现Externalizable接口的类必须提供一个无参构造函数，因为在反序列化时，JVM会先调用无参构造函数创建一个对象，然后再调用readExternal()方法来填充对象的状态。

今天带大家了解了的相关知识，希望对你有所帮助；关于文章的技术知识我们会一点点深入介绍，欢迎大家关注golang学习网公众号，一起学习编程~