深入浅出序列化之实现与认识(一)

今天整理了一下关于java对象序列化的一些基本和常用的知识点。

首先我们可以先来思考下，序列化为什么会存在？

在java中，是允许我们创建可以复用的java对象的，但是只是限于在jvm允许的情况下，如果jvm关闭了，java对象如何继续保存呢？
同时，当我们需要在两个不同服务器之间通信的时候，需要传递java对象，这个时候，java对象就需要以二进制的形式才能进行传递和通信。于是系列化就这么诞生了。

简单来说:

序列化就是把对象的信息和状态转化为可以存储或可以传输的行驶过程，把对象转化为字节序列的过程，称为对象的序列化。

反序列化就是把对象从字节序反序列化为(或者说恢复)对象，把字节序恢复为对象的过程就叫做反序列化。

在序列化中，为了把对象转化为二进制序列会使用不同的算法，评定一个序列化算法的好坏主要就是如下:
1.序列化以后的数据大小
2.序列化操作的速度和系统开销
这里我们主要讲解java方面的序列化，在java中提供了对象序列化机制，也就是实现Serializer接口就可以了。

但是java本身的提供的机制也是存在两个问题的:
1序列化的数据比较大，传输效率低。
2.其他语言无法识别和对接。

基于JDK 序列化方式实现

JDK 提供了Java 对象的序列化方式， 主要通过输出流
java.io.ObjectOutputStream 和对象输入流java.io.ObjectInputStream
来实现。其中，被序列化的对象需要实现java.io.Serializable 接口
下面我们可以自己来实现下，写一个序列化接口:

public interface ISerializer {

     byte[] serializer(T obj);

     T deSerializer(byte[] data, Class clazz);

}

实现类
public class JavaSerializer implements ISerializer{

    /**序列化 */
    @Override
    public  byte[] serializer(T obj) {

        ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
        ObjectOutputStream oos =null;
        try {
            oos = new ObjectOutputStream(byteArrayOutputStream);
            oos.writeObject(obj);
            return byteArrayOutputStream.toByteArray();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if(oos!=null){
                try {
                    oos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            try {
                byteArrayOutputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return null;
    }

    @Override
    public  T deSerializer(byte[] data, Class clazz) {

        ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(data);
        ObjectInputStream ois = null;
        try {

            ois = new ObjectInputStream(byteArrayInputStream);
            return (T) ois.readObject();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (ois != null) {
                try {
                    ois.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            try {
                byteArrayInputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return null;
    }
}

要序列化的类: User

public class User implements Serializable {
    
  //  private static final long serialVersionUID = 5896323642243314378L;

    private String name;

    private Integer age;

    public String getName() {
        return name;
    }

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

    public Integer getAge() {
        return age;
    }

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

    public User(String name, Integer age) {
        this.name = name;
        this.age = age;
    }

    public User() {
    }

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

这里需要注意的是，该类需要实现Serializer接口。
不然执行的时候会报错。

接下来，我们可以来进一步看一下关于序列化需要使用到的一些关键字还有如何使用:

1. serialVersionUID

Java 的序列化机制是通过判断类的serialVersionUID 来验证版本一致性的。在进行反序列化时，JVM 会把传来的字节流serialVersionUID
与本地相应实体类的serialVersionUID 进行比较，如果相同就认为是一致的，可以进行反序列化，否则就会出现序列化版本不一致的异常，即是InvalidCastException

如果没有为指定的class 配置serialVersionUID，那么java 编译器会自
动给这个class 进行一个摘要算法，类似于指纹算法，只要这个文件有
任何改动，得到的UID 就会截然不同的，可以保证在这么多类中，这个编号是唯一的serialVersionUID 有两种显示的生成方式：

一是默认的1L，比如：private static final long serialVersionUID = 1L;
二是根据类名、接口名、成员方法及属性等来生成一个64 位的哈希字
段当实现java.io.Serializable 接口的类没有显式地定义一个
serialVersionUID 变量时候，Java 序列化机制会根据编译的Class 动
生成一个serialVersionUID 作序列化版本比较用，这种情况下，如果
Class 文件(类名，方法明等)没有发生变化(增加空格，换行，增加注释等等)，就算再编译多次，serialVersionUID 也不会变化的。

2.静态变量，不参与序列化

3.父类的序列化
子类实现序列化接口，传递父类的属性，但是父类没有实现Serializable接口，那么反序列化后，输出父类属性的时候，不会输出，会显示为null，说明没有序列化。

一句话: 父类要实现序列化，也必须实现Serializer接口.

4.Transient 关键字

Transient 关键字的作用是控制变量的序列化，在变量声明前加上该关键字，可以阻止该变量被序列化到文件中，在被反序列化后，transient变量的值被设为初始值，如 int 型的是 0，对象型的是 null.

绕开transient 机制的办法(感觉暂时没什么需要用到的)

image.png

writeObject和readObject 这两个私有的方法，既不属于Object、也不是Serializable，为什么能够在序列化的时候被调用呢？

原因是，ObjectOutputStream使用了反射来寻找是否声明了这两个方法。因为ObjectOutputStream使用getPrivateMethod，所以这些方法必须声明为priate 以至于供ObjectOutputStream 来使用

序列化的存储规则

同一对象两次（开始写入文件到最终关闭流这个过程算一次，上面的演示效果是不关闭流的情况才能演示出效果）写入文件，打印出写入一次对象后的存储大小和写入两次后的存储大小，第二次写入对象时文件只增加了 5 字节Java 序列化机制为了节省磁盘空间，具有特定的存储规则，当写入文件的为同一对象时，并不会再将对象的内容进行存储，而只是再次存储一份引用，上面增加的 5 字节的存储空间就是新增引用和一些控制信息的空间。反序列化时，恢复引用关系.该存储规则极大的节省了存储空间。

image.png