精华内容
下载资源
问答
  • 哎,虽然自己熟的是Java,但很多Java基础知识都不知道,比如transient关键字以前都没用到过,所以不知道它的作用是什么,做笔试题时发现有一题是关于这个的,于是花个时间整理下transient关键字的使用,涨下姿势~~~...
  • Part 3: Electrical transient transmission by capacitive and inductive coupling via lines other than supply lines 道路车辆—传导和耦合引起的电气干扰—第 3 部分:通过除供电线路以外的线路通过电容和电感...
  • The test results demonstrate the superiority of the both DL algorithms over other methods in the application of power system transient disturbance classification. Keywords—Convolutional Neural ...
  • 从上篇内容不如题的文章《.net core 并发下的线程安全问题》扩展认识.net core注入中的三种模式:Singleton、Scoped 和 Transient 我们都知道在 Startup 的ConfigureServices 可以注入我们想要的服务,那么在注入的...
  • 主要介绍了Java transient关键字原理解析,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • The fundamental properties of laser-induced plasma in liquid water, such as the ultrafast electron migration and solvation, have not yet been clarified. We use 1650-nm femtosecond laser pulses to ...
  • transient修饰符的使用

    2015-09-23 16:15:25
    以前没有接触过这个小玩意,看到一个开源项目里有,就仔细研究了一下,transient修饰符的使用
  • 主要介绍了java中transient关键字用法,以实例形式分析了java中transient关键字的功能及使用技巧,具有一定参考借鉴价值,需要的朋友可以参考下
  • 主要和大家说一说java关键字final和transient,感兴趣的小伙伴们可以参考一下
  • 本文章向大家介绍Java transient关键字的使用方法和实例,包括的知识点有transient的作用、transient使用小结、transient使用细节,需要的朋友可以参考一下
  • applications requiring transient overvoltage protection capability. It is intended for use in voltage and ESD sensitive equipment such as computers, printers, business machines, communication systems ...
  • transient

    2018-02-03 20:52:00
    Java的serialization提供了一种持久化对象实例的机制。当持久化对象时,可能有一个特殊的对象数据成员,我们不想用...当一个对象被序列化的时候,transient型变量的值不包括在序列化的表示中,然而非tra...

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

    在HashMap中大量使用该关键字,是为了减少数据持久化中,所需要维护的数据量

    展开全文
  • Part 4: Electrical transient conduction along shielded high voltage supply lines only 道路车辆—传导和耦合引起的电气干扰—第 4 部分:仅沿屏蔽高压电源线的电气瞬态传导 本文件规定了测试方法和程序,以...
  • java关键字transient

    2017-06-25 14:58:05
    java关键字transient
  • Transient Voltage Suppressors (TVS’s) are devices used to protect vulnerable circuits from electrical overstress such as that caused by electrostatic discharge, inductive load switching and induced ...
  • Java关键字transient

    2019-04-10 01:03:48
    NULL 博文链接:https://jackyz548.iteye.com/blog/1662257
  • java中的transient关键字详解

    千次阅读 多人点赞 2019-11-25 08:07:14
    说实话学了一段时间java的朋友对于`transient`这个关键字依旧很陌生基本没怎么用过,但是`transient`关键字在java中却起到了不可或缺的地位!如果要说讲到,我觉得最可能出现的地方是IO流中对象流(也叫序列化流)的...

    前言
    说实话学了一段时间java的朋友对于transient这个关键字依旧很陌生基本没怎么用过,但是transient关键字在java中却起到了不可或缺的地位!如果要说讲到,我觉得最可能出现的地方是IO流中对象流(也叫序列化流)的时候会讲到!

    相信很多人都是直到自己碰到才会关心这个关键字,记得博主第一次碰到transient关键字是在阅读JDK源码的时候。在学习java的过程中transient关键字少见的原因其实离不开它的作用:transient关键字的主要作用就是让某些被transient关键字修饰的成员属性变量不被序列化。实际上也正是因此,在学习过程中很少用得上序列化操作,一般都是在实际开发中!至于序列化,相信有很多小白童鞋一直迷迷糊糊或者没有具体的概念,这都不是事,下面博主会很清楚的让你记住啥是序列化,保证你这辈子忘不了(貌似有点夸张,有点装b,感觉要被打)

    1、何谓序列化?

    说起序列化,随之而来的另一个概念就是反序列化,小白童鞋不要慌,记住了序列化就相当于记住了反序列化,因为反序列化就是序列化反过来,所以博主建议只记住序列化概念即可,省的搞晕自己。

    专业术语定义的序列化:

    Java提供了一种对象序列化的机制。用一个字节序列可以表示一个对象,该字节序列包含该对象的数据、对象的类型和对象中存储的属性等信息。字节序列写出到文件之后,相当于文件中持久保存了一个对象的信息。反之,该字节序列还可以从文件中读取回来,重构对象,对它进行反序列化。对象的数据、对象的类型和对象中存储的数据信息,都可以用来在内存中创建对象。

    宜春的术语定义序列化:

    序列化: 字节 ——> 对象

    其实,我总结的就是上面的结论,如果不理解,直接参照专业术语的定义,理解之后就记住我的话就行了,记不住,请打死我(我踢m简直就是个天才)

    图理解序列化:
    在这里插入图片描述
    啥?你不懂啥是字节?其实,我在一篇IO流的文章里就已经介绍了序列化,放心,绝对特别详细光看文章名字就知道了

    史上最骚最全最详细的IO流教程,小白都能看懂!

    2、为何要序列化?

    从上一节提到序列化的概念,知道概念之后,我们就必须要知道 为何要序列化了。

    讲为何要序列化原因之前,博主我举个栗子:

    就像你去街上买菜,一般操作都是用塑料袋给包装起来,直到回家要做菜的时候就把菜给拿出来。而这一系列操作就像极了序列化和反序列化!

    Java中对象的序列化指的是将对象转换成以字节序列的形式来表示,这些字节序列包含了对象的数据和信息,一个序列化后的对象 可以被写到数据库或文件中,也可用于 网络传输,一般当我们使用 缓存cache(内存空间不够有可能会本地存储到硬盘)或 远程调用rpc(网络传输)的时候,经常需要让我们的实体类实现Serializable接口,目的就是为了让其可序列化。

    • 在开发过程中要使用transient关键字修饰的栗子:

    如果一个用户有一些密码等信息,为了安全起见,不希望在网络操作中被传输,这些信息对应的变量就可以加上transient关键字。换句话说,这个字段的生命周期仅存于调用者的内存中而不会写到磁盘里持久化。

    • 在开发过程中不需要transient关键字修饰的栗子:

    1、类中的字段值可以根据其它字段推导出来。
    2、看具体业务需求,哪些字段不想被序列化;

    不知道各位有木有想过为什么要不被序列化呢?其实主要是为了节省存储空间。优化程序!

    PS:记得之前看HashMap源码的时候,发现有个字段是用transient修饰的,我觉得还是有道理的,确实没必要对这个modCount字段进行序列化,因为没有意义,modCount主要用于判断HashMap是否被修改(像put、remove操作的时候,modCount都会自增),对于这种变量,一开始可以为任何值,0当然也是可以(new出来、反序列化出来、或者克隆clone出来的时候都是为0的),没必要持久化其值。

    当然,序列化后的最终目的是为了反序列化,恢复成原先的Java对象,要不然序列化后干嘛呢,就像买菜一样,用塑料袋包裹最后还是为了方便安全到家再去掉塑料袋,所以序列化后的字节序列都是可以恢复成Java对象的,这个过程就是反序列化。

    3、序列化与transient的使用

    1、需要做序列化的对象的类,必须实现序列化接口:Java.lang.Serializable 接口(一个标志接口,没有任何抽象方法),Java 中大多数类都实现了该接口,比如:StringInteger类等,不实现此接口的类将不会使任何状态序列化或反序列化,会抛NotSerializableException异常 。

    2、底层会判断,如果当前对象是 Serializable 的实例,才允许做序列化,Java对象 instanceof Serializable 来判断。

    3、在 Java 中使用对象流ObjectOutputStream来完成序列化以及ObjectInputStream流反序列化

    1. ObjectOutputStream:通过 writeObject()方法做序列化操作

    2. ObjectInputStream:通过 readObject() 方法做反序列化操作

    4、该类的所有属性必须是可序列化的。如果有一个属性不需要可序列化的,则该属性必须注明是瞬态的,使用transient 关键字修饰。
    在这里插入图片描述
    由于字节嘛所以肯定要涉及流的操作,也就是对象流也叫序列化流ObjectOutputstream,下面进行多种情况分析序列化的操作代码!

    在这里,我真的强烈建议看宜春博客的读者朋友,请试着去敲,切记一眼带过或者复制过去运行就完事了,特别是小白童鞋,相信我!你一定会有不一样的收获。千万不要觉得浪费时间,有时候慢就是快,宜春亲身体会!

    3.1、没有实现Serializable接口进行序列化情况

    package TransientTest;
    import java.io.*;
    
    class UserInfo {  //================================注意这里没有实现Serializable接口
        private String name;
        private transient String password;
    
        public UserInfo(String name,String psw) {
            this.name = name;
            this.password=psw;
        }
    
        @Override
        public String toString() {
            return "UserInfo{" +
                    "name='" + name + '\'' +
                    ", password='" + password + '\'' +
                    '}';
        }
    }
    
    public class TransientDemo {
        public static void main(String[] args) {
    
            UserInfo userInfo=new UserInfo("老王","123");
            System.out.println("序列化之前信息:"+userInfo);
    
            try {
                ObjectOutputStream output=new ObjectOutputStream(new FileOutputStream("userinfo.txt"));
                output.writeObject(new UserInfo("老王","123"));
                output.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
    

    运行结果
    在这里插入图片描述

    3.2、实现Serializable接口序列化情况

    当我们加上实现Serializable接口再运行会发现,项目中出现的userinfo.txt文件内容是这样的:
    在这里插入图片描述
    其实这都不是重点,重点是序列化操作成功了!

    3.3、普通序列化情况

    package TransientTest;
    import java.io.*;
    
    class UserInfo implements Serializable{  //第一步实现Serializable接口
        private String name;
        private String password;//都是普通属性==============================
    
        public UserInfo(String name,String psw) {
            this.name = name;
            this.password=psw;
        }
    
        @Override
        public String toString() {
            return "UserInfo{" +
                    "name='" + name + '\'' +
                    ", password='" + password + '\'' +
                    '}';
        }
    }
    
    public class TransientDemo {
        public static void main(String[] args) throws ClassNotFoundException {
    
            UserInfo userInfo=new UserInfo("程序员老王","123");
            System.out.println("序列化之前信息:"+userInfo);
    
            try {
                ObjectOutputStream output=new ObjectOutputStream(new FileOutputStream("userinfo.txt")); //第二步开始序列化操作
                output.writeObject(new UserInfo("程序员老王","123"));
                output.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
    
            try {
                ObjectInputStream input=new ObjectInputStream(new FileInputStream("userinfo.txt"));//第三步开始反序列化操作
                Object o = input.readObject();//ObjectInputStream的readObject方法会抛出ClassNotFoundException
                System.out.println("序列化之后信息:"+o);
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
    

    运行结果:

    序列化之前信息:UserInfo{name='程序员老王', password='123'}
    序列化之后信息:UserInfo{name='程序员老王', password='123'}
    

    3.4、transient序列化情况

    package TransientTest;
    import java.io.*;
    
    class UserInfo implements Serializable{  //第一步实现Serializable接口
        private String name;
        private transient String password; //特别注意:属性由transient关键字修饰===========
    
        public UserInfo(String name,String psw) {
            this.name = name;
            this.password=psw;
        }
    
        @Override
        public String toString() {
            return "UserInfo{" +
                    "name='" + name + '\'' +
                    ", password='" + password + '\'' +
                    '}';
        }
    }
    
    public class TransientDemo {
        public static void main(String[] args) throws ClassNotFoundException {
    
            UserInfo userInfo=new UserInfo("程序员老王","123");
            System.out.println("序列化之前信息:"+userInfo);
    
            try {
                ObjectOutputStream output=new ObjectOutputStream(new FileOutputStream("userinfo.txt")); //第二步开始序列化操作
                output.writeObject(new UserInfo("程序员老王","123"));
                output.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
    
            try {
                ObjectInputStream input=new ObjectInputStream(new FileInputStream("userinfo.txt"));//第三步开始反序列化操作
                Object o = input.readObject();//ObjectInputStream的readObject方法会抛出ClassNotFoundException
                System.out.println("序列化之后信息:"+o);
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
    

    运行结果:

    序列化之前信息:UserInfo{name='程序员老王', password='123'}
    序列化之后信息:UserInfo{name='程序员老王', password='null'}
    

    特别注意结果,添加transient修饰的属性值为默认值null!如果被transient修饰的属性为int类型,那它被序列化之后值一定是0,当然各位可以去试试,这能说明什么呢?说明被标记为transient的属性在对象被序列化的时候不会被保存(或者说变量不会持久化)

    3.5、static序列化情况

    package TransientTest;
    import java.io.*;
    
    class UserInfo implements Serializable{  //第一步实现Serializable接口
        private String name;
        private static String password; //特别注意:属性由static关键字修饰==============
    
        public UserInfo(String name, String psw) {
            this.name = name;
            this.password=psw;
        }
    
        @Override
        public String toString() {
            return "UserInfo{" +
                    "name='" + name + '\'' +
                    ", password='" + password + '\'' +
                    '}';
        }
    }
    
    public class TransientDemo {
        public static void main(String[] args) throws ClassNotFoundException {
    
            UserInfo userInfo=new UserInfo("程序员老王","123");
            System.out.println("序列化之前信息:"+userInfo);
    
            try {
                ObjectOutputStream output=new ObjectOutputStream(new FileOutputStream("userinfo.txt")); //第二步开始序列化操作
                output.writeObject(new UserInfo("程序员老王","123"));
                output.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
    
            try {
                ObjectInputStream input=new ObjectInputStream(new FileInputStream("userinfo.txt"));//第三步开始反序列化操作
                Object o = input.readObject();//ObjectInputStream的readObject方法会抛出ClassNotFoundException
                System.out.println("序列化之后信息:"+o);
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
    

    运行结果:

    序列化之前信息:UserInfo{name='程序员老王', password='123'}
    序列化之后信息:UserInfo{name='程序员老王', password='123'}
    

    这个时候,你就会错误的认为static修饰的也被序列化了,其实不然,实际上这里很容易被搞晕!明明取出null(默认值)就可以说明不会被序列化,这里明明没有变成默认值,为何还要说static不会被序列化呢?

    实际上,反序列化后类中static型变量name的值实际上是当前JVM中对应static变量的值,这个值是JVM中的并不是反序列化得出的。也就是说被static修饰的变量并没有参与序列化!但是咱也不能口说无凭啊,是的,那我们就来看两个程序对比一下就明白了!

    第一个程序:这是一个没有被static修饰的name属性程序:

    package Thread;
    import java.io.FileInputStream;
    import java.io.FileOutputStream;
    import java.io.ObjectInputStream;
    import java.io.ObjectOutputStream;
    import java.io.Serializable;
    
    class UserInfo implements Serializable {
        private String name;
        private transient String psw;
    
        public UserInfo(String name, String psw) {
            this.name = name;
            this.psw = psw;
        }
    
        public  String getName() {
            return name;
        }
    
        public  void setName(String name) {
            this.name = name;
        }
    
        public String getPsw() {
            return psw;
        }
    
        public void setPsw(String psw) {
            this.psw = psw;
        }
    
        public String toString() {
            return "name=" + name + ", psw=" + psw;
        }
    }
    public class TestTransient {
        public static void main(String[] args) {
            UserInfo userInfo = new UserInfo("程序员老过", "456");
            System.out.println(userInfo);
            try {
                // 序列化,被设置为transient的属性没有被序列化
                ObjectOutputStream o = new ObjectOutputStream(new FileOutputStream("UserInfo.txt"));
                o.writeObject(userInfo);
                o.close();
            } catch (Exception e) {
                // TODO: handle exception
                e.printStackTrace();
            }
            try {
                //在反序列化之前改变name的值 =================================注意这里的代码
                userInfo.setName("程序员老改");
                // 重新读取内容
                ObjectInputStream in = new ObjectInputStream(new FileInputStream("UserInfo.txt"));
                UserInfo readUserInfo = (UserInfo) in.readObject();
                //读取后psw的内容为null
                System.out.println(readUserInfo.toString());
            } catch (Exception e) {
                // TODO: handle exception
                e.printStackTrace();
            }
        }
    }
    

    运行结果:

    name=程序员老过, psw=456
    name=程序员老过, psw=null
    

    从程序运行结果中可以看出,在反序列化之前试着改变name的值为程序员老改,结果是没有成功的!

    第二个程序:这是一个被static修饰的name属性程序:

    package Thread;
    import java.io.FileInputStream;
    import java.io.FileOutputStream;
    import java.io.ObjectInputStream;
    import java.io.ObjectOutputStream;
    import java.io.Serializable;
    
    class UserInfo implements Serializable {
        private static final long serialVersionUID = 996890129747019948L;
        private static String name;
        private transient String psw;
    
        public UserInfo(String name, String psw) {
            this.name = name;
            this.psw = psw;
        }
    
        public  String getName() {
            return name;
        }
    
        public  void setName(String name) {
            this.name = name;
        }
    
        public String getPsw() {
            return psw;
        }
    
        public void setPsw(String psw) {
            this.psw = psw;
        }
    
        public String toString() {
            return "name=" + name + ", psw=" + psw;
        }
    }
    public class TestTransient {
        public static void main(String[] args) {
            UserInfo userInfo = new UserInfo("程序员老过", "456");
            System.out.println(userInfo);
            try {
                // 序列化,被设置为transient的属性没有被序列化
                ObjectOutputStream o = new ObjectOutputStream(new FileOutputStream("UserInfo.txt"));
                o.writeObject(userInfo);
                o.close();
            } catch (Exception e) {
                // TODO: handle exception
                e.printStackTrace();
            }
            try {
                //在反序列化之前改变name的值
                userInfo.setName("程序员老改");
                // 重新读取内容
                ObjectInputStream in = new ObjectInputStream(new FileInputStream("UserInfo.txt"));
                UserInfo readUserInfo = (UserInfo) in.readObject();
                //读取后psw的内容为null
                System.out.println(readUserInfo.toString());
            } catch (Exception e) {
                // TODO: handle exception
                e.printStackTrace();
            }
        }
    }
    

    运行结果:

    name=程序员老过, psw=456
    name=程序员老改, psw=null
    

    从程序运行结果中可以看出,在反序列化之前试着改变name的值为程序员老改,结果是成功的!现在对比一下两个程序是不是就很清晰了?

    static关键字修饰的成员属性优于非静态成员属性加载到内存中,同时静态也优于对象进入到内存中,被static修饰的成员变量不能被序列化,序列化的都是对象,静态变量不是对象状态的一部分,因此它不参与序列化。所以将静态变量声明为transient变量是没有用处的。因此,反序列化后类中static型变量name的值实际上是当前JVM中对应static变量的值,这个值是JVM中的并不是反序列化得出的。

    如果对static关键字还是不太清楚理解的童鞋可以参考这篇文章,应该算是不错的:深入理解static关键字

    3.6、final序列化情况

    对于final关键字来讲,final变量将直接通过值参与序列化,至于代码程序我就不再贴出来了,大家可以试着用final修饰验证一下!

    主要注意的是final 和transient可以同时修饰同一个变量,结果也是一样的,对transient没有影响,这里主要提一下,希望各位以后在开发中遇到这些情况不会满头雾水!

    4、java类中serialVersionUID作用

    既然提到了transient关键字就不得不提到序列化,既然提到了序列化,就不得不提到serialVersionUID了,它是啥呢?基本上有序列化就会存在这个serialVersionUID。
    在这里插入图片描述
    serialVersionUID适用于Java的序列化机制。简单来说,Java的序列化机制是通过判断类的serialVersionUID来验证版本一致性的。在进行反序列化时,JVM会把传来的字节流中的serialVersionUID与本地相应实体类的serialVersionUID进行比较,如果相同就认为是一致的,可以进行反序列化,否则就会出现序列化版本不一致的异常,即是InvalidCastException,在开发中有时候可写可不写,建议最好还是写上比较好。

    5、transient关键字小结

    1、变量被transient修饰,变量将不会被序列化
    2、transient关键字只能修饰变量,而不能修饰方法和类。
    3、被static关键字修饰的变量不参与序列化,一个静态static变量不管是否被transient修饰,均不能被序列化。
    4、final变量值参与序列化,final transient同时修饰变量,final不会影响transient,一样不会参与序列化

    第二点需要注意的是:本地变量是不能被transient关键字修饰的。变量如果是用户自定义类变量,则该类需要实现Serializable接口

    第三点需要注意的是:反序列化后类中static型变量的值实际上是当前JVM中对应static变量的值,这个值是JVM中的并不是反序列化得出的。

    结语:被transient关键字修饰导致不被序列化,其优点是可以节省存储空间。优化程序!随之而来的是会导致被transient修饰的字段会重新计算,初始化!

    如果本文对你有一点点帮助,那么请点个赞呗,谢谢~

    若有不足或者不正之处,欢迎指正批评,感激不尽!如果有疑问欢迎留言,绝对第一时间回复!

    最后,欢迎各位关注宜春的公众号,一起探讨技术,向往技术,追求技术,说好了来了就是盆友喔…

    在这里插入图片描述

    展开全文
  • A transient-improved dynamic-replica LDO regulator with bulk modulation
  • 从Serilizable说到transient2.序列化属性对象的类需要实现`Serilizable`接口?3.不想被序列化的字段怎么办?4.`ArrayList`里面的`elementData`都被`transient` 关键字修饰了,为什么`ArrayList`还可以序列化呢?5....

    1.从Serilizable说到transient

    我们知道,如果一个对象需要序列化,那么需要实现Serilizable接口,那么这个类的所有非静态属性,都会被序列化。

    注意:上面说的是非静态属性,因为静态属性是属于类的,而不是属于类对象的,而序列化是针对类对象的操作,所以这个根本不会序列化。下面我们可以实验一下:
    实体类Teacher.class:

    import java.io.Serializable;
    
    class Teacher implements Serializable {
        public int age;
        public static String SchoolName;
    
        public Teacher(int age) {
            this.age = age;
        }
    
        @Override
        public String toString() {
            return "Teacher{" +
                    "age=" + age +
                    '}';
        }
    }
    

    测试代码SerialTest.java,基本思路就是初始化的时候,静态属性SchoolName为"东方小学",序列化对象之后,将静态属性修改,然后,反序列化,发现其实静态变量还是修改之后的,说明静态变量并没有被序列化。

    import java.io.*;
    
    public class SerialTest {
        public static void main(String[] args) {
            Teacher.SchoolName = "东方小学";
            serial();
            Teacher.SchoolName = "西方小学";
            deserial();
            System.out.println(Teacher.SchoolName);
        }
        // 序列化
        private static void serial(){
            try {
                Teacher teacher = new Teacher(9);
                FileOutputStream fileOutputStream = new FileOutputStream("Teacher.txt");
                ObjectOutputStream objectOutputStream= new ObjectOutputStream(fileOutputStream);
                objectOutputStream.writeObject(teacher);
                objectOutputStream.flush();
            } catch (Exception exception) {
                exception.printStackTrace();
            }
        }
        // 反序列化
        private static void deserial() {
            try {
                FileInputStream fis = new FileInputStream("Teacher.txt");
                ObjectInputStream ois = new ObjectInputStream(fis);
                Teacher teacher = (Teacher) ois.readObject();
                ois.close();
                System.out.println(teacher.toString());
            } catch (IOException | ClassNotFoundException e) {
                e.printStackTrace();
            }
        }
    }
    

    输出的结果,证明静态变量没有被序列化!!!

    Teacher{age=9}
    西方小学
    

    2.序列化属性对象的类需要实现Serilizable接口?

    突然想到一个问题,如果有些属性是对象,而不是基本类型,需不需要改属性的类型也实现Serilizable呢?

    问题的答案是:需要!!!

    下面是实验过程:

    首先,有一个Teacher.java,实现了Serializable,里面有一个属性是School类型:

    import java.io.Serializable;
    
    class Teacher implements Serializable {
        public int age;
    
        public School school;
        public Teacher(int age) {
            this.age = age;
        }
    
        @Override
        public String toString() {
            return "Teacher{" +
                    "age=" + age +
                    '}';
        }
    }
    

    School类型,不实现Serializable:

    
    public class School {
        public String name;
    
        public School(String name) {
            this.name = name;
        }
    
        @Override
        public String toString() {
            return "School{" +
                    "name='" + name + '\'' +
                    '}';
        }
    }
    
    

    测试代码,我们只测试序列化:

    import java.io.*;
    
    public class SerialTest {
        public static void main(String[] args) {
            serial();
        }
    
        private static void serial(){
            try {
                Teacher teacher = new Teacher(9);
                teacher.school = new School("东方小学");
                FileOutputStream fileOutputStream = new FileOutputStream("Teacher.txt");
                ObjectOutputStream objectOutputStream= new ObjectOutputStream(fileOutputStream);
                objectOutputStream.writeObject(teacher);
                objectOutputStream.flush();
            } catch (Exception exception) {
                exception.printStackTrace();
            }
        }
    
    }
    

    会发现报错了,报错的原因是:School不能被序列化,也就是没有实现序列化接口,所以如果我们想序列化一个对象,那么这个对象的属性也必须是可序列化的,或者**它是transient**修饰的。

    java.io.NotSerializableException: com.aphysia.transienttest.School
    	at java.io.ObjectOutputStream.writeObject0(ObjectOutputStream.java:1184)
    	at java.io.ObjectOutputStream.defaultWriteFields(ObjectOutputStream.java:1548)
    	at java.io.ObjectOutputStream.writeSerialData(ObjectOutputStream.java:1509)
    	at java.io.ObjectOutputStream.writeOrdinaryObject(ObjectOutputStream.java:1432)
    	at java.io.ObjectOutputStream.writeObject0(ObjectOutputStream.java:1178)
    	at java.io.ObjectOutputStream.writeObject(ObjectOutputStream.java:348)
    	at com.aphysia.transienttest.SerialTest.serial(SerialTest.java:18)
    	at com.aphysia.transienttest.SerialTest.main(SerialTest.java:9)
    

    当我们将School实现序列化接口的时候,发现一切就正常了…问题完美解决

    3.不想被序列化的字段怎么办?

    但是如果有一个变量不是静态变量,但是我们也不想序列化它,因为它可能是一些密码等敏感的字段,或者它是不那么重要的字段,我们不希望增加报文大小,所以想在序列化报文中排除该字段。或者改字段存的是引用地址,不是真正重要的数据,比如ArrayList里面的elementData

    这个时候就需要使用transient 关键字,将改字段屏蔽。

    当我们用transient修饰School的时候:

    import java.io.Serializable;
    
    class Teacher implements Serializable {
        public int age;
    
        public transient School school;
        public Teacher(int age) {
            this.age = age;
        }
    
        @Override
        public String toString() {
            return "Teacher{" +
                    "age=" + age +
                    ", school=" + school +
                    '}';
        }
    }
    
    import java.io.Serializable;
    
    public class School implements Serializable {
        public String name;
    
        public School(String name) {
            this.name = name;
        }
    
        @Override
        public String toString() {
            return "School{" +
                    "name='" + name + '\'' +
                    '}';
        }
    }
    
    

    执行下面序列化和反序列化的代码:

    import java.io.*;
    
    public class SerialTest {
        public static void main(String[] args) {
            serial();
            deserial();
        }
    
        private static void serial(){
            try {
                Teacher teacher = new Teacher(9);
                teacher.school = new School("东方小学");
                FileOutputStream fileOutputStream = new FileOutputStream("Teacher.txt");
                ObjectOutputStream objectOutputStream= new ObjectOutputStream(fileOutputStream);
                objectOutputStream.writeObject(teacher);
                objectOutputStream.flush();
            } catch (Exception exception) {
                exception.printStackTrace();
            }
        }
    
        private static void deserial() {
            try {
                FileInputStream fis = new FileInputStream("Teacher.txt");
                ObjectInputStream ois = new ObjectInputStream(fis);
                Teacher teacher = (Teacher) ois.readObject();
                ois.close();
                System.out.println(teacher.toString());
            } catch (IOException | ClassNotFoundException e) {
                e.printStackTrace();
            }
        }
    }
    

    执行结果如下,可以看到teacher字段反序列化出来,其实是null,这也是transient起作用了。
    但是注意,transient只能修饰变量,但是不能修饰类和方法,

    4.ArrayList里面的elementData都被transient 关键字修饰了,为什么ArrayList还可以序列化呢?

    这里提一下,既然transient修饰了ArrayList的数据节点,那么为什么序列化的时候我们还是可以看到ArrayList的数据节点呢?
    这是因为序列化的时候:

    如果仅仅实现了Serializable接口,那么序列化的时候,肯定是调用java.io.ObjectOutputStream.defaultWriteObject()方法,将对象序列化。然后如果是transient修饰了该属性,肯定该属性就不能序列化。
    但是,如果我们虽然实现了Serializable接口,也transient修饰了该属性,该属性确实不会在默认的java.io.ObjectOutputStream.defaultWriteObject()方法里面被序列化了,但是我们可以重写一个writeObject()方法,这样一来,序列化的时候调用的就是writeObject(),而不是java.io.ObjectOutputStream.defaultWriteObject()

    下面的源码是ObjectInputStream.writeObject(Object obj),里面底层其实会有反射的方式调用到重写的对象的writeObject()方法,这里不做展开。

        public final void writeObject(Object obj) throws IOException {
            // 如果可以被重写,那么就会调用重写的方法
            if (enableOverride) {
                writeObjectOverride(obj);
                return;
            }
            try {
                writeObject0(obj, false);
            } catch (IOException ex) {
                if (depth == 0) {
                    writeFatalException(ex);
                }
                throw ex;
            }
        }
    

    ArrayList重写的writeOject()方法如下:

        private void writeObject(java.io.ObjectOutputStream s)
            throws java.io.IOException{
            // Write out element count, and any hidden stuff
            int expectedModCount = modCount;
            // 默认的序列化对象的方法
            s.defaultWriteObject();
    
            // Write out size as capacity for behavioural compatibility with clone()
            s.writeInt(size);
    
            // Write out all elements in the proper order.
            for (int i=0; i<size; i++) {
                // 序列化对象的值
                s.writeObject(elementData[i]);
            }
    
            if (modCount != expectedModCount) {
                throw new ConcurrentModificationException();
            }
        }
    

    我们可以看到,writeOject()里面其实在里面调用了默认的方法defaultWriteObject()defaultWriteObject()底层其实是调用改了writeObject0()ArrayList重写的writeOject()的思路主要是先序列化默认的,然后序列化数组大小,再序列化数组elementData里面真实的元素。这就达到了序列化元素真实内容的目的。

    5.除了transient,有没有其他的方式,可以屏蔽反序列化?

    且慢,问出这个问题,答案肯定是有的!!!那就是Externalizable接口。

    具体情况:Externalizable意思就是,类里面有很多很多属性,但是我只想要一部分,要屏蔽大部分,那么我不想在大部分的属性前面加关键字transient,我只想标识一下自己序列化的字段,这个时候就需要使用Externalizable接口。

    show me the code!

    首先定义一个Person.java,里面有三个属性

    • age:年龄
    • name:名字(被transient修饰)
    • score:分数

    实现了Externalizable接口,就必须实现writeExternal()readExternal()方法。

    • writeExternal:将需要序列化的属性进行自定义序列化
    • readExternal:将需要反序列化的属性进行自定义反序列化
    import java.io.Externalizable;
    import java.io.IOException;
    import java.io.ObjectInput;
    import java.io.ObjectOutput;
    
    public class Person implements Externalizable {
        public int age;
        public transient String name;
        public int score;
    
        // 必须实现无参构造器
        public Person() {
        }
    
        public Person(int age, String name, int score) {
            this.age = age;
            this.name = name;
            this.score = score;
        }
    
        @Override
        public void writeExternal(ObjectOutput out) throws IOException {
            /*
             * 指定序列化时候写入的属性。这里不写入score
             */
            out.writeObject(age);
            out.writeObject(name);
            out.writeObject(score);
        }
    
        @Override
        public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
            /*
             * 指定序列化时候写入的属性。这里仍然不写入年龄
             */
            this.age = (int)in.readObject();
            this.name = (String)in.readObject();
        }
    
        @Override
        public String toString() {
            return "Person{" +
                    "age=" + age +
                    ", name='" + name + '\'' +
                    ", score='" + score + '\'' +
                    '}';
        }
    }
    
    

    上面的代码,我们可以看出,序列化的时候,将三个属性都写进去了,但是反序列化的时候,我们仅仅还原了两个,那么我们来看看测试的代码:

    import java.io.*;
    
    public class ExternalizableTest {
        public static void main(String[] args) {
            serial();
            deserial();
        }
    
        private static void serial(){
            try {
                Person person = new Person(9,"Sam",98);
                FileOutputStream fileOutputStream = new FileOutputStream("person.txt");
                ObjectOutputStream objectOutputStream= new ObjectOutputStream(fileOutputStream);
                objectOutputStream.writeObject(person);
                objectOutputStream.flush();
            } catch (Exception exception) {
                exception.printStackTrace();
            }
        }
    
        private static void deserial() {
            try {
                FileInputStream fis = new FileInputStream("person.txt");
                ObjectInputStream ois = new ObjectInputStream(fis);
                Person person = (Person) ois.readObject();
                ois.close();
                System.out.println(person);
            } catch (IOException | ClassNotFoundException e) {
                e.printStackTrace();
            }
        }
    }
    

    测试结果如下,就可以发现其实前面两个都反序列化成功了,后面那个是因为我们重写的时候,没有自定义该属性的反序列化,所以没有是正常的啦…

    Person{age=9, name='Sam', score='0'}
    

    如果细心点,可以发现,有一个字段是transient修饰的,不是说修饰了,就不会被序列化么,怎么序列化出来了。

    没错,只要实现了Externalizable接口,其实就不会被transient左右了,只会按照我们自定义的字段进行序列化和反序列化,这里的transient是无效的…

    关于序列化的transient暂时到这,keep going~

    此文章仅代表自己(本菜鸟)学习积累记录,或者学习笔记,如有侵权,请联系作者删除。人无完人,文章也一样,文笔稚嫩,在下不才,勿喷,如果有错误之处,还望指出,感激不尽~

    技术之路不在一时,山高水长,纵使缓慢,驰而不息。

    公众号:秦怀杂货店

    展开全文
  • A fast-transient-response fully integrated digital LDO with adaptive current step size control
  • Ultrafast transient absorption measurements of photocarrier dynamics in monolayer and bulk ReSe2
  • Java关键字—-transient

    2021-01-20 02:59:25
    本篇文章序列化、反序列化用的类是同一个类,可以通过注释main中1然后修改Stu类实现有无transient关键字修饰、serialVersionUID是否不同,得到以下结果: 1、serialVersionUID的数值大小不会影响序列化后的字节数...
  • 6q24暂时性新生儿糖尿病:病例报道和文献复习,张辛寒,翁建平,6q24暂时性新生儿糖尿病是一类罕见疾病,直到目前,在中国尚未有完整的临床报道。本文的目的是报道我国第一例有详细临床资料的6q24�
  • 1. transient关键字的用途 用于在实现Serializable接口的类中标记成员变量,使该类对象在序列化和反序列化过程中忽略该成员变量的处理。 2. transient序列化和反序列化过程中的处理方式 在序列化过程中,transient...

    1. transient关键字的用途

    用于在实现Serializable接口的类中标记成员变量,使该类对象在序列化和反序列化过程中忽略该成员变量的处理。

    2. transient序列化和反序列化过程中的处理方式

    1. 在序列化过程中,transient关键字修饰的成员变量默认处理方式使直接忽略
    2. 在反序列化过程中,transient关键字修饰的成员变量默认赋值该成员变量类型的默认值,例如int型为0,boolean为false,对象类型为null。

    3. transient默认处理方式引发的问题

    反序列化过程中,transient修饰的成员变量赋值可能不是期望的默认值,例如:

    import java.io.*;
    public class JavaSerializableObj {
        
        public static void main(String[] args) {
            Obj obj = new Obj();
            System.out.println("Obj.member = " + obj.getMember() + "; Obj.ignore = " + obj.getIgnore());
            try {
                FileOutputStream fos = new FileOutputStream("obj");
                ObjectOutputStream oos = new ObjectOutputStream(fos);
                oos.writeObject(obj);
                oos.close();
                System.out.println("write obj to file success");
            } catch (Exception ex) {
                ex.printStackTrace();
            }
            try {
                FileInputStream fis = new FileInputStream("obj");
                ObjectInputStream ois = new ObjectInputStream(fis);
                obj = (Obj) ois.readObject();
                ois.close();
                System.out.println("read obj from file success");
            } catch (Exception ex) {
                ex.printStackTrace();
            }
            System.out.println("Obj.member = " + obj.getMember() + "; Obj.ignore = " + obj.getIgnore());
        }
        public static class Obj implements Serializable {
            private final String member = "Member";
            private final transient String ignore = new String("Ignore");
            public String getMember() {
                return member;
            }
            public String getIgnore() {
                return ignore;
            }
        }
    }
    

    以上输出的结果为:

    Obj.member = Member; Obj.ignore = Ignore
    write obj to file success
    read obj from file success
    Obj.member = Member; Obj.ignore = null
    

    Obj类中transient修饰的成员变量ignore为final类型,并且默认值为new String(“Ignore”),但反序列化后缺为null,因为在反序列化过程中对象类型的值默认处理为null,这可能就不是业务逻辑所期望的。
    注意:如果这里ignore的初始值改为ignore = “ignore”(非new出来的对象),反序列化却可以正常恢复ignore默认值,原因是final String字符串对象以字符串字面量赋值,java编译器编译的时候其实把该对象编译优化为常量,反序列化自然就没有问题了。

    4. 自定义序列化和反序列化过程

    为了解决transient关键字在序列化和反序列化过程中带来的问题,对有特殊业务要求的场景可以通过自定义序列化和反序列化过程来解决这些问题。
    Serializable接口提供了三个自定义序列化过程的方法:

    /**
    * 处理对象序列化过程,默认应该调用out.defaultWriteObject()方法序列化
    * 非static和transient修饰的成员变量
    */
    private void writeObject(java.io.ObjectOutputStream out)
           throws IOException
    /**
    * 处理对象反序列化过程,默认应该调用in.defaultReadObject()方法反序列化
    * 非station和transient修饰的成员变量
    */
    private void readObject(java.io.ObjectInputStream in)
           throws IOException, ClassNotFoundException;
    /**
    * 用于反序列化过程中识别到未定义成员变量时的回调处理,常见于同个类在反序列化时修改了继承关系,
    * 或远程传输过来的序列化数据版本与当前类的序列化版本不一致。
    */
    private void readObjectNoData()
           throws ObjectStreamException;
    

    针对上面的问题可以将Obj类处理为:

        public static class Obj implements Serializable {
            private final String member = "Member";
            private final transient String ignore = new String("Ignore");
            public String getMember() {
                return member;
            }
            public String getIgnore() {
                return ignore;
            }
            
            private void readObject(java.io.ObjectInputStream in)
                    throws IOException, ClassNotFoundException{
                in.defaultReadObject();
                //final变量需要通过反射来赋值
                try {
                    Field ignoreField = getClass().getDeclaredField("ignore");
                    ignoreField.setAccessible(true);
                    ignoreField.set(this, new String("Read Ignore"));
                    ignoreField.setAccessible(false);
                } catch (NoSuchFieldException | IllegalAccessException e) {
                    e.printStackTrace();
                }
            }
        }
    

    输出结果为:

    Obj.member = Member; Obj.ignore = Ignore
    write obj to file success
    read obj from file success
    Obj.member = Member; Obj.ignore = Read Ignore
    
    展开全文
  • JAVA @Transient注解

    千次阅读 2018-06-01 21:14:10
    哎,虽然自己最熟的是Java,但很多Java基础知识都不知道,比如transient关键字以前都没用到过,所以不知道它的作用是什么,今天做笔试题时发现有一题是关于这个的,于是花个时间整理下transient关键字的使用,涨下...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 138,208
精华内容 55,283
关键字:

transient