Java IO.pdf - Nguyen Dang Binh

when deserialized elementCount will be set to numSerializable
out.writeInt(numSerializable);
for (int i = 0; i < elementCount; i++) {
if (elementData[i] instanceof Serializable) {
out.writeObject(elementData[i]);
}
}
}
Java I/O
This still isn't a perfect solution. The vector may contain an object that implements
Serializable but isn't serializable: for example, a hash table that contains a socket. It seems
as if it would be a better solution to catch any such NotSerializableExceptions inside the
readExternal() method, then write null, possibly after backing the stream up to the
beginning of the element that threw the exception (using mark() and reset() and an extra
buffered stream if necessary). However, my tests showed that you cannot catch a
NotSerializableException inside the writeExternal() method. I can see no reason why
this should be the case. It's probably a result of how serialization is implemented by native
code in the virtual machine, so the exception isn't thrown exactly where the Java code
indicates it is. (I suspect this should be classified as a bug.)
11.9 Resolving Classes
The readObject() method of java.io.ObjectInputStream only creates new objects from
known classes. It doesn't load classes. If a class for an object can't be found, readObject()
throws a ClassNotFoundException. It specifically does not attempt to read the class data
from the object stream. This is limiting for some things you might want to do, particularly
RMI. Therefore, trusted subclasses of ObjectInputStream may be allowed to load classes
from the stream or some other source like a URL. Specifically, a class is trusted if, and only
if, it was loaded from the local class path; that is, the ClassLoader object returned by
getClassLoader() is null.
Two protected methods are involved. The first is the annotateClass() method of
ObjectOutputStream :
protected void annotateClass(Class c) throws IOException
In ObjectOutputStream this is a do-nothing method. A subclass of ObjectOutputStream
can provide a different implementation that provides data for the class. For instance, this
might be the byte code of the class itself or a URL where the class can be found.
Standard object input streams cannot read and resolve the class data written by
annotateClass(). For each subclass of ObjectOutputStream that overrides
annotateClass(), there will normally be a corresponding subclass of ObjectInputStream
that implements the resolveClass() method:
protected Class resolveClass(ObjectStreamClass v)
throws IOException, ClassNotFoundException
In java.io.ObjectInputStream, this is a do-nothing method. A subclass of
ObjectInputStream can provide an implementation that loads a class based on the data read
from the stream. For instance, if annotateClass() wrote byte code to the stream, then
260