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

对象的序列化和反序列化

序列化 (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编程思想
• www.cnblogs.com/xdp-gacl/p/…
• blog.csdn.net/zyhlwzy/art…