深入了解java序列化

旧城等待， 2022-06-12 05:11 139阅读 0赞

在日常开发中，前端与后端的交互，系统之间的远程调用都需要使用到序列化技术，在java中使用序列化非常简单，只需要将被序列化的对象的类实现Java.io.Serializable接口即可。  
对于实现序列化接口的类，我们需要注意两点：

1.  类中的静态变量我们是无法序列化的，因为序列化只是针对对象，而静态变量是类级别的。
2.  当子类实现序列化接口，而父类没有实现序列化接口时，将子类进行序列化，再反序列化回来后，发现父类中的属性会被重新初始化，也就是说会调用父类的无参构造。如果没有无参构造，则会抛出异常。

下面是通过两个小案例来证明：

public class SeriaTest implements Serializable{ 
    
        private static final long serialVersionUID = 1L;
    
        private static Integer count = 10;
    
        public static void main(String[] args) {
            try(ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("D:\\test.obj"));
                ObjectInputStream ois = new ObjectInputStream(new FileInputStream("D:\\test.obj"))) {
                oos.writeObject(new SeriaTest());
                count = 20;
                SeriaTest seriaTest = (SeriaTest) ois.readObject();
                System.out.println(seriaTest.count);
            } catch (Exception e) {
                System.out.println("序列化反序列化时出现异常："+e);
            }
        }
    }

这段代码的运行结果为20，说明静态变量不会被序列化。

public class Fu { 
    
        public String fu;
        public String getFu() {
            return fu;
        }
        public void setFu(String fu) {
            this.fu = fu;
        }
    }
    
    public class Zi extends Fu implements Serializable{ 
    
        private static final long serialVersionUID = 1L;
        public String zi;
    
        public Zi(){
            fu = "fu";
            zi = "zi";
        }
        public String getZi() {
            return zi;
        }
        public void setZi(String zi) {
            this.zi = zi;
        }
    }
    
    public class SeriaTest{ 
    
        public static void main(String[] args) {
            public static void main(String[] args) {
            try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("D:\\test.obj"));
            ObjectInputStream ois = new ObjectInputStream(new FileInputStream("D:\\test.obj"))){
                oos.writeObject(new Zi());
                Zi zi = (Zi) ois.readObject();
                System.out.println(zi.fu);
                System.out.println(zi.zi);
            } catch (Exception e) {
            }
        }
    }

这段代码的运行结果为null,zi。验证了上面的第二点。

将对象序列化实际上调用的就是ObjectOutputStream的wirteObject方法，跟踪源代码可知能被序列化的对象除了是实现Serializable接口的对象，还可以是String，数组或者枚举对象：

if (paramObject instanceof String) {
            writeString((String) paramObject, paramBoolean);
    } else if (((Class) localObject2).isArray()) {
            writeArray(paramObject, localObjectStreamClass, paramBoolean);
    } else if (paramObject instanceof Enum) {
            writeEnum((Enum) paramObject, localObjectStreamClass,paramBoolean);
    } else if (paramObject instanceof Serializable) {
            writeOrdinaryObject(paramObject, localObjectStreamClass,paramBoolean);
    }

再继续跟进writeOrdinaryObject方法，我们会发现会有这么一段逻辑：

if ((paramObjectStreamClass.isExternalizable()) && (!(paramObjectStreamClass.isProxy())))
        writeExternalData((Externalizable) paramObject);
    else
        writeSerialData(paramObject, paramObjectStreamClass);

先判断是不是实现了Externalizable接口（这个是Serializable的子接口，这里先不管，后面会解释），如果不是，则执行writeSerialData方法。跟进去：

if (localObjectStreamClass.hasWriteObjectMethod()) { ********省略******* localObjectStreamClass.invokeWriteObject(paramObject, this); ********省略******* } else { defaultWriteFields(paramObject, localObjectStreamClass); }

我们发现源代码先判断了一下这个需要被序列化的类中有没有writeObject这个方法，如果有，那么就执行，如果没有，那么就执行默认的序列化方法。对于这个writeObject方法，有以下几个要求：

*  方法名必须叫writeObject
 *  必须是私有的方法
 *  返回值类型必须为void
    
    只有满足了以上三点，在序列化对象的时候，才会执行我们自定义的序列化方法。当然，我们除了可以重写writeObject方法，我们还可以重写readObject,readObjectNoData,writeReplace,readResolve等方法，这些方法之间有什么联系，有什么作用呢？我们通过一段代码来探索一下：

public class SeriaTest implements Serializable{ 
    
        private static final long serialVersionUID = 1L;
    
        public Integer count = 10;
    
        public SeriaTest(Integer count){
            this.count = count;
        }
    
        public static void main(String[] args) {
            try(ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("D:\\test.obj"));
                ObjectInputStream ois = new ObjectInputStream(new FileInputStream("D:\\test.obj"))) {
                oos.writeObject(new SeriaTest(20));
                SeriaTest seriaTest = (SeriaTest) ois.readObject();
                System.out.println(seriaTest.count);
            } catch (Exception e) {
                System.out.println("序列化反序列化时出现异常："+e);
            }
        }
    
        private void writeObject(ObjectOutputStream oos) throws IOException{
            System.out.println("序列化前执行了自定义的writeObject方法");
            oos.defaultWriteObject();
            System.out.println("序列化后执行了自定义的writeObject方法");
        }
    
        private Object writeReplace() {
            System.out.println("序列化时执行了自定义的writeReplace方法");
            SeriaTest s = new SeriaTest(10);
            return s;
        }
    }

执行结果如下：

序列化时执行了自定义的writeReplace方法
    序列化前执行了自定义的writeObject方法
    序列化后执行了自定义的writeObject方法
    10

根据执行结果我们我们可以知道，在对象序列化的时候，会先去执行被序列化的类中的writeReplace方法，再执行writeObject方法，如果重写了writeReplace方法，那么被序列化的对象就是这个方法的返回值，而writeObject方法主要作用就是在序列化前后可以做处理操作。  
对应的读操作的方法分别是readResolve方法和readObject方法，将上面的代码再完善一下：

执行结果符合我们的预期：

序列化时执行了自定义的writeReplace方法
    序列化前执行了自定义的writeObject方法
    序列化后执行了自定义的writeObject方法
    反序列化前执行了自定义的readObject方法
    反序列化后执行了自定义的readObject方法
    反序列化前执行了自定义的readReslove方法
    30

至于readObjectNoData方法，这个比较少见，这个方法的作用就是当一个对象被序列化后，反序列化时可以添加属性。（具体可参考：[readObjectNoData方法作用][readObjectNoData]）

下面我们再来解析一下上面提到的Externalizable接口，这个接口是Serializable接口的子接口，这个接口有两个抽象方法：writeExternal和readExternal，这个两个方法分别对应于writeObject和readObject，不同点在于writeObject和readObject都是私有方法，所以其子类不能复用并且不能复写，而writeExternal和readExternal是共有方法，其子类可以复用并且复写。

public class SeriaTest implements Externalizable{ 
    
        private String name;
        private Integer age;
    
        public static void main(String[] args) {
            try(ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("D:\\test.obj"));
                ObjectInputStream ois = new ObjectInputStream(new FileInputStream("D:\\test.obj"))
                ) {
                oos.writeObject(new SeriaTest());
                SeriaTest seriaTest = (SeriaTest) ois.readObject();
                System.out.println(seriaTest.name);
                System.out.println(seriaTest.age);
            } catch (Exception e) {
                System.out.println("序列化反序列化时出现异常："+e);
            }
        }
    
        @Override
        public void writeExternal(ObjectOutput paramObjectOutput)
                throws IOException {
            System.out.println("writeExternal.....");
            paramObjectOutput.writeInt(18);
            paramObjectOutput.write("zhangsan".getBytes(Charset.forName("UTF-8")));
        }
    
        @Override
        public void readExternal(ObjectInput paramObjectInput) throws IOException,
                ClassNotFoundException {
            System.out.println("readExternal.....");
            age = paramObjectInput.readInt();
            name = paramObjectInput.readLine();
        }
    
    }

执行结果如下：

writeExternal.....
    readExternal.....
    zhangsan
    18

[readObjectNoData]: http://blog.csdn.net/dont27/article/details/38309061