序列化与反序列化,使用中千万要避开这些坑!

沙海
沙海
沙海
1789
文章
2
评论
2021年7月19日01:25:30
评论
8 8289字阅读27分37秒
摘要

智能摘要

智能摘要

类中存在引用对象,这个类对象在什么情况下可以实现序列化?子类实现Serializable接口,父类没有实现,子类可以序列化吗?子类实现Serializable接口,父类没有实现,子类可以序列化!!类中存在引用对象,这个类对象在什么情况下可以实现序列化?类中存在引用对象,那么这个引用对象必须是可序列化的,这个类才能序列化。

原文约 2899 | 图片 11 | 建议阅读 6 分钟 | 评价反馈

序列化与反序列化,使用中千万要避开这些坑!

Java学习者社区

序列化与反序列化,使用中千万要避开这些坑!

来源:liuchenyang0515.blog.csdn.net/

article/details/118463573

文章目录

  1. 序列化与反序列化的概念

  2. 子类实现Serializable接口,父类没有实现,子类可以序列化吗?

  3. 类中存在引用对象,这个类对象在什么情况下可以实现序列化?

  4. 同一个对象多次序列化之间有属性更新,前后的序列化有什么区别?

1.序列化与反序列化的概念

先说说序列化和反序列化的概念

  • 序列化:将对象写入到IO流中

  • 反序列化:从IO流中恢复对象

Serializable接口是一个标记接口,不用实现任何方法,标记当前类对象是可以序列化的,是给JVM看的。

序列化机制允许将这些实现序列化接口的对象转化为字节序列,这些字节序列可以保证在磁盘上或者网络传输后恢复成原来的对象。序列化就是把对象存储在JVM以外的地方,序列化机制可以让对象脱离程序的运行而独立存在。

序列化在业务代码也许用的不多,但是在框架层面用的是很多的。

相关技术:Session的序列化或者反序列化

先给出序列化的例子,请记住这个People类,后面会根据这个类来改造讲解。

public class People {    private Long id;    public People(Long id) {        this.id = id;    }    public Long getId() {        return id;    }    public void setId(Long id) {        this.id = id;    }    @Override    public String toString() {        return "People{" +                "id=" + id +                '}';    }}
import java.io.*;// 屏蔽编译器的警告@SuppressWarnings("all")public class Main {    /**     * <h1>序列化和反序列化 People 对象</h1>     */    private static void testSerializablePeople() throws Exception {        // 序列化的步骤        // 用于存储序列化的文件,这里的java_下划线仅仅为了说明是java序列化对象,没有任何其他含义        File file = new File("/tmp/people_10.java_");        if (!file.exists()) {            // 1,先得到文件的上级目录,并创建上级目录            file.getParentFile().mkdirs();            try {                // 2,再创建文件                file.createNewFile();            } catch (IOException e) {                e.printStackTrace();            }        }        People p = new People(10L);        // 创建一个输出流        ObjectOutputStream oos = new ObjectOutputStream(                new FileOutputStream(file)        );        // 输出可序列化对象        oos.writeObject(p);        // 关闭输出流        oos.close();        // 反序列化的步骤        // 创建一个输入流        ObjectInputStream ois = new ObjectInputStream(                new FileInputStream(file)        );        // 得到反序列化的对象,这里可以强转为People类型        Object newPerson = ois.readObject();        // 关闭输入流        ois.close();        System.out.println(newPerson);    }    public static void main(String[] args) throws Exception {        testSerializablePeople();    }}

运行之后,看到磁盘文件因为序列化而多了一个文件

序列化与反序列化,使用中千万要避开这些坑!

控制台中因反序列化输出的对象信息打印如下:

序列化与反序列化,使用中千万要避开这些坑!

2.子类实现Serializable接口,父类没有实现,子类可以序列化吗?

去掉父类People的implements Serializable,让父类不实现序列化接口,子类Worker实现序列化接口

public class Worker extends People implements Serializable {    private String name;    private Integer age;    public Worker(Long id, String name, Integer age) {        super(id);        this.name = name;        this.age = age;    }}
 public static void main(String[] args) throws Exception {        testSerizableWorker();    }    /**     * <h2>子类实现序列化, 父类不实现序列化</h2>     * */    private static void testSerizableWorker() throws Exception {        File file = new File("/tmp/worker_10.java_");        if (!file.exists()) {            // 1,先得到文件的上级目录,并创建上级目录            file.getParentFile().mkdirs();            try {                // 2,再创建文件                file.createNewFile();            } catch (IOException e) {                e.printStackTrace();            }        }        Worker p = new Worker(10L, "lcy", 18);        // 创建一个输出流        ObjectOutputStream oos = new ObjectOutputStream(                new FileOutputStream(file)        );        // 输出可序列化对象        oos.writeObject(p);        // 关闭输出流        oos.close();        ObjectInputStream ois = new ObjectInputStream(new FileInputStream(file));        Object newWorker = ois.readObject(); // 父类没有序列化的时候,需要调用父类的无参数构造方法        ois.close();        System.out.println(newWorker);    }

再次测试运行

序列化与反序列化,使用中千万要避开这些坑!

结果显示没有有效地构造器,原来是因为父类没有序列化的时候,Object newWorker = ois.readObject()需要直接调用父类的无参数构造方法,不经过子类的无参构造方法。

我们在父类People中加上空的构造方法之后再次执行

序列化与反序列化,使用中千万要避开这些坑!

结果却发现打印的不是Worker,而是父类People,因为子类没有实现toString而调用父类的toString,所以打印了People对象,至于父类成员变量id为什么是null,原因如下:

1、一个子类实现了 Serializable 接口,它的父类都没有实现 Serializable接口,序列化该子类对象。要想反序列化后输出父类定义的某变量的数值,就需要让父类也实现Serializable接口或者父类有默认的无参的构造函数。

2、在父类没有实现Serializable 接口时,虚拟机是不会序列化父对象的,而一个 Java对象的构造必须先有父对象,才有子对象,反序列化也不例外。所以反序列化时,为了构造父对象,只能调用父类的无参构造函数作为默认的父对象。因此当我们取父对象的变量值时,它的值是调用父类无参构造函数后的值,如果在父类无参构造函数中没有对变量赋值,那么父类成员变量值都是默认值,如这里的Long型就是null。

3、根据以上特性,我们可以将不需要被序列化的字段抽取出来放到父类中,子类实现 Serializable接口,父类不实现Serializable接口但提供一个空构造方法,则父类的字段数据将不被序列化。

最后加上子类Worker的toString方法,打印结果如下:

序列化与反序列化,使用中千万要避开这些坑!

总结:

  • 子类实现Serializable接口,父类没有实现,子类可以序列化!!

  • 这种情况父类一定要提供空构造方法,不要忘了子类的toString方法!

3.类中存在引用对象,这个类对象在什么情况下可以实现序列化?

来一个组合对象,里面引用People对象,此时People对象没有实现Serializable接口,能否序列化呢?代码给出来,大家可以自行复制测试一下。

public class Combo implements Serializable {    private int id;    private People people;    public Combo(int id, People people) {        this.id = id;        this.people = people;    }    public int getId() {        return id;    }    public void setId(int id) {        this.id = id;    }    public People getPeople() {        return people;    }    public void setPeople(People people) {        this.people = people;    }        @Override    public String toString() {        return "Combo{" +                "id=" + id +                ", people=" + people +                '}';    }}
public class People {    private Long id;    public People() {    }    public People(Long id) {        this.id = id;    }    public Long getId() {        return id;    }    public void setId(Long id) {        this.id = id;    }    @Override    public String toString() {        return "People{" +                "id=" + id +                '}';    }}
    private static void testSerializableCombo() throws Exception {        File file = new File("/tmp/combo_10.java_");        if (!file.exists()) {            // 1,先得到文件的上级目录,并创建上级目录            file.getParentFile().mkdirs();            try {                // 2,再创建文件                file.createNewFile();            } catch (IOException e) {                e.printStackTrace();            }        }        Combo p = new Combo(1, new People(10L));        // 创建一个输出流        ObjectOutputStream oos = new ObjectOutputStream(                new FileOutputStream(file)        );        // 输出可序列化对象        oos.writeObject(p);        // 关闭输出流        oos.close();        ObjectInputStream ois = new ObjectInputStream(new FileInputStream(file));        Object newCombo = ois.readObject();        ois.close();        System.out.println(newCombo);    }    public static void main(String[] args) throws Exception {        testSerializableCombo();    }

运行结果如下

序列化与反序列化,使用中千万要避开这些坑!

直接爆出异常,说明People类没有序列化。

当People加上implements Serializable实现序列化接口后,再次执行如下

序列化与反序列化,使用中千万要避开这些坑!

总结:

  • 一个类里面所有的属性必须是可序列化的,这个类才能顺利的序列化。

比如,类中存在引用对象,那么这个引用对象必须是可序列化的,这个类才能序列化。

4.同一个对象多次序列化之间有属性更新,前后的序列化有什么区别?

下面例子中People是可序列化的,每次序列化之前都会把People的id值修改了,用来观察看看,多次序列化期间,如果对象属性更新,是否会影响序列化,反序列化有什么区别。

/** * <h2>同一个对象多次序列化的问题, 坑</h2> * */private static void sameObjectRepeatedSerialization() throws Exception {    File file = new File("/tmp/peopele_more.java_");    if (!file.exists()) {        // 1,先得到文件的上级目录,并创建上级目录        file.getParentFile().mkdirs();        try {            // 2,再创建文件            file.createNewFile();        } catch (IOException e) {            e.printStackTrace();        }    }    People p = new People(10L);    ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(file));    // 未序列化,先修改属性    p.setId(11L);    oos.writeObject(p);    // 序列化一次后,再次修改属性    p.setId(15L);    oos.writeObject(p);    // 序列化两次后,再次修改属性    p.setId(20L);    oos.writeObject(p);    oos.close();    ObjectInputStream ois = new ObjectInputStream(new FileInputStream(file));    Object people1 = ois.readObject();    Object people2 = ois.readObject();    Object people3 = ois.readObject();    ois.close();    System.out.println(((People) people1).getId());    System.out.println(((People) people2).getId());    System.out.println(((People) people3).getId());}public static void main(String[] args) throws Exception {    sameObjectRepeatedSerialization();}

运行结果如下

序列化与反序列化,使用中千万要避开这些坑!

结果发现反序列化读出的值都是一样的。说明当对象第一次序列化成功后,后续这个对象属性即使有修改,也不会对后面的序列化造成成影响。

这其实是序列化算法的原因,所有要序列化的对象都有一个序列化的编码号,当试图序列化一个对象,会检查这个对象是否已经序列化过,若从未序列化过,才会序列化为字节序列去输出。若已经序列化过,则会输出一个编码符号,不会重复序列化一个对象。如下

序列化与反序列化,使用中千万要避开这些坑!

序列化一次后,后续继续序列化并未重复转换为字节序列,而是输出字符q~

总结:

  • 当第一次序列化之后,不管如何修改这个对象的属性,都不会对后续的序列化产生影响,反序列化的结果都和第一次相同。

推荐阅读• 三种方式,教你优雅的替换if-else语句!• 京东一面:说出ThreadLocal的使用场景及使用方式• Java必会的工具库,让你的代码量减少90%• SQL 注入真是防不胜防!最近面试BATJ,整理一份面试资料《Java面试BAT通关手册》,覆盖了Java核心技术、JVM、Java并发、SSM、微服务、数据库、数据结构等等。获取方式:点“在看”,关注公众号并回复 Java 领取,更多内容陆续奉上。

文章有帮助的话,在看,转发吧。

谢谢支持哟 (*^__^*)

继续阅读
weinxin
资源分享QQ群
本站是一个IT技术分享社区, 会经常分享资源和教程; 分享的时代, 请别再沉默!
沙海
匿名

发表评论

匿名网友 填写信息

:?: :razz: :sad: :evil: :!: :smile: :oops: :grin: :eek: :shock: :???: :cool: :lol: :mad: :twisted: :roll: :wink: :idea: :arrow: :neutral: :cry: :mrgreen: