Advanced   Java   Services

Serialisierung  (Lesen und Schreiben von Objekten)

Mit ObjectOutputStream und ObjectInputStream kann man Objekte speichern oder einlesen. Voraussetzung dafür ist allerdings, daß die zugehörigen Klassen das Interface Serializable implementiert haben. Bei diesem Interface handelt es sich um ein sog. "tagging interface", also um ein Markierungsinterface, das zur Typprüfung veredent wird und keine Implementierung von Methoden fordert. Hat ein Objekt den Typ Serializable, so gilt es als dauerhaft speicherbar, also persistent. Das Speichern eines Objektes ist gewissermaßen ein Einfrieren des Zustands um zu einem späteren Zeitpunkt das Objekt in desem Zustand wiederherzustellen.

Der Versuch, ein Objekt zu speichern, das nicht vom Typ Serializable ist, endet zur Laufzeit mit einer NotSerializableException, einer Unterklasse von ObjectStreamException. Es folgt ein Auszug aus der API.

Will man eine Reihe von Objekten gleichen Typs wegschreiben, so ist das Vorgehen sehr einfach und analog zu den bereits besprochenen Vorgängen. Das folgende Beispiel erzeugt Datumsobjekte für den Monat Januar 2001 und speichert sie in eine Datei.

/**
 * Date-Objekte für Januar 2001 wegschreiben
 */
private static void writeDateObjects(String fileName)
{
   System.out.println("write date objects");
   Calendar cal = Calendar.getInstance();

   // wegschreiben
   try(FileOutputStream fos = new FileOutputStream(fileName);
         BufferedOutputStream bos = new BufferedOutputStream(fos);
         ObjectOutputStream oos = new ObjectOutputStream(bos);)
   {
      for(int i = 1; i < 32; i++)
      {
         cal.set(2001, 0, i);
         oos.writeObject(cal.getTime()); // Date
      }
      System.out.println("date objects written");
   }
   catch(IOException ex)
   {
      System.out.println(ex);
   }
}

Das folgende Beispiel speichert die aktuelle Uhrzeit, danach die Anzahl der Millisekunden seit dem 01.01.1970 (Typ long) und danch den Namen der Zeitzone (Typ String). Verwendet wird das in Java 7 eingeführte try with resources.

private static void writeObjects(String fileName)
{
   Calendar cal = Calendar.getInstance();
   Date date = new Date();

   // wegschreiben
   try(ObjectOutputStream oos = new ObjectOutputStream(new BufferedOutputStream(new FileOutputStream(fileName)));)
   {
      Date time = cal.getTime();
      System.out.println("schreibe: " + time);
      oos.writeObject(time); // liefert Date, schreibt Date
      long millis = date.getTime();
      System.out.println("schreibe: " + millis);
      oos.writeLong(millis); // schreibt long
      TimeZone tz = cal.getTimeZone();
      System.out.println("schreibe: " + tz.getDisplayName());
      oos.writeObject(tz.getDisplayName()); // liefert String, schreibt String
      System.out.println("data written");
   }
   catch(IOException ex)
   {
      System.out.println(ex);
   }
}

Wie schon aus den Methoden eingangs ersichtlich kann man mit ObjectOutputStream auch Variable mit einem primitiven Datentyp schreiben.

Das Einlesen von Objekten kann ein komplexer Vorgang werden. Wir werden die obigen Beispiele fortführen und die entsprechenden Objekte wieder "auftauen". Das Lesen von Objekten kommt einem Konstruktoraufruf gleich. Es werden Objekte initialisiert, Typ und Zustand werden der serialisierten Form entnommen. Zunächst wieder ein Auszug aus der API.

Für das Einlesen unserer Ojekte setzen wir voraus, daß der Typ bekannt ist (Date), aber die Anzahl der Datensätze nicht bekannt ist. Wir wollen also bis zum Dateiende lesen. Die dafür zuständige Methode readObject() gibt nun nicht, wie vielleicht zu erwarten, am Dateiende null zurück (vgl. die Methode readLine() bei BufferedReader) sondern wirft eine EOFException.

private static void readDateObjects(String fileName)
{
   System.out.println("read date objects");

   ObjectInputStream ois = null;
   Object ob = null;
   int count = 0;

   try
   {
      ois = new ObjectInputStream(new BufferedInputStream(new FileInputStream(fileName)));
      for(;;)
      {
         ob = ois.readObject();
         count++;
         System.out.println(ob);
      }
      // System.out.println(ob);
   }
   catch(EOFException ex) // wg. readObject
   {
      System.out.println("--- EOF ---");
      System.out.println("Es wurden " + count + " Objekte eingelesen");
   }
   catch(IOException ex)
   {
      System.out.println(ex);
   }
   catch(ClassNotFoundException ex) // wg. readObject
   {
      System.out.println(ex);
   }
   finally
   {
      try
      {
         if (ois != null) ois.close();
      }
      catch(IOException ex)
      {
      }
   }
}

Da wir das Dateiende erst durch eine Exception erkennen, müssen wird Datei nach dieser Exception schließen. Dafür bietet sich finally an, wobei wir allerdings in finally noch einmal ein try catch Konstrukt unterbringen müssen, da die close()-Methode eine IOException wirft, eine typische Situation, auf die wir auch bei Datenbankzugriffen stoßen. des weiteren muß noch eine ClassCastException abgefangen werden, die readObject() werfen könnte. Will man keine abgestufte Reaktion, so kann man, wie immer, mehrere catch-Verzweigungen durch ein einziges catch unter Verwendung der ersten Oberklasse ersetzen.

Der umgekehrte Vorgang des zweiten Beispiels erfordert nun ein Einlesen eines Dateobjekts, gefolgt von einer long-Zahl, gefolgt von einem String. Kennt man die Datentypen ist das Einlesen einfach. Auch hier kann man das elegante try with resources verwenden.

private static void readObjects(String fileName)
{
   System.out.println("read data");
   try(ObjectInputStream ois = new ObjectInputStream(new BufferedInputStream(new FileInputStream(fileName)));)
   {
      Object ob = ois.readObject();
      System.out.println("gelesen : " + ob); // java.util.Date
      long lon = ois.readLong();
      System.out.println("gelesen : " + lon);
      ob = ois.readObject(); // wirft OptionalDataException
      System.out.println("gelesen : " + ob);
      System.out.println("end read");
   }
   catch(IOException | ClassNotFoundException ex)
   {
      ex.printStackTrace();
   }
}

Anders ist es, wenn man die Reihenfolge nicht kennt. Wir machen nun absichtlich einen Fehler und versuchen zwei Objekte hintereinander einzulesen. Das zweite readObject() wirft nämlich eine OptionalDataException, wenn es nicht auf Objektdaten stößt. Da der interne Dateipositionszeiger stehenbleibt, haben wir im catch()-Block die Chance, die long-zahl einzulesen. readLong() liest genau 8 byte und interpretiert sie als long-Zahl. Das nächste readObject() liest dann den String ein.

/**
 * Einlesen mit Fehler
 */
private static void readObjects2(String fileName)
{
   System.out.println("read data");
   Object ob = null;
   ObjectInputStream ois = null;

   try
   {
      ois = new ObjectInputStream(new BufferedInputStream(new FileInputStream(fileName)));
      ob = ois.readObject();
      System.out.println("gelesen : " + ob); // java.util.Date
      // falsches Lesen
      ob = ois.readObject(); // wirft OptionalDataException
   }
   catch(OptionalDataException ex) // Primitive data was found in the stream instead of objects.
   {
      System.out.println("OptionalDataException"); //
      try
      {
         long lo = ois.readLong();
         System.out.println("gelesen : " + lo);
         ob = ois.readObject();
         System.out.println("gelesen : " + ob);
      }
      catch(IOException ex2)
      {
         System.out.println(ex2);
      }
      catch(ClassNotFoundException ex2) // wg. readObject
      {
         System.out.println(ex2);
      }
   }
   catch(IOException ex)
   {
      System.out.println(ex);
   }
   catch(ClassNotFoundException ex) // wg. readObject
   {
      System.out.println(ex);
   }
   finally
   {
      try
      {
         if (ois != null) ois.close();
      }
      catch(IOException ex)
      {
      }
   }
}