|
Java Platform 1.2 Beta 4 |
|||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
| SUMMARY: INNER | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD | |||||||||
java.lang.Object
|
+--java.io.InputStream
|
+--java.io.ObjectInputStream
ObjectInputStream ensures that the types of all objects in the graph created from the stream match the classes present in the Java Virtual Machine. Classes are loaded as required using the standard mechanisms.
Only objects that support the java.io.Serializable or java.io.Externalizable interface can be read from streams. The method readObject is used to read an object from the stream. Java's safe casting should be used to get the desired type. In Java, strings and arrays are objects and are treated as objects during serialization. When read they need to be cast to the expected type.
Primitive data types can be read from the stream using the appropriate method on DataInput.
The default deserialization mechanism for objects restores the contents of each field to the value and type it had when it was written. Fields declared as transient or static are ignored by the deserialization process. References to other objects cause those objects to be read from the stream as necessary. Graphs of objects are restored correctly using a reference sharing mechanism. New objects are always allocated when deserializing, which prevents existing objects from being overwritten.
Reading an object is analogous to running the constructors of a new object. Memory is allocated for the object and initialized to zero (NULL). No-arg constructors are invoked for the non-serializable classes and then the fields of the serializable classes are restored from the stream starting with the serializable class closest to java.lang.object and finishing with the object's most specifiec class.
For example to read from a stream as written by the example in
ObjectOutputStream:
FileInputStream istream = new FileInputStream("t.tmp");
ObjectInputStream p = new ObjectInputStream(istream);
int i = p.readInt();
String today = (String)p.readObject();
Date date = (Date)p.readObject();
istream.close();
Classes control how they are serialized by implementing either the
java.io.Serializable or java.io.Externalizable interfaces.Implementing the Serializable interface allows object serialization to save and restore the entire state of the object and it allows classes to evolve between the time the stream is written and the time it is read. It automatically traverses references between objects, saving and restoring entire graphs. Serializable classes that require special handling during the serialization and deserialization process should implement both of these methods:
private void writeObject(java.io.ObjectOutputStream stream)
throws IOException;
private void readObject(java.io.ObjectInputStream stream)
throws IOException, ClassNotFoundException;
The readObject method is responsible for reading and restoring the state of the object for its particular class using data written to the stream by the corresponding writeObject method. The method does not need to concern itself with the state belonging to its superclasses or subclasses. State is restored by reading data from the ObjectInputStream for the individual fields and making assignments to the appropriate fields of the object. Reading primitive data types is supported by DataInput.
Serialization does not read or assign values to the fields of any object that does not implement the java.io.Serializable interface. Subclasses of Objects that are not serializable can be serializable. In this case the non-serializable class must have a no-arg constructor to allow its fields to be initialized. In this case it is the responsibility of the subclass to save and restore the state of the non-serializable class. It is frequently the case that the fields of that class are accessible (public, package, or protected) or that there are get and set methods that can be used to restore the state.
Any exception that occurs while deserializing an object will be caught by the ObjectInputStream and abort the reading process.
Implementing the Externalizable interface allows the object to assume complete control over the contents and format of the object's serialized form. The methods of the Externalizable interface, writeExternal and readExternal, are called to save and restore the objects state. When implemented by a class they can write and read their own state using all of the methods of ObjectOutput and ObjectInput. It is the responsibility of the objects to handle any versioning that occurs.
DataInput,
ObjectOutputStream,
Serializable| Inner Class Summary | |
| static | ObjectInputStream.GetField
Provide access to the persistent fields read from the input stream. |
| Constructor Summary | |
| ObjectInputStream()
Provide a way for subclasses that are completely reimplementing ObjectInputStream to not have to allocate private data just used by this implementation of ObjectInputStream. |
|
| ObjectInputStream(InputStream in)
Create an ObjectInputStream that reads from the specified InputStream. |
|
| Method Summary | |
| int | available()
Returns the number of bytes that can be read without blocking. |
| void | close()
Closes the input stream. |
| void | defaultReadObject()
Read the non-static and non-transient fields of the current class from this stream. |
| protected boolean | enableResolveObject(boolean enable)
Enable the stream to allow objects read from the stream to be replaced. |
| int | read()
Reads a byte of data. |
| int | read(byte[] b,
int off,
int len)
Reads into an array of bytes. |
| boolean | readBoolean()
Reads in a boolean. |
| byte | readByte()
Reads an 8 bit byte. |
| char | readChar()
Reads a 16 bit char. |
| double | readDouble()
Reads a 64 bit double. |
| ObjectInputStream.GetField | readFields()
Reads the persistent fields from the stream and makes them available by name. |
| float | readFloat()
Reads a 32 bit float. |
| void | readFully(byte[] data,
int offset,
int size)
Reads bytes, blocking until all bytes are read. |
| void | readFully(byte[] data)
Reads bytes, blocking until all bytes are read. |
| int | readInt()
Reads a 32 bit int. |
| String | readLine()
Deprecated. This method does not properly convert bytes to characters. see DataInputStream for the details and alternatives. |
| long | readLong()
Reads a 64 bit long. |
| Object | readObject()
Read an object from the ObjectInputStream. |
| protected Object | readObjectOverride()
This method is called by trusted subclasses of ObjectOutputStream that constructed ObjectOutputStream using the protected no-arg constructor. |
| short | readShort()
Reads a 16 bit short. |
| protected void | readStreamHeader()
The readStreamHeader method is provided to allow subclasses to read and verify their own stream headers. |
| int | readUnsignedByte()
Reads an unsigned 8 bit byte. |
| int | readUnsignedShort()
Reads an unsigned 16 bit short. |
| String | readUTF()
Reads a UTF format String. |
| void | registerValidation(ObjectInputValidation obj,
int prio)
Register an object to be validated before the graph is returned. |
| protected Class | resolveClass(ObjectStreamClass v)
Load the local class equivalent of the specified stream class description. |
| protected Object | resolveObject(Object obj)
This method will allow trusted subclasses of ObjectInputStream to substitute one object for another during deserialization. |
| int | skipBytes(int len)
Skips bytes, block until all bytes are skipped. |
| Methods inherited from class java.io.InputStream | |
| mark , markSupported , read , reset , skip | |
| Methods inherited from class java.lang.Object | |
| clone , equals , finalize , getClass , hashCode , notify , notifyAll , toString , wait , wait , wait | |
| Constructor Detail |
public ObjectInputStream(InputStream in)
throws IOException,
StreamCorruptedException
protected ObjectInputStream()
throws IOException,
SecurityException
checkPermission method with the
SerializablePermission("enableSubclassImplementation")
permission to ensure the caller has permission to enable subclassing.| Method Detail |
public final Object readObject()
throws OptionalDataException,
ClassNotFoundException,
IOException
The root object is completly restored when all of its fields and the objects it references are completely restored. At this point the object validation callbacks are executed in order based on their registered priorities. The callbacks are registered by objects (in the readObject special methods) as they are individually restored. Exceptions are thrown for problems with the InputStream and for classes that should not be deserialized. All exceptions are fatal to the InputStream and leave it in an indeterminate state; it is up to the caller to ignore or recover the stream state.
protected Object readObjectOverride()
throws OptionalDataException,
ClassNotFoundException,
IOException
ObjectInputStream(),
#readObject(ObjectInputStream)
public void defaultReadObject()
throws IOException,
ClassNotFoundException,
NotActiveException
public ObjectInputStream.GetField readFields()
throws IOException,
ClassNotFoundException,
NotActiveException
public void registerValidation(ObjectInputValidation obj,
int prio)
throws NotActiveException,
InvalidObjectException
obj
- the object to receive the validation callback.
prio
- controls the order of callbacks;zero is a good default.
Use higher numbers to be called back earlier, lower numbers for later
callbacks. Within a priority, callbacks are processed in no
particular order.
protected Class resolveClass(ObjectStreamClass v)
throws IOException,
ClassNotFoundException
By default the class name is resolved relative to the class that called readObject.
protected Object resolveObject(Object obj)
throws IOException
This method is called after an object has been read but before it is returned from readObject. The default resolveObject method just returns the new object.
When a subclass is replacing objects it must insure that the substituted object is compatible with every field where the reference will be stored. Objects whose type is not a subclass of the type of the field or array element abort the serialization by raising an exception and the object is not be stored.
This method is called only once when each object is first encountered. All subsequent references to the object will be redirected to the new object.
protected boolean enableResolveObject(boolean enable)
throws SecurityException
checkPermission method with the
SerializablePermission("enableSubstitution")
permission to ensure the caller has permission to
enable the stream to allow objects read from the stream to be replaced.
protected void readStreamHeader()
throws IOException,
StreamCorruptedException
public int read()
throws IOException
public int read(byte[] b,
int off,
int len)
throws IOException
b
- the buffer into which the data is read
off
- the start offset of the data
len
- the maximum number of bytes readDataInputStream.readFully(byte[],int,int)
public int available()
throws IOException
public void close()
throws IOException
public boolean readBoolean()
throws IOException
public byte readByte()
throws IOException
public int readUnsignedByte()
throws IOException
public short readShort()
throws IOException
public int readUnsignedShort()
throws IOException
public char readChar()
throws IOException
public int readInt()
throws IOException
public long readLong()
throws IOException
public float readFloat()
throws IOException
public double readDouble()
throws IOException
public void readFully(byte[] data)
throws IOException
b
- the buffer into which the data is read
public void readFully(byte[] data,
int offset,
int size)
throws IOException
b
- the buffer into which the data is read
off
- the start offset of the data
len
- the maximum number of bytes to read
public int skipBytes(int len)
throws IOException
n
- the number of bytes to be skipped
public String readLine()
throws IOException
public String readUTF()
throws IOException
|
Java Platform 1.2 Beta 4 |
|||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
| SUMMARY: INNER | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD | |||||||||