java.io.Serializable（序列化）接口详细总结

最新推荐文章于 2024-04-27 09:13:51 发布

小鲁蛋儿

最新推荐文章于 2024-04-27 09:13:51 发布

阅读量6.9k

点赞数 15

分类专栏： Java基础文章标签： java

本文链接：https://blog.csdn.net/qq_51409098/article/details/126412452

版权

Java基础专栏收录该内容

40 篇文章 3 订阅

订阅专栏

3、验证“serialVersionUID”不一致导致反序列化失败

一、概念

Java对象序列化的意思就是将对象的状态转化成字节流，以后可以通过这些值再生成相同状态的对象。对象序列化是对象持久化的一种实现方法，它是将对象的属性和方法转化为一种序列化的形式用于存储和传输。反序列化就是根据这些保存的信息重建对象的过程。

序列化：将Java对象转化为字节序列的过程。

反序列化：将字节序列转化为Java对象的过程。

二、为什么要序列化和反序列化

我们知道，当两个进程进行远程通信时，可以相互发送各种类型的数据，包括文本、图片、音频、视频等，而这些数据都会以二进制序列的形式在网络上传送。那么当两个Java进程进行通信时，能否实现进程间的对象传送呢？答案是可以的。如何做到呢？

这就需要Java序列化与反序列化了。换句话说，一方面，发送方需要把这个Java对象转换为字节序列，然后在网络上传送；另一方面，接收方需要从字节序列中恢复出Java对象。

当我们明晰了为什么需要Java序列化和反序列化后，我们很自然地会想Java序列化的好处。其好处一是实现了数据的持久化，通过序列化可以把数据永久地保存到硬盘上（通常存放在文件里），二是，利用序列化实现远程通信，即在网络上传送对象的字节序列。

三、涉及到的javaAPI　

java.io.ObjectOutputStream：表示对象输出流，它的writeObject(Object obj)方法可以对参数指定的obj对象进行序列化，把得到的字节序列写到一个目标输出流中。
java.io.ObjectInputStream：表示对象输入流，它的readObject()方法源输入流中读取字节序列，再把它们反序列化成为一个对象，并将其返回。

只有实现了Serializable或Externalizable接口的类的对象才能被序列化，否则抛出异常。

四、序列化和反序列化的步骤

序列化：

步骤一：创建一个对象输出流，它可以包装一个其它类型的目标输出流，如文件输出流：

 ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream(“目标地址路径”));

步骤二：通过对象输出流的writeObject()方法写对象：

out.writeObject("Hello");

out.writeObject(new Date());

反序列化：

步骤一：创建一个对象输入流，它可以包装一个其它类型输入流，如文件输入流：

 ObjectInputStream in = new ObjectInputStream(new fileInputStream(“目标地址路径”));

步骤二：通过对象输出流的readObject()方法读取对象：

String obj1 = (String)in.readObject();

Date obj2 =  (Date)in.readObject();

说明：为了正确读取数据，完成反序列化，必须保证向对象输出流写对象的顺序与从对象输入流中读对象的顺序一致。

五、举个例子

我们首先写个Person实现Serializable接口：

public class Person implements Serializable {
    //序列化ID
    private static final long serialVersionUID = -5809782578272943999L;

    private int id;
    private String name;
    private int age;


    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
    @Override
    public String toString() {
        return "Person{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

序列化代码

    @Test
    public void test5(){
        Person person = new Person();
        person.setAge(12);
        person.setId(1);
        person.setName("小明");

        ObjectOutputStream oos = null;
        try {
            oos = new ObjectOutputStream(new FileOutputStream("d:/io/data.txt"));
            oos.writeObject(person);
            System.out.println("序列化成功");
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
        }
    }

代码很简单，首先创建一个对象输出流ObjectOutputStream，它可以包装一个其它类型的目标输出流，如文件输出流FileOutputStream，并指定存储的位置为“d:/io/data.txt”，然后通过对象输出流的writeObject()方法写对象便执行了序列化过程。运行看一下效果，正确的话便会在控制台打印“”，并且在本地E盘下会创建一个data.txt文件。

反序列化代码

    @Test
    public void test6(){
        Person person = null;
        ObjectInputStream ois = null;
        try {
            ois = new ObjectInputStream(new FileInputStream("d:/io/data.txt"));
            person = (Person) ois.readObject();
            System.out.println(person);
            System.out.println("反序列化成功");
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } finally {
            try {
                if(ois != null){
                    ois.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

执行反序列化的代码也是很简单的，首先创建一个输入流对象ObjectInputStream，然后从指定的目录下“d:/io/data.txt”获取它的字节序列，然后通过输入流对象的readObject()方法将其获得的对象强制转化为Person对象，这就完成了反序列化工作，正确的反序列化成功的情况下控制台打印输出为：

六、序列话ID的作用

在前面的介绍中，我们在代码里会发现有这样一个变量：serialVersionUID，那么这个变量serialVersionUID到底具有什么作用呢？能不能去掉呢？

1、序列化ID的作用

其实，这个序列化ID起着关键的作用，它决定着是否能够成功反序列化！简单来说，Java的序列化机制是通过在运行时判断类的serialVersionUID来验证版本一致性的。在进行反序列化时，JVM会把传来的字节流中的serialVersionUID与本地实体类中的serialVersionUID进行比较，如果相同则认为是一致的，便可以进行反序列化，否则就会报序列化版本不一致的异常。等会我们可以通过代码验证一下。

2、序列化ID如何产生

当我们一个实体类中没有显示的定义一个名为“serialVersionUID”、类型为long的变量时，Java序列化机制会根据编译时的class自动生成一个serialVersionUID作为序列化版本比较，这种情况下，只有同一次编译生成的class才会生成相同的serialVersionUID。譬如，当我们编写一个类时，随着时间的推移，我们因为需求改动，需要在本地类中添加其他的字段，这个时候再反序列化时便会出现serialVersionUID不一致，导致反序列化失败。那么如何解决呢？便是在本地类中添加一个“serialVersionUID”变量，值保持不变，便可以进行序列化和反序列化。

3、验证“serialVersionUID”不一致导致反序列化失败

public class Person implements Serializable {
    //序列化ID
    //private static final long serialVersionUID = -5809782578272943999L;

    private int id;
    private String name;
    //private int age;


    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

//    public int getAge() {
//        return age;
//    }
//
//    public void setAge(int age) {
//        this.age = age;
//    }
//    @Override
//    public String toString() {
//        return "Person{" +
//                "id=" + id +
//                ", name='" + name + '\'' +
//                ", age=" + age +
//                '}';
//    }
}

复制上文的序列化与反序列化代码

    @Test
    /**
     * 对象序列化
     */
    public void test5(){
        Person person = new Person();
        person.setId(1);
//      person.setAge(12);
        person.setName("小明");

        ObjectOutputStream oos = null;
        try {
            oos = new ObjectOutputStream(new FileOutputStream("d:/io/data.txt"));
            oos.writeObject(person);
            System.out.println("序列化成功");
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if(oos != null) {
                    oos.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

运行一下，会在控制台中打印“序列化成功。”，然后我们在Person类中再添加一个字段，name，然后直接从data.txt中反序列化，再运行一下，看看会出现什么问题。

    @Test
    /**
     * 对象反序列化
     */
    public void test6(){
        Person person = null;
        ObjectInputStream ois = null;
        try {
            ois = new ObjectInputStream(new FileInputStream("d:/io/data.txt"));
            person = (Person) ois.readObject();
            System.out.println(person);
            System.out.println("反序列化成功");
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } finally {
            try {
                if(ois != null){
                    ois.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

运行一下，不出意外，报了一个异常。

总结：

虚拟机是否允许反序列化，不仅取决于类路径和功能代码是否一致，一个非常重要的一点是两个类的序列化 ID 是否一致（就是 private static final long serialVersionUID = 1L）。

参考文章：

java序列化和反序列化使用总结_ostracod_lvj的博客-CSDN博客

java 序列化ID的作用_ostracod_lvj的博客-CSDN博客_序列化id有什么用

小鲁蛋儿

关注

15
点赞
踩
54

收藏

觉得还不错? 一键收藏
打赏
0
评论
java.io.Serializable（序列化）接口详细总结

虚拟机是否允许反序列化，不仅取决于类路径和功能代码是否一致，一个非常重要的一点是两个类的序列化 ID 是否一致（就是 private static final long serialVersionUID = 1L）。
复制链接

扫一扫