从java看序列化

绝地灬酷狼 2022-05-09 03:40 90阅读 0赞

### 一、序列化是什么 ###

信息的传递、交换支撑整个互联网产业，那么信息的交流的过程中遵循着什么样的标准。常见的网络传输协议有 TCP/IP 协议，OSI协议等模型。我们的通讯协议往往根据不同的应用场景采用不同分层模型，因不同模型功能定义不一样，因此粒度的划分也有所不同，比如：TCP/IP协议是一个四层协议，而OSI模型却是七层协议模型。

在 TCP/IP 协议模型中分为：网络接口层、网际层、传输层、应用层。OSI 协议模型分为：物理层、数据链路层，网络层、传输层、会话层、表示层以及我们的应用层。

在 OSI 模型中的表示层主要负责把应用层中应用程序的对象转换成对应的二进制串或者将二进串转换成我们应用程序中对象。而这两个转换的过程便被称作为序列化和反序列化，因此序列化和反序列属于通信协议的一部分。就一般而言，TCP/IP 模型中的应用层对应着 OSI 模型中的应用层、展示层、会话层， 因此序列化协议属于 TCP/IP 协议应用层的一部分。

+ 序列化和反序列化属于通信协议的一部分。
    + 序列化：将数据结构(C)或对象(java)转换成二进制串的过程。
    + 反序列化：将在序列化过程中所生成的二进制串转换成数据结构(C)或者对象(java)的过程。

### 二、序列化有什么特点 ###

序列化协议的实现有很多种，Java Serialization 只是众多实现方式中的一种。好的序列化实现方式需要从以下点去考虑：通用型、强壮性、可扩展性/兼容性以及安全性。

*  通用性  
    序列化是否支持跨平台、夸语言，学习成本是否足够低，以及流行度怎么样；流行度从侧面也反映该它对跨平台、跨语言的支持度，以及它社区活跃度等等。
 *  强健性  
    强壮性也被称为鲁棒性。一门好的技术，工具框架往往是经过长的时间去持续的优化、大而全的测试，慢慢被大众所接受。但是，为了支撑跨平台、跨语言或者是支持某一中特性去牺牲我们的强健性。
 *  可调试性/可读性  
    序列化和反序列化作用于对象和二进制间相互转化的过程。在转化的过程一旦出错，由于二进制数据的不可读性，那么就可能需要花费大量的时间去调试。因此实现方案有没有提供相应的文档、调试工具、平台作为支撑这也是在技术选型的过程需要考量的。
 *  性能  
    讨论性能就是讨论时间复杂度、空间复杂度。就 Java 而言，序列化将会在需要序列化的实例对象上加上类描述，数据上加上字段描述以用于反序列化。这样不仅增加了在网络传输的过程中带宽的开销，也增加了在持久化的过程中磁盘的开销。再有复杂的实现方式在序列化和反序列化都会增加相应的时间开销。
 *  可扩展性/兼容性  
    在当下的互联网时代，出陈推新，软件迭代非常快，应用程序中的业务实体对象字段的增减是否支持就服务，对以前经过序列化而持久化的数据在反序列化的过程是否兼容？
 *  安全性/访问限制  
    序列化会把业务数据完全存储到二进制流中，而且这个过程是可逆的、可见的，因此给安全带来了极大的挑战。

### 三、Java 序列化的代价 ###

降低了“改变这个类的实现”的灵活性

如果你的类实现了序列化，而且这个类得到了广泛的应用，就得持久支持此类的序列化形式。而倘若你的实现方式仅仅采用的是 Java 默认的实现方式，那么这种序列化形式将会永远束缚这个类最初的内部表示方法（功能代码等）。接受了这种默认的序列化形式，以后需要改变这个类的内部结构就有可能导致前后序列化形式的不兼容，使用新的版本进行反序列有可能导致失败。

每个可序列化的类都有一个都有一个唯一的标识号与其关联，也就是我们通常说的 serialVersionUID。如果可序列化的类没有显示的声明该常量，Java 虚拟机会自动根据这个类调用一个复杂的运算过程，从而在产生运行时的 serialVersionUID。这个自动生成的值将会受到类名、实现的接口名称、以及所有的公有方法和受保护的成员名称所影响。如果你通过任何方式改变了这些信息，兼容性都会遭到破坏，在运行时会导致 InvalidClassException 异常。

如果你没有显示的声明 serialVersionUID，就算类的信息没有发生改变，在跨 Java 虚拟机进行反序列化的时候也有可能失败。不同 Java 虚拟机序列化的实现方式上可能有所不同，这些细微的差别都有可能导致运行时生成的 serialVersionUID 不一致从而导致反序列化失败。

它增加了出现BUG和安全漏洞的可能性

序列化给我们的应用程序会带来一系列的安全问题。无论是接收了默认的序列化行为，还是实现自己的了序列化方法，反序列化就像提供了一个“隐藏的构造器”，它具备了和其他构造器相同的特点，这样就为攻击者留下了攻击的漏洞。最典型的就是 Struts 2.x 经常爆出反序列化的漏洞。

随着版本的迭代更新，相关的测试负担也增加

当一个可序列类被修订后，很重要的一点是，要检查是否可以“在新版本中序列化一个实例，然后在旧版本中是否可以被反序列化。旧版本中序列化的实例在新版本中是否仍可以做反序列化操作”。因此，测试所需要的工作量与“可序列化类的数量和发行的版本号”的乘积成正比。因此在最初编写一个可序列化类的时候就应该精心设计自定义的序列化形式，这样测试的要求便会降低。

### 四、Java 序列化应该知道几件事 ###

序列化ID问题 （serialVersionUID）

虽然两个类的功能代码完全一致，但是序列化 ID 不同，他们无法相互序列化和反序列化。Eclipse 提供了两种生成策略：一个是固定的 1L；一个是随机生成一个不重复的 long 类型数据（实际上是使用 JDK 工具 serialver 生成）。在没有特殊需求，采用默认的就好，这样可以确保代码一致时反序列化成功。

静态变量序列化

Java 序列化是不保存静态变量。Java 序列化的本质是为了存储、传输实例对象数据，序列化的是实例对象的成员变量，而静态变量、常量都属于类的成员。

父类的序列化与 Transient 关键字

一个子类实现了 Serializable 接口，它的父类都没有实现 Serializable 接口，序列化该子类对象，然后反序列化后输出父类定义的某变量的数值，该变量数值与序列化时的数值不同。

要想将父类对象也序列化，就需要让父类也实现Serializable 接口。如果父类不实现的话的，就 需要有默认的无参的构造函数。在父类没有实现 Serializable 接口时，虚拟机是不会序列化父对象的，而一个 Java 对象的构造必须先有父对象，才有子对象，反序列化也不例外。所以反序列化时，为了构造父对象，只能调用父类的无参构造函数作为默认的父对象。因此当我们取父对象的变量值时，它的值是调用父类无参构造函数后的值。如果你考虑到这种序列化的情况，在父类无参构造函数中对变量进行初始化，否则的话，父类变量值都是默认声明的值，如 int 型的默认是 0，string 型的默认是 null。

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

对敏感字段加密（模糊化数据）

我们的实体对象可能存在敏感数据，比如年龄、身份信息，银行卡号等等。由于在某一些业务场景会在网络中进行传输，也有可能持久化到日志文件、硬盘、数据库等，这时候便需要读该部分数据进行模糊化处理，甚至是加密签名等处理。这样这些信息只能通过反序列化才能进行有效的读取，一定程度保证序列化对象的数据安全。

使用序列化代理代替序列化实例

前面谈到实现 Serializable 接口，会增加出错和出现安全问题的可能性，因为他是跳出使用普通构造方法之外的机制来创建的实例对象，然可使用序列化代理模式会大大的降低此类的风险。

### 五、Java 序列化的简单应用（Java clone）      Java 序列化较为常见的就是用于深克隆，前提是需要克隆的对象实现了序列化。 ###

private static Serializable clone(Serializable object) throws IOException, ClassNotFoundException{
            //将对象写到流里  
             ByteArrayOutputStream bo =new ByteArrayOutputStream();  
             ObjectOutputStream oo=new ObjectOutputStream(bo);  
             oo.writeObject(object);  
             
             //从流里读出来  
             ByteArrayInputStream bi=new ByteArrayInputStream(bo.toByteArray());  
             ObjectInputStream oi=new ObjectInputStream(bi);
             
            return (Serializable) oi.readObject();  
        }

### Java 序列化基本实现 ###

在Java中，只要一个类实现了java.io.Serializable接口，那么它就可以被序列化。

Person.java

package me.knight.serialize.model;
    
    import java.io.Serializable;
    
    public class Person implements Serializable{
        /**
         * 
         */
        private static final long serialVersionUID = 1L;
        private String name;
        private Address addr;
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public Address getAddr() {
            return addr;
        }
        
        public void setAddr(Address addr) {
            this.addr = addr;
        }
    
        @Override
        public String toString() {
            return "Person [name=" + name + ", addr=" + addr + "]";
        }
    }

Address.java

package me.knight.serialize.model;
    
    import java.io.Serializable;
    
    
    public class Address implements  Serializable{
        
        /**
         * 
         */
        private static final long serialVersionUID = 1L;
        
        private String street;
    
        public String getStreet() {
            return street;
        }
    
        public void setStreet(String street) {
            this.street = street;
        }
    
        @Override
        public String toString() {
            return "Address [street=" + street + "]";
        }
        
    }

SerializeUtil.java

package me.knight.serialize;
    
    import java.io.File;
    import java.io.FileInputStream;
    import java.io.FileOutputStream;
    import java.io.IOException;
    import java.io.ObjectInputStream;
    import java.io.ObjectOutputStream;
    
    import me.knight.serialize.model.Address;
    import me.knight.serialize.model.Person;
    
    public class SerializeUtil {
        public static void main(String[] args) throws IOException,
                ClassNotFoundException {
            Person origin = getPerson();
            serialize(getPerson());
            
            Person clone = deserializePerson();
            
            System.out.println("p1 和 p2 是否是同一对象:" + (origin == clone));
            System.out.println("p1:" + origin);
            System.out.println("p2:" + clone);
            
            System.out.println("p1 和 p2 是否是同一对象:" + (origin.getAddr() == clone.getAddr()));
            System.out.println("p1 和 p2 的地址是否相同:" + origin.getAddr().toString().equals(clone.getAddr().toString()));
        }
    
        public static Person serialize(Person person) throws IOException {
            // ObjectOutputStream
            // 对象输出流，将Person对象存储到D盘的serialize_person文件中，完成对Person对象的序列化操作
            ObjectOutputStream oo = new ObjectOutputStream(new FileOutputStream(
                    new File("D:/serialize_person.txt")));
            oo.writeObject(person);
            System.out.println("Person对象序列化成功！");
            oo.close();
    
            return person;
        }
    
        private static Person deserializePerson() throws IOException,ClassNotFoundException {
            @SuppressWarnings("resource")
            ObjectInputStream ois = new ObjectInputStream(new FileInputStream(new File("D:/serialize_person.txt")));
        
            Person person = (Person) ois.readObject();
            System.out.println("Person对象反序列化成功！");
            return person;
        }
    
        private static Person getPerson() {
            Person person = new Person();
            person.setName("非典型程序员");
    
            Address addr = new Address();
            addr.setStreet("程序员胡同168号");
    
            person.setAddr(addr);
    
            return person;
        }
    }

输出结果

Person对象序列化成功！
    Person对象反序列化成功！
    p1 和 p2 是否是同一对象:false
    p1:Person [name=非典型程序员, addr=Address [street=程序员胡同168号]]
    p2:Person [name=非典型程序员, addr=Address [street=程序员胡同168号]]
    p1 和 p2 是否是同一对象:false
    p1 和 p2 的地址是否相同:true

本文转自：[https://www.jianshu.com/p/52b754c2175b][https_www.jianshu.com_p_52b754c2175b]

[https_www.jianshu.com_p_52b754c2175b]: https://www.jianshu.com/p/52b754c2175b