一文了解Java序列化与反序列化

野性酷女 2024-04-06 13:41 55阅读 0赞

#### 目录 ####

*  序列化示例
 *  有父类的对象序列化
 *  Serializable和Externalizable区别
 *  序列化和反序列化实现
 *  serialVersionUID不一致有什么问题
 *   *  1、先注释掉反序列化代码, 执行序列化代码, 然后User类新增一个属性sex
     *  2、再注释掉序列化代码执行反序列化代码
     *  3、指定serialVersionUID
 *  序列化字段修饰
 *  static属性为什么不会被序列化?
 *  serialVersionUID也被static修饰, 为什么serialVersionUID会被序列化?
 *  小结

![在这里插入图片描述][b7da9a05ce4d45afb838b619e3402369.png]  
相关阅读：  
[什么是序列化][Link 1]

## 序列化示例 ##

String类型序列化的源码示例:

public final class String
        implements java.io.Serializable, Comparable<String>, CharSequence {
        
        /** The value is used for character storage. */
        private final char value[];
    
        /** Cache the hash code for the string */
        private int hash; // Default to 0
    
        /** use serialVersionUID from JDK 1.0.2 for interoperability */
        private static final long serialVersionUID = -6849794470754667710L;
    
        private static final ObjectStreamField[] serialPersistentFields =
            new ObjectStreamField[0];
    
        public String() {
        
            this.value = "".value;
        }
    ...
    }

> String类型实现了Serializable接口, 并显示指定serialVersionUID的值.

对象持久化到数据库示例：

<insert id="insertUser" parameterType="xxx.User">  
        INSERT INTO user(name, age) VALUES (#{name}, #{age})  
    </insert>

实际上我们并不是将整个对象持久化到数据库中, 而是将对象中的属性持久化到数据库中, 而这些属性都是实现了Serializable接口的基本属性。

## 有父类的对象序列化 ##

> 在Java中，如果对象的类或父类实现了Serializable接口或Externalizable接口，则称该对象可序列化。

有继承的对象序列化有如下三种情况：

> 1.  如果父类可序列化，则子类可自动序列化
> 2.  即使父类不可序列化，子类仍可以序列化
> 3.  如果我们希望子类不被序列化，即使父类是可序列化的

类可序列化时，子类自动变为可序列化示例：

import java.io.FileInputStream;
    import java.io.FileOutputStream;
    import java.io.IOException;
    import java.io.NotSerializableException;
    import java.io.ObjectInputStream;
    import java.io.ObjectOutputStream;
    import java.io.Serializable;
    
    class Parent implements Serializable {
        
        String name = "三省同学";
    }
    
    class Child extends Parent {
        
        String name1 = "sxtx";
    }
    
    /**
     * 父类序列化，子类自动序列化示例
     *
     * @Author sxtx
     */
    public class SerializableExample {
        
        public static void main(String[] args) throws IOException, ClassNotFoundException {
        
            Child writer = new Child();
            FileOutputStream fos = new FileOutputStream("file.txt");
            ObjectOutputStream oos = new ObjectOutputStream(fos);
            oos.writeObject(writer);
    
            FileInputStream fis = new FileInputStream("file.txt");
            ObjectInputStream ois = new ObjectInputStream(fis);
            Child reader = (Child) ois.readObject();
            System.out.println(reader.name + "," + reader.name1);
        }
    }

输出：

三省同学,sxtx

## Serializable和Externalizable区别 ##

> 1、Serializable序列化时不会调用默认的构造器，而Externalizable序列化时会调用默认构造器的。  
> 2、Serializable：一个对象想要被序列化，那么它的类就要实现此接口，这个对象的所有属性（包括private属性、包括其引用的对象）都可以被序列化和反序列化来保存、传递。  
> 3、Externalizable：他是Serializable接口的子类，有时我们不希望序列化那么多，可以使用这个接口，这个接口的writeExternal()和readExternal()方法可以指定序列化哪些属性。

## 序列化和反序列化实现 ##

三种实现方式如下：

1、若User类仅仅实现了Serializable接口，则可以按照以下方式进行序列化和反序列化。

> ObjectOutputStream采用默认的序列化方式，对User对象的非transient的实例变量进行序列化。  
> ObjcetInputStream采用默认的反序列化方式，对User对象的非transient的实例变量进行反序列化。

2、若User类仅仅实现了Serializable接口，并且还定义了readObject(ObjectInputStream in)和writeObject(ObjectOutputSteam out)，则采用以下方式进行序列化与反序列化。

> ObjectOutputStream调用User对象的writeObject(ObjectOutputStream out)的方法进行序列化。
> 
> ObjectInputStream会调用User对象的readObject(ObjectInputStream in)的方法进行反序列化。

3、若User类实现了Externalnalizable接口，且User类必须实现readExternal(ObjectInput in)和writeExternal(ObjectOutput out)方法，则按照以下方式进行序列化与反序列化。

> ObjectOutputStream调用User对象的writeExternal(ObjectOutput out))的方法进行序列化。  
> ObjectInputStream会调用User对象的readExternal(ObjectInput in)的方法进行反序列化。

**代码示例：**

@Data
    public class User implements Serializable {
        
    
        private String name;  
        private Integer age;
    
        @Override
        public String toString() {
        
            return "User{" +
                    "name='" + name + '\'' +
                    ", age=" + age +
                    '}';
        }
    }

**先进行序列化, 再进行反序列化.**

public static void main(String[] args) throws Exception {
        
         User user = new User();  
         user.setName("三省同学");
         user.setAge(18);  
         System.out.println("序列化前的结果: " + user);
    
         ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(new File("D:\\file.txt")));
         oos.writeObject(user);
         oos.close();
    
         ObjectInputStream ois = new ObjectInputStream(new FileInputStream(new File("D:\\file.txt")));
         User dUser = (User) ois.readObject();
         System.out.println("反序列化后的结果: "+ dUser);
     }

结果:

序列化前的结果: User{
        name='三省同学', age=18}
    反序列化后的结果: User{
        name='三省同学', age=18}

## serialVersionUID不一致有什么问题 ##

### 1、先注释掉反序列化代码, 执行序列化代码, 然后User类新增一个属性sex ###

@Data
    public class User implements Serializable {
        
    
        private String name;  
        private Integer age;
        private String sex;
    
        @Override
        public String toString() {
        
            return "User{" +
                    "name='" + name + '\'' +
                    ", age=" + age +
                    ", sex='" + sex + '\'' +
                    '}';
        }
    }

### 2、再注释掉序列化代码执行反序列化代码 ###

最后结果如下:

序列化前的结果: User{
        name='三省同学', age=18}
    
    Exception in thread "main" java.io.InvalidClassException: xxx.User; local class incompatible: stream classdesc serialVersionUID = -5701321611009304438, local class serialVersionUID = 1670957499376994577
    	at java.io.ObjectStreamClass.initNonProxy(ObjectStreamClass.java:616)
    	at java.io.ObjectInputStream.readNonProxyDesc(ObjectInputStream.java:1630)
    	at java.io.ObjectInputStream.readClassDesc(ObjectInputStream.java:1521)
    	at java.io.ObjectInputStream.readOrdinaryObject(ObjectInputStream.java:1781)
    	at java.io.ObjectInputStream.readObject0(ObjectInputStream.java:1353)
    	at java.io.ObjectInputStream.readObject(ObjectInputStream.java:373)
    	at xxx.SerializableTest.main(SerializableTest.java:18)

**报错结果为序列化与反序列化产生的serialVersionUID不一致.**

### 3、指定serialVersionUID ###

private static final long serialVersionUID = 1L;

再执行上述步骤, 结果如下:

序列化前的结果: User{
        name='tyshawn', age=18} 
    反序列化后的结果: User{
        name='tyshawn', age=18, sex='null'}

**指定serialVersionUID可解决了序列化与反序列化产生的serialVersionUID不一致的问题.**

## 序列化字段修饰 ##

> 被transient关键字修饰的属性不会被序列化, static属性也不会被序列化.

## static属性为什么不会被序列化? ##

> 因为序列化是针对对象而言的, 而static属性优先于对象存在, 随着类的加载而加载, 所以不会被序列化.

## serialVersionUID也被static修饰, 为什么serialVersionUID会被序列化? ##

其实`serialVersionUID`属性并没有被序列化, JVM在序列化对象时会自动生成一个`serialVersionUID`, 然后将我们显示指定的`serialVersionUID`属性值赋给自动生成的`serialVersionUID`.

## 小结 ##

1、序列化时，只对对象的状态进行保存，而不管对象的方法；  
2、当一个父类实现序列化，子类自动实现序列化，不需要显式实现Serializable接口；  
3、当一个对象的实例变量引用其他对象，序列化该对象时也把引用对象进行序列化；  
4、并非所有的对象都可以序列化，比如：

> 安全方面的原因：  
> 如一个对象拥有private，public等field，对于一个要传输的对象，比如写到文件，或者进行RMI传输等等，在序列化进行传输的过程中，这个对象的private等域是不受保护的；
> 
> 资源分配方面的原因：  
> 比如socket，thread类，如果可以序列化，进行传输或者保存，也无法对他们进行重新的资源分配，而且，也是没有必要这样实现；

5、声明为static和transient类型的成员数据不能被序列化。因为static代表类的状态，transient代表对象的临时数据。

6、序列化运行时使用一个称为 serialVersionUID 的版本号与每个可序列化类相关联，该序列号在反序列化过程中用于验证序列化对象的发送者和接收者是否为该对象加载了与序列化兼容的类。为它赋予明确的值。显式地定义serialVersionUID有两种用途：

> 在某些场合，希望类的不同版本对序列化兼容，因此需要确保类的不同版本具有相同的serialVersionUID；
> 
> 在某些场合，不希望类的不同版本对序列化兼容，因此需要确保类的不同版本具有不同的serialVersionUID。

7、Java有很多基础类已经实现了serializable接口，比如String,Vector等。但是也有一些没有实现serializable接口的；

8、如果一个对象的成员变量是一个对象，那么这个对象的数据成员也会被保存！这是能用序列化解决深拷贝的重要原因；

![在这里插入图片描述][5e1b731011d04f1b8b5bb34319048090.png]

点赞 收藏 关注  
三月春花渐次醒，迢迢年华谁老去

[b7da9a05ce4d45afb838b619e3402369.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/06/d3a6e851922043f691111bd4be78dc80.png
[Link 1]: https://ssxtx.blog.csdn.net/article/details/120162499
[5e1b731011d04f1b8b5bb34319048090.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/06/ea44bbf829994012a17ed611a9a622fe.png