Java IO.pdf - Nguyen Dang Binh

Java I/O
the resolveClass() method would need to have a class loader that read the data from the
stream. If annotateClass() wrote the URL of the class to the stream, then the
resolveClass() method would need a class loader that read the URL from the stream and
downloaded the class from that URL.
The resolveClass() method is called exactly once for each class encountered in the stream
(not just those written by annotateClass()). resolveClass() is responsible for knowing
what sort of data needs to be read to reconstruct the class and for reading it from the input
stream. resolveClass() should then load and return the class. If it can't do so, it should
throw a ClassNotFoundException . If it returns a class, but that class's SUID does not match
the SUID of the class in the stream, then the runtime throws a ClassNotFoundException.
11.10 Resolving Objects
There may be occasions where you want to replace the objects read from the stream with
other, alternative objects. Perhaps an old version of a program whose data you need to read
used Franc objects, but the new version of the program uses Euro objects. The
ObjectInputStream can replace each Franc object read with the equivalent Euro object.
Only trusted subclasses of ObjectInputStream may replace objects. A class is only trusted if
it was loaded from the local class path; that is, the class loader returned by
getClassLoader() is null. To make it possible for a trusted subclass to replace objects, you
must first pass true to its enableResolveObject() method:
protected final boolean enableResolveObject(boolean enable)
throws SecurityException
Generally, you would do this in the constructor of any class that needed to replace objects.
Once object replacement is enabled, whenever an object is read, it is passed to the
ObjectInputStream subclass's resolveObject() method before readObject() returns:
protected Object resolveObject(Object o) throws IOException
The resolveObject() method may return the object itself (the default behavior) or return
a different object. Resolving objects is a tricky business. The substituted object must be
compatible with the use of the original object, or errors will soon surface as the program tries
to invoke methods or access fields that don't exist. Most of the time, the replacing object is an
instance of a subclass of the class of the replaced object. Another possibility is that the
replacing object and the object it replaces are both instances of different subclasses of
a common superclass or interface, where the original object was only used as an instance of
that superclass or interface.
11.11 Validation
It is not always enough to merely restore the state of a serialized object. You may need to
verify that the value of a field still makes sense, you may need to notify another object that
this object has come into existence, or you simply may need to have the entire graph of
the object available before you can finish initializing it.
261