Java IO.pdf - Nguyen Dang Binh

Java I/O
Let's look closer at the serialization parts of this program. What does it mean to serialize
ZipFile? Internally a ZipFile object is a filename and a long integer that serves as a native
file descriptor to interface with the native zlib library. File descriptors have no state that
would make sense across multiple runs of the same program or from one machine to the next.
This is why ZipFile is not itself declared serializable. However, if you know the filename,
you can create a new ZipFile object that is the same for all practical purposes.
This is the approach Example 11.3 takes. To serialize an object, the writeObject() method
writes the filename onto the output stream. The readObject() method reads this name back
in and recreates the object. When readObject() is invoked, the virtual machine creates a
new SerializableZipFile object out of thin air; no constructor is invoked. The zf field is
set to null. Next, the private readObject() method of this object is called. The value of
filename is read from the stream. Finally, a new ZipFile object is created from the filename
and assigned to zf.
This scheme isn't perfect. In particular, the whole thing may come crashing down if the actual
file that's referred to isn't present when the object is deserialized. This might happen if the
actual file was deleted in between the time the object was written and the time it was read, for
example. However, this will only result in an IOException, which the client programmer
should be ready for in any case.
The main() method tests this scheme by creating a serializable zip file with a name passed in
from the command line. Then the serializable zip file is serialized. Next the
SerializableZipFile object is deserialized from the same byte array it was previously
written into. Here's the result:
D:\JAVA>java SerializableZipFile test.zip
Wrote object!
Read object!
11.8.2 The default WriteObject( ) and defaultReadObject( ) Methods
Sometimes rather than changing the format of an object that's serialized, all you want to do is
add some additional information, perhaps something that isn't normally serialized, like a static
field. In this case, you can use ObjectOutputStream's defaultWriteObject() method to
write the state of the object, then use ObjectOutputStream's defaultReadObject() method
to read the state of the object. After this is done, you can perform any custom work you need
to do on serialization or deserialization.
public final void defaultReadObject()
throws IOException, ClassNotFoundException, NotActiveException
public final void defaultWriteObject() throws IOException
For example, let's suppose an application that would otherwise be serializable contains a
Socket field. As well as this field, assume it contains more than a few other complex fields,
so that serializing it by hand, while possible, would be onerous. It might look something like
this:
254