你不得不知道的对象的序列化和反序列化

对象的序列化和反序列化

序列化 (Serialization)将对象的状态信息转换为可以存储或传输的形式的过程。在序列化期间，对象将其当前状态写入到临时或持久性存储区。以后，可以通过从存储区中读取或反序列化对象的状态，重新创建该对象。

当你创建对象时，只要你需要，它就会一直存在，但是当程序终止的时候，那么这个对象也就随之消失了，尽管这么做是有意义的，但是仍旧存在某些的情况，如果对象能够在程序不运行的情况下仍能存在并且保存其信息，那将会是非常有用的。这样在下次运行程序的同事，该对象能够被重建并且拥有的信息与程序上次运行时它所拥有的信息相同。

简单来说序列化和反序列化如下

• 序列化：把对象转换为字节序列的过程称为对象的序列化
• 反序列化：把字节序列恢复为对象的过程称为对象的反序列化

而什么时候会用到序列化呢？一般在以下的情况中会使用到序列化

• 对象的持久化：把对象的字节序列永久地保存到硬盘上，通常存放在一个文件中

在很多应用中，需要对某些对象进行序列化，让它们离开内存空间，入住物理硬盘，以便长期保存。比如最常见的是Web服务器中的Session对象，当有 10万用户并发访问，就有可能出现10万个Session对象，内存可能吃不消，于是Web容器就会把一些seesion先序列化到硬盘中，等要用了，再把保存在硬盘中的对象还原到内存中。

• 远程调用：在网络上传送对象的字节序列

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

序列化的基本实现

只要对象实现了Serializable接口，对象的序列化就会变得十分简单。要序列化一个对象首先要创建某些OutputStream对象，然后将其封装在一个ObejctOutputStream对象内，这时只需要调用writeObject()即可将对象序列化，并将其发送给OutputStream。

对象序列化是基于字节的，所以要使用InputStream和OutputStream继承层次结构

如果要反向上面的过程(即将一个序列还原为一个对象)，需要将一个InputStream封装在ObjectInputStream内，然后调用readObject()，和往常一样，我们最后获得是一个引用，它指向了一个向上转型的Object，所以必须向下转型才能直接设置它们。

对象序列化不仅能够将实现了接口的那个类进行序列化，也能够将其引用的对象也实例化，以此类推。这种情况可以被称之为对象网。单个对象可与之建立连接。

下面我们举个例子可以看到在序列化和反序列过程中，对象网中的连接的对象信息都没有变。

public class TestSerializable {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        String fileName = "/Users/hupengfei/mytest.sql";
        Worm w = new Worm(6,'a');
        System.out.println("w:"+w);
        ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream(fileName));
        out.writeObject("Worm Storage\n");
        out.writeObject(w);
        out.close();
        ObjectInputStream in = new ObjectInputStream(new FileInputStream(fileName));
        String s = (String) in.readObject();
        Worm w2 = (Worm) in.readObject();
        System.out.println(s+"w2:"+w2);
    }
}

class Data implements Serializable{
    private Integer i ;
    public Data(Integer i ){
        this.i = i;
    }

    @Override
    public String toString() {
        return i.toString();
    }
}

class Worm implements Serializable{

    private static final long serialVersionUID = 8033549288339500180L;

    private static Random random = new Random(47);

    private Data [] d = {
            new Data(random.nextInt(10)),
            new Data(random.nextInt(10)),
            new Data(random.nextInt(10))
    };

    private Worm next;
    private char c;
    public Worm(int i ,char x){
        System.out.println("Worm Constructor:"+i);
        c = x;
        if (--i>0){
            next = new Worm(i,(char)(x+1));
        }
    }

    public Worm(){
        System.out.println("Default Constructor");
    }

    @Override
    public String toString() {
        StringBuffer result = new StringBuffer(":");
        result.append(c);
        result.append("(");
        for (Data data: d){
            result.append(data);
        }
        result.append(")");
        if (next!=null){
            result.append(next);
        }
        return result.toString();
    }
}

可以看到打印信息如下

Worm Constructor:6
Worm Constructor:5
Worm Constructor:4
Worm Constructor:3
Worm Constructor:2
Worm Constructor:1
w::a(853):b(119):c(802):d(788):e(199):f(881)
Worm Storage
w2::a(853):b(119):c(802):d(788):e(199):f(881)

在生成Data对象时是用随机数初始化的，从输出中可以看出，被还原后的对象确实包含了原对象中的所有链接。

上面我们举了个如何进行序列化的例子，其中或许看到了serialVersionUID这个字段，如果不加的话，那么系统会自动的生成一个，而如果修改了类的话，哪怕加一个空格那么这个serialVersionUID也会改变，那么在反序列化的时候就会报错，因为在反序列化的时候会将serialVersionUID和之前的serialVersionUID进行对比，只有相同的时候才会反序列化成功。所以还是建议显视的定义一个serialVersionUID。

transient(瞬时)关键字

当我们在对序列化进行控制的时候，可能需要某个字段不想让Java进行序列化机制进行保存其信息与恢复。如果一个对象的字段保存了我们不希望将其序列化的敏感信息（例如密码）。尽管我们使用private关键字但是如果经过序列化，那么在进行反序列化的时候也是能将信息给恢复过来的。我们举个例子如下：

我们定义个Student类

class Student implements Serializable{
    private static final long serialVersionUID = 1734284264262085307L;
    private String password;
------get set 方法
}

然后将其序列化到文件中然后再从文件中反序列化

public static void main(String[] args) throws IOException, ClassNotFoundException {
    String fileName="/Users/hupengfei/mytest.sql";
    Student student = new Student();
    student.setPassword("123456");
    ObjectOutputStream objectOutputStream = new ObjectOutputStream(new FileOutputStream(fileName));
    objectOutputStream.writeObject(student);
    ObjectInputStream objectInputStream = new ObjectInputStream(new FileInputStream(fileName));
    Student readStudent = (Student) objectInputStream.readObject();
    System.out.println(readStudent.getPassword());
}

然后发现输出为

readStudent的password=123456

此时我们如果想password参数在序列化的时候存储其值，那么可以加上transient关键字，就像下面一样

private transient String password;

然后输出如下

readStudent的password=null

发现在序列化的时候参数就已经没被保存进去了

参考文章

• Java编程思想
• https://www.cnblogs.com/xdp-gacl/p/3777987.html
• https://blog.csdn.net/zyhlwzy/article/details/79868138