Rheinwerk Computing < openbook > Rheinwerk Computing - Professionelle Bücher. Auch für Einsteiger.
Professionelle Bücher. Auch für Einsteiger.

Inhaltsverzeichnis
Vorwort
1 Java ist auch eine Sprache
2 Sprachbeschreibung
3 Klassen und Objekte
4 Der Umgang mit Zeichenketten
5 Eigene Klassen schreiben
6 Exceptions
7 Generics<T>
8 Äußere.innere Klassen
9 Besondere Klassen der Java SE
10 Architektur, Design und angewandte Objektorientierung
11 Die Klassenbibliothek
12 Bits und Bytes und Mathematisches
13 Datenstrukturen und Algorithmen
14 Threads und nebenläufige Programmierung
15 Raum und Zeit
16 Dateien, Verzeichnisse und Dateizugriffe
17 Datenströme
18 Die eXtensible Markup Language (XML)
19 Grafische Oberflächen mit Swing
20 Grafikprogrammierung
21 Netzwerkprogrammierung
22 Verteilte Programmierung mit RMI
23 JavaServer Pages und Servlets
24 Datenbankmanagement mit JDBC
25 Reflection und Annotationen
26 Dienstprogramme für die Java-Umgebung
A Die Begleit-DVD
Stichwort
Ihre Meinung?

Spacer
 <<   zurück
Java ist auch eine Insel von Christian Ullenboom
Das umfassende Handbuch
Buch: Java ist auch eine Insel

Java ist auch eine Insel
geb., mit DVD
1482 S., 49,90 Euro
Rheinwerk Computing
ISBN 978-3-8362-1506-0
Pfeil 17 Datenströme
  Pfeil 17.1 Stream-Klassen und Reader/Writer am Beispiel von Dateien
    Pfeil 17.1.1 Mit dem FileWriter Texte in Dateien schreiben
    Pfeil 17.1.2 Zeichen mit der Klasse »FileReader« lesen
    Pfeil 17.1.3 Kopieren mit »FileOutputStream« und »FileInputStream«
    Pfeil 17.1.4 Das FileDescriptor-Objekt *
  Pfeil 17.2 Basisklassen für die Ein-/Ausgabe
    Pfeil 17.2.1 Die abstrakten Basisklassen
    Pfeil 17.2.2 Übersicht über Ein-/Ausgabeklassen
    Pfeil 17.2.3 Die abstrakte Basisklasse »OutputStream«
    Pfeil 17.2.4 Die Schnittstellen »Closeable« und »Flushable«
    Pfeil 17.2.5 Ein Datenschlucker *
    Pfeil 17.2.6 Die abstrakte Basisklasse »InputStream«
    Pfeil 17.2.7 Ressourcen aus dem Klassenpfad und aus Jar–Archiven laden
    Pfeil 17.2.8 Ströme mit SequenceInputStream zusammensetzen *
    Pfeil 17.2.9 Die abstrakte Basisklasse »Writer«
    Pfeil 17.2.10 Die Schnittstelle »Appendable« *
    Pfeil 17.2.11 Die abstrakte Basisklasse »Reader«
  Pfeil 17.3 Formatierte Textausgaben
    Pfeil 17.3.1 Die Klassen »PrintWriter« und »PrintStream«
    Pfeil 17.3.2 »System.out«, »System.err« und »System.in«
  Pfeil 17.4 Schreiben und Lesen aus Strings und Byte-Feldern
    Pfeil 17.4.1 Mit dem »StringWriter« ein String-Objekt füllen
    Pfeil 17.4.2 CharArrayWriter
    Pfeil 17.4.3 »StringReader« und »CharArrayReader«
    Pfeil 17.4.4 Mit »ByteArrayOutputStream« in ein Byte-Feld schreiben
    Pfeil 17.4.5 Mit »ByteArrayInputStream« aus einem Byte-Feld lesen
  Pfeil 17.5 Datenströme filtern und verketten
    Pfeil 17.5.1 Streams als Filter verketten (verschalen)
    Pfeil 17.5.2 Gepufferte Ausgaben mit »BufferedWriter«/»BufferedOutputStream«
    Pfeil 17.5.3 Gepufferte Eingaben mit »BufferedReader«/»BufferedInputStream«
    Pfeil 17.5.4 »LineNumberReader« zählt automatisch Zeilen mit *
    Pfeil 17.5.5 Daten mit der Klasse »PushbackReader« zurücklegen *
    Pfeil 17.5.6 DataOutputStream/DataInputStream *
    Pfeil 17.5.7 Basisklassen für Filter *
    Pfeil 17.5.8 Die Basisklasse »FilterWriter« *
    Pfeil 17.5.9 Ein LowerCaseWriter *
    Pfeil 17.5.10 Eingaben mit der Klasse »FilterReader« filtern *
    Pfeil 17.5.11 Anwendungen für »FilterReader« und »FilterWriter« *
  Pfeil 17.6 Vermittler zwischen Byte-Streams und Unicode-Strömen
    Pfeil 17.6.1 Datenkonvertierung durch den »OutputStreamWriter«
    Pfeil 17.6.2 Automatische Konvertierungen mit dem »InputStreamReader«
  Pfeil 17.7 Kommunikation zwischen Threads mit Pipes *
    Pfeil 17.7.1 »PipedOutputStream« und »PipedInputStream«
    Pfeil 17.7.2 »PipedWriter« und »PipedReader«
  Pfeil 17.8 Datenkompression *
    Pfeil 17.8.1 Java-Unterstützung beim Komprimieren
    Pfeil 17.8.2 Datenströme komprimieren
    Pfeil 17.8.3 Zip-Archive
    Pfeil 17.8.4 Jar-Archive
  Pfeil 17.9 Prüfsummen
    Pfeil 17.9.1 Die Schnittstelle Checksum
    Pfeil 17.9.2 Die Klasse »CRC32«
    Pfeil 17.9.3 Die Adler32-Klasse
  Pfeil 17.10 Persistente Objekte und Serialisierung
    Pfeil 17.10.1 Objekte mit der Standard-Serialisierung speichern und lesen
    Pfeil 17.10.2 Zwei einfache Anwendungen der Serialisierung *
    Pfeil 17.10.3 Die Schnittstelle »Serializable«
    Pfeil 17.10.4 Nicht serialisierbare Attribute aussparen
    Pfeil 17.10.5 Das Abspeichern selbst in die Hand nehmen
    Pfeil 17.10.6 Tiefe Objektkopien *
    Pfeil 17.10.7 Versionenverwaltung und die SUID
    Pfeil 17.10.8 Wie die »ArrayList« serialisiert *
    Pfeil 17.10.9 Probleme mit der Serialisierung
  Pfeil 17.11 Alternative Datenaustauschformate
    Pfeil 17.11.1 Serialisieren in XML-Dateien
    Pfeil 17.11.2 XML-Serialisierung von JavaBeans mit JavaBeans Persistence *
    Pfeil 17.11.3 Open-Source Bibliothek XStream *
  Pfeil 17.12 Tokenizer *
    Pfeil 17.12.1 StreamTokenizer
  Pfeil 17.13 Zum Weiterlesen


Rheinwerk Computing - Zum Seitenanfang

17.10 Persistente Objekte und Serialisierung  Zur nächsten ÜberschriftZur vorigen Überschrift

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 Objekttyp und 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. [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 sehr wichtig bei entfernten Methodenaurufen 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 Internas 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, was 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 18, »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 Standard-serialisierung 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, welches 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 zum OR-Mapping keine Unterstütztung 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.


Rheinwerk Computing - Zum Seitenanfang

17.10.1 Objekte mit der Standard-Serialisierung speichern und lesen  Zur nächsten ÜberschriftZur vorigen Überschrift

Die Standard-Serialisierung bietet eine einfache Möglichkeit, 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-)Serialisierungs-Methode:

  • 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 17.26  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 falschlä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 17.27  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 »DataOutput« und »DataInput« *

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 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 schreibt die Schnittstelle DataInput Leseoperationen vor, die ObjectInput implementiert.


Rheinwerk Computing - Zum Seitenanfang

17.10.2 Zwei einfache Anwendungen der Serialisierung *  Zur nächsten ÜberschriftZur vorigen Überschrift

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 Object-OutputStream 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.


Rheinwerk Computing - Zum Seitenanfang

17.10.3 Die Schnittstelle »Serializable«  Zur nächsten ÜberschriftZur vorigen Überschrift

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.


Hinweis Werden Exemplare einer nicht-statischen inneren Klasse serialisiert, die äußere Klasse implementiert aber nicht Serializable, gibt es einen Fehler, denn intern hält ein Objekt der inneren Klasse einen Verweis auf das Exemplar der äußeren Klasse. Statische innere Klassen machen das nicht, was das Problem mit der Serialisierung lösen kann. Das Datenvolumen kann natürlich groß werden, wenn schlanke, nicht-statische innere Serializable-Klassen in einer äußeren Serializable-Klasse liegen, die sehr viele Eigenschaften besitzt.


»Person« als Beispiel für eine serialisierbare Klasse

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

Listing 17.28  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?


Hinweis Feld-Objekte sind standardmäßig serialisierbar – sie implementieren versteckt die Schnittstelle Serializable.


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.


Rheinwerk Computing - Zum Seitenanfang

17.10.4 Nicht serialisierbare Attribute aussparen  Zur nächsten ÜberschriftZur vorigen Überschrift

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, liegt zum Beispiel in der Sicherheit begründet. 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 17.29  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.


Hinweis Ausnahmen sind standardmäßg serialisierbar, da Throwable die Schnittstelle Serializable implementiert. Denn gibt es Serverfehler bei entfernten Methodenaufrufen, so werden die Fehler gerne mit über die Leitung übertragen. Natürlich darf in dem Fall die zu serialisierende Ausnahme auch nur serialisierbare Attribute referenzieren.


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.


Beispiel Das Thread-Objekt hinter t soll nicht serialisiert werden:

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.


Beispiel Von einer Klasse sollen der String s und das Datum date serialisiert werden:

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


Rheinwerk Computing - Zum Seitenanfang

17.10.5 Das Abspeichern selbst in die Hand nehmen  Zur nächsten ÜberschriftZur vorigen Überschrift

Die Java-Bibliothek realisiert intern ein Serialisierungs-Protokoll, das beschreibt, wie die Abbildung auf einen Bytestrom aussieht. Dieses »Object Serialization Stream Protocol« beschreibt Oracle unter http://download.oracle.com/javase/6/docs/platform/serialization/spec/protocol.html etwas genauer, aber Details sind normalerweise 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, und 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 17.30  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" );
  }
}

In der Ausgabe von Eclipse sind die Ausgaben »Base« und »Top« in einer anderen Farbe dargestellt.

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 sind. 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.


Hinweis Die Standard-Deserialisieriung hat mit finalen Variablen kein Problem. Wenn wir allerdings selbst readObject() aufrufen, können wir nicht problemlos finale Variablen initialisieren. Hier bietet sich an, auf defaultReadObject() zurückzugreifen oder abartig zu tricksen, was etwa nötig ist, wenn eine Variable final und transient ist, da ja transiente Variablen erst gar nicht von der Standardserialisierung berücksichtigt werden. Das Problem ist unter der Fehlernummer 6379948 (http://bugs.sun.com/bugdatabase/view_bug.do?bug_id= 6379948) geführt und dort werden auch einige Lösungen präsentiert.


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

Unsere nächste Klasse SpecialWomen deklariert zwei Attribute: name und alter. Da manche Frauen über ihr Alter nicht 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 17.31  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();  // Schreib Name, aber kein Alter
  }

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

Hinweis Es ist gar nicht so abwegig, nur eine readObject()-, aber keine writeObject()-Methode zu implementieren. In readObject() lässt ein defaultReadObject() alle Eigenschaften initialisieren und danach noch Initialisierungsarbeit ähnlich einem Konstruktor durchführen. Dazu zählen etwa die Initialisierung von transienten Attributen, die Registrierung von Listenern und Weiteres.


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/6/docs/platform/serialization/spec/output.html#5324 sowie unter https://www.galileo-press.de/openbook/java2/kap_12.htm#t24 und http://www.jguru.com/faq/view.jsp?EID=44039.


Rheinwerk Computing - Zum Seitenanfang

17.10.6 Tiefe Objektkopien *  Zur nächsten ÜberschriftZur vorigen Überschrift

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, das 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 17.32  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 17.33  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.


Rheinwerk Computing - Zum Seitenanfang

17.10.7 Versionenverwaltung und die SUID  Zur nächsten ÜberschriftZur vorigen Überschrift

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 17.34  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 17.35  com/tutego/insel/io/ser/InvalidSer.java, Ausschnitt main()

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

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

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

ObjectInputStream ois = new ObjectInputStream( new FileInputStream( Umbruch
  "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 bei Deserialisieren zu einem Fehler:

Exception in thread "main" java.io.InvalidClassException: com.tutego.insel.io.ser.Player; local class incompatible: stream classdesc serialVersionUID = Umbruch
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 wie der ist, wie ihn der Serialisierungsmechanismus berechnet. Auf diese Weise erreichen wir eine stream-kompatible Serialisierung.


Beispiel Dies wollen wir für unsere Klasse Player mit dem Dienstprogramm testen:

$ cd S:\Insel\programme\2_15_Streams\bin
$ 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, es 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.


Tipp Da der Wert der Variablen serialVersionUID egal ist, kann sie bei 1 beginnen und immer dann, wenn es inkompatible Änderungen gibt, um eins erhöht werden.



Rheinwerk Computing - Zum Seitenanfang

17.10.8 Wie die »ArrayList« serialisiert *  Zur nächsten ÜberschriftZur vorigen Überschrift

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 17.37  java.util.ArrayList.java, Ausschnitt

private void writeObject( ObjectOutputStream s ) throws IOException {
  int expectedModCount = modCount;
  s.defaultWriteObject();
  s.writeInt( elementData.length );
  for ( int i = 0; i < size; i++ )
    s.writeObject( elementData[ i ] );

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

private void readObject( ObjectInputStream s ) throws IOException, 
    ClassNotFoundException {
  s.defaultReadObject();
  int arrayLength = s.readInt();
  Object[] a = elementData = (E[]) new Object[ arrayLength ];
  for ( int i = 0; i < size; i++ )
    a[ i ] = s.readObject();
}

Rheinwerk Computing - Zum Seitenanfang

17.10.9 Probleme mit der Serialisierung  topZur vorigen Überschrift

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 Text-reprä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.


Bibliotheksdesign Heutzutage würden Bibliotheks-Designer keine Markierungsschnittstelle wie Serializable mehr einführen, sondern eine Annotation deklarieren. Die Serialisierungs-ID würde dann auch nicht mehr eine private statische Variable mit einem magischen Variablennamen sein, sondern ein Attribut der Annotation, sodass es zum Beispiel an eine Klasse heißen würde: @Serializable(1234566778L). Markierungsschnittstellen haben noch ein anderes Problem, was mit der Endgültigkeit von Vererbung und Typen zu tun hat: Implementiert eine Klase einmal Serializable, so gilt diese Eigenschaft auch für alle Unterklassen, auch wenn vielleicht die Unterklassen gar nicht serialisierbar sein sollen. Auch hier lösen Annotationen das Problem, denn es lässt sich einstellen, ob Annotationen vererbt werden sollen oder nicht. Zu guter Letzt: Für transiente, also nicht serialisierte Zustände hätte kein Schlüsselwort in der Sprache reserviert werden müssen, sondern lediglich eine neue Annotation deklariert werden. Auch statt der magischen privaten Methoden readObject()/writeObject() hätte gut eine Annotation deklariert werden können, die eben die Methoden markieren, die bei der (De-)Serialisierung aufgerufen werden sollen.




Ihr Kommentar

Wie hat Ihnen das <openbook> gefallen? Wir freuen uns immer über Ihre freundlichen und kritischen Rückmeldungen. >> Zum Feedback-Formular
 <<   zurück
 Ihre Meinung?
Wie hat Ihnen das <openbook> gefallen?
Ihre Meinung

 Buchempfehlungen
Zum Katalog: Java ist auch eine Insel






 Java ist auch
 eine Insel


Zum Katalog: Java SE Bibliotheken






 Java SE Bibliotheken


Zum Katalog: Professionell entwickeln mit Java EE 7






 Professionell
 entwickeln mit
 Java EE 7


Zum Katalog: Einstieg in Eclipse






 Einstieg in
 Eclipse


Zum Katalog: Einstieg in Java






 Einstieg in
 Java


 Shopping
Versandkostenfrei bestellen in Deutschland und Österreich
InfoInfo




Copyright © Rheinwerk Verlag GmbH 2011
Für Ihren privaten Gebrauch dürfen Sie die Online-Version natürlich ausdrucken. Ansonsten unterliegt das <openbook> denselben Bestimmungen, wie die gebundene Ausgabe: Das Werk einschließlich aller seiner Teile ist urheberrechtlich geschützt. Alle Rechte vorbehalten einschließlich der Vervielfältigung, Übersetzung, Mikroverfilmung sowie Einspeicherung und Verarbeitung in elektronischen Systemen.


[Rheinwerk Computing]

Rheinwerk Verlag GmbH, Rheinwerkallee 4, 53227 Bonn, Tel.: 0228.42150.0, Fax 0228.42150.77, service@rheinwerk-verlag.de