ObjectOutputStream JDK 1.6)

Description

public class ObjectOutputStream

An ObjectOutputStream writes primitive data types and graphs of Java objects to an OutputStream.

An ObjectOutputStream writes primitive data types and graphs of Java objects to an OutputStream. The objects can be read (reconstituted) using an ObjectInputStream. Persistent storage of objects can be accomplished by using a file for the stream. If the stream is a network socket stream, the objects can be reconstituted on another host or in another process.

Only objects that support the java.io.Serializable interface can be written to streams. The class of each serializable object is encoded including the class name and signature of the class, the values of the object's fields and arrays, and the closure of any other objects referenced from the initial objects.

The method writeObject is used to write an object to the stream. Any object, including Strings and arrays, is written with writeObject. Multiple objects or primitives can be written to the stream. The objects must be read back from the corresponding ObjectInputstream with the same types and in the same order as they were written.

Primitive data types can also be written to the stream using the appropriate methods from DataOutput. Strings can also be written using the writeUTF method.

The default serialization mechanism for an object writes the class of the object, the class signature, and the values of all non-transient and non-static fields. References to other objects (except in transient or static fields) cause those objects to be written also. Multiple references to a single object are encoded using a reference sharing mechanism so that graphs of objects can be restored to the same shape as when the original was written.

For example to write an object that can be read by the example in ObjectInputStream:

        FileOutputStream fos = new FileOutputStream("t.tmp");
        ObjectOutputStream oos = new ObjectOutputStream(fos);

        oos.writeInt(12345);
        oos.writeObject("Today");
        oos.writeObject(new Date());

        oos.close();

Classes that require special handling during the serialization and deserialization process must implement special methods with these exact signatures:

 private void readObject(java.io.ObjectInputStream stream)
     throws IOException, ClassNotFoundException;
 private void writeObject(java.io.ObjectOutputStream stream)
     throws IOException
 private void readObjectNoData() 
     throws ObjectStreamException;

The writeObject method is responsible for writing the state of the object for its particular class so that the corresponding readObject method can restore it. The method does not need to concern itself with the state belonging to the object's superclasses or subclasses. State is saved by writing the individual fields to the ObjectOutputStream using the writeObject method or by using the methods for primitive data types supported by DataOutput.

Serialization does not write out 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.

Serialization of an object can be prevented by implementing writeObject and readObject methods that throw the NotSerializableException. The exception will be caught by the ObjectOutputStream and abort the serialization 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.

Enum constants are serialized differently than ordinary serializable or externalizable objects. The serialized form of an enum constant consists solely of its name; field values of the constant are not transmitted. To serialize an enum constant, ObjectOutputStream writes the string returned by the constant's name method. Like other serializable or externalizable objects, enum constants can function as the targets of back references appearing subsequently in the serialization stream. The process by which enum constants are serialized cannot be customized; any class-specific writeObject and writeReplace methods defined by enum types are ignored during serialization. Similarly, any serialPersistentFields or serialVersionUID field declarations are also ignored--all enum types have a fixed serialVersionUID of 0L.

Primitive data, excluding serializable fields and externalizable data, is written to the ObjectOutputStream in block-data records. A block data record is composed of a header and data. The block data header consists of a marker and the number of bytes to follow the header. Consecutive primitive data writes are merged into one block-data record. The blocking factor used for a block-data record will be 1024 bytes. Each block-data record will be filled up to 1024 bytes, or be written whenever there is a termination of block-data mode. Calls to the ObjectOutputStream methods writeObject, defaultWriteObject and writeFields initially terminate any existing block-data record.

See also: DataOutput ObjectInputStream Serializable Externalizable Object Serialization Specification, Section 2, Object Output Classes

Methods

Hide/Show inherited methods

protected void annotateClass (Class<Object> cl) throws IOException

Subclasses may implement this method to allow class data to be stored in the stream.

protected void annotateProxyClass (Class<Object> cl) throws IOException

Subclasses may implement this method to store custom data in the stream along with descriptors for dynamic proxy classes.

public void close () throws IOException [Overrides OutputStream] [Specified in ObjectOutput]

Closes the stream.

public void defaultWriteObject () throws IOException

Write the non-static and non-transient fields of the current class to this stream.

Write the non-static and non-transient fields of the current class to
this stream. This may only be called from the writeObject method of the
class being serialized. It will throw the NotActiveException if it is
called otherwise.
Throws:
- IOException - if I/O errors occur while writing to the underlying OutputStream

protected void drain () throws IOException

Drain any buffered data in ObjectOutputStream.

protected boolean enableReplaceObject (boolean enable) throws SecurityException

Enable the stream to do replacement of objects in the stream.

public void flush () throws IOException [Overrides OutputStream] [Specified in ObjectOutput]

Flushes the stream.

pack-private int getProtocolVersion ()

Returns protocol version in use.

public PutField putFields () throws IOException

Retrieve the object used to buffer persistent fields to be written to the stream.

protected Object replaceObject (Object obj) throws IOException

This method will allow trusted subclasses of ObjectOutputStream to substitute one object for another during serialization.

public void reset () throws IOException

Reset will disregard the state of any objects already written to the stream.

public void useProtocolVersion (int version) throws IOException

Specify stream protocol version to use when writing the stream.

public void write (byte[] buf) throws IOException [Overrides OutputStream] [Specified in ObjectOutput]

Writes an array of bytes.

public void write (byte[] buf, int off, int len) throws IOException [Overrides OutputStream] [Specified in ObjectOutput]

Writes a sub array of bytes.

public void write (int val) throws IOException [Specified in ObjectOutput]

Writes a byte.

public void writeBoolean (boolean val) throws IOException

Writes a boolean.

public void writeByte (int val) throws IOException

Writes an 8 bit byte.

public void writeBytes (String str) throws IOException

Writes a String as a sequence of bytes.

public void writeChar (int val) throws IOException

Writes a 16 bit char.

public void writeChars (String str) throws IOException

Writes a String as a sequence of chars.

protected void writeClassDescriptor (ObjectStreamClass desc) throws IOException

Write the specified class descriptor to the ObjectOutputStream.

Write the specified class descriptor to the ObjectOutputStream. Class descriptors are used to identify the classes of objects written to the stream. Subclasses of ObjectOutputStream may override this method to customize the way in which class descriptors are written to the serialization stream. The corresponding method in ObjectInputStream, readClassDescriptor, should then be overridden to reconstitute the class descriptor from its custom stream representation. By default, this method writes class descriptors according to the format defined in the Object Serialization specification.

Note that this method will only be called if the ObjectOutputStream is not using the old serialization stream format (set by calling ObjectOutputStream's useProtocolVersion method). If this serialization stream is using the old format (PROTOCOL_VERSION_1), the class descriptor will be written internally in a manner that cannot be overridden or customized.
Parameters:
- desc - class descriptor to write to the stream
Throws:
- IOException - If an I/O error has occurred.
Since: 1.3
See Also: ObjectInputStream.readClassDescriptor(), ObjectOutputStream.useProtocolVersion(int), ObjectStreamConstants.PROTOCOL_VERSION_1,

public void writeDouble (double val) throws IOException

Writes a 64 bit double.

public void writeFields () throws IOException

Write the buffered fields to the stream.

public void writeFloat (float val) throws IOException

Writes a 32 bit float.

public void writeInt (int val) throws IOException

Writes a 32 bit int.

public void writeLong (long val) throws IOException

Writes a 64 bit long.

publicfinal void writeObject (Object obj) throws IOException [Specified in ObjectOutput]

Write the specified object to the ObjectOutputStream.

protected void writeObjectOverride (Object obj) throws IOException

Method used by subclasses to override the default writeObject method.

public void writeShort (int val) throws IOException

Writes a 16 bit short.

protected void writeStreamHeader () throws IOException

The writeStreamHeader method is provided so subclasses can append or prepend their own header to the stream.

pack-private void writeTypeString (String str) throws IOException

Writes string without allowing it to be replaced in stream.

public void writeUnshared (Object obj) throws IOException

Writes an "unshared" object to the ObjectOutputStream.

Writes an "unshared" object to the ObjectOutputStream. This method is identical to writeObject, except that it always writes the given object as a new, unique object in the stream (as opposed to a back-reference pointing to a previously serialized instance). Specifically:

An object written via writeUnshared is always serialized in the same manner as a newly appearing object (an object that has not been written to the stream yet), regardless of whether or not the object has been written previously.
If writeObject is used to write an object that has been previously written with writeUnshared, the previous writeUnshared operation is treated as if it were a write of a separate object. In other words, ObjectOutputStream will never generate back-references to object data written by calls to writeUnshared.

While writing an object via writeUnshared does not in itself guarantee a unique reference to the object when it is deserialized, it allows a single object to be defined multiple times in a stream, so that multiple calls to readUnshared by the receiver will not conflict. Note that the rules described above only apply to the base-level object written with writeUnshared, and not to any transitively referenced sub-objects in the object graph to be serialized.

ObjectOutputStream subclasses which override this method can only be constructed in security contexts possessing the "enableSubclassImplementation" SerializablePermission; any attempt to instantiate such a subclass without this permission will cause a SecurityException to be thrown.
Parameters:
- obj - object to write to stream
Throws:
- NotSerializableException - if an object in the graph to be serialized does not implement the Serializable interface
- InvalidClassException - if a problem exists with the class of an object to be serialized
- IOException - if an I/O error occurs during serialization
Since: 1.4

public void writeUTF (String str) throws IOException

Primitive data write of this String in modified UTF-8 format.

Fields

Hide/Show inherited fields

publicfinalstatic int baseWireHandle = "8257536" [Inherited From ObjectStreamConstants]

First wire handle to be assigned.

publicfinalstatic int PROTOCOL_VERSION_1 = "1" [Inherited From ObjectStreamConstants]

A Stream Protocol Version.

publicfinalstatic int PROTOCOL_VERSION_2 = "2" [Inherited From ObjectStreamConstants]

A Stream Protocol Version.

publicfinalstatic byte SC_BLOCK_DATA = "8" [Inherited From ObjectStreamConstants]