什么是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<Object> list=new ArrayList<Object>();
        list.add(name);
        list.add(age);
        return list;
    }
}

　　Java的序列化机制保证在序列化某个对象之前，先调用该对象的writeReplace()方法，如果返回另一个Java对象，则系统转为序列化另一个对象。就像上面，表面看是Person对象，实际上是实例化ArrayList。
　　那么这个时候我们会想，咦，不对啊！只有list被序列化，而list中的对象没有被序列化，为什么反序列化后还能够输出list中的元素呢？
　　其实，答案都在ArrayList类的源码里。
　　在解析ArrayList类的源码之前，我们要知道这个原则：

　　在序列化过程中，如果被序列化的类中定义了writeObject 和 readObject 方法，虚拟机会试图调用对象类里的 writeObject 和 readObject 方法，进行用户自定义的序列化和反序列化。
　　
　　如果没有这样的方法，则默认调用是 ObjectOutputStream 的 defaultWriteObject 方法以及 ObjectInputStream 的 defaultReadObject 方法。
　　
　　用户自定义的 writeObject 和 readObject 方法可以允许用户控制序列化的过程，比如可以在序列化的过程中动态改变序列化的数值。

　　知道了这个原则后我们再来看一下ArrayList类中readObject方法的源码：
　　

private void readObject(java.io.ObjectInputStream s)
        throws java.io.IOException, ClassNotFoundException {
        elementData = EMPTY_ELEMENTDATA;

        // Read in size, and any hidden stuff
        s.defaultReadObject();

        // Read in capacity
        s.readInt(); // ignored

        if (size > 0) {
            // be like clone(), allocate array based upon size not capacity
            ensureCapacityInternal(size);

            Object[] a = elementData;
            // Read in all elements in the proper order.
            for (int i=0; i<size; i++) {
                a[i] = s.readObject();
            }
        }
    }

　　我们再来看一下ArrayList类中writeObject方法的源码：
　　

private void writeObject(java.io.ObjectOutputStream s)
        throws java.io.IOException{
        // Write out element count, and any hidden stuff
        int expectedModCount = modCount;
        s.defaultWriteObject();

        // Write out size as capacity for behavioural compatibility with clone()
        s.writeInt(size);

        // Write out all elements in the proper order.
        for (int i=0; i<size; i++) {
            s.writeObject(elementData[i]);
        }

        if (modCount != expectedModCount) {
            throw new ConcurrentModificationException();
        }
    }

　　从上面的代码中我们可以看出什么呢？

　　其实ArrayList实际上是动态数组，每次在放满以后自动增长设定的长度值，如果数组自动增长长度设为100，而实际只放了一个元素，那就会序列化99个null元素。为了保证在序列化的时候不会将这么多null同时进行序列化，ArrayList把元素数组设置为transient。
　　为了防止一个包含大量空对象的数组被序列化，为了优化存储，所以，ArrayList使用transient来声明elementData。 但是，作为一个集合，在序列化过程中还必须保证其中的元素可以被持久化下来，所以，通过重写writeObject 和 readObject方法的方式把其中的元素保留下来。

　　writeObject方法把elementData数组中的元素遍历的保存到输出流（ObjectOutputStream）。
　　
　　readObject方法从输入流（ObjectInputStream）中读出对象并保存赋值到elementData数组中。

　　所以，即使只有list被序列化，而list中的对象没有被序列化，反序列化后还是能够输出list中的元素的！秘密就在ArrayList类的writeObject和readObject的方法中！
　　
　　我们也从中学习到了，通过在被序列化的类中增加writeObject 和 readObject方法，也是自定义序列化的一种方法。

　　至此，Java对象序列化的知识就介绍完毕了。以后就记得好好运用对象序列化噢~
　　
　　参考致谢：http://www.hollischuang.com/archives/1140