Java transient关键字

1. transient的作用及使用方法

      我们都知道一个对象只要实现了Serilizable接口,这个对象就可以被序列化,java的这种序列化模式为开发者提供了很多便利,我们可以不必关系具体序列化的过程,只要这个类实现了Serilizable接口,这个类的所有属性和方法都会自动序列化。

      然而在实际开发过程中,我们常常会遇到这样的问题,这个类的有些属性需要序列化,而其他属性不需要被序列化,打个比方,如果一个用户有一些敏感信息(如密码,银行卡号等),为了安全起见,不希望在网络操作(主要涉及到序列化操作,本地序列化缓存也适用)中被传输,这些信息对应的变量就可以加上transient关键字。换句话说,这个字段的生命周期仅存于调用者的内存中而不会写到磁盘里持久化。

      总之,java 的transient关键字为我们提供了便利,你只需要实现Serilizable接口,将不需要序列化的属性前添加关键字transient,序列化对象的时候,这个属性就不会序列化到指定的目的地中。

 

示例code如下:

复制代码
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;

/**
 * @description 使用transient关键字不序列化某个变量
 *        注意读取的时候,读取数据的顺序一定要和存放数据的顺序保持一致
 *        
 * @author Alexia
 * @date  2013-10-15
 */
public class TransientTest {
    
    public static void main(String[] args) {
        
        User user = new User();
        user.setUsername("Alexia");
        user.setPasswd("123456");
        
        System.out.println("read before Serializable: ");
        System.out.println("username: " + user.getUsername());
        System.err.println("password: " + user.getPasswd());
        
        try {
            ObjectOutputStream os = new ObjectOutputStream(
                    new FileOutputStream("C:/user.txt"));
            os.writeObject(user); // 将User对象写进文件
            os.flush();
            os.close();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
        try {
            ObjectInputStream is = new ObjectInputStream(new FileInputStream(
                    "C:/user.txt"));
            user = (User) is.readObject(); // 从流中读取User的数据
            is.close();
            
            System.out.println("\nread after Serializable: ");
            System.out.println("username: " + user.getUsername());
            System.err.println("password: " + user.getPasswd());
            
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

class User implements Serializable {
    private static final long serialVersionUID = 8294180014912103005L;  
    
    private String username;
    private transient String passwd;
    
    public String getUsername() {
        return username;
    }
    
    public void setUsername(String username) {
        this.username = username;
    }
    
    public String getPasswd() {
        return passwd;
    }
    
    public void setPasswd(String passwd) {
        this.passwd = passwd;
    }

}
复制代码

输出为:

复制代码
read before Serializable: 
username: Alexia
password: 123456

read after Serializable: 
username: Alexia
password: null
复制代码

密码字段为null,说明反序列化时根本没有从文件中获取到信息。

2. transient使用小结

1)一旦变量被transient修饰,变量将不再是对象持久化的一部分,该变量内容在序列化后无法获得访问。

2)transient关键字只能修饰变量,而不能修饰方法和类。注意,本地变量是不能被transient关键字修饰的。变量如果是用户自定义类变量,则该类需要实现Serializable接口。

3)被transient关键字修饰的变量不再能被序列化,一个静态变量不管是否被transient修饰,均不能被序列化。

第三点可能有些人很迷惑,因为发现在User类中的username字段前加上static关键字后,程序运行结果依然不变,即static类型的username也读出来为“Alexia”了,这不与第三点说的矛盾吗?实际上是这样的:第三点确实没错(一个静态变量不管是否被transient修饰,均不能被序列化),反序列化后类中static型变量username的值为当前JVM中对应static变量的值,这个值是JVM中的不是反序列化得出的,不相信?好吧,下面我来证明:

复制代码
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;

/**
 * @description 使用transient关键字不序列化某个变量
 *        注意读取的时候,读取数据的顺序一定要和存放数据的顺序保持一致
 *        
 * @author Alexia
 * @date  2013-10-15
 */
public class TransientTest {
    
    public static void main(String[] args) {
        
        User user = new User();
        user.setUsername("Alexia");
        user.setPasswd("123456");
        
        System.out.println("read before Serializable: ");
        System.out.println("username: " + user.getUsername());
        System.err.println("password: " + user.getPasswd());
        
        try {
            ObjectOutputStream os = new ObjectOutputStream(
                    new FileOutputStream("C:/user.txt"));
            os.writeObject(user); // 将User对象写进文件
            os.flush();
            os.close();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
        try {
            // 在反序列化之前改变username的值
            User.username = "jmwang";
            
            ObjectInputStream is = new ObjectInputStream(new FileInputStream(
                    "C:/user.txt"));
            user = (User) is.readObject(); // 从流中读取User的数据
            is.close();
            
            System.out.println("\nread after Serializable: ");
            System.out.println("username: " + user.getUsername());
            System.err.println("password: " + user.getPasswd());
            
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

class User implements Serializable {
    private static final long serialVersionUID = 8294180014912103005L;  
    
    public static String username;
    private transient String passwd;
    
    public String getUsername() {
        return username;
    }
    
    public void setUsername(String username) {
        this.username = username;
    }
    
    public String getPasswd() {
        return passwd;
    }
    
    public void setPasswd(String passwd) {
        this.passwd = passwd;
    }

}
复制代码

运行结果为:

复制代码
read before Serializable: 
username: Alexia
password: 123456

read after Serializable: 
username: jmwang
password: null
复制代码

这说明反序列化后类中static型变量username的值为当前JVM中对应static变量的值,为修改后jmwang,而不是序列化时的值Alexia。

3. transient使用细节——被transient关键字修饰的变量真的不能被序列化吗?

思考下面的例子:

复制代码
import java.io.Externalizable;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectInputStream;
import java.io.ObjectOutput;
import java.io.ObjectOutputStream;

/**
 * @descripiton Externalizable接口的使用
 * 
 * @author Alexia
 * @date 2013-10-15
 *
 */
public class ExternalizableTest implements Externalizable {

    private transient String content = "是的,我将会被序列化,不管我是否被transient关键字修饰";

    @Override
    public void writeExternal(ObjectOutput out) throws IOException {
        out.writeObject(content);
    }

    @Override
    public void readExternal(ObjectInput in) throws IOException,
            ClassNotFoundException {
        content = (String) in.readObject();
    }

    public static void main(String[] args) throws Exception {
        
        ExternalizableTest et = new ExternalizableTest();
        ObjectOutput out = new ObjectOutputStream(new FileOutputStream(
                new File("test")));
        out.writeObject(et);

        ObjectInput in = new ObjectInputStream(new FileInputStream(new File(
                "test")));
        et = (ExternalizableTest) in.readObject();
        System.out.println(et.content);

        out.close();
        in.close();
    }
}
复制代码

content变量会被序列化吗?好吧,我把答案都输出来了,是的,运行结果就是:

是的,我将会被序列化,不管我是否被transient关键字修饰

这是为什么呢,不是说类的变量被transient关键字修饰以后将不能序列化了吗?

      我们知道在Java中,对象的序列化可以通过实现两种接口来实现,若实现的是Serializable接口,则所有的序列化将会自动进行,若实现的是Externalizable接口,则没有任何东西可以自动序列化,需要在writeExternal方法中进行手工指定所要序列化的变量,这与是否被transient修饰无关。因此第二个例子输出的是变量content初始化的内容,而不是null。


原文地址:http://www.cnblogs.com/lanxuezaipiao/p/3369962.html

### Java中`transient`关键字的用法和含义 #### 1. `transient`关键字的核心作用 在Java中,`transient`关键字用于修饰类的成员变量,表示该变量在序列化过程中会被忽略。这意味着当一个实现了`Serializable`接口的对象被写入文件或其他存储介质时,`transient`修饰的字段不会参与序列化过程[^1]。 反序列化时,`transient`字段的值会被设置为其类型的默认值(例如,对象引用类型为`null`,基本数据类型则依据具体类型设定,默认值如`int`为0、`boolean`为`false`等)[^3]。 --- #### 2. 使用场景分析 ##### (1)保护敏感信息 如果某个字段包含敏感数据(如密码或密钥),可以通过将其声明为`transient`来避免这些数据被序列化并暴露给外部环境[^2]。 示例代码如下: ```java public class User implements Serializable { private static final long serialVersionUID = 1L; private String username; private transient String password; // 密码字段不会被序列化 // 构造方法、getter 和 setter 方法省略 } ``` 在此例子中,`password`字段由于被`transient`修饰,在序列化操作中将被跳过。 --- ##### (2)优化性能 对于一些体积较大或无需持久化的字段(如缓存数据),可以使用`transient`关键字减少序列化带来的额外开销[^3]。 示例代码如下: ```java public class LargeDataObject implements Serializable { private static final long serialVersionUID = 1L; private byte[] dataCache; // 缓存数据 private transient List<String> temporaryList; // 大型临时列表,不需序列化 // 构造方法、getter 和 setter 方法省略 } ``` 在这里,`temporaryList`是一个大型临时结构,通过标记为`transient`,可以在序列化时节省资源。 --- ##### (3)派生数据管理 某些情况下,字段的数据可以从其他已有的字段计算得出。在这种情形下,没有必要保存这些派生字段的原始值,可以直接标注为`transient`。 示例代码如下: ```java public class DerivedDataClass implements Serializable { private static final long serialVersionUID = 1L; private int baseValue; private transient int derivedValue; public DerivedDataClass(int baseValue) { this.baseValue = baseValue; this.derivedValue = calculateDerived(baseValue); } private int calculateDerived(int value) { return value * 2; // 假设这是一个简单的派生逻辑 } // getter 和 setter 方法省略 } ``` 在这个例子中,`derivedValue`由`baseValue`计算而来,因此不需要单独序列化它。 --- #### 3. 注意事项与最佳实践 ##### (1)`final`变量的影响 如果一个字段既是`final`又是`transient`,那么即使经过序列化和反序列化,它的值仍然保持不变。这可能会违背开发者原本期望的行为[^4]。 示例代码如下: ```java public class FinalTransientExample implements Serializable { private static final long serialVersionUID = 1L; private final transient int id = 42; // 序列化后仍为42 } ``` 这种设计通常不符合实际需求,应尽量避免。 --- ##### (2)静态变量不受影响 需要注意的是,`static`变量本身是不会参与到序列化过程中的,因此即便加上`transient`也毫无意义[^4]。 示例代码如下: ```java public class StaticTransientExample implements Serializable { private static final long serialVersionUID = 1L; private static transient int count = 0; // 这里加`transient`没有任何效果 } ``` --- ##### (3)文档说明的重要性 为了提高代码可维护性和团队协作效率,应在类的文档注释中明确指出哪些字段被标记为`transient`及其原因[^4]。 --- #### 4. 特殊情况:如何强制序列化`transient`字段? 尽管`transient`字段默认不会被序列化,但在特定需求下也可以通过自定义序列化机制实现对其的序列化支持。 示例代码如下: ```java import java.io.*; public class CustomSerializationExample implements Serializable { private static final long serialVersionUID = 1L; private transient String secretMessage; public CustomSerializationExample(String message) { this.secretMessage = message; } private void writeObject(ObjectOutputStream oos) throws IOException { oos.defaultWriteObject(); oos.writeObject(secretMessage); // 手动序列化`transient`字段 } private void readObject(ObjectInputStream ois) throws IOException, ClassNotFoundException { ois.defaultReadObject(); secretMessage = (String) ois.readObject(); // 手动反序列化`transient`字段 } } ``` 此方式允许开发人员灵活控制序列化行为。 --- ### 总结 `transient`关键字的主要功能在于控制序列化过程中哪些字段应该被排除在外。其典型应用场景包括但不限于保护敏感信息、提升性能以及简化派生数据管理等方面。然而,在实际应用中还需注意遵循一定的编码规范以规避潜在问题。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值