精华内容
下载资源
问答
  • Serializable接口

    2020-06-09 11:16:11
    文章目录什么是Serializable接口什么是序列化?序列化与反序列化为什么要实现SerializableSerializable接口作用为什么...一般情况下,我们在定义实体类时会继承Serializable接口,类似这样: 我们实体类引用了Seri


    一般情况下,我们在定义实体类时会继承Serializable接口,类似这样:
    在这里插入图片描述
    我们在实体类中引用了Serializable这个接口,那么这个接口到底有什么?细心的你会发现我们还定义了个serialVersionUID变量。这个变量到底有什么作用?

    什么是Serializable接口

    一个对象序列化的接口,一个类只有实现了Serializable接口,它的对象才能被序列化。

    什么是序列化?

    序列化是将对象状态转换为可保持或传输的格式的过程。与序列化相对的是反序列化,它将流转换为对象。这两个过程结合起来,可以轻松地存储和传输数据。

    序列化与反序列化

    把对象转换为字节序列的过程称为对象的序列化
    把字节序列恢复为对象的过程称为对象的反序列化

    为什么要实现Serializable

    工作中我们经常在进行持久化操作和返回数据时都会使用到javabean来统一封装参数,方便操作,一般我们也都会实现Serializable接口,那么问题来了,
      1.为什么要进行序列化?
      2.每个实体bean都必须实现serializabel接口吗?
      3.我做一些项目的时候,没有实现序列化,同样没什么影响,到底什么时候应该进行序列化操作呢?

    首先第一个问题,实现序列化的两个原因:1、将对象的状态保存在存储媒体中以便可以在以后重新创建出完全相同的副本;2、按值将对象从一个应用程序域发送至另一个应用程序域。实现serializabel接口的作用是就是可以把对象存到字节流,然后可以恢复,所以你想如果你的对象没实现序列化怎么才能进行持久化和网络传输呢,要持久化和网络传输就得转为字节流,所以在分布式应用中及设计数据持久化的场景中,你就得实现序列化。

    第二个问题,是不是每个实体bean都要实现序列化,答案其实还要回归到第一个问题,那就是你的bean是否需要持久化存储媒体中以及是否需要传输给另一个应用,没有的话就不需要,例如我们利用fastjson将实体类转化成json字符串时,并不涉及到转化为字节流,所以其实跟序列化没有关系。

    第三个问题,有的时候并没有实现序列化,依然可以持久化到数据库。这个其实我们可以看看实体类中常用的数据类型,例如Date、String等等,它们已经实现了序列化,而一些基本类型,数据库里面有与之对应的数据结构,从我们的类声明来看,我们没有实现serializabel接口,其实是在声明的各个不同变量的时候,由具体的数据类型帮助我们实现了序列化操作。
      
      另外需要注意的是,在NoSql数据库中,并没有与我们java基本类型对应的数据结构,所以在往nosql数据库中存储时,我们就必须将对象进行序列化,同时在网络传输中我们要注意到两个应用中javabean的serialVersionUID要保持一致,不然就不能正常的进行反序列化。

    Serializable接口作用

    我们来看看Serializable到底是什么,跟进去看一下,我们发现Serializable接口里面竟然什么都没有,只是个空接口
    在这里插入图片描述
    一个接口里面什么内容都没有,我们可以将它理解成一个标识接口

    比如在课堂上有位学生遇到一个问题,于是举手向老师请教,这时老师帮他解答,那么这位学生的举手其实就是一个标识,自己解决不了问题请教老师帮忙解决。在Java中的这个Serializable接口其实是给jvm看的,通知jvm,我不对这个类做序列化了,你(jvm)帮我序列化就好了。

    Serializable接口就是Java提供用来进行高效率的异地共享实例对象的机制,实现这个接口即可。

    为什么要定义serialversionUID变量

    简单看一下 Serializable接口的说明

    在这里插入图片描述
    从说明中我们可以看到,如果我们没有自己声明一个serialVersionUID变量,接口会默认生成一个serialVersionUID

    但是强烈建议用户自定义一个serialVersionUID,因为默认的serialVersinUID对于class的细节非常敏感,反序列化时可能会导致InvalidClassException这个异常。

    这个serialVersionUID是用来辅助对象的序列化与反序列化的,原则上序列化后的数据当中的serialVersionUID与当前类当中的serialVersionUID一致,那么该对象才能被反序列化成功

    这个serialVersionUID的详细的工作机制是:在序列化的时候系统将serialVersionUID写入到序列化的文件中去,当反序列化的时候系统会先去检测文件中的serialVersionUID是否跟当前的文件的serialVersionUID是否一致,如果一直则反序列化成功,否则就说明当前类跟序列化后的类发生了变化,比如是成员变量的数量或者是类型发生了变化,那么在反序列化时就会发生crash,并且回报出错误

    Serializable序列化的简要说明

    一、 持久化的简单介绍:

    “持久化”意味着对象的“生存时间”并不取决于程序是否正在执行——它存在或“生存”于程序的每一次调用之间。通过序列化一个对象,将其写入磁盘,以后在程序再次调用时重新恢复那个对象,就能圆满实现一种“持久”效果。

    二、 语言里增加了对象序列化的概念后,可提供对两种主要特性的支持:

    • 远程方法调用(RMI)使本来存在于其他机器的对象可以表现出好象就在本地机器上的行为。将消息发给远程对象时,需要通过对象序列化来传输参数和返回值。
    • 使用一个Java Bean 时,它的状态信息通常在设计期间配置好。程序启动以后,这种状态信息必须保存下来,以便程序启动以后恢复;具体工作由对象序列化完成。

    三、 Serializable的一些说明:

    • 对象的序列化处理非常简单,只需对象实现了Serializable 接口即可(该接口仅是一个标记,没有方法)
    • 序列化的对象包括基本数据类型,所有集合类以及其他许多东西,还有Class 对象
    • 对象序列化不仅保存了对象的“全景图”,而且能追踪对象内包含的所有句柄并保存那些对象;接着又能对每个对象内包含的句柄进行追踪
    • 使用transient关键字修饰的的变量,在序列化对象的过程中,该属性不会被序列化。

    四、 序列化的步骤:

    • 首先要创建某些OutputStream对象:OutputStream outputStream = new FileOutputStream(“output.txt”)
    • 将其封装到ObjectOutputStream对象内:ObjectOutputStream objectOutputStream = new ObjectOutputStream(outputStream);
    • 此后只需调用writeObject()即可完成对象的序列化,并将其发送给OutputStream:objectOutputStream.writeObject(Object);
    • 最后不要忘记关闭资源:objectOutputStream.close(), outputStream .close();

    五、 反序列化的步骤:

    • 首先要创建某些OutputStream对象:InputStream inputStream= new FileInputStream(“output.txt”)
    • 将其封装到ObjectInputStream对象内:ObjectInputStream objectInputStream= new ObjectInputStream(inputStream);
    • 此后只需调用readObject()即可完成对象的反序列化:objectInputStream.readObject();
    • 最后不要忘记关闭资源:objectInputStream.close(),inputStream.close();
    展开全文
  • Java里面的接口,虽然定义了但是没有定义方法,某些情况下,还得要求一个类必须实现它们,这个时候这些接口是作为一个标识,例如,Serializable接口和Cloneable接口

    Serializable接口和Cloneable接口都只是一个标识接口,它们没有定义任何方法

    为了实现java对象浅复制,要求该类必须要实现Cloneable接口,除此之外还包括:

    (1)在派生类中覆盖基类的clone()方法,并声明为public(Object类中的clone()方法为protected的);

    (2)在派生类的clone()方法中,调用super.clone();

    为了实现java对象深复制,可以利用序列化——将对象写到流里的过程,而一个类只有实现了Serializable接口,它的对象才是可序列化的

    注意:这样做的前提是对象以及对象内部所有引用到的对象都是可串行化的,否则,就需要仔细考察那些不可串行化的对象可否设成transient,从而将之排除在复制过程之外。

    展开全文
  • 一般情况下,我们定义实体类时会继承Serializable接口 我们实体类引用了Serializable这个接口,那么这个接口到底有什么?细心的你会发现我们还定义了个serialVersionUID变量。这个变量到底有什么作用 什么...

    关于serializable
    一般情况下,我们在定义实体类时会继承Serializable接口
    在这里插入图片描述
    我们在实体类中引用了Serializable这个接口,那么这个接口到底有什么?细心的你会发现我们还定义了个serialVersionUID变量。这个变量到底有什么作用

    什么serializable接口
    一个对象序列化的接口,一个类只有实现了Serializable接口,它的对象才能被序列化。

    什么是序列化?
    序列化是将对象状态转换为可保持或传输的格式的过程。与序列化相对的是反序列化,它将流转换为对象。这两个过程结合起来,可以轻松地存储和传输数据。

    为什么要序列化对象
    把对象转换为字节序列的过程称为对象的序列化
    把字节序列恢复为对象的过程称为对象的反序列化

    什么情况下需要序列化?
    当我们需要把对象的状态信息通过网络进行传输,或者需要将对象的状态信息持久化,以便将来使用时都需要把对象进行序列化

    那为什么还要继承Serializable。那是存储对象在存储介质中,以便在下次使用的时候,可以很快捷的重建一个副本。

    或许你会问,我在开发过程中,实体并没有实现序列化,但我同样可以将数据保存到mysql、Oracle数据库中,为什么非要序列化才能存储呢?

    我们来看看Serializable到底是什么,跟进去看一下,我们发现Serializable接口里面竟然什么都没有,只是个空接口

    在这里插入图片描述
    比如在课堂上有位学生遇到一个问题,于是举手向老师请教,这时老师帮他解答,那么这位学生的举手其实就是一个标识,自己解决不了问题请教老师帮忙解决。在Java中的这个Serializable接口其实是给jvm看的,通知jvm,我不对这个类做序列化了,你(jvm)帮我序列化就好了。

    什么是JVM?
    JVM是Java Virtual Machine(Java虚拟机)的缩写,JVM是一种用于计算设备的规范,它是一个虚构出来的计算机,是通过在实际的计算机上仿真模拟各种计算机功能来实现的。

    为什么要定义serialversionUID变量
    从说明中我们可以看到,如果我们没有自己声明一个serialVersionUID变量,接口会默认生成一个serialVersionUID

    是的,你没有看错,序列化与反序列化操作过程就是这么的简单。只需要将User写入到文件中,然后再从文件中进行恢复,恢复后得到的内容与之前完全一样,但是两者是不同的对象。前面提到过一个问题,如果将serialVersionUID变量去掉,我们来看看,会发生什么事情。

    刚开始提到了,serialVersionUID要不要指定呢?如果不指定会出现什么样的后果?如果指定了以后后边的值又代表着什么意思呢?既然系统指定了这个字段,那么肯定是有它的作用的。

    这个serialVersionUID是用来辅助对象的序列化与反序列化的,原则上序列化后的数据当中的serialVersionUID与当前类当中的serialVersionUID一致,那么该对象才能被反序列化成功。这个serialVersionUID的详细的工作机制是:在序列化的时候系统将serialVersionUID写入到序列化的文件中去,当反序列化的时候系统会先去检测文件中的serialVersionUID是否跟当前的文件的serialVersionUID是否一致,如果一直则反序列化成功,否则就说明当前类跟序列化后的类发生了变化,比如是成员变量的数量或者是类型发生了变化,那么在反序列化时就会发生crash,并且回报出错误

    总结一下

    实现Serializable接口的类可以被ObjectOutputStream转换为字节流,同时可以通过ObjectInputStream再将其解析为对象,我们可以通过类型信息和字节在内存中重新创建对象。也就是序列化和反序列化。对象到字节文件再到对象。

     serialVersionUID:是java序列化时通过判断类的serialVersionUID来验证版本是否一致。
    
     在进行反序列化话的时候时候JVM会把传递过来的字节流中的serialVersionUID和本地相应实体类的serialVersionUID进行比较。如果相同则说明一致,可以进行反序列化,否则会出现InvalidCastException异常.
    
    展开全文
  • Serializable接口:序列化

    2020-10-11 00:21:22
    麻木地搬着Ctrl-C、Ctrl-V的砖,不知道重复了多少次定义Java实体对象时“implements Serializable”的C/V大法后,脑海突然冒出一个思维(A):问了自己一句“Java实体对象为什么一定要实现Serializable接口呢?...

    最近这段时间一直在学习java框架,麻木地搬着Ctrl-C、Ctrl-V的砖,在不知道重复了多少次定义Java实体对象时“implements Serializable”的C/V大法后,脑海中突然冒出一个思维(A):问了自己一句“Java实体对象为什么一定要实现Serializable接口呢?

    查看 官方文档 就会发现 Serializable接口中一个成员函数或者成员变量也没有。那么这个接口的作用是什么呢。网上找了一些博客看过之后,知道这个接口的作用是实现序列化。

    那什么是序列化呢?

    Serializable是java.io包中定义的、用于实现Java类的序列化操作而提供的一个语义级别的接口。Serializable序列化接口没有任何方法或者字段,只是用于标识可序列化的语义。实现了Serializable接口的类可以被ObjectOutputStream转换为字节流,同时也可以通过ObjectInputStream再将其解析为对象。例如,我们可以将序列化对象写入文件后,再次从文件中读取它并反序列化成对象,也就是说,可以使用表示对象及其数据的类型信息和字节在内存中重新创建对象。

    而这一点对于面向对象的编程语言来说是非常重要的,因为无论什么编程语言,其底层涉及IO操作的部分还是由操作系统其帮其完成的,而底层IO操作都是以字节流的方式进行的,所以写操作都涉及将编程语言数据类型转换为字节流,而读操作则又涉及将字节流转化为编程语言类型的特定数据类型。而Java作为一门面向对象的编程语言,对象作为其主要数据的类型载体,为了完成对象数据的读写操作,也就需要一种方式来让JVM知道在进行IO操作时如何将对象数据转换为字节流,以及如何将字节流数据转换为特定的对象,而Serializable接口就承担了这样一个角色。

    序列化:对象的寿命通常随着生成该对象的程序的终止而终止,有时候需要把在内存中的各种对象的状态(也就是实例变量,不是方法)保存下来,并且可以在需要时再将对象恢复。虽然你可以用你自己的各种各样的方法来保存对象的状态,但是Java给你提供一种应该比你自己的好的保存对象状态的机制,那就是序列化。

    总结:Java 序列化技术可以使你将一个对象的状态写入一个Byte 流里(系列化),并且可以从其它地方把该Byte 流里的数据读出来(反序列化)。

    系列化的用途

    • 想把的内存中的对象状态保存到一个文件中或者数据库中时候
    • 想把对象通过网络进行传播的时候

    如何序列化

    只要一个类实现Serializable接口,那么这个类就可以序列化了。
    例如有一个 User类,实现了Serializable接口,那么这个类就可以被序列化了。

    下面我们可以通过例子来实现将序列化的对象存储到文件,然后再将其从文件中反序列化为对象,代码示例如下:

    先定义一个序列化对象User:

    public class User implements Serializable { 
        private static final long serialVersionUID = 1L; 
     
        private String userId; 
        private String userName; 
     
        public User(String userId, String userName) { 
            this.userId = userId; 
            this.userName = userName; 
        } 
    } 
    

    然后我们编写测试类,来对该对象进行读写操作,我们先测试将该对象写入一个文件:

    public class SerializableTest { 
     
        /** 
         * 将User对象作为文本写入磁盘 
         */ 
        public static void writeObj() { 
            User user = new User("1001", "Joe"); 
            try { 
                ObjectOutputStream objectOutputStream = new ObjectOutputStream(new FileOutputStream("D:\\user.txt")); 
                objectOutputStream.writeObject(user); 
                objectOutputStream.close(); 
            } catch (IOException e) { 
                e.printStackTrace(); 
            } 
        } 
     
        public static void main(String args[]) { 
            writeObj(); 
        } 
    } 
    

    运行上述代码,我们就将User对象及其携带的数据写入了文本user.txt中,我们可以看下user.txt中存储的数据此时是个什么格式:
    在这里插入图片描述
    注意:writeObject(Object obj)写入的文件是以二进制文件存储的,所以会乱码!

    我们看到对象数据以二进制文本的方式被持久化到了磁盘文件中。在进行反序列化测试之前,我们可以尝试下将User实现Serializable接口的代码部分去掉,看看此时写操作是否还能成功,结果如下:
    在这里插入图片描述
    结果不出所料,果然是不可以的,抛出了NotSerializableException异常,提示非可序列化异常,也就是说没有实现Serializable接口的对象是无法通过IO操作持久化的。

    接下来,我们继续编写测试代码,尝试将之前持久化写入user.txt文件的对象数据再次转化为Java对象,代码如下:

    public class SerializableTest { 
        /** 
         * 将类从文本中提取并赋值给内存中的类 
         */ 
        public static void readObj() { 
            try { 
                ObjectInputStream objectInputStream = new ObjectInputStream(new FileInputStream("/Users/guanliyuan/user.txt")); 
                try { 
                    Object object = objectInputStream.readObject(); 
                    User user = (User) object; 
                    System.out.println(user); 
                } catch (ClassNotFoundException e) { 
                    e.printStackTrace(); 
                } 
            } catch (IOException e) { 
                e.printStackTrace(); 
            } 
        } 
     
     
        public static void main(String args[]) { 
            readObj(); 
        } 
    } 
    

    Java对象为啥要实现Serializable接口?

    最近这段时间一直在忙着编写Java业务代码,麻木地搬着Ctrl-C、Ctrl-V的砖,在不知道重复了多少次定义Java实体对象时“implements Serializable”的C/V大法后,脑海中突然冒出一个思维(A):问了自己一句“Java实体对象为什么一定要实现Serializable接口呢?”

    作者:无敌码农来源:无敌码农|2019-05-14 09:05
    收藏
    分享

    导读

    最近这段时间一直在忙着编写Java业务代码,麻木地搬着Ctrl-C、Ctrl-V的砖,在不知道重复了多少次定义Java实体对象时“implements Serializable”的C/V大法后,脑海中突然冒出一个思维(A):问了自己一句“Java实体对象为什么一定要实现Serializable接口呢?”,关于这个问题,脑海中的另一个思维(B)立马给出了回复“居然问这么幼稚和基础的问题,实现Serilizable接口是为了序列化啊!”,思维(A):“哦,好吧!然而,然后呢?”

    此时思维(B)陷入了沉默,突然感觉自己有点浅薄了,好像写了这么多年Java还真是没有太关注过Serializable这个接口!为什么一定要实现Serializable接口?它的底层原理是什么?为什么一定要序列化,序列化又是什么?关于这些问题,不知道各位读者朋友有没有过类似的问题,如果有那么我们就在这篇文章中一起寻找答案吧!当然,如果你对这些问题都很清楚,也欢迎表达看法!

    Serializable接口概述

    Serializable是java.io包中定义的、用于实现Java类的序列化操作而提供的一个语义级别的接口。Serializable序列化接口没有任何方法或者字段,只是用于标识可序列化的语义。实现了Serializable接口的类可以被ObjectOutputStream转换为字节流,同时也可以通过ObjectInputStream再将其解析为对象。例如,我们可以将序列化对象写入文件后,再次从文件中读取它并反序列化成对象,也就是说,可以使用表示对象及其数据的类型信息和字节在内存中重新创建对象。

    而这一点对于面向对象的编程语言来说是非常重要的,因为无论什么编程语言,其底层涉及IO操作的部分还是由操作系统其帮其完成的,而底层IO操作都是以字节流的方式进行的,所以写操作都涉及将编程语言数据类型转换为字节流,而读操作则又涉及将字节流转化为编程语言类型的特定数据类型。而Java作为一门面向对象的编程语言,对象作为其主要数据的类型载体,为了完成对象数据的读写操作,也就需要一种方式来让JVM知道在进行IO操作时如何将对象数据转换为字节流,以及如何将字节流数据转换为特定的对象,而Serializable接口就承担了这样一个角色。

    下面我们可以通过例子来实现将序列化的对象存储到文件,然后再将其从文件中反序列化为对象,代码示例如下:

    先定义一个序列化对象User:

    public class User implements Serializable { 
        private static final long serialVersionUID = 1L; 
     
        private String userId; 
        private String userName; 
     
        public User(String userId, String userName) { 
            this.userId = userId; 
            this.userName = userName; 
        } 
    } 
    

    然后我们编写测试类,来对该对象进行读写操作,我们先测试将该对象写入一个文件:

    public class SerializableTest { 
     
        /** 
         * 将User对象作为文本写入磁盘 
         */ 
        public static void writeObj() { 
            User user = new User("1001", "Joe"); 
            try { 
                ObjectOutputStream objectOutputStream = new ObjectOutputStream(new FileOutputStream("/Users/guanliyuan/user.txt")); 
                objectOutputStream.writeObject(user); 
                objectOutputStream.close(); 
            } catch (IOException e) { 
                e.printStackTrace(); 
            } 
        } 
     
        public static void main(String args[]) { 
            writeObj(); 
        } 
    } 
    

    运行上述代码,我们就将User对象及其携带的数据写入了文本user.txt中,我们可以看下user.txt中存储的数据此时是个什么格式:

    java.io.NotSerializableException: cn.wudimanong.serializable.User 
        at java.io.ObjectOutputStream.writeObject0(ObjectOutputStream.java:1184) 
        at java.io.ObjectOutputStream.writeObject(ObjectOutputStream.java:348) 
        at cn.wudimanong.serializable.SerializableTest.writeObj(SerializableTest.java:19) 
        at cn.wudimanong.serializable.SerializableTest.main(SerializableTest.java:27) 
    

    我们看到对象数据以二进制文本的方式被持久化到了磁盘文件中。在进行反序列化测试之前,我们可以尝试下将User实现Serializable接口的代码部分去掉,看看此时写操作是否还能成功,结果如下:

    结果不出所料,果然是不可以的,抛出了NotSerializableException异常,提示非可序列化异常,也就是说没有实现Serializable接口的对象是无法通过IO操作持久化的。

    接下来,我们继续编写测试代码,尝试将之前持久化写入user.txt文件的对象数据再次转化为Java对象,代码如下:

    public class SerializableTest { 
        /** 
         * 将类从文本中提取并赋值给内存中的类 
         */ 
        public static void readObj() { 
            try { 
                ObjectInputStream objectInputStream = new ObjectInputStream(new FileInputStream("/Users/guanliyuan/user.txt")); 
                try { 
                    Object object = objectInputStream.readObject(); 
                    User user = (User) object; 
                    System.out.println(user); 
                } catch (ClassNotFoundException e) { 
                    e.printStackTrace(); 
                } 
            } catch (IOException e) { 
                e.printStackTrace(); 
            } 
        } 
     
     
        public static void main(String args[]) { 
            readObj(); 
        } 
    } 
    

    通过反序列化操作,可以再次将持久化的对象字节流数据通过IO转化为Java对象,结果如下:
    在这里插入图片描述

    此时,如果我们再次尝试将User实现Serializable接口的代码部分去掉,发现也无法再文本转换为序列化对象,说明在Java中如何要实现对象的IO读写操作,都必须实现Serializable接口,否则代码就会报错!

    序列化&反序列化

    什么是序列化/反序列化?序列化是指把对象转换为字节序列的过程,我们称之为对象的序列化,就是把内存中的这些对象变成一连串的字节(bytes)描述的过程。

    而反序列化则相反,就是把持久化的字节文件数据恢复为对象的过程。那么什么情况下需要序列化呢?大概有这样两类比较常见的场景:1)、需要把内存中的对象状态数据保存到一个文件或者数据库中的时候,这个场景是比较常见的,例如我们利用mybatis框架编写持久层insert对象数据到数据库中时;2)、网络通信时需要用套接字在网络中传送对象时,如我们使用RPC协议进行网络通信时。

    关于serialVersionUID

    对于JVM来说,要进行持久化的类必须要有一个标记,只有持有这个标记JVM才允许类创建的对象可以通过其IO系统转换为字节数据,从而实现持久化,而这个标记就是Serializable接口。而在反序列化的过程中则需要使用serialVersionUID来确定由那个类来加载这个对象,所以我们在实现Serializable接口的时候,一般还会要去尽量显示地定义serialVersionUID,如:

     private static final long serialVersionUID = 1L; 
    

    在反序列化的过程中,如果接收方为对象加载了一个类,如果该对象的serialVersionUID与对应持久化时的类不同,那么反序列化的过程中将会导致InvalidClassException异常。例如,在之前反序列化的例子中,我们故意将User类的serialVersionUID改为2L,如:

     private static final long serialVersionUID = 2L; 
    

    那么此时,在反序例化时就会导致异常,如下:

    在这里插入图片描述

    如果我们在序列化中没有显示地声明serialVersionUID,则序列化运行时将会根据该类的各个方面计算该类默认的serialVersionUID值。但是,Java官方强烈建议所有要序列化的类都显示地声明serialVersionUID字段,因为如果高度依赖于JVM默认生成serialVersionUID,可能会导致其与编译器的实现细节耦合,这样可能会导致在反序列化的过程中发生意外的InvalidClassException异常。因此,为了保证跨不同Java编译器实现的serialVersionUID值的一致,实现Serializable接口的必须显示地声明serialVersionUID字段。

    此外serialVersionUID字段地声明要尽可能使用private关键字修饰,这是因为该字段的声明只适用于声明的类,该字段作为成员变量被子类继承是没有用处的!有个特殊的地方需要注意的是,数组类是不能显示地声明serialVersionUID的,因为它们始终具有默认计算的值,不过数组类反序列化过程中也是放弃了匹配serialVersionUID值的要求。

    参考自:https://developer.51cto.com/art/201905/596334.htm

    展开全文
  • Object serialization 允许你将实现了Serializable接口的对象转换为字节序列,这些字节序列可以被完全存储以备以后重新生成原来的对象。 serialization不但可以本机做,而且可以经由网络操作(RMI)。这个好处...
  • 为什么为我们编写实体类的时候需要去继承Serializable接口? 代码示例: 问题: 我们实体类引用了Serializable这个接口,那么这个接口到底有什么? 发现我们还定义了个serialVersionUID变量。这个变量到底有...
  • 另外还定义了个serialVersionUID变量,这个变量又有什么作用呢? 什么是Serializable接口 一个对象序列化的接口,一个类只有实现了Serializable接口,它的对象才能被序列化。 什么是序列化? 序列化 ...
  • Object serialization的定义:Object serialization 允许你将实现了Serializable接口的对象转换为字节序列,这些字节序列可以被完全存储以备以后重新生成原来的对象。 serialization不但可以本机做,而且可以经由...
  • Object serialization的定义: Object serialization 允许你将实现了Serializable接口的对象转换为字节序列,这些字节序列可以被完全存储以备以后重新生成原来的对象。 <br />serialization不但...
  • 一般情况下,我们定义实体类时会继承Serializable接口,类似这样: 我们实体类引用了Serializable这个接口,那么这个接口到底有什么?细心的你会发现我们还定义了个serialVersionUID变量。这个变量到底有什么...
  • Object serialization的定义:Object serialization 允许你将实现了Serializable接口的对象转换为字节序列,这些字节序列可以被完全存储以备以后重新生成原来的对象。serialization不但可以本机做,而且可以经由...
  • 最近这段时间一直忙着编写Java业务代码,麻木地搬着Ctrl-C、Ctrl-V的砖,不知道重复了多少次定义Java实体对象时“implements Serializable”的C/V大法后,脑海突然冒出一个思维(A):问了自己一句“Java实...
  • 实现了Serializable接口的类可以被ObjectOutputStream转换为字节流,同时也可以通过ObjectInputStream再将其解析为对象。例如,我们可以将序列化对象写入文件后,再次从文件读取它并反序列化成对象,也就是说,...
  • 【java】java实体类为什么要实现...最近看了看大佬写的代码发现,实体类大佬实现了Serializable接口。 老实说:这个结果我以前貌似学过,但是一直没用过,所以看着一脸懵逼。 但是大佬总不可能乱写啊...
  • 序列化接口Serializable

    2020-06-29 22:43:12
    一般情况下,我们定义实体类时会继承Serializable接口,类似这样: 我们实体类引用了Serializable这个接口,那么这个接口到底有什么?细心的你会发现我们还定义了个serialVersionUID变量。这个变量到底有什么...
  • 麻木地搬着Ctrl-C、Ctrl-V的砖,不知道重复了多少次定义Java实体对象时“implements Serializable”的C/V大法后,脑海突然冒出一个思维(A):问了自己一句“Java实体对象为什么一定要实现Serializable接口呢?...
  • Java Bean类实现Serializable接口的原因

    千次阅读 2016-08-17 21:18:39
    序列化的过程,有些数据字段我们不想将其序列化,对于此类字段我们只需要在定义时给它加上transient关键字即可,对于transient字段序列化机制会跳过不会将其写入文件,当然也不可被恢复。但有时我们想将某一字段...
  • 序列化定义:Java对象的序列化指的是将对象转换成以字节序列的形式来表示,这些字节序列包含了对象的数据和信息(对象的瞬时状态),一个序列化后的对象可以被写到数据库或文件,也可用于网络传输 应用场景:...

空空如也

空空如也

1 2 3 4 5 ... 14
收藏数 276
精华内容 110
关键字:

在serializable接口中定义了