精华内容
下载资源
问答
  • java的transient关键字

    2021-01-13 09:24:39
    java的transient关键字作用
    import java.io.Serializable;
    /**
     * @Description transient关键字  被修饰的字段不会被序列化传输(继承Serializable)
     * @Author rll
     * @Date 2021-01-04 10:16
     */
    public class User implements Serializable {
        private static final long serialVersionUID = 5001293179270499108L;
        private String name;
        private transient String pwd;
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public String getPwd() {
            return pwd;
        }
    
        public void setPwd(String pwd) {
            this.pwd = pwd;
        }
    }
    import java.io.*;
    /**
     * @Description transient关键字
     * @Author rll
     * @Date 2021-01-04 10:21
     */
    public class TransientTest {
        public static void main(String[] args) {
            User u1= new User();
            u1.setName("testName");
            u1.setPwd("pwd123");
            System.out.println("read before Serializable: ");
            System.out.println("username: " + u1.getName());
            System.err.println("password: " + u1.getPwd());
    
            String fileName = "D:/user.txt";
            //写入文件
            try {
                ObjectOutputStream oops = new ObjectOutputStream(new FileOutputStream(fileName));
                oops.writeObject(u1);
                oops.flush();
                oops.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            //读取对象
            try {
                ObjectInputStream oips = new ObjectInputStream(new FileInputStream(fileName));
                User u2 = (User) oips.readObject();
                oips.close();
                System.out.println("read after Serializable: ");
                System.out.println("username: " + u2.getName());
                System.err.println("password: " + u2.getPwd());
            } catch (IOException | ClassNotFoundException e) {
                e.printStackTrace();
            }
        }
    }

     

    展开全文
  • Java的transient关键字

    2019-10-24 18:45:56
    Java的transient关键字被用来表示变量将不被序列化处理。那么在理解transient关键字之前,我们先了解下什么是序列化。 什么是序列化 序列化是对象进行持久化处理,也就是说,将对象转化成一个字节流进行存储...

    Java 中的 transient 关键字被用来表示变量将不被序列化处理。那么在理解 transient 关键字之前,我们先了解下什么是序列化。

    什么是序列化

    序列化是对象进行持久化处理,也就是说,将对象转化成一个字节流进行存储(比如存储为一个字节文件)或传输(通过网络传输字节)。同时,我们也可以从字节中反序列化一个对象出来。这是Java程序中一个重要的概念,因为网络应用中通常需要将对象序列化成字节传输。每一个需要序列化的对象,都要实现 Serializable 接口。

    transient关键字

    默认情况下,对象所有的变量都会转变成持久状态。但是有时候,一些变量可能不需要序列化,因为没必要对这些变量进行序列化。这时,你就可以将这些变量申明为 transient。如果一个变量被申明为 transient,那么这个变量就不会被序列化。

    通过下面这个例子应该能够解释 transient 关键字的作用:

    public class NameStore implements Serializable {
        private String firstName;
        private transient String middleName;
        private String lastName;
    
        public NameStore (String fName, String mName, String lName){
            this.firstName = fName;
            this.middleName = mName;
            this.lastName = lName;
        }
    
        @Override
        public String toString() {
            return "NameStore{" +
                    "firstName='" + firstName + '\'' +
                    ", middleName='" + middleName + '\'' +
                    ", lastName='" + lastName + '\'' +
                    '}';
        }
    }
    
    public class TransientExample {
        public static void main(String[] args) throws Exception {
            NameStore nameStore = new NameStore("Steve", "Middle","Jobs");
            ObjectOutputStream o = new ObjectOutputStream(new FileOutputStream("nameStore"));
            // writing to object
            o.writeObject(nameStore);
            o.close();
    
            // reading from object
            ObjectInputStream in = new ObjectInputStream(new FileInputStream("nameStore"));
            NameStore nameStore1 = (NameStore)in.readObject();
            System.out.println(nameStore1);
        }
    }

    上面例子的输出:

    NameStore{firstName='Steve', middleName='null', lastName='Jobs'}

    middleName 变量被申明为 transient,因此没有被序列化。

    转载:https://www.cnblogs.com/bluemilk/p/10666990.html

     

     

    展开全文
  • java 的transient关键字

    2020-10-05 10:22:35
    接下来总结序列化时候,可以总结一波transient关键字https://baijiahao.baidu.com/s?id=1636557218432721275&wfr=spider&for=pc

    接下来总结序列化的时候,可以总结一波transient关键字https://baijiahao.baidu.com/s?id=1636557218432721275&wfr=spider&for=pc

    展开全文
  • Java的 transient关键字

    2015-11-16 18:03:43
    哎,虽然自己最熟Java,但很多Java基础知识都不知道,比如transient关键字以前都没用到过,所以不知道它作用是什么,今天做笔试题时发现有一题是关于这个,于是花个时间整理下transient关键字的使用,涨下...
    哎,虽然自己最熟的是Java,但很多Java基础知识都不知道,比如transient关键字以前都没用到过,所以不知道它的作用是什么,今天做笔试题时发现有一题是关于这个的,于是花个时间整理下transient关键字的使用,涨下姿势~~~好了,废话不多说,下面开始:
    

    1. transient的作用及使用方法

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

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

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

     

    示例code如下:

    1. <span style="font-size:12px;">import java.io.FileInputStream;  
    2. import java.io.FileNotFoundException;  
    3. import java.io.FileOutputStream;  
    4. import java.io.IOException;  
    5. import java.io.ObjectInputStream;  
    6. import java.io.ObjectOutputStream;  
    7. import java.io.Serializable;  
    8.   
    9. /** 
    10.  * @description 使用transient关键字不序列化某个变量 
    11.  *        注意读取的时候,读取数据的顺序一定要和存放数据的顺序保持一致 
    12.  *         
    13.  * @author Alexia 
    14.  * @date  2013-10-15 
    15.  */  
    16. public class TransientTest {  
    17.       
    18.     public static void main(String[] args) {  
    19.           
    20.         User user = new User();  
    21.         user.setUsername("Alexia");  
    22.         user.setPasswd("123456");  
    23.           
    24.         System.out.println("read before Serializable: ");  
    25.         System.out.println("username: " + user.getUsername());  
    26.         System.err.println("password: " + user.getPasswd());  
    27.           
    28.         try {  
    29.             ObjectOutputStream os = new ObjectOutputStream(  
    30.                     new FileOutputStream("C:/user.txt"));  
    31.             os.writeObject(user); // 将User对象写进文件  
    32.             os.flush();  
    33.             os.close();  
    34.         } catch (FileNotFoundException e) {  
    35.             e.printStackTrace();  
    36.         } catch (IOException e) {  
    37.             e.printStackTrace();  
    38.         }  
    39.         try {  
    40.             ObjectInputStream is = new ObjectInputStream(new FileInputStream(  
    41.                     "C:/user.txt"));  
    42.             user = (User) is.readObject(); // 从流中读取User的数据  
    43.             is.close();  
    44.               
    45.             System.out.println("\nread after Serializable: ");  
    46.             System.out.println("username: " + user.getUsername());  
    47.             System.err.println("password: " + user.getPasswd());  
    48.               
    49.         } catch (FileNotFoundException e) {  
    50.             e.printStackTrace();  
    51.         } catch (IOException e) {  
    52.             e.printStackTrace();  
    53.         } catch (ClassNotFoundException e) {  
    54.             e.printStackTrace();  
    55.         }  
    56.     }  
    57. }  
    58.   
    59. class User implements Serializable {  
    60.     private static final long serialVersionUID = 8294180014912103005L;    
    61.       
    62.     private String username;  
    63.     private transient String passwd;  
    64.       
    65.     public String getUsername() {  
    66.         return username;  
    67.     }  
    68.       
    69.     public void setUsername(String username) {  
    70.         this.username = username;  
    71.     }  
    72.       
    73.     public String getPasswd() {  
    74.         return passwd;  
    75.     }  
    76.       
    77.     public void setPasswd(String passwd) {  
    78.         this.passwd = passwd;  
    79.     }  
    80.   
    81. }</span>  


    输出为:

    [java] view plaincopy
    1. <span style="font-size:12px;">read before Serializable:   
    2. username: Alexia  
    3. password: 123456  
    4.   
    5. read after Serializable:   
    6. username: Alexia  
    7. password: null</span>  

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

    2. transient使用小结

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

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

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

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

    [java] view plaincopy
    1. <span style="font-size:12px;">import java.io.FileInputStream;  
    2. import java.io.FileNotFoundException;  
    3. import java.io.FileOutputStream;  
    4. import java.io.IOException;  
    5. import java.io.ObjectInputStream;  
    6. import java.io.ObjectOutputStream;  
    7. import java.io.Serializable;  
    8.   
    9. /** 
    10.  * @description 使用transient关键字不序列化某个变量 
    11.  *        注意读取的时候,读取数据的顺序一定要和存放数据的顺序保持一致 
    12.  *         
    13.  * @author Alexia 
    14.  * @date  2013-10-15 
    15.  */  
    16. public class TransientTest {  
    17.       
    18.     public static void main(String[] args) {  
    19.           
    20.         User user = new User();  
    21.         user.setUsername("Alexia");  
    22.         user.setPasswd("123456");  
    23.           
    24.         System.out.println("read before Serializable: ");  
    25.         System.out.println("username: " + user.getUsername());  
    26.         System.err.println("password: " + user.getPasswd());  
    27.           
    28.         try {  
    29.             ObjectOutputStream os = new ObjectOutputStream(  
    30.                     new FileOutputStream("C:/user.txt"));  
    31.             os.writeObject(user); // 将User对象写进文件  
    32.             os.flush();  
    33.             os.close();  
    34.         } catch (FileNotFoundException e) {  
    35.             e.printStackTrace();  
    36.         } catch (IOException e) {  
    37.             e.printStackTrace();  
    38.         }  
    39.         try {  
    40.             // 在反序列化之前改变username的值  
    41.             User.username = "jmwang";  
    42.               
    43.             ObjectInputStream is = new ObjectInputStream(new FileInputStream(  
    44.                     "C:/user.txt"));  
    45.             user = (User) is.readObject(); // 从流中读取User的数据  
    46.             is.close();  
    47.               
    48.             System.out.println("\nread after Serializable: ");  
    49.             System.out.println("username: " + user.getUsername());  
    50.             System.err.println("password: " + user.getPasswd());  
    51.               
    52.         } catch (FileNotFoundException e) {  
    53.             e.printStackTrace();  
    54.         } catch (IOException e) {  
    55.             e.printStackTrace();  
    56.         } catch (ClassNotFoundException e) {  
    57.             e.printStackTrace();  
    58.         }  
    59.     }  
    60. }  
    61.   
    62. class User implements Serializable {  
    63.     private static final long serialVersionUID = 8294180014912103005L;    
    64.       
    65.     public static String username;  
    66.     private transient String passwd;  
    67.       
    68.     public String getUsername() {  
    69.         return username;  
    70.     }  
    71.       
    72.     public void setUsername(String username) {  
    73.         this.username = username;  
    74.     }  
    75.       
    76.     public String getPasswd() {  
    77.         return passwd;  
    78.     }  
    79.       
    80.     public void setPasswd(String passwd) {  
    81.         this.passwd = passwd;  
    82.     }  
    83.   
    84. }</span>  

    运行结果为:

    [java] view plaincopy
    1. <span style="font-size:12px;">read before Serializable:   
    2. username: Alexia  
    3. password: 123456  
    4.   
    5. read after Serializable:   
    6. username: jmwang  
    7. password: null</span>  

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

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

    思考下面的例子:

    [java] view plaincopy
    1. <span style="font-size:12px;">import java.io.Externalizable;  
    2. import java.io.File;  
    3. import java.io.FileInputStream;  
    4. import java.io.FileOutputStream;  
    5. import java.io.IOException;  
    6. import java.io.ObjectInput;  
    7. import java.io.ObjectInputStream;  
    8. import java.io.ObjectOutput;  
    9. import java.io.ObjectOutputStream;  
    10.   
    11. /** 
    12.  * @descripiton Externalizable接口的使用 
    13.  *  
    14.  * @author Alexia 
    15.  * @date 2013-10-15 
    16.  * 
    17.  */  
    18. public class ExternalizableTest implements Externalizable {  
    19.   
    20.     private transient String content = "是的,我将会被序列化,不管我是否被transient关键字修饰";  
    21.   
    22.     @Override  
    23.     public void writeExternal(ObjectOutput out) throws IOException {  
    24.         out.writeObject(content);  
    25.     }  
    26.   
    27.     @Override  
    28.     public void readExternal(ObjectInput in) throws IOException,  
    29.             ClassNotFoundException {  
    30.         content = (String) in.readObject();  
    31.     }  
    32.   
    33.     public static void main(String[] args) throws Exception {  
    34.           
    35.         ExternalizableTest et = new ExternalizableTest();  
    36.         ObjectOutput out = new ObjectOutputStream(new FileOutputStream(  
    37.                 new File("test")));  
    38.         out.writeObject(et);  
    39.   
    40.         ObjectInput in = new ObjectInputStream(new FileInputStream(new File(  
    41.                 "test")));  
    42.         et = (ExternalizableTest) in.readObject();  
    43.         System.out.println(et.content);  
    44.   
    45.         out.close();  
    46.         in.close();  
    47.     }  
    48. }</span>  

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

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

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

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

    展开全文
  • java 的transient关键字的作用是需要实现Serilizable接口,将不需要序列化的属性前添加关键字transient,序列化对象的时候,这个属性就不会序列化到指定的目的地中。 transient使用小结 1)一旦变量被transient...
  • 原帖:https://www.cnblogs.com/lanxuezaipiao/p/3369962.html 哎,虽然自己最熟Java,但很多Java基础知识都不知道,比如transient关键字以前都没用到过,所以不知道它作用是什么,今天做笔试题时发现有一题...
  • Java的serialization提供了一种持久化对象实例的机制。当持久化对象时,可能有一个特殊的对象数据成员,我们不想用serialization机制来保存它。为了在一个特定对象的一个域上关闭serialization,可以在这个域前加上...
  • [size=large][/size][b]transient 关键字表示在Serializable 时候不保存该值。[/b]
  • 主要介绍了javatransient关键字用法,以实例形式分析了javatransient关键字的功能及使用技巧,具有一定参考借鉴价值,需要朋友可以参考下
  • Java的序列化机制是RMI、EJB、JNNI等技术的技术基础。 序列化分为两大部分:序列化和反序列化。序列化是这个过程的第一部分,将数据分解成字节流,以便存储在文件中或在网络上传输。反序列化就是打开字节流并重构...
  • Volatile修饰成员变量在每次被线程访问时,...Java语言规范中指出:为了获得最佳速度,允许线程保存共享成员变量私有拷贝,而且只当线程进入或者离开同步代码块时才与共享成员变量原始值对比。这样当多个线程...
  • Java_transient关键字

    2012-03-17 00:16:37
    JAVAtransient关键字的讲解
  • Javatransient关键字的详细总结

    万次阅读 多人点赞 2018-06-14 22:15:12
    一、概要介绍Java的transient关键字,transient是短暂的意思。对于transient 修饰的成员变量,在类实例的序列化处理过程中会被忽略。 因此,transient变量不会贯穿对象的序列化和反序列化,生命周期仅存于调用者的...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 2,264
精华内容 905
关键字:

java的transient关键字

java 订阅