HomeDigital EditionSys-Con RadioSearch Java Cd
Advanced Java AWT Book Reviews/Excerpts Client Server Corba Editorials Embedded Java Enterprise Java IDE's Industry Watch Integration Interviews Java Applet Java & Databases Java & Web Services Java Fundamentals Java Native Interface Java Servlets Java Beans J2ME Libraries .NET Object Orientation Observations/IMHO Product Reviews Scalability & Performance Security Server Side Source Code Straight Talking Swing Threads Using Java with others Wireless XML
 

Data is one of those housekeeping duties that has to be performed by everyone who uses a computer. Whatever level they are on, somewhere along the line data is stored, files are created and directories are made.

Last month I introduced the whole notion of data and suggested ways in which we might handle various quantities of the stuff. One of the greatest problems faced by the developer is that of storage. Every situation seems to call for a different solution. For example, last month we looked at storing small amounts of data through the use of INI, or program information files. A complete class for this type of manipulation was developed and by the time implementation was complete we had a class that allowed the storing and retrieval of data arranged in key/value pairs.

In this column we will look at the saving and loading of complete classes through the use of the Object Serialization mechanism introduced in the 1.1 version of the JDK.

"Our object in the construction of the state is the greatest happiness of the whole, and not that of any one class."

These words were uttered by Plato around 400 B.C., and it makes you wonder just how old this supposedly new object-orientation really is. While we ponder this in the back of our minds, let's have a look at Object Serialization.

Object Serialization
In a nutshell, Object Serialization is a mechanism that allows an object to be represented as a byte stream. This byte stream can then be passed on to any of the Java streams, such as sockets and files, and then reassembled back into the original object with no data loss. Using this technique, not only can objects be safely saved and restored, but they can also be passed onto other machines in a distributed environment. In fact, Remote Method Invocation, or RMI, uses serialization in exactly this manner.

At this point you may be thinking that it sounds a little complicated. More hassle than it's really worth. Be prepared to be pleasantly surprised. Object Serialization has been made so easy to use, there's really no excuse for not taking advantage of it. Let's look at an example.

Listing 1 shows the saving of both a String and a Date object. You will notice the first thing that is created is an instance to an OutputStream. In this instance we are using a FileOutputStream, but this could have been any output stream. Next we create an ObjectOutputStream instance, which is what we will use to write the data to the output stream. Writing the actual objects out to disk is then a simple matter of calling the writeObject( ) method for each object that is to be saved.

The ObjectOutput interface is part of the java.io package. Listing 2 shows the main methods for this interface, of which ObjectOutputStream is an implementation.

As seen in Listing 2, the most important method is writeObject(...), which takes as a parameter a reference to an Object which can be transposed to a stream of bytes.

Recreating the objects is as simple as writing them in the first place. For each output-orientated method/class, the equivalent input methods exist. For example, to read back in the objects we wrote out earlier, we can use the code shown in Listing 3.

Instead of using writeObject(...), we use readObject(...), casting the objects necessary. One important point must be made, and that is the order in which objects are read and written. Generally, they have to be read in the same order they were written out in. This ensures the correct data is associated with each object.

The majority of the classes in JDK1.1 can be read and written using this technique. For example, let's say you had a Hashtable and it was populated with hundreds of String objects. Writing this out to disk can be performed using one call to writeObject(...) with the hash table as the object reference passed in. This will write out all the data associated with the hash table, including all the String objects. This is one of the greatest features of object serialization, the ability to present the developer with an interface that makes the saving and retrieval of objects a really trivial matter.

If the majority of the classes in the JDK are already for serialization, how do you go about making your own classes serializable? This is a very easy thing to do. Simply have your class implement the java.io.Serializable interface. Listing 4 illustrates this.

That's it! It's as simple as that. Once your class implements this interface, it can be read and saved as easily as the examples earlier in this article.

Summary
This article took a look at the Object Serialization method that was introduced in the 1.1 release of the JDK. As was demonstrated, reading and writing of object data is made extremely easy. But this isn't limited to just saving data in files. The same technique can be used to send complete objects to processes running on other machines via Sockets.

In next month's article we will look at JDBC and how we can start reading and writing volumes of data stored in an external database.

About the Author
Alan Williamson is on the Board of Directors at N-ARY Limited, a UK-based Java software company, specializing solely in JDBC and Java Servlets. He has recently completed his second book, focusing purely on Java Servlets, with his first book looking at using Java/JDBC/Servlets to provide an efficient database solution. He can be reached at [email protected] (http://www.n-ary.com) and welcomes all suggestions and comments.

	

Listing 1: Saving string and date object.
  
String tText = ěPlease save me!î;  
Date   tWhen = new Date();  

FileOutputStream     FS = new FileOutputStream("saveme.txt");  
ObjectOutputStream   OS = new ObjectOutputStream(FS);  
OS.writeObject( tText );  
OS.writeObject( tWhen );  
OS.flush();  

Listing 2: Main methods of ObjectOutput interface.
  
public interface ObjectOutput extends DataOutput  
{  
  public void writeObject(Object obj) throws IOException;  
  public void write(int b) throws IOException;  
  public void write(byte b[]) throws IOException;  
  public void write(byte b[], int off, int len) throws IOException;  
  public void flush() throws IOException;  
  public void close() throws IOException;  
}  

Listing 3.
  
String tText;  
Date   tWhen;  

FileIntputStream     FS = new FileInputStream("saveme.txt");  
ObjectOutputStream   IS = new ObjectInputStream(FS);  
tText                   = (String)IS.readObject();  
tWhen                   = (Date)IS.readObject();  

Listing 4: Implementing java.io.Serializable interface.
  
public class myClass implements java.io.Serializable  
{  
  String Name = ěî;  
  int age = 39;  

  public class myClass(){  
    Name = ěCeriî;  
    age  = 19;  
  }  
}  
  
      
 

All Rights Reserved
Copyright ©  2004 SYS-CON Media, Inc.
  E-mail: [email protected]

Java and Java-based marks are trademarks or registered trademarks of Sun Microsystems, Inc. in the United States and other countries. SYS-CON Publications, Inc. is independent of Sun Microsystems, Inc.