Java transient案例如何使用

wen java案例 2026-07-01 24

Java transient关键字详解：从入门到实战案例

目录导读

transient关键字是什么？
为什么要使用transient？
transient实战案例演示
关键问答Q&A
注意事项与最佳实践

transient关键字是什么？

在Java中，transient是一个修饰符，用于标记类的成员变量，它的核心作用是告诉JVM：在序列化对象时，跳过这个字段，不将其写入字节流。

Java transient案例如何使用

基础语法

public class User implements Serializable {
    private String name;
    private transient String password; // 序列化时忽略
    private transient int age;         // 序列化时忽略
}

运行机制

当对象实现Serializable接口后，默认所有非transient字段都会被序列化
被transient修饰的字段在反序列化后会恢复为默认值（引用类型为null，基本类型为0/false）

为什么要使用transient？

场景1：敏感数据保护

密码、银行卡号等敏感信息不应暴露在序列化文件中，使用transient可以防止数据泄露。

场景2：不必要的数据

某些字段可以通过计算得到，如年龄（由出生日期计算）,无需存储。

场景3：非可序列化对象

如果字段引用了未实现Serializable的第三方类，直接序列化会抛出NotSerializableException，使用transient跳过它们是常见解决方案。

场景4：减少网络传输量

在RPC（远程过程调用）或微服务通信中，跳过无用字段可降低带宽消耗。

transient实战案例演示

案例1：用户登录系统（密码保护）

import java.io.*;
public class User implements Serializable {
    private static final long serialVersionUID = 1L;
    private String username;
    private transient String password; // 密码不序列化
    private int loginCount;
    public User(String username, String password) {
        this.username = username;
        this.password = password;
        this.loginCount = 0;
    }
    // getters/setters...
    public static void main(String[] args) throws Exception {
        User user = new User("admin", "mypassword123");
        // 序列化
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("user.ser"));
        oos.writeObject(user);
        oos.close();
        // 修改原对象
        user = null;
        // 反序列化
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("user.ser"));
        User loadedUser = (User) ois.readObject();
        ois.close();
        System.out.println("用户名: " + loadedUser.getUsername());
        System.out.println("密码: " + loadedUser.getPassword()); // 输出 null
        System.out.println("登录次数: " + loadedUser.getLoginCount());
    }
}

输出结果：

用户名: admin
密码: null
登录次数: 0

案例2：缓存场景（忽略计算字段）

import java.io.*;
import java.time.LocalDate;
import java.time.Period;
public class Employee implements Serializable {
    private static final long serialVersionUID = 2L;
    private String name;
    private LocalDate birthDate;
    private transient int age; // 动态计算，不序列化
    public Employee(String name, LocalDate birthDate) {
        this.name = name;
        this.birthDate = birthDate;
        this.age = Period.between(birthDate, LocalDate.now()).getYears();
    }
    // 反序列化后手动恢复年龄
    private void readObject(ObjectInputStream ois) throws IOException, ClassNotFoundException {
        ois.defaultReadObject();
        // 反序列化执行后的自定义逻辑
        this.age = Period.between(this.birthDate, LocalDate.now()).getYears();
    }
    public int getAge() {
        return age;
    }
    public static void main(String[] args) throws Exception {
        Employee emp = new Employee("张三", LocalDate.of(1990, 5, 15));
        System.out.println("序列化前年龄: " + emp.getAge());
        // 序列化与反序列化
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("emp.ser"));
        oos.writeObject(emp);
        oos.close();
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("emp.ser"));
        Employee loadedEmp = (Employee) ois.readObject();
        ois.close();
        System.out.println("反序列化后年龄: " + loadedEmp.getAge()); // 自动重新计算
    }
}

案例3：防止序列化代理模式失效

public class SingletonServer implements Serializable {
    private static final long serialVersionUID = 3L;
    private static final SingletonServer INSTANCE = new SingletonServer();
    private transient String config; // 单例属性
    private SingletonServer() {}
    public static SingletonServer getInstance() {
        return INSTANCE;
    }
    // 防止反序列化破坏单例
    protected Object readResolve() {
        return INSTANCE;
    }
}