@adamhand 2019-01-21T21:24:23.000000Z 字数 15455 阅读 989

序列化

概念

内存中的数据对象只有转化为二进制流才能进行数据持久化和网络传输。将数据对象转化为二进制流的过程称为序列化。反之，将二进制流恢复为数据对象的过程称为反序列化。

序列化的常用场景如下：

把的内存中的对象状态保存到一个文件中或者数据库中；
用套接字在网络上传送对象；
通过RMI或RPC传输对象；

实现序列化的方法

实现Serializable接口

大致步骤如下：

需要序列化的对象实现Serializable接口；
生成serialVersionUID（IDEA中可以自动生成，具体方法百度）；
使用ObjectOutputStream将对象序列化到磁盘或字符数组；使用ObjcetInputStream将对象进行反序列化（还可以使用commons-lang3工具包里面的类实现对象的序列化及反序列化，需要用到commons-lang.jar）；

实例如下：

import java.io.Serializable;
public class User implements Serializable {
    private static final long serialVersionUID = 7090848137142510895L;
    private String name;
    private String gender;
    public User(String name, String gender) {
        this.name = name;
        this.gender = gender;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getGender() {
        return gender;
    }
    public void setGender(String gender) {
        this.gender = gender;
    }
    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", gender='" + gender + '\'' +
                '}';
    }
}

public class Main {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
//使用ObjectOutputStream和ObjectInputStream
//        User user = new User("Bob", "male");
////
////        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(new File("object.txt")));
////        oos.writeObject(user);
////        oos.close();
////        System.out.println(user);
////
////        ObjectInputStream ois = new ObjectInputStream(new FileInputStream(new File("object.txt")));
////        User person = (User)ois.readObject();
////
////        System.out.println(person);
        //使用工具包
        User user = new User("Bob", "male");
        byte[] bytes = SerializationUtils.serialize(user);
        User person = SerializationUtils.deserialize(bytes);
        System.out.println(person);
    }
}

实现Externalizable接口

Externalizable继承了Serializable，该接口中定义了两个抽象方法：writeExternal()与readExternal()。当使用Externalizable接口来进行序列化与反序列化的时候需要开发人员重写writeExternal()与readExternal()方法。如果在这两个重写的方法中什么都不干，序列化的属性值为默认值（String类型为null,int类型为0）；

另外，在使用Externalizable进行序列化的时候，在读取对象时，会调用被序列化类的无参构造器去创建一个新的对象，然后再将被保存对象的字段的值分别填充到新对象中。所以，实现Externalizable接口的类必须要提供一个public的无参的构造器。

示例如下：

public class User implements Externalizable {
    private static final long serialVersionUID = 2119162474847154958L;
    private String name;
    private String gender;
    public User() {
    }
    public User(String name, String gender) {
        this.name = name;
        this.gender = gender;
    }
    @Override
    public void writeExternal(ObjectOutput out) throws IOException {
        out.writeObject(name);
        out.writeObject(gender);
    }
    @Override
    public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
        name = (String) in.readObject();
        gender = (String) in.readObject();
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getGender() {
        return gender;
    }
    public void setGender(String gender) {
        this.gender = gender;
    }
    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", gender='" + gender + '\'' +
                '}';
    }
}

public class Main {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        User user = new User("Bob", "male");
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(new File("Object1.txt")));
        oos.writeObject(user);
        oos.close();
        System.out.println(user);
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream(new File("Object1.txt")));
        User person =  (User)ois.readObject();
        System.out.println(person);
    }
}

Hessian序列化

Hessian序列化是一种支持动态类型、跨语言、基于对象传输的网络协议。Java对象序列化第二进制流可以被其他语言（如C++、Python）反序列化。Hessian具有如下特点：

自描述序列化类型。不依赖外部描述文件或接口定义，用一个字节标识常用基础类型，极大缩短二进制流。
语言无关，支持脚本语言。
协议简单，比Java原生序列化高效。

相比Hessian1.0，Hessian2.0增加了压缩编码，其序列化二进制流大小是Java序列化的50%，序列化耗时是Java序列化的30%，反序列化耗时是Java反序列化耗时的20%。

Hessian会把复杂对象所有属性存储在一个Map中进行序列化。所以在父类、子类存在同名成员变量的情况下，Hessian序列化时，先序列化子类，然后序列化父类，因此反序列化结果会导致子类同名成员变量会被父类的值覆盖。

实例如下(过程和Java原生序列化基本相同，需要导入hessian.jar包)：

public class User implements Serializable {
    private static final long serialVersionUID = 1L;
    private String name;
    private String gender;
    public User(String name, String gender) {
        this.name = name;
        this.gender = gender;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getGender() {
        return gender;
    }
    public void setGender(String gender) {
        this.gender = gender;
    }
    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", gender='" + gender + '\'' +
                '}';
    }
}

public class Main {
    public static void main(String[] args) {
        User user = new User("Bob", "male");
        System.out.println(user);
        byte[] bytes = serialize(user);
        User person = deserialize(bytes);
        System.out.println(person);
    }
    public static byte[] serialize(User user){
        ByteArrayOutputStream baos = null;
        HessianOutput ho = null;
        try {
            baos = new ByteArrayOutputStream();
            ho = new HessianOutput(baos);
            ho.writeObject(user);
            return baos.toByteArray();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return null;
    }
    public static User deserialize(byte[] bytes){
        ByteArrayInputStream bais = null;
        HessianInput hi = null;
        try {
            bais = new ByteArrayInputStream(bytes);
            hi = new HessianInput(bais);
            return (User) hi.readObject();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return null;
    }
}

打印结果如下：

User{name='Bob', gender='male'}
User{name='Bob', gender='male'}

JSON

JSON（JavaScript Object Notation，JavaScript对象表示法），是一种轻量级的数据交换格式，是JavaScript的严格子集。JSON序列化就是将数据对象转化为JSON字符串。在序列化过程中抛弃了类型信息，所以反序列化时只有提供类型信息才能准确地反序列化。JSON可读性好，性能也不错。

示例如下（使用的是阿里巴巴的fastjson，需要导入fastjson.jar；另外，需要被序列化的对象中必须有无参构造函数）：

public class Main {
    public static void main(String[] args) {
        User user = new User("Bob", "male");
        System.out.println(user);
        byte[] bytes = serialize(user);
        User person = deserialize(bytes);
        System.out.println(person);
    }
    public static byte[] serialize(User user){
        ByteArrayOutputStream baos = null;
        HessianOutput ho = null;
        try {
            baos = new ByteArrayOutputStream();
            ho = new HessianOutput(baos);
            ho.writeObject(user);
            return baos.toByteArray();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return null;
    }
    public static User deserialize(byte[] bytes){
        ByteArrayInputStream bais = null;
        HessianInput hi = null;
        try {
            bais = new ByteArrayInputStream(bytes);
            hi = new HessianInput(bais);
            return (User) hi.readObject();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return null;
    }
}

输出结果为：

User{name='Bob', gender='male'}
User{name='Bob', gender='male'}

Protobuf

protocol buffer（简称protobuf）是google开发的开源的序列化方案，它的好处很多，独立于语言，独立于平台，最最重要的是它的效率相当高，用protobuf序列化后的大小是json的10分之一，xml格式的20分之一，是二进制序列化的10分之一。

protobuf使用起来非常简单，它的主要流程是：写一个.proto文件用来描述序列化的格式，然后用protobuf提供的protoc工具将.proto文件编译成一个Java文件。

要使用protouf，首先选需要到官网下载protobuf的相应版本。这里选用3.3.0。

将下载好的zip解压，能看到bin目录下有一个protoc.exe的文件，等下需要用它来编译文件。直接在bin目录下创建一个User.proto的描述文件，内容如下：

syntax = "proto3";
option java_package = "java.com";
option java_outer_classname = "UserProto";
message User{
    string name = 1;
    string gender = 2;
    int32 age = 3;
    Address addr = 4;
}
message Address{
    string country = 1;
    string city = 2;
}

syntax = "proto3"; 使用proto3版协议
option java_package = "SerializeDemo.ProtoBufDemo.ProtoBuf"; 编译之后生成的Java文件的包名。这里我打算将生成的Java文件放到SerializeDemo.ProtoBufDemo.ProtoBuf目录下。
option java_outer_classname = "UserProto"; 编译之后生成的Java类的类名
message 相当于Java中的class

进入bin目录，使用如下指令生成.java文件。

protoc --java_out=./ ./User.proto

第一个./表示生成的.java文件存放在当前目录下。第二个./表示.proto文件存放的地址。

然后，将生成的UserProto.java文件放入工程目录中，并引入maven依赖：

<dependency>
    <groupId>com.google.protobuf</groupId>
    <artifactId>protobuf-java</artifactId>
    <version>3.3.0</version>
</dependency>

接下来编写测试代码，使用Socket来传输User对象。

Server端：

public class ProtoBufServer {
    public static void main(String[] args) throws IOException {
        ServerSocket serverSocket = new ServerSocket(8080);
        while (true){
            Socket socket = serverSocket.accept();
            byte[] data = new byte[1024];
            socket.getInputStream().read(data);
            int dataBodyLen = data[0];
            System.out.println("data body length: "+ dataBodyLen);
            byte[] dataBody = new byte[dataBodyLen];
            System.arraycopy(data, 1, dataBody, 0, dataBodyLen);
            UserProto.User user = UserProto.User.parseFrom(dataBody);
            System.out.println("received : ");
            System.out.println(user.getName()+" "+user.getGender()+" "+user.getAge()+ " "+user.getAddr());
        }
    }
}

Client端：

public class ProtoBufClient {
    public static void main(String[] args) throws IOException {
        Socket socket = new Socket("127.0.0.1", 8080);
        UserProto.User.Builder user = UserProto.User.newBuilder();
        UserProto.Address.Builder address = UserProto.Address.newBuilder();
        address.setCountry("China").setCity("hangzhou");
        user.setName("张三").setGender("male").setAge(21).setAddr(address);
        byte[] messageBody = user.build().toByteArray();
        int headLen = 1;
        byte[] message = new byte[headLen + messageBody.length];
        message[0] = (byte)messageBody.length;
        System.arraycopy(messageBody, 0, message, 1, messageBody.length);
        System.out.println("message length: "+ message.length);
        socket.getOutputStream().write(message);
    }
}

依次启动server端和client端，打印结果如下：

server端：

data body length: 35
received : 
张三 male 21 country: "China"
city: "hangzhou"

client端：

message length: 36

Protostuff

protostuff是一个基于protobuf实现的序列化方法，它较于protobuf最明显的好处是，在几乎不损耗性能的情况下做到了不用我们写.proto文件来实现序列化。

示例如下（需要protostuff-api.jar、protostuff-collectionschema.jar、protostuff-core.jar和protostuff-runtime.jar）：

public class Main {
    public static void main(String[] args) {
        User user = new User("Bob", "male");
        System.out.println(user);
        byte[] bytes = serializer(user);
        User person = deserializer(bytes, User.class);
        System.out.println(person);
    }
    public static byte[] serializer(User user){
        RuntimeSchema<User> poSchema = RuntimeSchema.createFrom(User.class);
        return ProtostuffIOUtil.toByteArray(user, poSchema, LinkedBuffer.allocate(LinkedBuffer.DEFAULT_BUFFER_SIZE));
    }
    public static User deserializer(byte []bytes,Class<User> c) {
        User user = null;
        try {
            user = c.newInstance();
            Schema schema = RuntimeSchema.getSchema(user.getClass());
            ProtostuffIOUtil.mergeFrom(bytes,user,schema);
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
        return user;
    }
}

打印结果如下：

User{name='Bob', gender='male'}
User{name='Bob', gender='male'}

kryo

kryo，是一个快速序列化/反序列化工具，效率比java高出一个级别，序列化出来的结果，是其自定义的、独有的一种格式，体积更小，一般只用来进行序列化和反序列化，而不用于在多个系统、甚至多种语言间进行数据交换（目前 kryo 也只有 java 实现），目前已经有多家大公司使用，相对比较稳定。

由于kryo不是线程安全的，针对多线程情况下的使用，要对kryo进行一个简单的封装设计，从而可以多线程安全的使用序列化和反序列化

示例如下（）:

未完，待续。示例程序编译有问题。

fst

fst是完全兼容JDK序列化协议的系列化框架，序列化速度大概是JDK的4-10倍，大小是JDK大小的1/3左右。

示例如下（需要fst.jar包）:

未完，待续。示例程序编译有问题。

需要注意的问题

serialVersionUID

在实现Serializable 接口的时候，一定要给 serialVersionUID 赋值，这标志着这对象的唯一身份，如果序列化和反序列化时的serialVersionUID不通过，反序列化就会失败；同时，如果不给serialVersionUID显示赋值，每次运行时，编译器都会生成一个serialVersionUID，如果类的源码有修改，那么重新编译之后serialVersionUID的取值可能会发生变化。

同时，如果没有特殊需求，就是用默认的 1L 就可以，这样可以确保代码一致时反序列化成功。那么随机生成的序列化 ID 有什么作用呢，有些时候，通过改变序列化 ID 可以用来限制某些用户的使用。

静态对象序列化的问题

序列化时，并不保存静态变量，这其实比较容易理解，序列化保存的是对象的状态，静态变量属于类的状态，因此 序列化并不保存静态变量。

示例如下：

public class Test implements Serializable {
    private static final long serialVersionUID = 1L;
    public static int staticVar = 5;
    public static void main(String[] args) {
        try {
            //初始时staticVar为5
            ObjectOutputStream out = new ObjectOutputStream(
                    new FileOutputStream("result.obj"));
            out.writeObject(new Test());
            out.close();
            //序列化后修改为10
            Test.staticVar = 10;
            ObjectInputStream oin = new ObjectInputStream(new FileInputStream(
                    "result.obj"));
            Test t = (Test) oin.readObject();
            oin.close();
            //再读取，通过t.staticVar打印新的值
            System.out.println(t.staticVar);
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

打印结果是10。原因就是静态变量不会被序列化，打印的值是新赋的值。

父类的序列化

一个子类实现了 Serializable 接口，它的父类都没有实现 Serializable 接口，序列化该子类对象，然后反序列化后输出父类定义的某变量的数值，该变量数值与序列化时的数值不同。这是因为，如果父类没有继承Serializable接口，那么父类不会被序列化。

示例如下：

public class Human {
    protected String height;
    protected String weight;
    public Human() {
    }
    public Human(String height, String weight) {
        this.height = height;
        this.weight = weight;
    }
    public String getHeight() {
        return height;
    }
    public void setHeight(String height) {
        this.height = height;
    }
    public String getWeight() {
        return weight;
    }
    public void setWeight(String weight) {
        this.weight = weight;
    }
    @Override
    public String toString() {
        return "Human{" +
                "height='" + height + '\'' +
                ", weight='" + weight + '\'' +
                '}';
    }
}

public class Person extends Human implements Serializable {
    private String name;
    private String gender;
    public Person(String height, String weight, String name, String gender) {
        super(height, weight);
        this.name = name;
        this.gender = gender;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getGender() {
        return gender;
    }
    public void setGender(String gender) {
        this.gender = gender;
    }
    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", gender='" + gender + '\'' +
                '}';
    }
    public String humanToString(){
        return super.toString();
    }
}

public class Main {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        Person p = new Person("180", "60", "Bob", "male");
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(new File("Object3.txt")));
        oos.writeObject(p);
        oos.close();
        System.out.println(p.humanToString());
        System.out.println(p);
        System.out.println();
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream(new File("Object3.txt")));
        Person p1 = (Person) ois.readObject();
        ois.close();
        System.out.println(p1.humanToString());
        System.out.println(p1);
    }
}

打印结果为：

Human{height='180', weight='60'}
Person{name='Bob', gender='male'}
Human{height='null', weight='null'}
Person{name='Bob', gender='male'}

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

transient关键字

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

序列化原理

序列化的步骤如下：

输出序列化的头部信息，包括标识序列化协议的幻数以及协议的版本；
按照由子类到父类的顺序，递归的输出类的描述信息，直到不再有父类为止；类描述信息按照类元数据，类属性信息的顺序写入序列化流中；
按照由父类到子类的顺序，递归的输出对象域的实际数据值；而对象的属性信息是按照基本数据类型到java对象类型的顺序写入序列化流中；其中java对象类型的属性会从步骤(1)重新开始递归的输出，直到不再存在java对象类型的属性。

序列化漏洞

序列化通常会通过网络传输对象，而对象中往往有敏感数据，所以序列化往往会成为黑客攻击点。为了防范这种攻击，一种方式是使用transient关键字对敏感数据进行修饰，避免使敏感数据转化成二进制流，另一种方法是使用对称加密或非对称加密的方法对敏感数据进行加密。

在序列化过程中，虚拟机会试图调用对象类里的 writeObject 和 readObject 方法，进行用户自定义的序列化和反序列化，如果没有这样的方法，则默认调用是 ObjectOutputStream 的 defaultWriteObject 方法以及 ObjectInputStream 的 defaultReadObject 方法。用户自定义的 writeObject 和 readObject 方法可以允许用户控制序列化的过程，比如可以在序列化的过程中动态改变序列化的数值。基于这个原理，可以在实际应用中得到使用，用于敏感字段的加密工作，清单 3 展示了这个过程。

模拟程序如下：

public class Encryption implements Serializable {
    private static final long serialVersionUID = 1L;
    private String password = "pass";
    public String getPassword() {
        return password;
    }
    public void setPassword(String password) {
        this.password = password;
    }
    private void writeObject(ObjectOutputStream out) {
        try {
            ObjectOutputStream.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 {
            ObjectInputStream.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();
        }
    }
    public static void main(String[] args) {
        try {
            ObjectOutputStream out = new ObjectOutputStream(
                    new FileOutputStream("result.obj"));
            out.writeObject(new Encryption());
            out.close();
            ObjectInputStream oin = new ObjectInputStream(new FileInputStream(
                    "result.obj"));
            Encryption t = (Encryption) oin.readObject();
            System.out.println("解密后的字符串:" + t.getPassword());
            oin.close();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

结果如下：

原密码:pass
加密后的密码encryption
要解密的字符串:encryption
解密后的字符串:pass

序列化在Java中的应用

ArrayList中运用了序列化的知识，具体可以参见另一篇笔记——《Java集合》。

总结

序列化对象必须实现序列化接口。
序列化对象里面的属性是对象的话也要实现序列化接口。
类的对象序列化后，类的序列化ID不能轻易修改，不然反序列化会失败。
类的对象序列化后，类的属性有增加或者删除不会影响序列化，只是值会丢失。
如果父类序列化了，子类会继承父类的序列化，子类无需添加序列化接口。
如果父类没有序列化，子类序列化了，子类中的属性能正常序列化，但父类的属性会丢失，不能序列化。
用Java序列化的二进制字节数据只能由Java反序列化，不能被其他语言反序列化。如果要进行前后端或者不同语言之间的交互一般需要将对象转变成Json/Xml通用格式的数据，再恢复原来的对象。
声明为static和transient类型的成员数据不能被序列化。因为static代表类的状态，transient代表对象的临时数据。

参考

Java 之 Serializable序列化和反序列化的概念,作用的通俗易懂的解释
 深入分析Java的序列化与反序列化
 http://www.importnew.com/17964.html
关于Java序列化你应该知道的一切
 Java 序列化的高级认识
 序列化和反序列化的底层实现原理是什么？
关于Java序列化你应该知道的一切
 常被问到的十个 Java 面试题
 java序列化及项目中常用的序列化工具比较
 Hessian实现序列化、反序列化、案例
 简单的使用protobuf和protostuff
Google Protocol Buffer 的使用和原理
 高性能的序列化与反序列化：kryo的简单使用
 Java序列化的原理
 Java中序列化实现原理研究
 Java序列化机制原理
 简单的使用protobuf和protostuff

序列化

概念

实现序列化的方法

实现Serializable接口

实现Externalizable接口

Hessian序列化

JSON

Protobuf

Protostuff

kryo

未完，待续。示例程序编译有问题。

fst

未完，待续。示例程序编译有问题。

需要注意的问题

serialVersionUID

静态对象序列化的问题

父类的序列化

transient关键字

序列化原理

序列化漏洞

序列化在Java中的应用

总结

参考

内容目录