一. 对象次第读写 1. 实现对象的serialize操作 1.1. Serializable接口 只要让一个类实现出Serializable接口,就可对它的对象进行serialize操作了。Serializable接口仅仅是一个标志性接口,不具有任何的函数。也就是说,只要一个类实现了Serializable(在类名后加“implements Serializable”),那么那个类就可以进行Serialize操作了。 1.2. 对象所包含的对象的Serialization 1) Java库中的对象,如String,都实现了Serializable接口,所以它们都可进行serialization操作。 2) 对一个对象进行Serialize操作时,不仅会把对象在内存中的数据保存下来,还会把对象中所包含的可serialize成员对象也保存下来。如果对象中包含了没有实现Serializable接口的成员对象,那将在尝试对对象进行Serialize操作时,将发生错误。 3) 对一个Serializable对象进行次第读取时,并不会调用任何构造函数(包括default构造函数)。这是因为对象中的所有数据都是通过InputStream读取的数据来恢复的,所有不用通过构造函数来进行初始化。 import java.io.*; class Data implements Serializable{//(1) private int i; Data(int x) { i = x; } public String toString(){ return Integer.toString(i); } } class Worm implements Serializable{ private static int r(){ return (int)(Math.random() * 10); } //(2) private Data[] d = { new Data(r()), new Data(r()), new Data(r()) }; private Worm next; private char c; Worm(int i, char x){ System.out.println(" Worm constructor: " + i); c = x; if(--i > 0) next = new Worm(i, (char)(x + 1)); //(3) } Worm(){ System.out.println(" Default constructor " ); } public String toString(){ String s = ":" + c + "("; for(int i=0; i s += d[i].toString(); s += ")"; if(next!=null) s += next.toString(); return s; } } public class TestSerialization { public static void main(String[] args) throws ClassNotFoundException, IOException{ Worm w = new Worm(6, 'a'); System.out.println("w = " + w); ObjectOutputStream out = new ObjectOutputStream( new FileOutputStream("F:\\nepalon\\Worm.out")); out.writeObject("Worm storage"); out.writeObject(w); //(5) out.close(); ObjectInputStream in = new ObjectInputStream( new FileInputStream("F:\\nepalon\\Worm.out")); String s = (String)in.readObject(); //(4) Worm w2 = (Worm)in.readObject(); //(6) System.out.println(s + " , w2 = " + w2); ByteArrayOutputStream bout = new ByteArrayOutputStream(); ObjectOutputStream out2 = new ObjectOutputStream(bout); out2.writeObject("Worm storage"); out2.writeObject(w); out2.flush(); ObjectInputStream in2 = new ObjectInputStream( new ByteArrayInputStream( bout.toByteArray())); s = (String)in2.readObject(); Worm w3 = (Worm)in2.readObject(); System.out.println(s + " , w3 = " + w3); } } 运行结果为: Worm constructor: 6 Worm constructor: 5 Worm constructor: 4 Worm constructor: 3 Worm constructor: 2 Worm constructor: 1 w = :a(993):b(769):c(379):d(532):e(151):f(481) Worm storage , w2 = :a(993):b(769):c(379):d(532):e(151):f(481) Worm storage , w3 = :a(993):b(769):c(379):d(532):e(151):f(481) 代码(2)合成了一个Date数组;代码(3)用类似递归的方法生成了一 个Worm对象链。由结果可见Worm对象的成员Data数组及由Worm对象所产生的Worm对象链都能被很好的保存了下来。代码(4)则证明了Java库的类型都实现了Serializable接口的。 如果去掉(1)处代码,不让class Data实现Serializable接口,那么当调用writeObject()(如代码(5))来保存对象时,将产生NotSerializableException异常,因为在保存Worm对象时会去保存它的所有成员对象,但Data是不能Serialize的,所以会产生异常。 4) 进行次第读取时,在执行读取操作的class中一定要能找到相应的class文件。 在上面的代码中,如果class TestSerialization和class Worm分别处于两个不同的文件中,那么在代码(6)中执行了次第读取操作来还原一个对象时,就要确保在TestSerialization所在的文件中能找到Worm所在的文件,否则会产生ClassNotFoundException异常。 1.3. 关键字transient 当一个成员被声明为transient时,在对象被保存的时候,该成员将不被保存。 class Blip3 implements Serializable{ int i; String s1; transient String s2; public Blip3(String x, int a){ System.out.println("Blip3(String x, int a)"); //在non-default构造函数中初始化i、s1和s2 i = a; s1 = x; s2 = x; } public String toString(){ String s22 = (s2==null)?"s2 is null":s2; return "s1 = " + s1 + " , s2 = " + s22 + ", i = " + i; } } public class TestSerialization{ public static void main(String[] args) throws ClassNotFoundException, IOException{ System.out.println("Constructor Object: "); Blip3 b3 = new Blip3("A String", 47); System.out.println(b3); ObjectOutputStream out = new ObjectOutputStream( new FileOutputStream("F:\\nepalon\\test\\Blip3.out")); out.writeObject(b3); out.close(); ObjectInputStream in = new ObjectInputStream( new FileInputStream("F:\\nepalon\\test\\Blip3.out")); System.out.println("Recovering Object: "); b3 = (Blip3)in.readObject(); System.out.println(b3); } } 运行结果为: Constructor Object: Blip3(String x, int a) s1 = A String , s2 = A String, i = 47 Recovering Object: s1 = A String , s2 = s2 is null, i = 47 由于s2被声明为transient,所以它将不被保存。 2. 通过Externalizable接口来实现次第读写 通过实现了Externalizable接口来产生Serialize功能,我们将取得更大的控制权。 2.1. 通过实现了Externalizable接口来产生Serialize功能 1) 在保存对象时不会保存任何成员对象。但我们可以手工保存成员对象(下面将讲到)。 2) Default构造函数必须为public。因为在次第读取对象时,会调用default构造函数。因为对象中的成员对象不一定会被保存,所以要通过构造函数来进行初始化。 3) Extrenalizable接口有writeExternal(ObjectOutput)和readExternal(ObjectInput)两个函数。在对实现了Externalizable接口的类进行次第读写时,会调用这两个函数。但是在恢复对象时,是先调用default构造函数再调用readExternal()函数的。 import java.io.*; class Blip1 implements Externalizable{ public Blip1(){ //(1) System.out.println("Blip1 Constructor"); } public void writeExternal(ObjectOutput out) throws IOException{ System.out.println("Blip1.writeExternal"); } public void readExternal(ObjectInput in) throws IOException{ System.out.println("Blip1.readexternal"); } } class Blip2 implements Externalizable{ Blip2(){ //(2) System.out.println("Blip2 Constructor"); } public void writeExternal(ObjectOutput out) throws IOException{ System.out.println("Blip2.writeExternal"); } public void readExternal(ObjectInput in) throws IOException{ System.out.println("Blip2.readexternal"); } } public class TestSerialization{ public static void main(String[] args) throws ClassNotFoundException, IOException{ System.out.println("Constructor Object: "); Blip1 b1 = new Blip1(); Blip2 b2 = new Blip2(); ObjectOutputStream out = new ObjectOutputStream( new FileOutputStream("F:\\nepalon\\Blips.out")); System.out.println("Saveing Object: "); out.writeObject(b1); out.writeObject(b2); out.close(); ObjectInputStream in = new ObjectInputStream( new FileInputStream("F:\\nepalon\\Blips.out")); System.out.println("Recovering Object: "); b1 = (Blip1)in.readObject(); //b2 = (Blip2)in.readObject(); (3) } } 运行结果为: Constructor Object: Blip1 Constructor Blip2 Constructor Saveing Object: Blip1.writeExternal Blip2.writeExternal Recovering Object: Blip1 Constructor Blip1.readexternal 在上面的代码中,class Blip1的default构造函数为public(代码(1)),所以可以完成次第读写的操作。但是class Blip2的default构造函数不为public(代码(2)),所以在进行次第读取(代码(3))操作时,会产生InvalidClassException的异常。 从运行结果可看出,在恢复对象时会调用对象的defqult构造函数。 2.2. Externalizable接口和Serializable接口的区别 1) 通过实现Serializable接口的方法,在保存对象时会把对象中所包含的成员对象也保存下来;而通过实现Externalizable接口的方法,在保存对象时不会保存任何成员对象。 2) 通过实现Serializable接口的方法,在恢复对象时不会调用任何构造函数(包括default构造函数);而通过实现Externalizable接口的方法,在恢复对象时会调用default构造函数。然后再调用readExternal()函数。 2.3. 利用writeExternal()和readExternal()函数来控制成员对象 由于通过实现Externalizable接口的方法,在保存对象时不会保存任何成员对象,但如果要在保存对象的时候要保存对象的成员对象时,我们可以通过这两个函数来实现。 class Blip3 implements Externalizable{ int i; String s1; String s2; public Blip3(){ System.out.println("Blip3 Constructor"); //在default构造函数中只对s2进行初始化 s2 = "default String"; //(1) } public Blip3(String x, int a){ System.out.println("Blip1(String x, int a)"); //在non-default构造函数中初始化i、s1和s2 i = a; s1 = x; s2 = x; } public String toString(){ return "s1 = " + s1 + " , s2 = " + s2 + ", i = " + i; } public void writeExternal(ObjectOutput out) throws IOException{ System.out.println("Blip3.writeExternal"); out.writeObject(s1); out.writeInt(i); } public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException{ System.out.println("Blip2.readExternal"); s1 = (String)in.readObject(); i = in.readInt(); } } public class TestSerialization{ public static void main(String[] args) throws ClassNotFoundException, IOException{ System.out.println("Constructor Object: "); Blip3 b3 = new Blip3("A String", 47); System.out.println(b3); ObjectOutputStream out = new ObjectOutputStream( new FileOutputStream("F:\\nepalon\\test\\Blip3.out")); System.out.println("Saveing Object: "); out.writeObject(b3); out.close(); ObjectInputStream in = new ObjectInputStream( new FileInputStream("F:\\nepalon\\test\\Blip3.out")); System.out.println("Recovering Object: "); b3 = (Blip3)in.readObject(); System.out.println(b3); } } 运行结果为: Constructor Object: Blip3(String x, int a) s1 = A String , s2 = A String, i = 47 Saveing Object: Blip3.writeExternal Recovering Object: Blip3 Constructor Blip2.readExternal s1 = A String , s2 = default String, i = 47 //(2) 在上面代码中,在writeExternal()函数中保存了i和s1,在readExternal()函数中恢复了i和s2;而在default构造函数中我们只初始化了s2(代码(1))。从结果(2)处可证明,s2在对象被恢复时在default构造函数中被初始化;而s1和i由于在保存对象时也被保存了,所以能恢复到原来的值。 3. 扩增Serializable接口以实现Externalizable接口的功能 虽然Serializable接口只是个标志封闭器,不具有任何函数,但我们可在实现了该接口的类中扩增writeObject()和readObject()函数,这是Java中最怪异的地方。 3.1. 实现扩增的语法 这两函数的定义为: private void writeObject(ObjectOutputStream stream) throws IOException{; private void readObject(ObjectInputStream stream) throws IOException, ClassNotFoundException; 3.2. Java的怪异之处 1) 在下面的代码中我们可以看到,Blip3只实现了Serializable接口,而该接口只是个标志接口,所以这两个函数并不是接口的一部分。 2) 这两个函数被声明为private,按理只能在它们所在的类中被调用,但事实却是它们能被ObjectOutputStream和ObjectInputStream对象的writeObject()和readObject()函数调用。 3.3. readObject()和writeObject()函数的使用及其工作过程 3.3.1 工作过程 当调用ObjectOutputStream.writeObject(Object)时,传入的Serializable对象会被检查是否实现自己的writeObject(ObjectOutputStream)。如果有,就会执行扩增的writeObject(ObjectOutputStream)函数。当调用ObjectInputStream.readObject()时的工作过程也一样。 3.3.2 在扩增的writeObject(ObjectOutputStream)中我们可以通过调用defaultWriteobject()函数来执行缺省的writeObject();在扩增的readObject(ObjectInputStream)函数中,我们可以通过调用defaultReadObject()函数来执行缺省的readObject()。在相应的缺省函数中都只对non-transient成员对象进行操作。 import java.io.*; class Blip3 implements Serializable{ String s1; transient String s2; public Blip3(String a, String b){ s1 = "Not Transient: " + a; s2 = "Transient: " + b; } public String toString(){ return "s1 = " + s1 + "\ns2 = " + s2 ; } //函数(1) private void writeObject(ObjectOutputStream stream) throws IOException{ stream.defaultWriteObject(); stream.writeObject(s2); } //函数(2) private void readObject(ObjectInputStream stream) throws IOException, ClassNotFoundException{ stream.defaultReadObject(); s2 = (String)stream.readObject(); } } public class TestSerialization{ public static void main(String[] args) throws ClassNotFoundException, IOException{ Blip3 b3 = new Blip3("Test1", "Test2"); System.out.println("Before:\n" + b3); ByteArrayOutputStream bout = new ByteArrayOutputStream(); ObjectOutputStream out = new ObjectOutputStream(bout); out.writeObject(b3); out.close(); ObjectInputStream in = new ObjectInputStream( new ByteArrayInputStream(bout.toByteArray())); System.out.println("Recovering Object: "); b3 = (Blip3)in.readObject(); System.out.println("After:\n" + b3); } } 运行结果为: Before: s1 = Not Transient: Test1 s2 = Transient: Test2 Recovering Object: After: s1 = Not Transient: Test1 s2 = Transient: Test2 在代码的函数(1)中,先保存non-transient成员对象,再保存transient成员对象。在函数(2)中,先恢复non-transient成员对象,再恢复transient成员对象。保存的顺序和恢复的顺序必须相同,否则数据会出错。 4. 关于Serialize的扩充话题 4.1 当多个对象被保存到同一个Stream时,如果这些对象的成员对象中有指向相同的第三对象的reference,那么在恢复时也将指向同一个对象。但不相同的两个Stream中的对象的则不同。 import java.io.*; import java.util.ArrayList; class House implements Serializable {} class Animal implements Serializable{ String name; House house; Animal(String nm, House h){ name = nm; house = h; } public String toString(){ return name + "[" + super.toString() + "], " + house + "\n"; } } public class TestSerialization{ public static void main(String[] args) throws ClassNotFoundException, IOException{ House house = new House(); ArrayList animals = new ArrayList(); animals.add(new Animal("dog", house)); animals.add(new Animal("hamster", house)); animals.add(new Animal("cat", house)); System.out.println("animals: " + animals); //在同一个Stream(Stream1)中保存两次 ByteArrayOutputStream buf1 = new ByteArrayOutputStream(); ObjectOutputStream o1 = new ObjectOutputStream(buf1); o1.writeObject(animals); o1.writeObject(animals); //在另一个Stream(Stream2)中保存 ByteArrayOutputStream buf2 = new ByteArrayOutputStream(); ObjectOutputStream o2 = new ObjectOutputStream(buf2); o2.writeObject(animals); //恢复Stream1中的两个对象 ObjectInputStream in1 = new ObjectInputStream( new ByteArrayInputStream( buf1.toByteArray())); ArrayList animal1 = (ArrayList)in1.readObject(); ArrayList animal2 = (ArrayList)in1.readObject(); //恢复Stream2中的对象 ObjectInputStream in2 = new ObjectInputStream( new ByteArrayInputStream( buf2.toByteArray())); ArrayList animal3 = (ArrayList)in2.readObject(); System.out.println("animal1: " + animal1); System.out.println("animal2: " + animal2); System.out.println("animal3: " + animal3); } } 运行结果为: animals: [dog[Animal@1], House@2 , hamster[Animal@3], House@2 , cat[Animal@4], House@2 ] animal1: [dog[Animal@14], House@15 , hamster[Animal@16], House@15 , cat[Animal@17], House@15 ] animal2: [dog[Animal@14], House@15 , hamster[Animal@16], House@15 , cat[Animal@17], House@15 ] animal3: [dog[Animal@18], House@19 , hamster[Animal@1a], House@19 , cat[Animal@1b], House@19 ] 当在同一个Stream中两次保存animals对象时,它们被恢复后是完全一样的,所以结果中animals1和animals2的对象的地址是一样的。但当把animals保存到另一个Stream中时,当它被恢复后可看到与前两个是不一样的。由结果可知animals1与animals2的信息一样,但这两个对象的信息与animals3的不一样。
|