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

    2016-11-15 15:21:25
    Java transient关键字

    Java transient关键字使用小记

          哎,虽然自己最熟的是Java,但很多Java基础知识都不知道,比如transient关键字以前都没用到过,所以不知道它的作用是什么,今天做笔试题时发现有一题是关于这个的,于是花个时间整理下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。

    展开全文
  • Java Transient关键字

    2016-07-25 22:33:33
    Java Transient关键字 本文主要介绍了Java transient关键字的使用,包括其使用场景以及使用细节。

    Java Transient关键字


    1. transient关键字的使用场景

    在对象序列化过程中,类的某些属性不需要格式化时,会用transient关键字加以配合使用。例如,对于某些敏感的字段信息,为了安全起见,不希望进行网络传输(主要涉及到序列化操作,本地序列化缓存同样适用),对于这些字段可以使用transient关键字。也就是说,在对象序列化过程中,transient关键字修饰的字段的生命周期仅仅限于调用者内存期,不会写到磁盘里持久化或者进行网络传输。
    代码示例

    >

    
    import java.io.File;
    import java.io.FileInputStream;
    import java.io.FileOutputStream;
    import java.io.IOException;
    import java.io.ObjectInputStream;
    import java.io.ObjectOutputStream;
    import java.io.Serializable;
    /**
     * 
     * 

    * Title: 对Java中Transient关键字的验证操作 *

    *

    * Description: *

    * * @author Bruce-Jiang * @Date 2016年7月25日下午8:12:18 * @Version */ public class Transitent { private static ObjectOutputStream oos = null; private static ObjectInputStream ois = null; // 获取项目路径下的某个目录 static { try { File file = new File(""); // 当前项目的绝对路径 String folderPath = file.getCanonicalPath(); oos = new ObjectOutputStream(new FileOutputStream(new File( folderPath, "/data/ser.txt"))); ois = new ObjectInputStream(new FileInputStream(new File( folderPath, "/data/ser.txt"))); } catch (IOException e) { e.printStackTrace(); } } public static void main(String[] args) { /** * 运行结果 * Bruce * null */ Transitent.serializeOjbect(new User("Bruce","123456")); } /** * 执行序列化,反序列化的方法 * @param object */ public static void serializeOjbect(Object object) { try { // 序列化 oos.writeObject(object); // 反序列化 User user = (User) ois.readObject(); System.out.println(user.getUsername()); System.out.println(user.getPassword()); } catch (IOException e) { e.printStackTrace(); } catch (ClassNotFoundException e) { e.printStackTrace(); } finally { oos = null; ois = null; } } } class User implements Serializable { /** * */ private static final long serialVersionUID = 5079515464322746070L; private String username; private transient String password; public User() { } public User(String username, String password) { this.username = username; this.password = password; } }


    2. transient使用细节

    以下所有的讨论都是在被序列化对象实现Serializable接口的基础上的

    1>transient关键字是只能修饰字段,不能修饰类和方法,并且需要Serializable接口使用;

    2>自定义变量被transient修饰后,在对象就行序列化操作时,将不包括该字段;

    3>对于变量中的特例,被static关键字修饰的字段,无论是否被transient修饰,均不能被序列化。解释其中的原因:某个类在进行实例化对象的时候,在堆内存空间内为对象开辟存储空间,但是static关键字修饰的字段在类字节码加载时被初始化,其存在于方法区中,对象在进行序列化时,所有的数据均取自于堆中的实例对象。



    在对象进行序列化操作时,我们通常有两种实现方式:

    1.类定义时实现Serializable接口。实例化对象的序列化完全自动进行,transient关键字,对其中的字段序列化有限制作用。

    2.类定义时继承Externalizable接口,此时需要在writeExternal方法中进行手工指定所要序列化的字段,字段是否序列化与是否被transient修饰无关。


    3. 小结

    以上所有内容来源于Java核心技术 II 以及互联网某些博主的博客,对此表示感谢!

    展开全文
  • Java transient 关键字

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

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

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

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

    转载于:https://www.cnblogs.com/baokang/p/5184527.html

    展开全文
  • JAVA transient关键字

    2012-02-29 16:44:32
    Java transient关键字使用小结及一些需要注意的细节 1、transient关键字只能修饰变量,而不能修饰方法和类。注意,本地变量是不能被transient关键字修饰的。 2、被transient关键字修饰的变量不再能被序列化,一个...

    Java transient关键字使用小结及一些需要注意的细节

    1、transient关键字只能修饰变量,而不能修饰方法和类。注意,本地变量是不能被transient关键字修饰的。
    2、被transient关键字修饰的变量不再能被序列化,一个静态变量不管是否被transient修饰,均不能被序列化。
    3、一旦变量被transient修饰,变量将不再是对象持久化的一部分,该变量内容在序列化后无法获得访问。也可以认为在将持久化的对象反序列化后,被transient修饰的变量将按照普通类成员变量一样被初始化。

     

    Volatile修饰的成员变量在每次被线程访问时,都强迫从主内存中重读该成员变量的值。而且,当成员变量发生变化时,强迫线程将变化值回写到主内存。这样在任何时刻,两个不同的线程总是看到某个成员变量的同一个值。

    Java语言规范中指出:为了获得最佳速度,允许线程保存共享成员变量的私有拷贝,而且只当线程进入或者离开同步代码块时才与共享成员变量的原始值对比。

    这样当多个线程同时与某个对象交互时,就必须要注意到要让线程及时的得到共享成员变量的变化。

    而volatile关键字就是提示VM:对于这个成员变量不能保存它的私有拷贝,而应直接与共享成员变量交互。

    使用建议:在两个或者更多的线程访问的成员变量上使用volatile。当要访问的变量已在synchronized代码块中,或者为常量时,不必使用。

    由于使用volatile屏蔽掉了VM中必要的代码优化,所以在效率上比较低,因此一定在必要时才使用此关键字。

    java关键字Transient

    转自http:
    //horst.sun.blog.163.com/blog/static/348849612007614494492/

    翻译自http:
    //www.devx.com/tips/Tip/13726。

    Java的serialization提供了一种持久化对象实例的机制。当持久化对象时,可能有一个特殊的对象数据成员,我们不想
    用serialization机制来保存它。为了在一个特定对象的一个域上关闭serialization,可以在这个域前加上关键字transient。
    transient是Java语言的关键字,用来表示一个域不是该对象串行化的一部分。当一个对象被串行化的时候,transient型变量的值不包括在串行化的表示中,然而非transient型的变量是被包括进去的。
    注意static变量也是可以串行化的

    首先,让我们看一些Java serialization的代码:

    public class LoggingInfo implements java.io.Serializable   
    {   
        private Date loggingDate = new Date();   
        private String uid;   
        private transient String pwd;   
          
        LoggingInfo(String user, String password)   
        {   
            uid = user;   
            pwd = password;   
        }   
        public String toString()   
        {   
            String password=null;   
            if(pwd == null)   
            {   
            password = "NOT SET";   
            }   
            else  
            {   
                password = pwd;   
            }   
            return "logon info: \n   " + "user: " + uid +   
                "\n   logging date : " + loggingDate.toString() +   
                "\n   password: " + password;   
        }   
    }   
    


    现在我们创建一个这个类的实例,并且串行化(serialize)它 ,然后将这个串行化对象写如磁盘。

    LoggingInfo logInfo = new LoggingInfo("MIKE", "MECHANICS");   
    System.out.println(logInfo.toString());   
    try  
    {   
       ObjectOutputStream o = new ObjectOutputStream(   
                    new FileOutputStream("logInfo.out"));   
       o.writeObject(logInfo);   
       o.close();   
    }   
    catch(Exception e) {//deal with exception}   
      
    To read the object back, we can write   
      
    try  
    {   
       ObjectInputStream in =new ObjectInputStream(   
                    new FileInputStream("logInfo.out"));   
       LoggingInfo logInfo = (LoggingInfo)in.readObject();   
       System.out.println(logInfo.toString());   
    }   
    catch(Exception e) {//deal with exception}   
      
    


    如果我们运行这段代码,我们会注意到从磁盘中读回(read——back (de-serializing))的对象打印password为"NOT SET"。这是当我们定义pwd域为transient时,所期望的正确结果。
    现在,让我们来看一下粗心对待transient域可能引起的潜在问题。假设我们修改了类定义,提供给transient域一个默认值,
    代码如下:

    public class GuestLoggingInfo implements java.io.Serializable   
    {   
        private Date loggingDate = new Date();   
        private String uid;   
        private transient String pwd;   
          
        GuestLoggingInfo()   
        {   
            uid = "guest";   
            pwd = "guest";   
        }   
        public String toString()   
        {   
            //same as above   
         }   
    }   
    


    现在,如果我们穿行化GuestLoggingInfo的一个实例,将它写入磁盘,并且再将它从磁盘中读出,我们仍然看到读回的对象打印password 为 "NOT SET"。当从磁盘中读出某个类的实例时,实际上并不会执行这个类的构造函数,
    而是载入了一个该类对象的持久化状态,并将这个状态赋值给该类的另一个对象。

    展开全文
  • 前言说实话学了一段时间java的朋友对于transient这个关键字依旧很陌生基本没怎么用过,但是transient关键字java中却起到了不可或缺的地位!如果要说讲到,我觉得最可能出现的地方是IO流中对象流(也叫序列化流)的...
  • 主要为大家详细介绍了Java transient关键字的使用方法,感兴趣的小伙伴们可以参考一下
  • java transient关键字

    2018-02-04 22:23:50
    有时候我们的一些敏感信息比如密码并不想序列化传输给对方,这个时候transient关键字就派上用场了,如果一个类的变量加上了transient关键字那么这个字段就不会被序列化 下面这个例子我们利用transient避免User序列化...
  • Java 中的 transient 关键字被用来表示变量将不被序列化处理。那么在理解 transient 关键字之前,我们先了解下什么是序列化。什么是序列化序列化是对象进行持久化处理,也就是说,将对象转化成一个字节流进行存储...
  • java transient 关键字

    2019-01-18 15:24:00
    Javatransient关键字的作用,简单地说,就是让某些被修饰的成员属性变量不被序列化,这一看好像很好理解,就是不被序列化,那么什么情况下,一个对象的某些字段不需要被序列化呢?如果有如下情况,可以考虑使用...
  • 主要介绍了Java transient关键字原理解析,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下

空空如也

空空如也

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

javatransient关键字

java 订阅