`

Java transient关键字使用小记

    博客分类:
  • Java
阅读更多
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。
分享到:
评论

相关推荐

    Java_transient关键字

    ### Java中的transient关键字详解 在Java编程语言中,`transient`关键字是一个非常重要的概念,主要用于对象序列化过程中对特定变量的控制。当一个类实现了`Serializable`接口时,其对象可以被序列化为一个持久化的...

    Java中的transient关键字.doc

    Java 中的 transient 关键字 在 Java 编程中,transient 关键字是一个非常重要的概念,它用来说明一个属性是临时的,不会被序列化。在 Java 中,序列化是指将对象的状态信息转换为字节流的过程,以便于对象在网络上...

    Java之transient关键字.Java

    在Java编程语言中,`transient`关键字是一个非常重要的特性,它用于标记对象的某个成员变量不应该被序列化。...这些都是Java后端开发中常见的知识点,但根据要求,这里主要讨论了`transient`关键字的使用和意义。

    Java transient关键字原理解析

    Java transient关键字原理解析 Java 中的 transient 关键字是一个重要的概念,它被用来表示变量将不被序列化处理。那么在理解 transient 关键字之前,我们先了解下什么是序列化。 序列化是对象进行持久化处理,也...

    Java transient关键字与序列化操作实例详解

    transient关键字的使用可以提高网络传输性能,因为它可以避免将无效元素序列化,减少网络传输的数据量。同时,transient关键字也可以用于保障数据的安全,因为它可以避免将敏感数据序列化。 transient关键字和序列...

    java中transient关键字用法分析

    主要介绍了java中transient关键字用法,以实例形式分析了java中transient关键字的功能及使用技巧,具有一定参考借鉴价值,需要的朋友可以参考下

    深入理解Java虚拟机-Java内存区域透彻分析(序列化、反序列化概念及其使用场景+实现序列化的方式+transient关键字)

    深入理解Java虚拟机-Java内存区域透彻分析(序列化、反序列化概念及其使用场景+实现序列化的方式+transient关键字) Java序列化和反序列化是Java虚拟机中的一种重要机制,它们可以将Java对象转换为二进制数据,然后...

    Java transient 关键字详解及实例代码

    Java中的`transient`关键字是用于标记类的成员变量,表明该变量不应该参与序列化过程。当一个类实现了`Serializable`接口,其对象可以被序列化,即将对象的状态转换为字节流,以便存储或在网络中传输。序列化是Java...

    java关键字transient

    在Java编程语言中,`transient`是一个非常重要的关键字,它与对象持久化和序列化密切相关。当一个字段被声明为`transient`时,它表明该字段的值不会随着对象的序列化而保存。这通常用于那些不希望或者不需要在序列化...

    Java的关键字与保留字

    在深入探讨Java的关键字与保留字之前,我们首先需明确两个概念:关键字和保留字。在编程语言中,关键字是预定义的具有特殊含义的标识符,它们在编译时被解析器识别并执行特定的功能;而保留字则是语言设计者为未来...

    Java关键字Transient与串行化

    在Java编程语言中,`transient`关键字与对象的序列化(serialization)机制密切相关,它在处理对象状态的持久化时扮演着关键角色。本文将深入探讨`transient`关键字的功能、用途以及它如何影响Java对象的序列化过程。 ...

    Java基础之关键字_Java基础之关键字_源码

    在编程语言的学习中,了解和掌握关键字是至关重要的一步,特别是在Java这种强类型的语言中。本文将深入探讨Java中的关键字,这些关键字是Java语法结构的基础,它们被Java编译器特殊处理,有着特定的含义和功能。 ...

    Java中的transient关键字介绍

    在Java编程语言中,`transient`关键字是一个非常重要的概念,它与对象的序列化密切相关。序列化是指将对象的状态转换为字节流,以便存储或在网络上传输。当一个类实现了`Serializable`接口,它的实例就可以被序列化...

    java关键字总结文档

    需要注意的是,虽然像`const`和`goto`这样的关键字在Java中并未使用,但在某些情况下仍被视为保留字。此外,诸如`true`、`false`和`null`虽然不是关键字,但在Java中有着特殊的意义,不应将它们用作标识符。

    transient Java语言的关键字

    transient是Java语言的关键字,用来表示一个域不是该对象串行化的一部分。当一个对象被串行化的时候,

    Java关键字transient

    在Java编程语言中,`transient`是一个非常重要的关键字,它与对象的序列化息息相关。序列化是将一个对象的状态转换为字节流的过程,这样就可以存储或在网络中传输。当我们标记一个字段为`transient`时,意味着该字段...

Global site tag (gtag.js) - Google Analytics