Java transient关键字

最新推荐文章于 2023-06-14 09:39:33 发布
最新推荐文章于 2023-06-14 09:39:33 发布
阅读量237 收藏
点赞数
分类专栏： java transient 文章标签： 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
04-10
NULL 博文链接：https://jackyz548.iteye.com/blog/1662257
Java transient关键字原理解析
08-25
Java transient关键字原理解析 Java 中的 transient 关键字是一个重要的概念，它被用来表示变量将不被序列化处理。那么在理解 transient 关键字之前，我们先了解下什么是序列化。 序列化是对象进行持久化处理，也...
Java transient关键字使用小记
weixin_33841503的博客
10-15 733
      哎，虽然自己最熟的是Java，但很多Java基础知识都不知道，比如transient关键字以前都没用到过，所以不知道它的作用是什么，今天做笔试题时发现有一题是关于这个的，于是花个时间整理下transient关键字的使用，涨下姿势~~~好了，废话不多说，下面开始： 1. transient的作用及使用方法       我们都知道一个对象只要实现了Serilizable接口，这个对象就...
Java--@Transient关键字
MinggeQingchun的博客
11-18 5696
Java 中 @Transient关键字的作用是需要实现Serilizable接口，将不需要序列化的属性前添加关键字transient，序列化对象的时候，这个属性就不会序列化到指定的目的地中。 用法 @transient 就是在给某个javabean上需要添加个属性，但是这个属性你又不希望给存到数据库中去，仅仅是做个临时变量，用一下。不修改已经存在数据库的数据的数据结构。 那么这个注解就可以一用。 只要在你准备添加的临时属性上添加这个注解，然后getter和setter自动完成一下，就可以啦。
transient的用法
zhenzhenbei的博客
06-03 834
对象序列化时，遇到变量被声明为transient，不知道它作用是什么，所以学习下 一个对象只要实现了Serilizable接口，该对象就可以被序列化，有时并不是所有属性都需要序列化，对于不需要序列化的属性，只要在属性前添加关键字transient，序列化对象的时候，该属性就不会序列化。 1）一旦变量被transient修饰，变量将不再是对象持久化的一部分，该变量内容在序列化后无法获得访问。 2）t...
java transient 关键字
luoqintao的专栏
05-17 531
transient 简而言之，过客，不被序列化 java语言的关键字，变量修饰符，如果用transient声明一个实例变量，当对象存储时，它的值不需要维持。 Java的serialization提供了一种持久化对象实例的机制。当持久化对象时，可能有一个特殊的对象数据成员，我们不想用serialization机制来保存它。为了在一个特定对象的一个域上关闭serialization，可以
Java transient关键字与序列化操作实例详解
08-25
Java transient关键字与序列化操作实例详解 Java语言中的transient关键字是用来修饰变量的，表明该变量不会被Java虚拟机（JVM）序列化，即不会被写入到二进制流中。序列化是Java语言中的一种机制，用于将对象转换为...
Java中@Transient的使用
weixin_45599402的博客
05-11 2468
Java中@Transient的使用 1 初识Transient 最近在写一个课程平台时遇到一点小问题，通过课程号查询其目录，这里使用的方法是通过递归的方式进行查询，表中有个pid的字段，这样就可以通过pid找到其子目录。当我直接在Entity实体类添加一个children的列表时就报错了，显示的是对应数据表中没有此字段。此时就需要在实体类加一个children的列表，但是对应的数据表中是不需要添加此字段的，此时我们就可以使用Transient注解，表示该属性并非是一个要映射到数据表中的字段。 2 具
transient的用途及使用方法
qq_36312376的博客
08-04 754
1，用途 　　我们知道，当一个对象实现了Serilizable接口，这个对象就可以被序列化，我们不关心其内在的原理，只需要了解这个类实现了Serilizable接口，这个类的所有属性和方法都会自动序列化。而在开发过程中，我们可能要求：当对象被序列化时（写入字节序列到目标文件）时，有些属性需要序列化，而其他属性不需要被序列化，打个比方，如果一个用户有一些敏感信息（如密码，银行卡号等），为了安全起见...
java transient
一个编码爱好者的博客
08-19 553
1. transient的作用及使用方法   我们都知道一个对象只要实现了Serilizable接口，这个对象就可以被序列化，java的这种序列化模式为开发者提供了很多便利，我们可以不必关系具体序列化的过程，只要这个类实现了Serilizable接口，这个类的所有属性和方法都会自动序列化。       然而在实际开发过程中，我们常常会遇到这样的问题，这个类的有些属性需要序列化，而其他属性不需要...
Java transient
nauygnoz的博客
08-03 191
java的序列化模式为开发者提供了很多便利。一个对象只要实现了Serilizable接口，那这个对象就被序列化。只要一个类实现了Serilizable接口，那这个类的所有属性和方法都会自动序列化。 但是在实际开发过程中，我们常常会遇到这样的问题，这个类的有些属性需要序列化，而其他属性不需要被序列化。打个比方，如果一个用户有一些敏感信息（如密码，银行卡号等），为了安全起见，不希望在网络操作（主要涉及到序列化操作，本地序列化缓存也适用）中被传输，那么这些信息对应的变量就可以加上transient关键字。换句话说
Java中的transient
qq_44515207的博客
09-13 7506
1. 作用 transient关键字的主要作用就是让某些被transient关键字修饰的成员属性变量不被序列化。 2. 什么是序列化？ 简单来说就是将java对象转化为字节流的形式。我们在程序中创建的JAVA对象只存在于JVM中, 当程序退出时, 这些对象也就消失了, 而序列化正是为了将这些对象保存起来以仅将来使用,也可以将已经序列化的对象传送给其他JVM来使用,这些序列化的字节流是于JVM无关的, 也就是说一个JVM序列化的对象可以在另一个JVM中反序列化。 反序列化就是将字节流转化为Java对象的过程。
java中transient
Jack__iT的博客
03-13 987
transient transient 是java中的关键字，变量修饰符，被 transient 修饰的变量不能被序列化。如果用transient声明一个实例变量，当对象存储时，它的值不需要维持。换句话来说就是，用transient关键字标记的成员变量不参与序列化过程。 什么是序列化 我们的对象并不只是存在内存中，还需要传输网络，或者保存起来下次再加载出来用，所以需要Java序...
java中的transient
joyyq的专栏
04-06 445
被声明为transient的属性，在序列化保存时是不会被保存的，比如密码这类信息，为了安全性，在序列化存储对象时不需要保存，则可以把密码声明为transient. 如下是transient的例子 保存对象前输出：saved User:cn.learn.test.User@1c39a2d->username=googlepassword=aaabbb111 从文件中重新读取该对象，输出：rea
JAVA中的TRANSIENT
qq513666573的专栏
08-12 468
转自：http://www.blogjava.net/liuganquan/archive/2007/04/22/112591.html JAVA中的TRANSIENT Java中的transient，看jdk源码的时候突然忘了这个是什么了，查了一下，是用于声明序列化
Java @Transient 注解使用 与 关键字transient
yuhui666666的博客
03-22 362
@Transient 注解使用:和orm有关 建实体类的时候，有时候实体类的属性和数据库表字段不一致，比如多一个属性，那你不加这个注解就会报错， 因为映射的时候会提示（提示啥我给忘了），尤其是用 Hibernate 这样的框架的时候，但是再新写一个实体类又不太好， 所以你要想写什么让 ORM 持久层忽略属性的实体类的时候，只要把这个东西加在你想忽略的属性上就可以了 java中的关键字transient:和流有关 ...
@Transient 注解
樂小伍
06-14 1057
java 的transient关键字的作用是需要实现Serilizable接口，将不需要序列化的属性前添加关键字transient，序列化对象的时候，这个属性就不会序列化到指定的目的地中。
java transient关键字
最新发布
05-22
### Java中`transient`关键字的用法和含义 #### 1. `transient`关键字的核心作用 在Java中，`transient`关键字用于修饰类的成员变量，表示该变量在序列化过程中会被忽略。这意味着当一个实现了`Serializable`接口的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值