7.10Persistente 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.[ 82 ](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 kommuniziert 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 8, »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. Und auch bei Apple sind Protocol Buffers im Einsatz, etwa bei den iCloud-Diensten.

Etwas weiter gedacht lassen sich auch Objekte in relationalen Datenbanken speichern, was sich objektrelationales 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) aus der Java Platform, Enterprise Edition, ist das zu schaffen. Auch von Hand können die Objekte über JDBC in die Datenbank gebracht werden, was aber nicht zeitgemäß ist.

 

7.10.1Objekte mit der Standardserialisierung speichern und lesen 

Die Standardserialisierung 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-)Serialisierungsmethoden:

• Serialisierung: Die Klasse ObjectOutputStream und die Methode writeObject(Object). Während der Serialisierung geht der ObjectOutputStream die Zustände und Objektverweise rekursiv ab und schreibt die Zustände Schritt für Schritt in einen Ausgabestrom.

• Deserialisierung: Dem 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 7.30com/tutego/insel/io/ser/SerializeNameAndDate.java, main()

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(Object) zum Schreiben von Objekten. Damit wird das Serialisieren des String-Objekts (der Name) und des anschließenden Datum-Objekts zum Kinderspiel.

• 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(Object) 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. Die Typen NotSerializableException und InvalidClassException sind Unterklassen von IOException, sodass ein catch(IOException) diese Typen gleich mit fängt.

Objekte über die Standardserialisierung 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 7.31com/tutego/insel/io/ser/DeSerializeNameAndDate.java, main()

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

• 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(Object) aus einer Schnittstelle ObjectOutput, genauso wie ObjectInputStream die Operation readObject() aus ObjectInput implementiert. Bis auf die Standardserialisierung 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.

 

7.10.2Zwei 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(Object) egal ist, wohin das Objekt geschoben wird. Dazu wird ja einfach dem Konstruktor von ObjectOutputStream ein OutputStream übergeben, und writeObject(Object) 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 bzw. über das Netzwerk verschickt werden.

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. So lässt sich auch die geschätzte Größe eines Objekts herauszufinden.

 

7.10.3Die 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 7.32com/tutego/insel/io/ser/Person.java

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

Statische Variablen wie BMI_OVERWEIGHT werden nicht mit dem Standardserialisierungs-Mechanismus 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.

 

7.10.4Nicht 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 7.33com/tutego/insel/io/ser/SerializeTransient.java, NotTransientNotSerializable

Der Fehler wird eine NotSerializableException sein:

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.

Die Variable serialPersistentFields *

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

 

7.10.5Das 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://docs.oracle.com/javase/8/docs/platform/serialization/spec/protocol.html etwas genauer, aber Details sind nicht nötig.

Es kann aber passieren, dass die Standardserialisierung 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:

und

Die Methode writeObject(ObjectOutputStream) ist für das Schreiben verantwortlich. Ist der Rumpf leer, gelangen keine Informationen in den Strom, und das Objekt wird folglich nicht gesichert. readObject(ObjectInputStream) 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 nichttransiente 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 mit serialisiert. 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 7.34com/tutego/insel/io/ser/WriteTop.java

Doch noch den Standardserialisierer nutzen

Die privaten Methoden readObject(ObjectInputStream)/writeObject(ObjectOutputStream) 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 privaten 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 privaten readObject(ObjectInputStream)/writeObject(ObjectOutputStream)-Methoden auch nachträglich dazu verpflichtet werden kann, die nichttransienten Attribute zu lesen oder zu schreiben. Und zwar helfen zwei Methoden aus den übergebenen Typen ObjectInputStream und ObjectOutputStream. Die Klasse ObjectOutputStream erweitert java.io.OutputStream unter anderem um die Methode defaultWriteObject(). Sie speichert die Attribute einer Klasse.

• public final void defaultWriteObject() throws IOException
  Schreibt alle nichtstatischen und nichttransienten Attribute in den Datenstrom. Die Methode kann nur innerhalb einer privaten writeObject(ObjectOutputStream)-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 private readObject(…)/writeObject(…)-Methoden, die den Standardserialisierer bemühen. Bei der Rekonstruktion über readObject() wird die Frau dann immer 30 bleiben:

Listing 7.35com/tutego/insel/io/ser/SpecialWomen.java

 

7.10.6Tiefe 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 7.36com/tutego/insel/io/ser/Dolly.java, deepCopy()

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. Ein try mit Ressourcen können wir uns hier sparen, und alle Fehler werden an den Aufrufer von deepClone(…) weitergereicht.

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

Listing 7.37Dolly.java, main()

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 o1 genauso wie o2 eine leere Liste, da o2 nur die Verweise auf die Map gespeichert hat, die dann aber geleert ist. Anders ist dies bei o3, der tiefen Kopie: Hier ist das Paar noch vorhanden.

 

7.10.7Versionenverwaltung 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 usw. 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 für ein Alter. Später ändern wir den Typ für das Alter in eine Fließkommazahl:

Listing 7.38com/tutego/insel/io/ser/Player.java, Player

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

Listing 7.39com/tutego/insel/io/ser/SerializePlayer.java, main()

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

Listing 7.40com/tutego/insel/io/ser/DeSerializePlayer.java, main()

Ändern wir die Klassendeklaration Player, sodass wir etwa aus dem int age ein double age machen, und führen dann noch einmal DeSerializePlayer auf, führt dies zu einem Fehler:

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.

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.

 

7.10.8Wie die ArrayList serialisiert * 

Am Beispiel einer java.util.ArrayList lässt sich sehr schön beobachten, wie sich die privaten 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 7.41java.util.ArrayList.java, Ausschnitt

 

7.10.9Probleme 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 Objektverbünde. Wünschenswert ist daher eine Textrepräsentation. Diese hat nicht die oben genannten Nachteile.

Ein weiteres Problem ist die Skalierbarkeit. Die Standardserialisierung 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.