浅谈java序列化和反序列化

浅谈java序列化和反序列化

RMI（一个class调另一个class，应用客户端和服务端之间的参数对象调用）是基于Java序列化技术的，一个JAVA对象实现Serializable接口，可以序列化为本地文件存储，拿到本地文件可以反序列化为对应的Java对象。
RMI 远程方法调用

RMI:远程方法调用(Remote Method Invocation)。能够让在客户端Java虚拟机上的对象像调用本地对象一样调用服务端java 虚拟机中的对象上的方法。

RMI远程调用：

1，客户调用客户端辅助对象stub上的方法

2，客户端辅助对象stub打包调用信息（变量，方法名），通过网络发送给服务端辅助对象skeleton

3，服务端辅助对象skeleton将客户端辅助对象发送来的信息解包，找出真正被调用的方法以及该方法所在对象

4，调用真正服务对象上的真正方法，并将结果返回给服务端辅助对象skeleton

5，服务端辅助对象将结果打包，发送给客户端辅助对象stub

6，客户端辅助对象将返回值解包，返回给调用者

7，客户获得返回值

序列化方法：
直接看代码：

package com.cclllday.serial.ymmbean;

import java.io.Serializable;

public class Driver implements Serializable {
    private static final long serialVersionUID = 1L;
    public static long getSerialVersionUID() {
        return serialVersionUID;
    }
    private String name;
    private String idCard;
    private Integer sex;
    private Integer age;

    public  int  testNum;

    public  Driver() {
        this.testNum = 1;
    }
    public String getName() {
        return name;
    }

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

    public String getIdCard() {
        return idCard;
    }

    public void setIdCard(String idCard) {
        this.idCard = idCard;
    }

    public Integer getSex() {
        return sex;
    }

    public void setSex(Integer sex) {
        this.sex = sex;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }
}

Driver bean实现Serializable接口，注意private static final long serialVersionUID = 1L;这个序列化ID（重要，后面讲解）

package com.cclllday.serial.ymmbean;

import java.io.*;

import static java.lang.System.*;

public class SerialTest {
    public static void main(String[] args){
        Driver driver = new Driver();
        try{
            ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("Driver.txt"));
            //第一次将对象写入文件
            out.writeObject(driver);
            System.out.println( new File("Driver.txt").length());

            out.flush();
            //第二次将对象写入文件
            //更改testNum值
            driver.testNum = 5;
            out.writeObject(driver);
            System.out.println( new File("Driver.txt").length());

            out.close();

            /*
            反序列化
             */
            ObjectInputStream in = new ObjectInputStream(new FileInputStream("Driver.txt"));
            Driver firstSerial = (Driver)in.readObject();
            Driver secondSerial = (Driver)in.readObject();

            System.out.println(firstSerial == secondSerial);
            //更改前的testNum
            System.out.println(firstSerial.testNum);

            //
        }catch(FileNotFoundException e){
            e.printStackTrace();;
            out.println("文件找不到!");
        }catch(IOException e){
            e.printStackTrace();
        }catch(Exception e){
            e.printStackTrace();
        }
    }

}

Test测试方法，我们可以看到成功序列化（工程目录下产生Driver.txt文件），成功打印file大小，以及Driver成员变量testNum的值。

我们会有疑问？
为什么两次object写入文件的大小不一样，不一样应该是2倍才好理解，因为写入了两次，而是增加了5字节。

序列化存储机制问题，我们写入的是同一个对象，只存储第一份引用，增加的字节可能是新增的引用和控制信息。反序列化时恢复引用关系，两个引用相同。

前面说到serialVersionUID ，这个是干什么的呢？
简单说，这个是一个对象的标识，虚拟机是否允许反序列化，不仅取决于类路径和功能代码是否一致，一个非常重要的一点是两个类的序列化 ID 是否一致（就是 private static final long serialVersionUID = 1L）。

如果我们更改了Driver类的ID，那么无法序列化成功，

package com.cclllday.serial.ymmbean;

import java.io.*;

import static java.lang.System.*;

public class SerialTest {
    public static void main(String[] args){
        Driver driver = new Driver();
        try{
//            ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("Driver.txt"));
//            //第一次将对象写入文件
//            out.writeObject(driver);
//            System.out.println( new File("Driver.txt").length());
//
//            out.flush();
//            //第二次将对象写入文件
//            //更改testNum值
//            driver.testNum = 5;
//            out.writeObject(driver);
//            System.out.println( new File("Driver.txt").length());
//
//            out.close();

            /*
            反序列化
             */
            ObjectInputStream in = new ObjectInputStream(new FileInputStream("Driver.txt"));
            Driver firstSerial = (Driver)in.readObject();
            Driver secondSerial = (Driver)in.readObject();

            System.out.println(firstSerial == secondSerial);
            //更改前的testNum
            System.out.println(firstSerial.testNum);
            System.out.println(Driver.getSerialVersionUID());

            //
        }catch(FileNotFoundException e){
            e.printStackTrace();;
            out.println("文件找不到!");
        }catch(IOException e){
            e.printStackTrace();
        }catch(Exception e){
            e.printStackTrace();
        }
    }

}

可以看到，本地Id是1234，对象更改为123，无法反序列化

我们也可以尝试不加Id，JVM会根据类信息以及对象信息给我们生成一个唯一的Id

//    public static long getSerialVersionUID() {
//        return serialVersionUID;
//    }
//
//    private static final long serialVersionUID = 1234L;

可以看到class serialId为一串数字

我们尝试更改Driver 代码，加一个成员变量声明。

Id值变了

实际上，我们给Driver加一个空格或者回车这样的小小改动都会导致ID变化，反序列化不成功，这也是功能代码不一样无法反序列化成功的原因。