java序列化机制

 

一、http://bbs.security.ccidnet.com/simple/index.php?t249048.html

  序列化是什么：
序列化就是将一个对象的状态（各个属性量）保存起来，然后在适当的时候再获得。
序列化分为两大部分：序列化和反序列化。序列化是这个过程的第一部分，将数据分解成字节流，以便存储在文件中或在网络上传输。反序列化就是打开字节流并重构对象。对象序列化不仅要将基本数据类型转换成字节表示，有时还要恢复数据。恢复数据要求有恢复数据的对象实例

  序列化的特点：
如果某个类能够被序列化，其子类也可以被序列化。声明为static和transient类型的成员数据不能被序列化。因为static代表类的状态， transient代表对象的临时数据。

  什么时候使用序列化：
1. 对象序列化可以实现分布式对象。主要应用例如：RMI要利用对象序列化运行远程主机上的服务，就像在本地机上运行对象时一样。
2. java 对象序列化不仅保留一个对象的数据，而且递归保存对象引用的每个对象的数据。可以将整个对象层次写入字节流中，可以保存在文件中或在网络连接上传递。利用 对象序列化可以进行对象的"深复制"，即复制对象本身及引用的对象本身。序列化一个对象可能得到整个对象序列。

 

二、http://blog.csdn.net/yakihappy/archive/2009/03/11/3979373.aspx

1、什么是串行化(序列化)

Java 串行化技术可以使你将一个对象的状态 写入一个 字节 流 里，并且可以从其它地方把该字节 流 里的数据读出来，重新构造一个相同的对象。这种机制允许你将对象通过网络进行传播 ，并可以随时把对象持久化到数据库、文件等系统里 。 Java 的串行化机制是 RMI 、 EJB 等技术的技术基础。用途：利用对象的串行化实现保存应用程序的当前工作状态，下次再启动的时候将自动地恢复到上次执行的状态。

序列化就是一种用来处理对象流 的机制，所谓对象流也就是将对象的内容进行流化 。可以对流化后的对象进行读写操作，也可将流化后的对象传输于网络之间 。序列化是为了解决在对对象流进行读写操作时所引发的问题。

序列化的实现：将需要被序列化的类实现 Serializable 接口 ，然后使用一个输出流 ( 如： FileOutputStream ) 来构造一个 ObjectOutputStream ( 对象流 ) 对象，接着，使用 ObjectOutputStream 对象的 writeObject(Object obj) 方法就可以将参数为 obj 的对象写出 ( 即保存其状态 ) ，要恢复的话则用输入流。

2 、串行化的特点：

    （ 1 ）如果某个类能够被串行化，其子类也可以被串行化。如果该类有父类，则分两种情况来考虑，如果该父类已经实现了可串行化接口。则其父类的相应字段及属性的处理和该类相同；如果该类的父类没有实现可串行化接口， 则该类的父类所有的字段属性将不会串行化。

  （ 2 ）声明为 static 和 transient 类型的成员数据不能被串行化 。因为 static 代表类的 状态， transient 代表对象的临时数据；

  （ 3 ）相关的类和接口：在 java.io 包中提供的涉及对象的串行化的类与接口有 ObjectOutput 接口、 ObjectOutputStream 类、 ObjectInput 接口、 ObjectInputStream 类。

     （ 1 ） ObjectOutput 接口：它继承 DataOutput 接口 并且支持对象的串行化，其内的 writeObject() 方法实现存储一个对象。 ObjectInput 接口：它继承 DataInput 接口并且支持对象的串行化，其内的 readObject() 方法实现读取一个对象。

    （ 2 ） ObjectOutputStream 类：它继承 OutputStream 类 并且实现 ObjectOutput 接口 。利用该类来实现将对象存储 （调用 ObjectOutput 接口中的 writeObject() 方法）。 ObjectInputStream 类：它继承 InputStream 类并且实现 ObjectInput 接口。利用该类来实现读取一个对象（调用 ObjectInput 接口中的 readObject() 方法）。

  对于父类的处理，如果父类没有实现串行化接口，则其必须有默认的构造函数（即没有参数的构造函数）。 否则编译 的时候就会报错。在反串行化的时候，默认构造函数会 被调用。但是若把父类标记为可以串行化，则在反串行化的时候，其默认构造函数不会 被调用。这是为什么呢？这是因为 Java 对串行化的对象进行反串行化的时候，直接从流里获取其对象数据来生成一个对象实例，而不是通过其构造函数来完成。

import java.io.*;

public class Cat implements Serializable {

        private String name;

        public Cat () {

                this.name = "new cat";

        }

        public String getName() {

                return this.name;

        }

        public void setName(String name) {

                this.name = name;

        }

        public static void main(String[] args) {         

                Cat cat = new Cat();

                try {

                        FileOutputStream fos = new FileOutputStream("catDemo.out");

                        ObjectOutputStream oos = new ObjectOutputStream(fos);

                        System.out.println(" 1> " + cat.getName());

                        cat.setName("My Cat");                       

                        oos.writeObject(cat);

                        oos.close();                       

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

                try {

                        FileInputStream fis = new FileInputStream("catDemo.out");

                        ObjectInputStream ois = new ObjectInputStream(fis);

                        cat = (Cat) ois.readObject();

                        System.out.println(" 2> " + cat.getName());

                        ois.close();

                } catch (Exception ex) {

                        ex.printStackTrace();

                }

        }

}//writeObject 和 readObject 本身就是线程安全的 ，传输过程中是不允许被并发访问的。所以对象能一个一个接连不断的传过来

 

三、

http://lionheart.javaeye.com/blog/139540

http://www.javaeye.com/topic/14707