序列化和反序列化

序列化：对象 ---> 字节序列

 

反序列化：  字节序列 ---> 对象

一、什么是序列化和反序列化

    当两个进程远程通信时，彼此可以发送各种类型的数据。 无论是何种类型的数据，都会以二进制序列的形式在网络上传送。比如，我们可以通过http协议发送字符串信息;我们也可以在网络上直接发送Java对象。发送方需要把这个Java对象转换为字节序列，才能在网络上传送;接收方则需要把字节序列再恢复为Java对象才能正常读取。

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

      对象序列化的作用有如下两种：

      1. 持久化： 把对象的字节序列永久地保存到硬盘上，通常存放在一个文件中，比如：休眠的实现。以后服务器session管理，hibernate将对象持久化实现。

      2. 网络通信：在网络上传送对象的字节序列。比如：服务器之间的数据通信、对象传递。

 

二、序列化涉及的类和接口

/**
 * 只有实现了Serializable接口的类才能被实例化
 */
package com.hpu.dayo9;

import java.io.*;

public class TestSerializable {
    public static void main(String[] args) throws FileNotFoundException {
        FileOutputStream fos = null;
        ObjectOutputStream oos = null;
        ObjectInputStream ois = null;
        FileInputStream fis = null;
        try{
            //通过ObjectOutputStream将Person对象的数据写入到文件中，
            //即序列化
            Person person = new Person("小明",10000.0);

            //序列化
            fos = new FileOutputStream("Serializable.txt");//字节输出流
            oos = new ObjectOutputStream(fos);//对象输出流
            //写出的内容人是给机器看的,人看不懂
            oos.writeObject(person);
            oos.flush();

            //反序列化
            fis = new FileInputStream("Serializable.txt");
            ois = new ObjectInputStream(fis);
            Person p = (Person) ois.readObject();
            System.out.println(p);
            
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            try{
                if (oos != null) {
                    oos.close();
                }
            }catch (IOException e){
                e.printStackTrace();
            }
            try{
                if (fos != null) {
                    fos.close();
                }
            }catch (IOException e){
                e.printStackTrace();
            }
            try{
                if (ois != null) {
                    ois.close();
                }
            }catch (IOException e){
                e.printStackTrace();
            }
            try{
                if (fis != null) {
                    fis.close();
                }
            }catch (IOException e){
                e.printStackTrace();
            }
        }
    }
}

class Person implements java.io.Serializable {

    //添加序列化ID,它决定着是否能够被实例化
    private static final long serialVersionUID = 1L;
    private String name;
    private Double salary;


    public Person() {
    }

    public Person(String name, Double salary) {
        this.name = name;
        this.salary = salary;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Double getSalary() {
        return salary;
    }

    public void setSalary(Double salary) {
        this.salary = salary;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", salary=" + salary +
                '}';
    }
}

序列化执行结果为：

序列化后的字节序列是一堆看不懂的符号

反序列化的执行结果为：

 

注意

      1. static属性不参与序列化。

      2. 对象中的某些属性如果不想被序列化，不能使用static，而是使用transient修饰。

      3. 为了防止读和写的序列化ID不一致，一般指定一个固定的序列化ID。