深入分析java序列化

浅浅的花香味﹌ 2022-08-03 00:47 235阅读 0赞

## 概念 ##

先来点简单的概念：  
**what?why？**  
什么是序列化？为什么要序列化？  
答曰：将java对象转成字节序列，用以传输和保存  
**where？**  
使用场景是什么？  
答曰：对象的传输；状态的备份，例如jvm的dump文件；  
好了，不装\*了，下面说的详细点。其实对象的序列化主要有两种用途：

*  把对象的字节序列永久地保存到硬盘上，通常存放在一个文件中
 *  在网络上传送对象的字节序列

在很多应用中，需要对某些对象进行序列化，让它们离开内存空间，入住物理硬盘，以便长期保存。比如最常见的是Web服务器中的Session对象，当有 10万用户并发访问，就有可能出现10万个Session对象，内存可能吃不消，于是Web容器就会把一些seesion先序列化到硬盘中，等要用了，再把保存在硬盘中的对象还原到内存中。  
当两个进程在进行远程通信时，彼此可以发送各种类型的数据。无论是何种类型的数据，都会以二进制序列的形式在网络上传送。发送方需要把这个Java对象转换为字节序列，才能在网络上传送；接收方则需要把字节序列再恢复为Java对象。

## 实现方式 ##

**how？**

1.  （需要序列化的类）实现Serializable接口。查看源码可知Serializable是个空接口（里面没有任何方法），即标记接口。作用就是明确地告诉java，这个类需要序列化，不实现这个接口，那这个对象是没法序列化和传输的（如果不加implements Serializable，会报错，建议试试，直观感受下），类似的标记接口还有cloneable。
2.  创建输入输出流。首先，序列化一个对象，需要要创建某些OutputStream(如FileOutputStream、ByteArrayOutputStream等)，然后将这些OutputStream封装在一个ObjectOutputStream中。这时候，只需要调用writeObject()方法就可以将对象序列化，并将其发送给OutputStream（对象的序列化是基于字节的，不能使用Reader和Writer等基于字符的层次结构）。其次，反序列的过程（即将一个序列还原成为一个对象），则需要将一个InputStream(如FileInputstream、ByteArrayInputStream等)封装在ObjectInputStream内，然后调用readObject()即可。简单来说即：  
    序列化：ObjectOutputStream.writeObject(Object)  
    反序列化：ObjectInputStream.readObject()

见下面的例子：  
先定义一个待序列化的对象：

package com.alibaba.serialize.common;
    
    import java.io.Serializable;
    
    /* * 不加implements Serializable，会报错 */
    public class User implements Serializable{ 
        private static final long serialVersionUID = 1L;
        private String username;
        private int age;
    
        public User(String username, int age) {
            this.username = username;
            this.age = age;
        }
    
        public String getUsername() {
            return username;
        }
    
        public void setUsername(String username) {
            this.username = username;
        }
    
        public int getAge() {
            return age;
        }
    
        public void setAge(int age) {
            this.age = age;
        }
    }

再写一个序列化的例子

package com.alibaba.serialize.common;
    
    import java.io.BufferedOutputStream;
    import java.io.FileNotFoundException;
    import java.io.FileOutputStream;
    import java.io.IOException;
    import java.io.ObjectOutputStream;
    
    public class SerializeExample { 
    
        public static final String out_file = "src/com/alibaba/serialize/temp.out";
    
        public static void main(String[] args) {
            User user = new User("tony", 18);
            try {
                //如果这里改成网络输出流而不是文件输出流（反序列化那里也同样改成网络输入流），则可以在网络上传输
                ObjectOutputStream out = new ObjectOutputStream(
                                   new BufferedOutputStream(new FileOutputStream(out_file)));
    
                out.writeObject("用户信息..");
                out.writeObject(user);
                out.close();
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            }
            System.out.println("序列化完成。请调用反序列化类DeserializeExample完成反序列化！");
        }
    }

最后再写一个反序列化的例子

package com.alibaba.serialize.common;
    
    import java.io.BufferedInputStream;
    import java.io.FileInputStream;
    import java.io.ObjectInputStream;
    
    public class DeserializeExample { 
        public static void main(String[] args) throws Exception{
                ObjectInputStream in = new ObjectInputStream(
                                   new BufferedInputStream(new FileInputStream(SerializeExample.out_file)));
                String title = (String) in.readObject();
                System.out.println(title);
                User user = (User) in.readObject();
                System.out.println("用户姓名："+user.getUsername());
                System.out.println("用户年龄："+user.getAge());
        }
    }

分别运行`SerializeExample` 和 `DeserializeExample` 可以看到对应的效果。

## 序列化的文件关系 ##

说几点平常不注意容易忽略的地方。

1.  如果一个类没有实现Serializable接口，但是它的基类实现了，那么这个类也是可以序列化的；
2.  相反，如果一个类实现了Serializable接口，但是它的父类没有实现，那么这个类还是可以序列化（Object是所有类的父类），但是序列化该子类对象，然后反序列化后输出父类定义的某变量的数值，会发现该变量数值与序列化时的数值不同（一般为null或者其他默认值），而且这个父类里面必须有无参的构造方法，不然子类反序列化的时候会报错。

见示例：  
先写个父类

package com.alibaba.serialize.parent;
    
    import java.io.Serializable;
    
    public class CarSerialize{ 
        private String name;
        private Long price;
    
        /* * 没有这个无参构造函数会报错，可以删除，测试下 */
        public CarSerialize() {
            super();
        }
    
        public CarSerialize(String name, Long price) {
            this.name = name;
            this.price = price;
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public Long getPrice() {
            return price;
        }
    
        public void setPrice(Long price) {
            this.price = price;
        }
    
    }

再写个子类

package com.alibaba.serialize.parent;
    
    import java.io.Serializable;
    
    public class BMWSerialize extends CarSerialize implements Serializable{ 
        private String name;
        private Long price;
    
        public BMWSerialize(String name, Long price) {
            super(name, price);
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public Long getPrice() {
            return price;
        }
    
        public void setPrice(Long price) {
            this.price = price;
        }   
    }

最后写个测试类

package com.alibaba.serialize.parent;
    
    import java.io.FileInputStream;
    import java.io.FileNotFoundException;
    import java.io.FileOutputStream;
    import java.io.IOException;
    import java.io.ObjectInputStream;
    import java.io.ObjectOutputStream;
    
    public class SerializeTest { 
    
        public static void main(String[] args) {
            try {
                ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("result.obj"));
                out.writeObject(new BMWSerialize("BMW",100L));
                out.close();
    
                ObjectInputStream oin = new ObjectInputStream(new FileInputStream("result.obj"));
                BMWSerialize bmw = (BMWSerialize) oin.readObject();
                System.out.println("解密后的字符串:" + bmw.getName());
                oin.close();
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            }
        }
    }

上述代码中，大家可以尝试按照我上面说的两点，分情况进行测试。

这里还有个需要注意的地方  
*同一个流的对象引用关系被很好地保留了下来，不同流的对象引用关系则无法保证匹配*  
这一点我感觉比较容易理解，就不写了，有时间可以测试下。

## 序列化ID ##

思考一个问题：如果序列化之后，两端或者版本不同，class不一致怎么办？

？？？  
？？？

这里就有**序列化ID**的概念了，serialVersionUID适用于JAVA的序列化机制。反序列化时，如果类发生了变动，则构造器和赋值语句不会生效。

简单来说，Java的序列化机制是通过判断类的serialVersionUID来验证版本一致性的。在进行反序列化时，JVM会把传来的字节流中的serialVersionUID与本地相应实体类的serialVersionUID进行比较，如果相同就认为是一致的，可以进行反序列化，否则就会出现序列化版本不一致的异常，即是InvalidCastException（如同上面一节，你把父类的无参构造方法删除之后，再反序列化也会报这个错）。

serialVersionUID有两种显示的生成方式：

*  一是默认的1L，比如：private static final long serialVersionUID = 1L
 *  二是根据类名、接口名、成员方法及属性等来生成一个64位的哈希字段，比如:`private static final long serialVersionUID = xxxxL;`

再思考一个问题，如果序列化ID是一样的，假设A端是序列化，B端是反序列化，反序列化之前B端序列化对象发生变化，会有几种情况？其实逻辑还是比较容易理解的，略微总结了下，大致如下：

*  B加字段：序列化，反序列化正常，B端新增加的int字段被赋予了字段类型的默认值（如0或者false）
 *  B删字段：序列化，反序列化正常（不会报错），B端字段少于A端，A端多的字段值丢失

## 自定义序列化 ##

既然题目是深入分析，那当然要接着分析，哈哈~所以，再问一个问题，当对象中有敏感字段怎么办？如password。是不是自己可以决定序列化方式呢？这里解释一下

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

基于这个原理，可以在实际应用中得到使用，用于敏感字段的加密工作，见示例（代码摘自[参考资料][Link 1]）。  
先写一个自定义序列化过程的待序列化对象。

package com.alibaba.serialize.customer;
    
    import java.io.IOException;
    import java.io.ObjectInputStream;
    import java.io.ObjectInputStream.GetField;
    import java.io.ObjectOutputStream;
    import java.io.ObjectOutputStream.PutField;
    import java.io.Serializable;
    
    public class SecurityInfo implements Serializable{ 
        private String password = "pass";
    
        public String getPassword() {
            return password;
        }
    
        public void setPassword(String password) {
            this.password = password;
        }
    
        private void writeObject(ObjectOutputStream out) {
            try {
                PutField putFields = out.putFields();
                System.out.println("原密码:" + password);
                password = "encryption";//模拟加密
                putFields.put("password", password);
                System.out.println("加密后的密码" + password);
                out.writeFields();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    
        private void readObject(ObjectInputStream in) {
            try {
                GetField readFields = in.readFields();
                Object object = readFields.get("password", "");
                System.out.println("要解密的字符串:" + object.toString());
                password = "pass";//模拟解密,需要获得本地的密钥
            } catch (IOException e) {
                e.printStackTrace();
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            }
    
        }
    }

再写一个测试类

package com.alibaba.serialize.customer;
    
    import java.io.FileInputStream;
    import java.io.FileNotFoundException;
    import java.io.FileOutputStream;
    import java.io.IOException;
    import java.io.ObjectInputStream;
    import java.io.ObjectOutputStream;
    
    public class CustomerSerialize { 
    
        public static void main(String[] args) {
            try {
                ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("result.obj"));
                out.writeObject(new SecurityInfo());
                out.close();
    
                ObjectInputStream oin = new ObjectInputStream(new FileInputStream("result.obj"));
                SecurityInfo t = (SecurityInfo) oin.readObject();
                System.out.println("解密后的字符串:" + t.getPassword());
                oin.close();
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            }
        }
    }

ok！运行下看看吧。  
其实说到自定义序列化，还可以通过实现java序列化另一个接口Externalizable，实现Externalizable接口就需要实现它的两个方法，如下：  
![Externalizable][]

大致总结了下，Externalizable和Serializable的区别：

<table> 
 <thead> 
  <tr> 
   <th>实现Serializable接口</th> 
   <th>实现Externalizable</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>系统自动存储必要信息</td> 
   <td>程序员决定存储哪些信息</td> 
  </tr> 
  <tr> 
   <td>Java内建支持，易于实现，只需实现该接口如何即可，无须任何代码支持</td> 
   <td>仅仅提供两个空方法，实现该接口必须为两个空方法提供实现</td> 
  </tr> 
  <tr> 
   <td>性能略差</td> 
   <td>性能略高</td> 
  </tr> 
 </tbody> 
</table>

其实虽然Externalizable性能高，但是我们一般很少在代码里看到，这个原因需要请假下别人，个人认为可能是自己写不够通用，太麻烦，而且一般敏感信息也不会这么传。

## 几种序列化协议比较 ##

这里主要介绍和对比几种当下比较流行的序列化协议，包括XML、JSON、Protobuf、Thrift和Avro。这里因为我用的也不多，只用过json和xml，所以，对比的话这里列了个参考资料： [http://tech.meituan.com/serialization\_vs\_deserialization.html][http_tech.meituan.com_serialization_vs_deserialization.html]

本文还参考：  
[http://blog.csdn.net/zhaozheng7758/article/details/7820018][Link 1]

感谢上述作者~

[Link 1]: http://blog.csdn.net/zhaozheng7758/article/details/7820018
[Externalizable]: /images/20220731/04ab5ca7903b4ca28ceb6ca61fb37a92.png
[http_tech.meituan.com_serialization_vs_deserialization.html]: http://tech.meituan.com/serialization_vs_deserialization.html