java 序列化机制和自定义序列化

序列化是将对象保存在磁盘中，或允许在网络中直接传输对象。对象序列化机制允许把内存中的java对象转成与平台无关的二进制流，从而将这种二进制文件持久的保存在磁盘上。其他程序一旦获得了这种二进制的流。就可以将这个二进制流恢复成原来的java对象

---

对象的序列化：指将一个java对象写入到IO流中，与此对应的是，对象的反序列化则是从IO流中恢复该对象.

如果要将某个对象保存到磁盘上或者通过网络传输，那么这个类应该实现Serializable接口或者Externalizable接口之一。

使用Serializable来实现序列化非常简单，主要让目标类实现Serializable标记接口即可，无需实现任何方法。

---

一旦某个类实现了Serializable接口，该类的对象就是可以序列化的.

package cn.lvkang.com.gradletest;

import java.io.BufferedWriter;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.OutputStreamWriter;
import java.io.Serializable;

public class SerTest implements Serializable {

    private int age = 25;
    private String name ="张三";

    private SerTest() {
        System.out.println(this.age+"-----------"+this.name);
    }

    public static void main(String[] args) {
        
        //对对象进行序列号
        try {
            ObjectOutputStream fos = new ObjectOutputStream(new FileOutputStream("object.txt"));
            SerTest ser = new SerTest();
            fos.writeObject(ser);

        } catch (Exception e) {
            e.printStackTrace();
        }

        //从文件中读取该对象，成为反序列化
        try {
            ObjectInputStream ois = new ObjectInputStream(new FileInputStream("object.txt"));
             SerTest serTest = (SerTest) ois.readObject();
            System.out.println(serTest.age);
            System.out.println(serTest.name);

        } catch (Exception e) {
            e.printStackTrace();
        }
    }

}

必须指出的是反序列化 的仅仅是java对象的数据，而不是java类，因此采用的反序列化恢复java对象时，必须提供该Java对象所属类的class文件，否则会引发ClassNotFoundException异常

还有一点，SerTest只有一个构造器，而且构造器中只有一个打印语句。而在反序列化时，并没有看到程序调用该构造器，这表明反序列化机制无需通过构造器来初始化java对象。

---

对象引用的序列化

如果某个类的成员变量不是基本类型或者String类型，而是一个引用类型，那么这个引用的类必须是可序列化的，否则拥有该引用变量的类也是不可序列化的.

如下：

class Person implements Serializable {
    String name;
    SerTest test;

    public Person(String name, SerTest test) {
        this.name = name;
        this.test = test;
    }
}

Person 持有SerTest的引用，只有SerTest是可序列化的，Person才可以被序列化，

假设有如下情景：

        SerTest test = new SerTest();
        Person p1 = new Person("张三",test);
        Person p2 = new Person("李四",test);

这里产生了一个问题，在序列化p1的时候，系统会将p1对象所引用的test对象一起序列化，如果程序在序列化p2的时候，系统一样会序列p2，并且序列化test。从而引起p1和p2使用的不是同一个对象，显然这个就违背了java序列化的初衷。所以java采用了一种特殊的算法。算法内容如下：

• 所有保存在磁盘中的对象都有一个序列化的编号。
• 当程序视图序列化一个对象时，程序将先简称该对象是否被序列化过，只有该对象从未被序列化过，系统才会将对象转换成字节序列并输出
• 如果这个对象已经被序列化过，程序将只是输出一个序列化编号，而不是重新序列化该对象。

根据上面的算法，可以知道 在程序在序列化p2的时候，发现test已经被序列化过了，所以程序不会对test进行序列化，3而是输出一个序列化编号。

---

自定义序列化：

在一些特殊的情况下，如果一个类中包含某种特殊的信息，如银行账户信息时，这是不希望将该实例变量值进行序列化，或者这个类的某个变量是不可被序列化的，因此不希望对该实例遍历进行递归序列化。

当某个对象进行序列化时，系统会自动把该对象的所有实例变量依次进行序列化，如果这个类的实例变量引用到其他类的对象，则被引用的对象也会被序列化，如果被引用的对象的实例变量也引用了其他类，在被引用的对象也会被实例化，这种情况称之为递归序列化。

通过在实例变量前面使用 transient关键字修饰， 可以指定java序列化时无需理会该实例变量.如下所示

public class SerTest implements Serializable {

    private transient int age = 25;
    private String name ="张三";

    private SerTest() {
        System.out.println(this.age+"-----------"+this.name);
    }

    public static void main(String[] args) {

        //对对象进行序列号
       try {
            ObjectOutputStream fos = new ObjectOutputStream(new FileOutputStream("object.txt"));
            SerTest ser = new SerTest();
            fos.writeObject(ser);

        } catch (Exception e) {
            e.printStackTrace();
        }

        //从文件中读取该对象，成为反序列化
        try {
            ObjectInputStream ois = new ObjectInputStream(new FileInputStream("object.txt"));
             SerTest serTest = (SerTest) ois.readObject();
            System.out.println(serTest.age);
            System.out.println(serTest.name);

        } catch (Exception e) {
            e.printStackTrace();
        }
    }

}

添加了transient 之后，该类的age属性将不会被序列化,同样的在进行反序列化的时候age是没有值的也就是为0。

对敏感的字段进行加密:

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

public class SerTest implements Serializable {

    private static ObjectOutputStream fos;
    private static ObjectInputStream ois;
    //敏感字段 年龄和 姓名
    private  int age = 28;
    private String name = "张三";

    private SerTest() {

    }

    //对象在序列化的时候调用
    private void writeObject(ObjectOutputStream fos) throws IOException {
        System.out.println("--------------加密中--------------");
        System.out.println("原来的姓名："+this.name);
        System.out.println("原来的年龄："+this.age);
        StringBuffer buffer = new StringBuffer(this.name);
        //对姓名进行反转
        fos.writeObject(buffer.reverse());
        //对年龄进行加密
        fos.writeInt(this.age*10*(5-2));
    }


    //对象在反序列化的时候调用
    private void readObject(ObjectInputStream ois) throws IOException, ClassNotFoundException {
        System.out.println("--------------加密后--------------");
        StringBuffer buffer = (StringBuffer) ois.readObject();
        this.name = buffer.toString();
        System.out.println("加密后的姓名："+this.name);
        this.age = ois.readInt();
        System.out.println("加密后的年龄："+this.age);
    }

    public static void main(String[] args) {
        try {
            SerTest test = new SerTest();
            fos = new ObjectOutputStream(new FileOutputStream("obj.obj"));
            fos.writeObject(test);//进行序列化
            fos.close();

            
            ois = new ObjectInputStream(new FileInputStream("obj.obj"));
            //进行反序列化，并且进行敏感字段的解密
            SerTest t = (SerTest) ois.readObject();

            System.out.println("---------------解密中-------------------");
            StringBuffer buffer = new StringBuffer(t.name);
            System.out.println("解密后的姓名："+buffer.reverse().toString());
            System.out.println("解密后的年龄："+(t.age/10/(5-2)));
            ois.close();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }

    }

}

在程序中使用了自定义序列化，在序列化的时候ObjectOutputStream /ObjectInputStream 会根据你传入的对象进行反射。判断你是否写了writeObject/readObject 方法。如果写了，就会调用你写的，否则就会调用默认的方法.

在序列化的时候对对象里面的数据进行了加密，然后取出来的时候又进行了解密。这就是对象的自定义序列化

---

静态变量序列化：

序列化保存的是对象的状态，而不是类的状态。静态变量属于类的状态，所以序列化的时候不会保存静态常量。

---

writeReplace 方法：

还有一种更彻底的自定义机制，他甚至可以自序列化的时候将该对象转为其他的对象。writeReplace将由序列化机制调用，只有该方法存在，就会被调用。如下所示：

public class SerTest implements Serializable {

    private static ObjectOutputStream fos;
    private static ObjectInputStream ois;
    //敏感字段 年龄和 姓名
    private  int age = 28;
    private String name = "张三";

    private SerTest() {
    }


    private Object writeReplace() throws ObjectStreamException {
        System.out.println("序列化中..............");
        ArrayList