java序列化机制（一）

序列化的目的

Serialization（序列化）是一种将对象以一连串的字节描述的过程；反序列化deserialization是一种将这些字节重建成一个对象的过程。

一般用于将对象保存在磁盘中或者跨进程通信（网络通信）。

序列化API

java.io.ObjectOutputStream和ObjectInputStream用于对象I/O。

要被序列化的对象必须实现Serializable或者Externalizeable接口。

实现Serializeable接口时不会序列化静态成员变量，使用transient关键字修饰的变量。

示例

javaBean

class Customer implements Serializable {

    private static final long serialVersionUID = 1L;

    private String name;
    private int age;
    private static int ID = 1000; // 不会被序列化
    private transient String fullName; // 不会被序列化

    public String getName() {
        return name;
    }

    public Customer(String name, int age, String fullName) {
        super();
        this.name = name;
        this.age = age;
        this.fullName = fullName;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public void updateID() {
        ID++;
    }

    public String getFullName() {
        return fullName;
    }

    public void setFullName(String fullName) {
        this.fullName = fullName;
    }

    @Override
    public String toString() {
        return "Customer [name=" + name + ", age=" + age 
                + ", fullName=" + fullName + " ID= " + ID + "]";
    }


}

序列化操作

public class Main {
    public static void main(String[] args) {
        FileOutputStream os = null;
        ObjectOutputStream oos = null;
        FileInputStream fis = null;
        ObjectInputStream ois = null;
        try {
            // 写入对象
            os = new FileOutputStream("./customer.obj");
            oos = new ObjectOutputStream(os);
            Customer c = new Customer("name_xx", 20, "full_name_xxx");
            c.updateID();
            oos.writeObject(c);
            // 读出对象
            fis = new FileInputStream("./customer.obj");
            ois = new ObjectInputStream(fis);
            Customer oc = (Customer) ois.readObject();
            System.out.println(oc);
            // 判断是否是同一对象
            System.out.println("c == oc: "+(c == oc));
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } finally {
            try {
                ois.close();
                fis.close();
                oos.close();
                os.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

}

输出结果

Customer [name=name_xx, age=20, fullName=null ID= 1001]
c == oc: false

结果表示通过序列化可以将对象存入本地或通过网络发送出去，通过反序列化将对象重新生成(静态字段和transient字段不会被序列化)，注意此时俩个对象不是同一个。

反序列化后知识状态和以前一致，即各个属性的值一样。但并不是同一个对象。
就像是对任意一个简单的对象进行序列化，再反序列化得到的对象也和之前的对象不是同一个。