Java序列化Serializable的那些事儿

﹏ヽ暗。殇╰゛Y 2022-05-08 02:52 198阅读 0赞

说到Java的序列化，有个问题就是为什么需要序列化，更优先的一个问题是什么是序列化。

# 序列化的含义 #

《Java编程思想》中这么解释，Java的对象序列化是将那些实现了Serializable接口的对象转换成一个字节序列，并能够在以后将这个字节序列完全恢复为原来的对象。

换句话说就是，主要将对象的可变信息以字节序列，保存在硬盘文件、数据库或者通过网络传输到另一个JVM中等等，等到需要在内存中恢复该对象当时的状态时，也就是当别的机器或程序运行时需要该对象的状态时，可以反序列化这些字节序列，将此对象还原出来使用（也说明了序列化是可以跨操作系统和JVM的）。这种机制就叫做序列化。

# 序列化的用途 #

明白了序列化的含义，也不难清楚序列化的用途了。

*  当你想把的内存中的对象状态保存到一个文件中或者数据库中时候；
 *  当你想用套接字在网络上传送对象的时候；
 *  当你想通过RMI传输对象的时候。

明白了序列化的含义及用途，接下来需要了解序列化的使用。

# 序列化的使用 #

package com.szh.serializable;
    
    import java.io.File;
    import java.io.FileInputStream;
    import java.io.FileOutputStream;
    import java.io.IOException;
    import java.io.ObjectInputStream;
    import java.io.ObjectOutputStream;
    import java.io.Serializable;
    
    public class TestSerializable {
    
        public static void main(String[] args) throws IOException, ClassNotFoundException {
            Person p1 = new Person();
            Dog d1 = new Dog();
            d1.setName("Dog1");
            p1.setId(1);
            p1.setName("Tom");
            p1.setDog(d1);
            // serializable
            if (!new File("E:/tests").exists()) {
                new File("E:/tests").mkdirs();
            }
            FileOutputStream fos = new FileOutputStream(new File("E:/tests/serializable_file.ser"));
            ObjectOutputStream oos = new ObjectOutputStream(fos);
            oos.writeObject(p1);
            oos.close();
            
            // deserializable
            FileInputStream fis = new FileInputStream(new File("E:/tests/serializable_file.ser"));
            ObjectInputStream ois = new ObjectInputStream(fis);
            Object obj = ois.readObject();
            ois.close();
            Person p = (Person) obj;
            System.out.println(p);
        }
        
        public static class Person implements Serializable {
            private static final long serialVersionUID = -1891426275960796136L;
            private transient int id;
            private String name;
            private transient Dog dog;
            
            public Dog getDog() {
                return dog;
            }
            public void setDog(Dog dog) {
                this.dog = dog;
            }
            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;
            }
            @Override
            public String toString() {
                return "Person [id=" + id + ", name=" + name + ", dog=" + dog + "]";
            }
        }
        
        public static class Dog {
            private String name;
    
            public String getName() {
                return name;
            }
    
            public void setName(String name) {
                this.name = name;
            }
    
            @Override
            public String toString() {
                return "Dog [name=" + name + "]";
            }
        }
    }

在序列化的使用中，主要有以下几个问题：

*  transient关键字的作用；
 *  serialVersionUID的作用；
 *  序列化警告的处理方式。

## transient关键字的作用 ##

transient，意为短暂的，临时的。在Java中，*transient*声明一个实例变量，当对象存储时，它的值不需要维持。换句话来说就是，用*transient*关键字标记的成员变量不参与序列化过程。

如示例代码中Person拥有一个transient修饰的id和Dog，程序运行后，经过序列化和反序列化，结果如下：

Person [id=0, name=Tom, dog=null]

可以发现，id和Dog可以认为分别为各自类型的缺省值，id=0，dog=null。明显这两个变量未经过序列化过程。

**注意：不需要经过序列化的类型的成员变量，使用transient修饰后可以不实现Serializable接口。如Person的Dog不需要序列化。当然，非要给Dog实现Serializable接口也不影响结果。有意思的是，在eclipse中自动生成toString()方法，发现使用了transient修饰的成员变量默认不被选择参与打印对象字符串。**

## serialVersionUID的作用 ##

当没有显式地定义long类型的serialVersionUID变量时，Java序列化机制会根据编译的class(它通过类名，方法名等诸多因素经过计算而得，理论上是一一映射的关系，也就是唯一的)自动生成一个serialVersionUID作序列化版本比较来使用。

解析serialVersionUID的jdk代码，可调试以下代码：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Nvbmd6ZWhhbw_size_16_color_FFFFFF_t_70][]

因此，也可验证没有显式添加serialVersionUID也同样拥有序列号，所以在序列化的时候必然也有jdk代码根据各种因素来生成serialVersionUID。

这种情况下，如果class文件(主要是类名、方法名等)没有发生变化(增加空格、换行、注释等等不会产生变化)，就算再编译多次，serialVersionUID也不会变化。但是一旦变化，如给类增加了方法、属性等，那么在反序列化时，就会出现序列化版本不一致的异常(InvalidCastException)！如下：

Exception in thread "main" java.io.InvalidClassException: com.szh.serializable.TestSerializable$Person; local class incompatible: stream classdesc serialVersionUID = -5579678255079137242, local class serialVersionUID = -1463584727334114570
    	at java.io.ObjectStreamClass.initNonProxy(ObjectStreamClass.java:617)
    	at java.io.ObjectInputStream.readNonProxyDesc(ObjectInputStream.java:1622)
    	at java.io.ObjectInputStream.readClassDesc(ObjectInputStream.java:1517)
    	at java.io.ObjectInputStream.readOrdinaryObject(ObjectInputStream.java:1771)
    	at java.io.ObjectInputStream.readObject0(ObjectInputStream.java:1350)
    	at java.io.ObjectInputStream.readObject(ObjectInputStream.java:370)
    	at com.szh.serializable.TestSerializable.main(TestSerializable.java:30)

因此，serialVersionUID即代表了对应类的版本号，目的是为了保证序列化和反序列化时，类信息的一致性和安全性。

## 序列化警告的处理方式 ##

在Java中，我们对警告不应无视，每一条警告都应该做合适的处理。那对于序列化时，我们实现了Serializable接口，却未显示定义serialVersionUID时，IDE会提示出三种处理方式：

*  Add default serial version ID；
 *  Add generated serial version ID；
 *  Add @SuppressWarnings 'serial' to 'Person'。

当我们选择**第一种**处理方式时，相当于显式地手动定义了类的当前版本（自己去维护）。当我们以后需要此类时，需要同步修改serialVersionUID。

当我们选择**第二种**处理方式时，相当于显式地自动定义了类的当前版本（根据类信息等内容自动生成）。当我们以后需要此类时，需要重新生成serialVersionUID。

当我们选择**第三种**处理方式时，相当于告诉编译器忽略此警告。那么问题来了，第三种方式貌似可有可无，毕竟相当于上面哪种都未选择。答案是否定的。

在Java中，任何警告我们都不应不处理（选择使用第三种注解方式忽略警告也认为是一种处理方式，但是三种方式都不选择的话，则认为是不处理），虽然使用@SuppressWarnings去忽略也是一样的运行效果。因为，这是一种很好地编码习惯，有时警告也会造成一些意想不到的问题，所以我们应当处理代码中所有的警告，对于确实可以忽略掉的警告，jdk提供了这个注解来标记代码警告行，这样便可以使我们的代码逻辑更加严密，因为我们处理了每一条警告。

那么我们如何在编译后的class文件中，找到类的版本信息呢？

## 序列化与字节码class文件 ##

class文件，存放了十六进制字节码，其中包含了类编译时的序列版本号。我们可以使用如下命令进行解析（反编译）：

javap -v class文件名 > 输出文件名
    如：javap -v E:/J2SE_workspace/MyTest/bin/com/szh/serializable/TestSerializable$Person.class > E:\test.txt

解析后可以看出来，对于第一第二种显式地添加版本号的类来说，能够明显找到serialVersionUID，而对于使用注解忽略或直接忽略的方式，则不能找到serialVersionUID。

不论三种中哪种处理警告的方式，在序列化到文件的这个过程中，此时类的版本号serialVersionUID必然已保存在了字节序列中。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Nvbmd6ZWhhbw_size_16_color_FFFFFF_t_70]: /images/20220508/073387e31d834c9ea5b1baeab12689f9.png