6.9 Persistente Objekte und Serialisierung

Objekte liegen zwar immer nur zur Laufzeit vor, doch auch nach dem Beenden der virtuellen Maschine soll ihre Struktur nicht verloren gehen. Gewünscht ist ein Mechanismus, der die Objektstruktur und Variablenbelegung zu einer bestimmten Zeit sicher (persistent) macht und an anderer Stelle wieder hervorholt und die Objektstruktur und Variablenbelegung restauriert. Im gespeicherten Datenformat müssen alle Informationen wie der Objekttyp und der Variablentyp enthalten sein, um später das richtige Wiederherstellen zu ermöglichen. Da Objekte oftmals weitere Objekte einschließen, müssen auch diese Unterobjekte gesichert werden (schreibe ich eine Liste mit Bestellungen, so ist die Liste ohne die referenzierten Objekte sinnlos). Genau dieser Mechanismus wird auch dann angewendet, wenn Objekte über das Netzwerk schwirren.[48](Die Rede ist hier von RMI.) Die persistenten Objekte sichern also neben ihren eigenen Informationen auch die Unterobjekte – also die von der betrachtenden Stelle aus erreichbaren. Beim Speichern wird rekursiv ein Objektbaum durchlaufen, um eine vollständige Datenstruktur zu erhalten. Der doppelte Zugriff auf ein Objekt wird hier ebenso beachtet wie der Fall, dass zyklische Abhängigkeiten auftreten. Jedes Objekt bekommt dabei ein Handle, sodass es im Datenstrom nur einmal kodiert wird.

Unter Java SE lassen sich Objekte über verschiedene Ansätze automatisch persistent abbilden und speichern:

• Standardserialisierung: Die Objektstruktur und Zustände werden in einem binären Format gesichert. Das Verfahren wird auch Java Object Serialization (JOS) genannt – der Punkt, mit dem wir uns im Folgenden beschäftigen wollen. Die Standardserialisierung ist bei entfernten Methodenaufrufen sehr wichtig und weniger, um Dinge über einen langen Zeitraum abzuspeichern und dann irgendwann einmal wieder aus dem Schrank zu holen.
• XML-Serialisierung über JavaBeans Persistence: JavaBeans – und nur solche – können wir in einem XML-Format sichern. Eine Lösung ist die JavaBeans Persistence (JBP), die ursprünglich für Swing gedacht war. Denn wenn der Zustand einer grafischen Oberfläche mit JOS binär persistiert wird, sind Änderungen an den Interna der Swing-API nicht so einfach möglich, da das Binärformat der JOS sehr eng mit dem Objektmodell verbunden ist. Das heißt, Objekte lassen sich mitunter nicht mehr aus dem Binärdokument rekonstruieren. JBP entkoppelt das, indem nur über Setter/Getter kommunziert wird und nicht auf internen Referenzen, die ein Implementierungsdetail sind, das sich jederzeit ändern kann. Heutzutage spielt JBP in der Praxis kaum eine Rolle.
• XML-Abbildung über JAXB: Mit JAXB steht eine zweite API zum Abbilden der Objektstruktur auf XML-Dokumente bereit. JAXB ist Teil der Standardbibliothek ab Version 6 und wird in Kapitel 7, »Die eXtensible Markup Language (XML)«, erklärt. Sie ist eine sehr wichtige Technologie, insbesondere für Web-Service-Aufrufe.

Die drei Möglichkeiten JOS, JBP und JAXB sind in Java SE schon eingebaut. Die Standardserialisierung erzeugt ein binäres Format und ist sehr stark auf Java ausgerichtet, sodass andere Systeme nicht viel mit den Daten anfangen können. XML ist als Format praktisch, da es auch von anderen Systemen verarbeitet werden kann. Ein anderes kompaktes Binärformat, das auch Interoperabilität erlaubt, ist Protocol Buffers (http://code.google.com/p/protobuf/) von Google; das Unternehmen setzt es intern ein, wenn unterschiedliche Anwendungen Daten austauschen sollen.

Etwas weiter gedacht lassen sich auch Objekte in relationalen Datenbanken speichern, was sich objekt-relationales Mapping (OR-Mapping) nennt. Das ist sehr anspruchsvoll, da die Objektmodelle und Tabellen so ganz anders sind. Die Java SE bietet keine Unterstützung für das OR-Mapping an, doch mit zusätzlichen Frameworks, wie der JPA (Java Persistence API), ist das zu schaffen. Auch von Hand können die Objekte über JDBC in die Datenbank gebracht werden, was aber nicht zeitgemäß ist.

6.9.1 Objekte mit der Standard-Serialisierung speichern und lesen

Die Standard-Serialisierung bietet eine einfache Möglichkeit, um Objekte persistent zu machen und später wiederherzustellen. Dabei werden die Objektzustände (keine statischen!) in einen Byte-Strom geschrieben (Serialisierung), woraus sie später wieder zu einem Objekt rekonstruiert werden können (Deserialisierung). Im Zentrum stehen zwei Klassen und ihre (De-) Serialisierungsmethode:

• Serialisierung: Die Klasse ObjectOutputStream und die Methode writeObject(). Während der Serialisierung geht ObjectOutputStream die Zustände und Objektverweise rekursiv ab und schreibt die Zustände Schritt für Schritt in einen Ausgabestrom.
• Deserialisierung: Zum Lesen der serialisierten Objektzustände dient die Klasse ObjectInputStream. Ihre Methode readObject() findet den Typ des serialisierten Objekts und baut daraus zur Laufzeit das Zielobjekt auf.

ObjectOutputStream

An einem Beispiel lässt sich gut erkennen, wie ein ObjectOutputStream einen String und das aktuelle Tagesdatum in einen OutputStream speichert. Um die Daten in eine Datei zu holen, ist der OutputStream ein FileOutputStream für eine Datei datum.ser. Der Dateiname wird meist so gewählt, dass er mit .ser endet:

Listing 6.25: com/tutego/insel/io/ser/SerializeAndDeserializeDate.java, serialize()

OutputStream fos = null;

try
{
  fos = new FileOutputStream( filename );
  ObjectOutputStream o = new ObjectOutputStream( fos );
  o.writeObject( "Today" );
  o.writeObject( new Date() );
}
catch ( IOException e ) { System.err.println( e ); }
finally { try { fos.close(); } catch ( Exception e ) { e.printStackTrace(); } }

Allen Anfang bildet wie üblich ein OutputStream, der die Zustände der Objekte und Meta-Informationen aufnimmt. In unserem Fall ist das der FileOutputStream. Die Verbindung zwischen der Datei und dem Objektstrom durch die Klasse ObjectOutputStream geschieht über den Konstruktor, der einen OutputStream annimmt. ObjectOutputStream implementiert die Schnittstelle ObjectOutput und bietet so beispielsweise die Methode writeObject() zum Schreiben von Objekten. Damit wird das Serialisieren des String-Objekts (das »Today«) und des anschließenden Datum-Objekts zum Kinderspiel.

class java.io.ObjectOutputStream
extends OutputStream
implements ObjectOutput, ObjectStreamConstants

• ObjectOutputStream(OutputStream out) throws IOException
  Erzeugt einen ObjectOutputStream, der in den angegebenen OutputStream schreibt. Ein Fehler kann von den Methoden aus dem OutputStream kommen.
• final void writeObject(Object obj) throws IOException
  Schreibt das Objekt.
• void flush() throws IOException
  Schreibt noch gepufferte Daten.
• void close() throws IOException
  Schließt den Datenstrom. Die Methode muss aufgerufen werden, bevor der Datenstrom zur Eingabe verwendet werden soll.

Die Methode writeObject() kann nicht nur bei Ein-/Ausgabefehlern eine IOException auslösen, sondern auch eine NotSerializableException, wenn das Objekt gar nicht serialisierbar ist, und eine InvalidClassException, wenn beim Serialisieren etwas falsch läuft.

Objekte über die Standard-Serialisierung lesen

Aus den Daten im Datenstrom stellt der ObjectInputStream ein neues Objekt her und initialisiert die Zustände, wie sie geschrieben wurden. Wenn nötig, restauriert der ObjectInputStream auch Objekte, auf die verwiesen wurde. Die Klasseninformationen müssen zur Laufzeit vorhanden sein, weil bei der Serialisierung nur die Zustände, aber keine .class-Dateien gesichert werden. Während des Lesens findet readObject() also bei unserem Beispiel den String und das Datum. Der ObjectInputStream erwartet die Rohdaten wie üblich über einen Eingabestrom. Kommen die Informationen aus einer Datei, verwenden wir den FileInputStream:

Listing 6.26: com/tutego/insel/io/ser/SerializeAndDeserializeDate.java, deserialize()

InputStream fis = null;

try
{
  fis = new FileInputStream( filename );
  ObjectInputStream o = new ObjectInputStream( fis );
  String string = (String) o.readObject();
  Date date     = (Date) o.readObject();
  System.out.println( string );
  System.out.println( date );
}
catch ( IOException e ) { System.err.println( e ); }
catch ( ClassNotFoundException e ) { System.err.println( e ); }
finally { try { fis.close(); } catch ( Exception e ) { } }

Die explizite Typumwandlung kann natürlich bei einer falschen Zuweisung zu einem Fehler führen. Bei generischen Typen ist diese Typanpassung immer etwas lästig.

class java.io.ObjectInputStream
extends InputStream
implements ObjectInput, ObjectStreamConstants

• ObjectInputStream(InputStream out) throws IOException
  Erzeugt einen ObjectInputStream, der aus einem gegebenen InputStream liest.
• final Object readObject() throws ClassNotFoundException, IOException
  Liest ein Object und gibt es zurück. Eine ClassNotFoundException wird ausgelöst, wenn das Objekt zu einer Klasse gehört, die nicht auffindbar ist.

Die Schnittstellen ObjectOutput und ObjectInput *

Die Klasse ObjectOutputStream bekommt die Vorgabe für writeObject() aus einer Schnittstelle ObjectOutput, genauso wie ObjectInputStream die Operation readObject() aus ObjectInput implementiert. Bis auf die Standard-Serialisierung haben die Schnittstellen ObjectOutput und ObjectInput in Java keine weitere Verwendung.

Die Schnittstelle ObjectOutput erweitert selbst die Schnittstelle DataOutput um das Schreiben von Primitiven: write(byte[]), write(byte[], int, int), write(int), writeBoolean(boolean), writeByte(int), writeBytes(String), writeChar(int), writeChars(String), writeDouble(double), writeFloat(float), writeInt(int), writeLong(long), writeShort(int) und writeUTF(String). Das ist bei einer eigenen angepassten Serialisierung interessant, wenn wir selbst das Schreiben von Zuständen übernehmen. Umgekehrt erweitert die Schnittstelle ObjectInput die Schnittstelle DataInput und bietet diverse readXXX()-Methoden.

6.9.2 Zwei einfache Anwendungen der Serialisierung *

Im Folgenden wollen wir uns zwei Beispiele für die Serialisierung anschauen:

• Objektzustände zu verpacken, ist bei der Kommunikation über ein Netzwerk sehr sinnvoll. Die Serialisierung kann einfach die Zustände von einem Rechner auf den anderen übertragen.
• Serialisierung ist aber auch eine Möglichkeit, die Zustände als Byte-Feld etwa in eine Datenbank zu schreiben. Dabei werden wir sehen, dass der ByteArrayOutputStream eine nützliche Stream-Klasse ist.

Objekte über das Netzwerk schicken

Es ist natürlich wieder feines objektorientiertes Design, dass es der Methode writeObject() egal ist, wohin das Objekt geschoben wird. Dazu wird ja einfach dem Konstruktor von ObjectOutputStream ein OutputStream übergeben, und writeObject() delegiert dann das Senden der entsprechenden Einträge an die passenden Methoden der Output-Klasse. Im Beispiel SerializeAndDeserializeDate haben wir ein FileOutputStream benutzt. Es gibt aber noch eine ganze Menge anderer Klassen, die vom Typ OutputStream sind. So können die Objekte auch in einer Datenbank abgelegt beziehungsweise über das Netzwerk verschickt werden. Wie dies funktioniert, zeigen die nächsten Zeilen:

Socket s = new Socket( host, port );
OutputStream os = s.getOutputStream();
ObjectOutputStream oos = new ObjectOutputStream( os );
oos.writeObject( object );
oos.flush();

Über s.getOutputStream() gelangen wir an den Datenstrom. Dann sieht alles wie gewohnt aus. Da wir allerdings auf der Empfängerseite noch ein Protokoll ausmachen müssen, verfolgen wir diesen Weg der Objektversendung nicht weiter und verlassen uns vielmehr auf eine Technik, die sich RMI nennt.

Objekte in ein Byte-Feld schreiben

Die Klassen ObjectOutputStream und ByteArrayOutputStream sind zusammen zwei gute Partner, wenn es darum geht, eine Repräsentation eines Objekts im Speicher zu erzeugen und die geschätzte Größe eines Objekts herauszufinden.

Object o = ...;
ByteArrayOutputStream baos = new ByteArrayOutputStream();
ObjectOutputStream    oos  = new ObjectOutputStream( baos );
oos.writeObject( o );
oos.close();
byte[] array = baos.toByteArray();

Nun steht das Objekt im Byte-Feld. Wollten wir die Größe erfragen, müssten wir das Attribut length des Felds auslesen.

6.9.3 Die Schnittstelle Serializable

Bisher nahmen wir immer an, dass eine Klasse weiß, wie sie geschrieben wird. Das funktioniert wie selbstverständlich bei vielen vorhandenen Klassen, und so müssen wir uns bei writeObject(new Date()) keine Gedanken darüber machen, wie die Bibliothek das Datum schreibt und auch wieder liest.

Damit Objekte serialisiert werden können, müssen die Klassen die Schnittstelle Serializable implementieren. Diese Schnittstelle enthält keine Methoden und ist nur eine Markierungsschnittstelle (engl. marker interface). Implementiert eine Klasse diese Schnittstelle nicht, folgt beim Serialisierungsversuch eine NotSerializableException. Eine Klasse wie java.util.Date implementiert somit Serializable, Thread jedoch nicht. Der Serialisierer lässt damit alle Klassen »durch«, die instanceof Serializable sind. Daraus folgt, dass alle Unterklassen einer Klasse, die serialisierbar ist, auch ihrerseits serialisierbar sind. So implementiert java. lang.Number – die Basisklasse der Wrapper-Klassen – die Schnittstelle Serializable, und die konkreten Wrapper-Klassen wie Integer, BigDecimal sind somit ebenfalls serialisierbar.

Die serialisierbare Klasse Person

Wir wollen im Folgenden eine Klasse Person serialisierbar machen. Dazu benötigen wir das folgende Gerüst:

Listing 6.27: com/tutego/insel/io/ser/Person.java

package com.tutego.insel.io.ser;

import java.io.Serializable;
import java.util.Date;

public class Person implements Serializable
{
  static int BMI_OVERWEIGHT = 25;

  String name;
  Date   birthday;
  double bodyHeight;
}

Erzeugen wir ein Person-Objekt p und rufen writeObject(p) auf, so schiebt der ObjectOutputStream die Variablen-Belegungen (hier name, birthday und bodyHeight) in den Datenstrom.

Statische Variablen wie BMI_OVERWEIGHT werden nicht mit dem Standard-Serialisierungsmechanismus gesichert. Bevor durch Deserialisierung ein Objekt einer Klasse erzeugt wird, muss schon die Klasse geladen sein, was bedeutet, dass statische Variablen schon initialisiert sind. Wenn zwei Objekte wieder deserialisiert werden, könnte es andernfalls vorkommen, dass beide unterschiedliche Werte aufweisen. Was sollte dann passieren?

Nicht serialisierbare Objekte

Nicht alle Objekte sind serialisierbar. Zu den nicht serialisierbaren Klassen gehören zum Beispiel Thread und Socket und viele weitere Klassen aus dem java.io-Paket. Das liegt daran, dass nicht klar ist, wie zum Beispiel ein Wiederaufbau aussehen sollte. Wenn ein Thread etwa eine Datei zum Lesen geöffnet hat, wie soll der Zustand serialisiert werden, sodass er beim Deserialisieren auf einem anderen Rechner sofort wieder laufen und dort weitermachen kann, wo er mit dem Lesen aufgehört hat?

Ob Objekte als Träger sensibler Daten serialisierbar sein sollen, ist gut zu überlegen. Denn bei der Serialisierung der Zustände – es werden auch private Attribute serialisiert, an die zunächst nicht so einfach heranzukommen ist – öffnet sich die Kapselung. Aus dem Datenstrom lassen sich die internen Belegungen ablesen und auch manipulieren.

6.9.4 Nicht serialisierbare Attribute aussparen

Es gibt eine Reihe von Objekttypen, die sich nicht serialisieren lassen – technisch gesprochen implementieren diese Klassen die Schnittstelle Serializable nicht. Der Grund, dass nicht alle Klassen diese Schnittstelle implementieren, kann zum Beispiel die Sicherheit sein: Ein Objekt, das Passwörter speichert, soll nicht einfach geschrieben werden. Da reicht es nicht, dass die Attribute privat sind, denn auch sie werden geschrieben. Der andere Punkt ist die Tatsache, dass sich nicht alle Zustände beim Deserialisieren wiederherstellen lassen. Was ist, wenn ein FileInputStream oder Thread serialisiert wird? Soll dann bei der Deserialisierung eine Datei geöffnet werden oder der Thread neu starten? Was ist, wenn die Datei nicht vorhanden ist? Da all diese Fragen ungeklärt sind, ist es am einfachsten, wenn die Klassen nicht serialisierbarer Objekte die Schnittstelle Serializable nicht implementieren.

Doch was soll geschehen, wenn ein Objekt geschrieben wird, das intern auf ein nicht serialisierbares Objekt – etwa auf einen Thread – verweist?

Die Serialisierung der folgenden Klasse führt zu einem Laufzeitfehler:

Listing 6.28: com/tutego/insel/io/ser/SerializeTransient.java, NotTransientNotSerializable

class NotTransientNotSerializable implements Serializable
{
  Thread t = new Thread();
//  transient Thread t = new Thread();
  String s = "Fremde sind Freunde, die man nur noch nicht kennengelernt hat.";
}

Der Fehler wird eine NotSerializableException sein:

Exception in thread "main" java.io.NotSerializableException: java.lang.Thread
  at java.io.ObjectOutputStream.writeObject0(ObjectOutputStream.java:1151)
  at java.io.ObjectOutputStream.defaultWriteFields(ObjectOutputStream.java:1504)
  at java.io.ObjectOutputStream.writeSerialData(ObjectOutputStream.java:1469)
  at java.io.ObjectOutputStream.writeOrdinaryObject(ObjectOutputStream.java:1387)
  at java.io.ObjectOutputStream.writeObject0(ObjectOutputStream.java:1145)
  at java.io.ObjectOutputStream.writeObject(ObjectOutputStream.java:326)
  at com.tutego.insel.io.ser.SerializeTransient.main(SerializeTransient.java:19)

Die Begründung dafür ist einfach: Ein Thread lässt sich nicht serialisieren.

Wollten wir ein Objekt vom Typ NotTransientNotSerializable ohne Thread serialisieren, müssen wir dem Serialisierungsmechanismus mitteilen: »Nimm so weit alle Objekte, aber nicht den Thread!«

Um Elemente bei der Serialisierung auszusparen, bietet Java zwei Möglichkeiten:

• ein spezielles Schlüsselwort: transient
• das Feld private final ObjectStreamField[] serialPersistentFields = {...}, das alle serialisierbaren Eigenschaften aufzählt

Statische Eigenschaften würden auch nicht serialisiert, aber das ist hier nicht unser Ziel.

Das Schlüsselwort transient

Um beim Serialisieren Attribute auszusparen, bietet Java den Modifizierer transient, der alle Attribute markiert, die nicht persistent sein sollen. Damit lassen wir die nicht serialisierbaren Kandidaten außen vor und speichern alles ab, was sich speichern lässt.

transient Thread t;

Die Variable serialPersistentFields *

Erkennt der Serialisierer in der Klasse eine private statische Feld-Variable serialPersistentFields, wird er die ObjectStreamField-Einträge des Feldes beachten und nur die dort aufgezählten Elemente serialisieren, egal, was transient markiert ist.

private static final ObjectStreamField[] serialPersistentFields {
  new ObjectStreamField( "name", String.class ),
  new ObjectStreamField( "date", Date.class )
};

6.9.5 Das Abspeichern selbst in die Hand nehmen

Die Java-Bibliothek realisiert intern ein Serialisierungsprotokoll, das beschreibt, wie die Abbildung auf einen Bytestrom aussieht. Dieses Object Serialization Stream Protocol beschreibt Oracle unter http://download.oracle.com/javase/7/docs/platform/serialization/spec/protocol.html etwas genauer, aber Details sind nicht nötig.

Es kann aber passieren, dass die Standard-Serialisierung nicht erwünscht ist, wenn zum Beispiel beim Zurücklesen weitere Objekte erzeugt werden sollen oder wenn beim Schreiben eine bessere Abbildung durch Kompression möglich ist.

Für diesen Fall müssen spezielle (private!) Methoden implementiert werden. Beide müssen die nachstehenden Signaturen aufweisen:

private synchronized void writeObject( java.io.ObjectOutputStream s )
  throws IOException

und

private synchronized void readObject( java.io.ObjectInputStream s )
  throws IOException, ClassNotFoundException

Die Methode writeObject() ist für das Schreiben verantwortlich. Ist der Rumpf leer, gelangen keine Informationen in den Strom, und das Objekt wird folglich nicht gesichert. readObject() wird während der Deserialisierung aufgerufen. Ist dieser Rumpf leer, werden keine Zustände rekonstruiert.

Mit diesen Methoden können wir also die Serialisierung selbst in die Hand nehmen und die Attribute so speichern, wie wir es für sinnvoll halten; eine Kompatibilität lässt sich erzwingen. Eine kleine Versionsnummer im Datenstrom könnte eine Verzweigung provozieren, in der die Daten der Version 1 oder andere Daten der Version 2 gelesen werden.

Beim Lesen können komplette Objekte wieder aufgebaut werden, und es lassen sich zum Beispiel nicht-transiente Objekte wiederbeleben. Stellen wir uns einen Thread vor, dessen Zustände beim Schreiben persistent gemacht werden; beim Lesen wird ein Thread-Objekt wieder erzeugt und zum Leben erweckt.

Oberklassen serialisieren sich gleich mit

Wird eine Klasse serialisiert, so werden automatisch die Informationen der Oberklasse mitserialisiert. Hierbei gilt, dass wie beim Konstruktor erst die Attribute der Oberklasse in den Datenstrom geschrieben werden und anschließend die Attribute der Unterklasse. Insbesondere bedeutet dies, dass die Unterklasse nicht noch einmal die Attribute der Oberklasse speichern sollte. Das folgende Programm zeigt den Effekt:

Listing 6.29: com/tutego/insel/io/ser/WriteTop.java

import java.io.*;

class Base implements Serializable
{
  private void writeObject( ObjectOutputStream oos )
  {
    System.err.println( "Base" );
  }
}

public class WriteTop extends Base
{
  public static void main( String[] args ) throws IOException
  {
    ObjectOutputStream oos = new ObjectOutputStream( System.out );
    oos.writeObject( new WriteTop() );
  }

  private void writeObject( ObjectOutputStream oos )
  {
    System.err.println( "Top" );
  }
}

Doch noch den Standardserialisierer nutzen

Die Methoden readObject()/writeObject() arbeiten nach dem Alles-oder-nichts-Prinzip. Erkennt der Serialisierer, dass die Schnittstelle Serializable implementiert wird, fragt er die Klasse, ob sie die Methoden implementiert. Wenn nicht, beginnt bei der Serialisierung der Serialisierungsmechanismus eigenständig, die Attribute auszulesen und in den Datenstrom zu schreiben. Gibt es die readObject()/writeObject()-Methoden, so wird der Serialisierer diese aufrufen und nicht selbst die Objekte nach den Werten fragen oder die Objekte mit Werten füllen.

Doch die Arbeit des Serialisierers ist eine große Hilfe. Falls viele Attribute zu speichern sind, fällt viel lästige Arbeit beim Programmieren an, da für jedes zu speichernde Attribut der Aufruf einer writeXXX()-Methode und beim Lesen eine entsprechende readXXX()-Methode nötig ist. Aus diesem Dilemma gibt es einen Ausweg, weil der Serialisierer in den readObject()/writeObject()-Methoden auch nachträglich dazu verpflichtet werden kann, die nicht-transienten Attribute zu lesen oder zu schreiben. Die privaten Methoden readObject() und writeObject() bekommen als Argument ein ObjectInputStream und ein ObjectOutputStream, die über die entsprechenden Methoden verfügen.

Die Klasse ObjectOutputStream erweitert java.io.OutputStream unter anderem um die Methode defaultWriteObject(). Sie speichert die Attribute einer Klasse.

class java.io.ObjectOutputStream
extends OutputStream
implements ObjectOutput, ObjectStreamConstants

• public final void defaultWriteObject() throws IOException
  Schreibt alle nicht-statischen und nicht-transienten Attribute in den Datenstrom. Die Methode kann nur innerhalb einer privaten writeObject()-Methode aufgerufen werden; andernfalls erhalten wir eine NotActiveException.

Das Gleiche gilt für die Methode defaultReadObject() in der Klasse ObjectInputStream.

Beispiel für defaultReadObject()/defaultWriteObject() *

Unsere nächste Klasse SpecialWomen deklariert zwei Attribute: name und alter. Da manche Frauen nicht über ihr Alter sprechen wollen, soll alter nicht serialisiert werden; es ist transient. Wir implementieren eigene readObject()/writeObject()-Methoden, die den Standardserialisierer bemühen. Bei der Rekonstruktion über readObject() wird die Frau dann immer 30 bleiben:

Listing 6.30: com/tutego/insel/io/ser/SpecialWomen.java

package com.tutego.insel.io.ser;

import java.io.*;

public class SpecialWomen implements Serializable
{
  private static final long serialVersionUID = 2584203323009771108L;

  String name = "Madonna";
  transient int age = 30;

  private void writeObject( ObjectOutputStream oos ) throws IOException
  {
    oos.defaultWriteObject();  // Schreibe Name, aber kein Alter
  }

  private void readObject( ObjectInputStream ois ) throws IOException
  {
    try
    {
      ois.defaultReadObject(); // Lies Name, aber kein Alter
      age = 30;
    }
    catch ( ClassNotFoundException e )
    {
      throw new IOException( "No class found. HELP!!" );
    }
  }
}

Der andere macht’s: writeReplace() und readResolve() *

Eine Klasse muss die Serialisierung nicht selbst übernehmen, sondern kann die Arbeit abgeben. Dazu muss zum Schreiben eine Methode writeReplace() implementiert werden, die eine Referenz auf ein Objekt liefert, das das Schreiben übernimmt. Anregungen finden Leser unter http://download.oracle.com/javase/7/docs/platform/serialization/spec/output.html#5324 sowie unter http://www.jguru.com/faq/view.jsp?EID=44039.

6.9.6 Tiefe Objektkopien *

Implementieren Klassen die Markierungsschnittstelle Serializable und überschreiben sie die clone()-Methode von Object, so können sie eine Kopie der Werte liefern. Die üblichen Implementierungen liefern aber nur flache Kopien. Dies bedeutet, dass Referenzen auf Objekte, die von dem zu klonenden Objekt ausgehen, beibehalten und diese Objekte nicht extra kopiert werden. Als Beispiel kann die Datenstruktur List genügen, die Map-Objekte enthält. Ein Klon dieser Liste ist lediglich eine zweite Liste, deren Elemente auf die gleichen Maps zeigen.

Möchten wir das Verhalten ändern und eine tiefe Kopie anfertigen, so haben wir dank eines kleinen Tricks damit keine Mühe: Wir könnten das zu klonende Objekt einfach serialisieren und dann wieder auspacken. Die zu klonenden Objekte müssen dann neben Cloneable noch das Serializable-Interface implementieren:

Listing 6.31: com/tutego/insel/io/ser/Dolly.java, deepCopy()

@SuppressWarnings("unchecked")
public static <T> T deepCopy( T o ) throws Exception
{
  ByteArrayOutputStream baos = new ByteArrayOutputStream();
  new ObjectOutputStream( baos ).writeObject( o );

  ByteArrayInputStream bais = new ByteArrayInputStream( baos.toByteArray() );
  Object p = new ObjectInputStream( bais ).readObject();

  return (T) p;
}

Das Einzige, was wir zum Gelingen der Methode deepCopy() beitragen müssen, ist, das Objekt in einem Byte-Feld zu serialisieren, es wieder auszulesen und zu einem Objekt zu konvertieren. Den Einsatz eines ByteArrayOutputStream haben wir schon beobachtet, als wir die Länge eines Objekts herausfinden wollten. Nun fügen wir das Feld einfach wieder zu einem ByteArrayInputStream hinzu, aus dessen Daten dann ObjectInputStream das Objekt rekreieren kann.

Überzeugen wir uns anhand eines kleinen Programms, dass die tiefe Kopie tatsächlich etwas anderes als ein clone() ist:

Listing 6.32: Dolly.java, main()

Map<String,String> map = new HashMap<String,String>();
map.put( "Cul de Paris", "hinten unter dem Kleid getragenes Gestell oder Polster" );

LinkedList<Map<String,String>> l1 = new LinkedList<Map<String,String>>();
l1.add( map );

@SuppressWarnings("unchecked")
List<Map<String, String>> l2 = (List<Map<String, String>>) l1.clone();

List<Map<String,String>> l3 = (List<Map<String,String>>) deepCopy( l1 );

map.clear();

System.out.println( l1 ); // [{}]
System.out.println( l2 ); // [{}]
System.out.println( l3 ); // [{Cul de Paris=hinten unter dem Kleid ...}]

Zunächst erstellen wir eine Map, die wir anschließend in eine Liste packen. Die Map enthält ein Pärchen. Kopiert clone() die Liste, so wird sie zwar selbst kopiert, aber nicht die referenzierten Map-Objekte – erst die tiefe Kopie kopiert die Map mit. Das sehen wir dann, wenn wir den Eintrag aus der Map löschen. Dann ergibt l1 genauso wie l2 eine leere Liste, da l2 nur die Verweise auf die Map gespeichert hat, die dann aber geleert ist. Anders ist dies bei l3, der tiefen Kopie: Hier ist das Paar noch vorhanden.

6.9.7 Versionenverwaltung und die SUID

Die erste Version einer Klassenbibliothek ist in der Regel nicht vollständig und nicht beendet. Es kann gut sein, dass Attribute und Methoden nachträglich in die Klasse eingefügt, gelöscht oder modifiziert werden. Das bedeutet aber auch, dass die Serialisierung zu einem Problem werden kann. Denn ändert sich der Variablentyp oder kommen Variablen hinzu, ist eine gespeicherte Objektserialisierung nicht mehr gültig.

Bei der Serialisierung wird in Java nicht nur der Objektinhalt geschrieben, sondern zusätzlich eine eindeutige Kennung der Klasse, die UID. Die UID ist ein Hashcode aus Namen, Attributen, Parametern, Sichtbarkeit und so weiter. Sie wird als long wie ein Attribut gespeichert. Ändert sich der Aufbau einer Klasse, ändern sich der Hashcode und damit die UID. Klassen mit unterschiedlicher UID sind nicht kompatibel. Erkennt der Lesemechanismus in einem Datenstrom eine UID, die nicht zur Klasse passt, wird eine InvalidClassException ausgelöst. Das bedeutet, dass schon ein einfaches Hinzufügen von Attributen zu einem Fehler führt.

Wir wollen uns dies einmal anhand einer einfachen Klasse ansehen. Wir entwickeln eine Klasse Player mit einem einfachen Ganzzahlattribut. Später fügen wir eine Fließkommazahl hinzu:

Listing 6.33: com/tutego/insel/io/ser/InvalidSer.java, Player

class Player implements Serializable
{
  String name;
  int    age;
}

Dann benötigen wir noch das Hauptprogramm. Wir bilden ein Exemplar von Player und schreiben es in eine Datei:

Listing 6.34: com/tutego/insel/io/ser/InvalidSer.java, Ausschnitt main()

ObjectOutputStream oos = new ObjectOutputStream(
                           new FileOutputStream( "c:/test.ser" ) );
oos.writeObject( new Player() );
oos.close();

Ohne Änderungen können wir es direkt wieder deserialisieren:

Listing 6.35: com/tutego/insel/io/ser/InvalidSer.java, Ausschnitt main()

ObjectInputStream ois = new ObjectInputStream(
                          new FileInputStream( "c:/test.ser" ) );
Player player = (Player) ois.readObject();
System.out.println( player );
ois.close();

Ändern wir die Klassendeklaration Player, sodass wir etwa aus dem int age ein double age machen, führt dies beim Deserialisieren zu einem Fehler:

Exception in thread "main" java.io.InvalidClassException: com.tutego.insel.io.ser.Player; local class incompatible: stream classdesc serialVersionUID = 44259824709362049, 
  local class serialVersionUID = 8962277452270582278
  at java.io.ObjectStreamClass.initNonProxy(ObjectStreamClass.java:562)
  at java.io.ObjectInputStream.readNonProxyDesc(ObjectInputStream.java:1583)
  at java.io.ObjectInputStream.readClassDesc(ObjectInputStream.java:1496)
  at java.io.ObjectInputStream.readOrdinaryObject(ObjectInputStream.java:1732)
  at java.io.ObjectInputStream.readObject0(ObjectInputStream.java:1329)
  at java.io.ObjectInputStream.readObject(ObjectInputStream.java:351)
  at com.tutego.insel.io.ser.InvalidSer.main(InvalidSer.java:22)

Die eigene SUID

Dem oberen Fehlerauszug entnehmen wir, dass der Serialisierungsmechanismus die SUID selbst berechnet. Das Attribut ist als statische, finale Variable mit dem Namen serialVersionUID in der Klasse abgelegt. Ändern sich die Klassenattribute, ist es günstig, eine eigene SUID einzutragen, denn der Mechanismus zum Deserialisieren kann dann etwas gutmütiger mit den Daten umgehen. Beim Einlesen gibt es nämlich Informationen, die nicht hinderlich sind. Wir sprechen in diesem Zusammenhang auch von stream-kompatibel. Dazu gehören zwei Bereiche:

• Neue Felder: Befinden sich in der neuen Klasse Attribute, die im Datenstrom nicht benannt sind, werden diese Attribute mit 0 oder null initialisiert.
• Fehlende Felder: Befinden sich im Datenstrom Attribute, die in der neuen Klasse nicht vorkommen, werden sie einfach ignoriert.

Die SUID kann eigentlich beliebig sein, doch die IDE bzw. das kleine Java-Dienstprogramm serialver berechnet einen Wert, der der gleiche Wert wie der ist, den der Serialisierungsmechanismus berechnet. Auf diese Weise erreichen wir eine stream-kompatible Serialisierung.

$ serialver  com.tutego.insel.io.ser.Player
com.tutego.insel.io.ser.Player:    static final long serialVersionUID = 8962277452270582278L;

Die Anweisung aus der letzten Zeile können wir in unsere Klasse Player kopieren. Wird danach ein weiteres Attribut in die Klasse gesetzt, gelöscht oder ändert sich der Typ eines Attributs, tritt die InvalidClassException nicht mehr auf, da die Stream-Kompatibilität über die serialVersionUID gewährleistet ist.

6.9.8 Wie die ArrayList serialisiert *

Am Beispiel einer java.util.ArrayList lässt sich sehr schön beobachten, wie sich die Methoden writeObject() und readObject() nutzen lassen. Eine ArrayList beinhaltet eine Reihe von Elementen. Zur Speicherung nutzt die Datenstruktur ein internes Feld. Das Feld kann größer als die Anzahl der Elemente sein, damit bei jedem add() das Feld nicht immer neu vergrößert werden muss. Nehmen wir an, die ArrayList würde eine Standardserialisierung nutzen. Was passiert nun? Es könnte das Problem entstehen, dass bei nur einem Objektverweis in der Liste und einer internen Feldgröße von 1.000 Elementen leider 999 null-Verweise gespeichert würden. Das wäre aber Verschwendung! Besser ist es, eine angepasste Serialisierung zu verwenden:

Listing 6.36: java.util.ArrayList.java, Ausschnitt

private void writeObject(java.io.ObjectOutputStream s)
  throws java.io.IOException{
  // Write out element count, and any hidden stuff
  int expectedModCount = modCount;
  s.defaultWriteObject();

  // Write out array length
  s.writeInt(elementData.length);

  // Write out all elements in the proper order.
  for (int i=0; i<size; i++)
      s.writeObject(elementData[i]);

  if (modCount != expectedModCount) {
      throw new ConcurrentModificationException();
  }

}
private void readObject(java.io.ObjectInputStream s)
  throws java.io.IOException, ClassNotFoundException {
  // Read in size, and any hidden stuff
  s.defaultReadObject();

  // Read in array length and allocate array
  int arrayLength = s.readInt();
  Object[] a = elementData = new Object[arrayLength];

  // Read in all elements in the proper order.
  for (int i=0; i<size; i++)
      a[i] = s.readObject();
}

6.9.9 Probleme mit der Serialisierung

Der klassische Weg von einem Objekt zu einer persistenten Speicherung führt über den Serialisierungsmechanismus von Java über die Klassen ObjectOutputStream und ObjectInputStream. Die Serialisierung in Binärdaten ist aber nicht ohne Nachteile. Schwierig ist beispielsweise die Weiterverarbeitung von Nicht-Java-Programmen oder die nachträgliche Änderung ohne Einlesen und Wiederaufbauen der Objektverbunde. Wünschenswert ist daher eine Textrepräsentation. Diese hat nicht die oben genannten Nachteile.

Ein weiteres Problem ist die Skalierbarkeit. Die Standard-Serialisierung arbeitet nach dem Prinzip: Alles, was vom Basisknoten aus erreichbar ist, gelangt serialisiert in den Datenstrom. Ist der Objektgraph sehr groß, steigen die Zeit für die Serialisierung und das Datenvolumen an. Anders als bei anderen Persistenz-Konzepten ist es nicht möglich, nur die Änderungen (die Differenz) zu schreiben. Wenn sich zum Beispiel in einer sehr großen Adressliste die Hausnummer einer Person ändert, muss die gesamte Adressliste neu geschrieben werden – das nagt an der Performance.

Auch parallele Änderungen können ein Problem sein, da die Serialisierung über kein transaktionales Konzept verfügt. Während der Serialisierung sind die Objekte und Datenstrukturen nicht gesperrt, und ein anderer Thread kann derweil alles Mögliche modifizieren. Der Entwickler muss sich selbst auferlegen, während des Schreibens keine Änderungen vorzunehmen, damit der Schreibzugriff isoliert ist. Auch wenn es während des Schreibens ein Problem (etwa eine Ausnahme) gibt, kommt ein halbfertiger Datenstrom beim Client an.

Ihr Kommentar

Wie hat Ihnen das <openbook> gefallen? Wir freuen uns immer über Ihre freundlichen und kritischen Rückmeldungen.