Java序列化与反序列化

一、序列化和反序列化

序列化：把对象或数据结构转换为字节序列

反序列化：把字节序列恢复为对象或数据结构

当两个进程在进行远程通信时，彼此可以发送各种类型的数据。无论是何种类型的数据，都会以二进制序列的形式在网络上传送。发送方需要把这个Java对象转换为字节序列，才能在网络上传送；接收方则需要把字节序列再恢复为Java对象。

对象的序列化主要有两种用途：

1. 把对象的字节序列持久化，或存 硬盘 上，通常存放在一个文件中、或存在数据库中。

2.在网络上传送对象的字节序列，各远程服务之间的调用对象都需要序列化，如我们的服务thrift，client与service端的调用，对象必须经过序列化成二进制字符串才能进入应用层的下层（网络层、传输层、数据链路 层、还有物理层）进行传输。

       序列化和反序列化一般用于应用层,TCP/IP是一个五层协议，对于传输层以上的协议，全部被包含在应用层协议里面，所以序列化协议属于TCP/IP协议中应用层协议的一部分。在很多应用中，需要对某些对象进行序列化，让它们离开内存空间，入住物理硬盘，以便长期保存。比如最常见的是Web服务器中的Session对象，当有 10万用户并发访问，就有可能出现10万个Session对象，内存可能吃不消，于是Web容器就会把seesion先序列化到硬盘中，等要用了，再把保存在硬盘中的对象还原到内存中。

二、java的序列化和反序列化以及serialVersionUID的例子（存储和读取）

定义domain

public class Person implements Serializable{//注释号（2）
//public class Person {//没有序列化，注释号（1）
//private static final long serialVersionUID=1L;//没有显示实现序列化ID  注释号(3)
 
    private int id;
    private String name;
    private String sex;
    public Person() {
    }
    public Person(int id, String name) {
        this.id = id;
        this.name = name;
    }
    public Person(int id, String name, String sex) {
        this.id = id;
        this.name = name;
        this.sex = sex;
    }
    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 String getSex() {
        return sex;
    }
    public void setSex(String sex) {
        this.sex = sex;
    }
}

测试序列化的main()函数

public class TestSerializable {
    public static void main(String[] args) throws ClassNotFoundException {
        try {
            SerializePerson();
            Person person = DeserializePersopn();
            System.out.println("new person:" + person.getId()+"|"+person.getName());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    private static Person DeserializePersopn() throws ClassNotFoundException {
        try {
            ObjectInputStream ois=new ObjectInputStream(new FileInputStream(new File("/Users/weiguang/test.log")));
            Person person=(Person)ois.readObject();
            return person;
        } catch (IOException e) {
            e.printStackTrace();
        }
        return null;
    }
    private static void SerializePerson() throws IOException {
        Person person = new Person();
        person.setId(1);
        person.setName("weiguang");
        //*****************写入本地的文件************
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(new File("/Users/weiguang/test.log")));
        oos.writeObject(person);
        System.out.println("write finish !");
        oos.close();
    }
}

分析：

1、上面Person对象，假如没有实现序列化如注释（1），会出现：提示说IO没有序列化异常，原因是对象没有没序列化，所以没办法存进文件

2、Person序列化，如注释（2）:

3、假如我没有显示实现序列化ID，然后修改了Person类，如添加一个字段，会出现：

意思就是说，文件流中的class和classpath中的class，也就是修改过后的class，不兼容了，处于安全机制考虑，程序抛出了错误，并且拒绝载入。那么如果我们真的有需求要在序列化后添加一个字段或者方法呢？应该怎么办？那就是自己去指定serialVersionUID。在TestSerialversionUID例子中，没有指定Customer类的serialVersionUID的，那么java编译器会自动给这个class进行一个摘要算法，类似于指纹算法，只要这个文件 多一个空格，得到的UID就会截然不同的，可以保证在这么多类中，这个编号是唯一的。所以，添加了一个字段后，由于没有显指定 serialVersionUID，编译器又为我们生成了一个UID，当然和前面保存在文件中的那个不会一样了，于是就出现了2个序列化版本号不一致的错误。因此，只要我们自己指定了serialVersionUID，就可以在序列化后，去添加一个字段，或者方法，而不会影响到后期的还原，还原后的对象照样可以使用，而且还多了方法或者属性可以用。

serialVersionUID的取值是Java运行时环境根据类的内部细节自动生成的。如果对类的源代码作了修改，再重新编译，新生成的类文件的serialVersionUID的取值有可能也会发生变化。

类的serialVersionUID的默认值完全依赖于Java编译器的实现，对于同一个类，用不同的Java编译器编译，有可能会导致不同的 serialVersionUID，也有可能相同。

为了提高serialVersionUID的独立性和确定性，建议在一个可序列化类中显示的定义serialVersionUID，为它赋予明确的值。

显式地定义serialVersionUID有两种用途：

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

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

三、java序列化时，并不保存静态变量，序列化保存的是对象的状态，静态变量属于类的状态，因此 序列化并不保存静态变量。

比较容易理解，不举例子了

四、对敏感字段序列化时加密和反序列化时解密

在序列化过程中，虚拟机会试图调用对象类里的 writeObject 和 readObject 方法，例如上面第一个例子。进行用户自定义的序列化和反序列化，如果没有这样的方法，则默认调用是 ObjectOutputStream 的 defaultWriteObject 方法以及 ObjectInputStream 的 defaultReadObject 方法。用户自定义的 writeObject 和 readObject 方法可以允许用户控制序列化的过程，比如可以在序列化的过程中动态改变序列化的数值。

如对登录的密码进行加密：

private void writeObject(ObjectOutputStream out) {
        try {
            ObjectOutputStream.PutField putFields = out.putFields();
            password = "****";//模拟加密
            putFields.put("password", password);
            out.writeFields();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

五、java序列化存储机制（相同对象只存储同一个对象的应用）

先看一个例子：

private static void SerializePerson() throws IOException {
    Person person = new Person();
    person.setId(1);
    person.setName("weiguang");
    ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(new File("/Users/weiguang/test.log")));
    oos.writeObject(person);//第一次序列化
    System.out.println(new File("/Users/weiguang/test.log").length());
    oos.writeObject(person);//第二次序列化同一个对象
    System.out.println(new File("/Users/weiguang/test.log").length());
    System.out.println("write finish ! 序列化成功 ！");
    oos.close();
}

我们看到，第二次写入对象时文件只增加了 5 字节，并且两个对象是相等的，这是为什么呢？

Java 序列化机制为了节省磁盘空间，具有特定的存储规则，当写入文件的为同一对象时，并不会再将对象的内容进行存储，而只是再次存储一份引用，上面增加的 5 字节的存储空间就是新增引用和一些控制信息的空间。反序列化时，恢复引用关系，使得代码指向唯一的对象，二者相等，该存储规则极大的节省了存储空间。

 六、几种常见的序列化和反序列化协议

xml，json,protobuf、thrift和avro

对于protobuf和Avro协议不了解，常用的就json和thrift协议比较多。

json：采用“attribute－value”的方式来描述对象。类的描述方式就是“ array”。Json快速成为最广泛使用的序列化协议：这种 array格式非常符合工程师对对象的理解，它保持了xml的human-readable的优点相对于xml而言，序列化后的数据更加简洁。

thrift：thrift并不仅仅是序列化协议，而是一个rpc框架。相对于json和xml而言，thrift在对于对性能要求比较高的分布式系统，它是一个优秀的rpc解决方案；但是由于由于thrift的序列化被嵌入到thrift框架里面，thrift框架本身并没有透出序列化和反序列化接口，这导致其很难和其他传输层协议共同使用，例如http。