什么是Java对象序列化

1、含义

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

2、条件

　　若需要让某个对象支持序列化机制，则必须让它的类可序列化。必须实现如下两接口之一
　　1）、Seriallizable(常用)
　　2）、Externalizable
　　
　　建议：程序创建每个JavaBean类都实现Serializable。

3、作用

　　把内存中的Java对象转换成平台无关的二进制流，从而允许把这种二进制流持久地保存在磁盘上，有网络时就可以将二进制流传输到另一个网络节点

4、使用

　　废话少说，下面我们来看看怎么使用序列化

　　1）、使用对象流实现序列化
　　　使用Serializable来实现序列化非常简单，主要让目标类实现Serializable标记接口即可，无须实现任何方法。程序可通过如下两步骤序列化一个对象：

//（1）、创建个输出流
ObjectOutputStream oos = new ObjectOutputStream( new FileOutputStream("object.java"));
//（2）、调用输出流的writeObject()方法输出可序列化对象
oos.writeObject(per);

　
　　下面来看实际中的应用：

//先创建一个Person类
public class Person 
        implements java.io.Serializable
{
    private String name;
    private int age;
    //有参构造器
    public Person(String name,int age)
    {
        System.out.println("有参数的构造器");
        this.name=name;
        this.age=age;
    }
    //name和age的getter和setter方法
    ...
}

//将一个Person对象写入磁盘文件，即序列化
public class WriteObject
{
    public static void main(String[] args)
    {
        try(//在退出虚拟机时就可以清掉这些打开的资源了
            ObjectOutputStream oos = new ObjectOutputStream(
                            new FileOutputStream("object.txt")))
        {
            Person per = new Person("linkai",100);
            //将Person对象写入输出流
            oos.writeObject(per);
        }
        catch(IOException ex)
        {
            ex.printStackTrace();
        }
    }
}   

//从磁盘文件读写一个Person对象，即反序列化
public class ReadObject
{
     try(//同上，称为自动关闭资源
         //创建一个输出流
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("object.txt")))
        {
            Person p = (Person)ois.readObject();//从磁盘文件反序列化出一对象，强转为Person类型
            //当反序列化找不到对应的Java类时将会抛出ClassNotFoundException异常
            System.out.println("名称为"+p.getname()+"年龄为："+p.getage());
        }
        catch(Exception ex)
        {
            ex.printStackTrace();
        }
    }
}

　　以上就是序列化和反序列化的基础实现。还有一点需要指出：Person类构造器中的有参构造器中有一句普通的打印语句，但是反序列化时并没有该语句打印输出，这说明了什么呢？说明反序列化机制无须通过构造器来初始化Java对象
　　另外，若使用序列化机制向文件中写入了多个Java对象，使用反序列化机制恢复对象时必须按实际写入顺序读取。
　　
　　2）、对象引用的序列化
　　　　　
　　　前面介绍的Person类的两个对象分别是String和int类型，如果某个成员变量是引用类型，则该引用类型有没有什么要求呢？答案是肯定的，该引用类型也必须是可序列化的。否则，拥有该类型成员变量的类也是不可序列化的。
　　　
　Java为了保持Java序列化机制的初衷——避免重复序列化相同的对象，采用了一种特殊的算法，下面我们来看看它的内容：

• 所有保存到磁盘中的对象都有一个序列化编号

• 当程序试图序列化一个对象时，先检查该对象是否已被序列化，如果是（在本次虚拟机中），则直接输出一个序列化编号

  　下面我们来看看对象引用序列化的实际用法

//Person类和上面相同
...

//Boss类
public class Boss
    implements java.io.Serializable
{
    private String name;
    private Person worker;
    public Boss(String name , Person worker)
    {
        this.name=name;
        this.worker=worker;
    }
    //省略name和worker的getter,setter
    ...

//序列化
public class WriterTeacher
{
    public static void main(String[] args)
    {
        try(
            ObjectOutputStream oos =new ObjectOutputStream(
                    new FileOutputStream("file.txt")))
        {
            Person per =new Person("linkai",100);
            Boss b1=new Boss("lincoln",per);
            Boss b2=new Boss("kai",per);

            oos.writeObject(b1);
            oos.writeObject(b2);
            oos.writeObject(per);
            oos.writeObject(b2);//4次调用了writeObject()方法来输出对象，实际只序列化了三个对象
                                //序列的两个Boss对象的worker引用实际是同一个person对象
        }
        catch(IOException ex)
        {
            ex.printStackTrace();
        }
    }
}

//下面是反序列化操作
public class ReadTeacher
{
    public static void main(String[] args)
    {
        try(
                ObjectInputStrame ois = new ObjectInputStream(
                    new FileInputStream("file.txt")))
        {
            //必须按顺序读取文件中对象
            Boss b1=(Boss)ois.readObject();
            Boss b2=(Boss)ois.readObject();
            Person per=(Person)ois.readObject();
            Boss b3=(Boss)ois.readObject();

            //下列比较可以得出Java的序列化算法机制
            System.out.pintln("b1的worker引用与b2的worker引用是否相同"+(b1.getWorker()==b2.getWorker()));
            //输出true
            System.out.pintln("b2与b3是否是同一个对象"+(b2==b3));
            //输出true
            System.out.pintln("b1的worker引用与per是否相同"+(b1.getWorker()==per));
            //输出true
        }
        catch(Exception ex)
        {
            ex.printStackTrace();
        }
    }
}

　　另外，还需要注意一点。当使用序列化机制序列化可变对象时一定要注意，只有第一次调用writeObject()方法来输出对象时才会将对象转换成字节序列，并写入到ObjectOutputStream；在后面程序中，即使该对象的实例变量发生改变，再次调用writeObject（）方法输出该对象时，改变后的实例变量也不会被输出。

5、关于自定义序列化

　　在一些特殊场景下，如果一个类中包含某些实例变量敏感信息，如银行账户信息等，这时不希望将该实例变量值进行序列化；或者某个实例变量的类型是不可序列化的，因此不希望对该实例变量进行递归序列化，以免引发java.io.NotSerializableException异常。
　　
　　自定义序列化大体分为两种：
　　1）、使用transient（只能修饰实例变量）关键字修饰
　　　　如前面所说，但某些实例变量不需要序列化时可以使用transient修饰，则可以指定序列化时无需理会该变量。反序列化时该值则将会是0。
　　2）、让程序控制如何实例化各实例变量，即特殊处理
　　　　需要特殊处理的类应该提供如下特殊方法

• private void writeObject(java.io.ObjectOutputStream out)throws IOException;
• private void readObject(java.io.ObjectOutputStream in)throws IOException,ClassNotFoundException;
• private void readObjectNoData()throws ObjectStreamException;
  　　以下是代码实例：

//Person类和上面一样
...

//writeObject实例
private void writeObject(java.io.ObjectOutputStream out)throws IOException
{
    //将name实例变量值反转后写入二进制流
    out.writeObject(new StringBuffer(name).reverse());
    out.writeInt(age);
}
    private void readObject(java.io.ObjectOutputStream in)throws IOException,ClassNotFoundException
{
        //相反的操作反序列化
        this.name=((StringBuffer)in.readObject()).reverse().toString();
        //应该与writeObject方法中存储实例变量的顺序一致
    this.age=in.readInt();

}

　　上面程序的特殊之处就在于，序列化后的对象流，即使有黑客截获到Person对象流，他看到的name也是加密（反转）后的name值。这样就提高了序列化的安全性。
　　另外，还有一种更彻底的自定义机制，甚至可以在序列化对象时将该对象替换成其他对象。代码如下所示：

public class Person...
{
//Person类与上面相同
...

    //重写writeObject方法，程序在序列化之前会先调用该方法
    private Object writeReplace() throws ObjectStreamException
    {
        ArrayList