Weitere aktuelle Java-Titel finden Sie bei dpunkt.
 Inhaltsverzeichnis   Vorhergehendes Paket   Seite Zurück   Seite Vor   Nächstes Paket   Paketübersicht   Index

Klasse java.util.prefs.AbstractPreferences1.4

java.lang.Object
   |
   +--java.util.prefs.Preferences
         |
         +--java.util.prefs.AbstractPreferences

Deklaration

public abstract class AbstractPreferences
extends java.util.prefs.Preferences

Beschreibung

Diese Klasse kann als Basis für die Implementierung eines eigenen Preference-Service Provicers benutzt werden. Der Anwender der Preferences-API benutzt diese Klasse nicht, stattdessen greift er direkt auf die Klasse Preferences zurück. AbstractPreferences stellt die grundlegende Funktionalität eines Knotens in der Preference-Hierarchie bereit. Implementierungen müssen folgende Methoden implementieren: getSpi(String),putSpi(String) , removeSpi(String),childSpi(String) , removeNodeSpi(),keysSpi() ,childrenNamesSpi(),syncSpi(),flushSpi() . Alle weiteren Methoden der Klasse können nach den individuellen Anforderungen der Implementierung redefiniert werden (z. B. aus Performance-Gründen).


 
Datenelemente
protected final Objectlock
protected booleannewNode
 
Konstruktoren
protectedAbstractPreferences(AbstractPreferences parent, String name)
 
Methoden
public StringabsolutePath()
public voidaddNodeChangeListener(NodeChangeListener ncl)
public voidaddPreferenceChangeListener(PreferenceChangeListener pcl)
protected final AbstractPreferences[]cachedChildren()
protected abstract AbstractPreferenceschildSpi(String name)
public String[]childrenNames()
protected abstract String[]childrenNamesSpi()
public voidclear()
public voidexportNode(OutputStream os)
public voidexportSubtree(OutputStream os)
public voidflush()
protected abstract voidflushSpi()
public Stringget(String key, String def)
public booleangetBoolean(String key, boolean def)
public byte[]getByteArray(String key, byte[] def)
protected AbstractPreferencesgetChild(String nodeName)
public doublegetDouble(String key, double def)
public floatgetFloat(String key, float def)
public intgetInt(String key, int def)
public longgetLong(String key, long def)
protected abstract StringgetSpi(String key)
protected booleanisRemoved()
public booleanisUserNode()
public String[]keys()
protected abstract String[]keysSpi()
public Preferencesparent()
public voidput(String key, String value)
public voidputBoolean(String key, boolean value)
public voidputByteArray(String key, byte[] value)
public voidputDouble(String key, double value)
public voidputFloat(String key, float value)
public voidputInt(String key, int value)
public voidputLong(String key, long value)
protected abstract voidputSpi(String key, String value)
public voidremove(String key)
public voidremoveNode()
public voidremoveNodeChangeListener(NodeChangeListener ncl)
protected abstract voidremoveNodeSpi()
public voidremovePreferenceChangeListener(PreferenceChangeListener pcl)
protected abstract voidremoveSpi(String key)
public voidsync()
protected abstract voidsyncSpi()
public StringtoString()


 

Datenelemente im Detail

protected final Object lock
Ein Objekt, dessen Monitor als Lock für diesen Knoten benutzt wird.
protected boolean newNode
Hat den Wert true, wenn der Knoten neu erzeugt wurde und noch nicht persistent gespeichert wurde. Initial hat das Attribut den Wert false, wenn die Implementierung muss den Wert entsprechend ändern, wenn es sich um einen neuen Knoten handelt. Wenn das Attribut nach Abschluss des Erzeugungsvorgangs den Wert true hat, wird ein NodeChangeEvent ausgelöst.

 

Konstruktoren im Detail

protected AbstractPreferences(AbstractPreferences parent, String name)
Erzeugt einen neuen Einstellung-Knoten mit dem übergebenen Eltern-Knoten und dem relativen Namen zum Eltern-Knoten.

 

Methoden im Detail

public String absolutePath()
Liefert den absoluten Pfade des Einstellung-Knotens zurück. Relevant für den Pfad sind die Namen der Knotens zum Zeitpunkt der Erzeugung. Der Pfad wird analog zu einem Verzeichnis in Unix definiert, wobei der Wurzel-Knoten mit einem Schrägstrich identifiziert wird. Folgende Zeile zeigt eine beispielhafte Angabe eines absoluten Pfads:
/de/dpunkt/runtime/prefs
Um den absoluten Pfad zu ermitteln wird der Name des aktuellen Knotens und die Namen der Vorgänger-Knoten mit Schrägstrich getrennt zu einer Zeichenkette verknüpft.
public void addNodeChangeListener(NodeChangeListener ncl)
Fügt dem Knoten einen NodeChangeListener hinzu.NodeChangeListener werden über Änderungen informiert, die den Knoten selbst betreffen (z. B. Erzeugung oder Löschen von Kind-Knoten).
public void addPreferenceChangeListener(PreferenceChangeListener pcl)
Fügt dem Knoten einen PreferenceChangeListener hinzu.PreferenceChangeListener werden über Änderungen informiert, die die einzelnen Einstellungen innerhalb eines Knotens betreffen (z. B. Hinzufügen, Ändern oder Löschen eines Schlüssel-Wert-Paares).
protected final AbstractPreferences[] cachedChildren()
Liefert alle Kind-Knoten zurück, die nicht gelöscht wurden.
protected abstract AbstractPreferences childSpi(String name)
Liefert den Kind-Knoten mit dem übergebenen Namen zurück. Wenn der Kind-Knoten nicht existiert, muss er erzeugt werden. Es wird sichergestellt, dass der übergebene Name nicht null ist, nicht leer ist, keinen Schrägstrich enthält und nicht länger alsMAX_NAME_LENGTH ist.

Die Implementierung muss sicherstellen, dass der zurückgelieferte Knoten nicht bereits gelöscht wurde. Wenn ein Konten mit dem übergebenen Namen früher bereits gelöscht wurde, kann er nicht wiederverwendet werden, sondern es muss ein neuer Knoten erzeugt werden.

Die Persistenz eines neuen Knotens, der durch die Implementierung dieser Methode erzeugt wird, ist erst sichergestellt, nach einem Aufruf von flush(). Es ist somit freigestellt, Knoten zunächst intern zwischenzuspeichern und erst später zu speichern, wenn dies explizit gewünscht wird.

Vor dem Aufruf dieser Methode wird der Knoten mit dem internen Lock-Objekt gesperrt.
public String[] childrenNames()
Liefert die Namen der Kind-Knoten zurück. Die Namen werden aus den intern zwischengespeicherten Kind-Knoten und einem Aufruf von childrenNamesSpi() ermittelt. Die Namen werden dabei über einen TreeSet in einString -Array konvertiert.
Exception: BackingStoreException
protected abstract String[] childrenNamesSpi()
Liefert die Namen der Kind-Knoten zurück. Wenn es keinen Kind-Knoten gibt, wird ein Array der Länge Null zurückgeliefert.

Die Namen der Knoten, die bereits intern zwischengespeichert werden, müssen nicht unbedingt zurückgeliefert werden. Es ist aber auch kein Fehler wenn Sie ebenfalls im Ergebnis enthalten sind.

Vor dem Aufruf dieser Methode wird der Knoten mit dem internen Lock-Objekt gesperrt.
Exception: BackingStoreException
public void clear()
Löscht alle Schlüssel-Wert Paare in diesem Knoten. Diese Implementierung sperrt zunächst den Knoten mit dem intern Lock-Objekt, holt sich die Namen aller Schlüssel über die Methodekeys() und iteriert über die Namen, wobei für jeden Schlüssel die Methode remove(String) aufgerufen wird.
Exception: BackingStoreException
public void exportNode(OutputStream os)
Schreibt den einzelnen Knotens im XML-Format in den übergeben OutputStream.
Exception: IOException
Exception: BackingStoreException
public void exportSubtree(OutputStream os)
Schreibt die Einstellungen im aktuellen und den untergeordneten Knoten im XML-Format in den übergebenen OutputStream.
Exception: IOException
Exception: BackingStoreException
public void flush()
Schreibt die Einstellungen in diesem und allen zwischengespeicherten Kind-Knoten fest.

Die Implementierung dieser Methode sperrt den Knoten mit dem internen Lock-Objekt, ruft flushSpi() auf und gibt den Knoten wieder frei. Anschließend wird diese Vorgehensweise rekursiv auf alle zwischengespeicherten Kind-Knoten durchgeführt.
Exception: BackingStoreException
protected abstract void flushSpi()
Vor dem Aufruf dieser Methode wird der Knoten mit dem internen Lock-Objekt gesperrt. Bei Aufruf dieser Methode müssen alle zwischengespeicherten Änderungen über den verwendeten Persistent-Mechanismus festgeschrieben werden. Eine rekursive Speicherung der Unterknoten muss nicht durchgeführt werden.

Wenn eine rekursive Speicherung über diese Methode effizient bewerkstelligt kann, ist es ratsam dies zu nutzen und auch flush() entsprechend zu redefinieren, da dort die rekursive Traversierung der Kind-Knoten durchgeführt wird.

Exception: BackingStoreException
public String get(String key, String def)
Liefert den Wert zum übergebenen Schlüssel zurück. Die Implementierung ruft hierzu die Methode getSpi(String). Wenn die Methode null zurückliefert oder eine Exception auslöst, wirddef als Ergebnis geliefert.
public boolean getBoolean(String key, boolean def)
Liefert den Wert zum übergebenen Schlüssel als boolean zurück. Hierzu wird intern get(String,String) aufgerufen. Das Ergebnis dieses Aufrufs wird anschließend mit equalsIgnoreCase(String) mit »true« verglichen. Wenn dieser Vergleich false liefert, wird ein Vergleich mit »false« durchgeführt. Im Erfolgsfalle wird jeweils true zurückgeliefert. Beim Scheitern beider Vergleiche oder im Falle eines internen Fehlers wird def zurückgeliefert.
public byte[] getByteArray(String key, byte[] def)
Liefert den Wert zum übergebenen Schlüssel als Byte-Array zurück. Hierzu wird intern get(String,String) aufgerufen und der Wert von Base64 in ein Byte-Array konvertiert. Im Falle eines internen Fehlers wird def zurückgeliefert.
protected AbstractPreferences getChild(String nodeName)
Liefert den Kind-Knoten mit dem übergebenen Namen zurück, oder null, wenn der Kind-Knoten nicht existiert. Es wird gewährleistet, dass es sich beim übergebenen Namen syntaktisch um einen gültigen Knoten-Bezeichner handelt und dieser Knoten zuvor nicht gelöscht wurde.

Die Implementierung dieser Methode sperrt den Knoten mit dem internen Lock-Objekt, fragt die Namen der Kind-Knoten mit der Methode childrenNames() ab. Anschließend erfolgt eine Iteration über die Namen, wobei ein Vergleich der Namen durchgeführt wird. Wird der gesuchte Namen gefunden, wird der Knoten über die Methode childSpi(String) ermittelt und zurückgeliefert, ansonsten wird null zurückgeliefert.
Exception: BackingStoreException
public double getDouble(String key, double def)
Liefert den Wert zum übergebenen Schlüssel als double-Wert zurück.

Die Implementierung ruft get(key, null) und versucht das Ergebnis in einen double-Wert zu konvertieren. Bei Erfolg wird er zurückgeliefert, ansonsten gibt die Methode def zurück.
public float getFloat(String key, float def)
Liefert den Wert zum übergebenen Schlüssel als float-Wert zurück.

Die Implementierung ruft get(key, null) und versucht das Ergebnis in einen float-Wert zu konvertieren. Bei Erfolg wird er zurückgeliefert, ansonsten gibt die Methode def zurück.
public int getInt(String key, int def)
Liefert den Wert zum übergebenen Schlüssel als int-Wert zurück.

Die Implementierung ruft get(key, null) und versucht das Ergebnis in einen int-Wert zu konvertieren. Bei Erfolg wird er zurückgeliefert, ansonsten gibt die Methode def zurück.
public long getLong(String key, long def)
Liefert den Wert zum übergebenen Schlüssel als long-Wert zurück.

Die Implementierung ruft get(key, null) und versucht das Ergebnis in einen long-Wert zu konvertieren. Bei Erfolg wird er zurückgeliefert, ansonsten gibt die Methode def zurück.
protected abstract String getSpi(String key)
Liefert den Wert zum übergebenen Schlüssel zurück oder null, wenn zum Schlüssel kein Wert gespeichert ist.

Es wird sichergestellt, dass der Knoten nicht gelöscht wurde und dass der Schlüssel nicht null ist.

Wenn die Methode eine Exception auslöst, wird dies vom Aufrufer genauso behandelt wie die Rückgabe von null.
protected boolean isRemoved()
Liefert true, wenn dieser Knoten oder ein Vorfahre zuvor mit der Methode removeNode() gelöscht wurden.
public boolean isUserNode()
Liefert true zurück, wenn es sich um einen Knoten mit Benutzer-Einstellungen handelt.

Die Implementierung vergleicht den Wurzel-Knoten dieses Knotens mit dem Ergebnis von userRoot().
public String[] keys()
Liefert die Namen aller Schlüssel zurück, die in diesem Knoten gespeichert sind.

Die Implementierung dieser Methode sperrt den Knoten mit dem internen Lock-Objekt, prüft, ob der Knoten nicht bereits gelöscht wurde und ruft anschließend keysSpi() auf.
Exception: BackingStoreException
protected abstract String[] keysSpi()
Liefert die Namen aller Schlüssel in diesem Knoten zurück, denen ein Wert zugeordnet ist. Wenn es in diesem Knoten keine Schlüssel gibt, wird ein Array der Länge Null zurückgeliefert.

Vor Aufruf dieser Methode wird der Knoten mit dem internen Lock-Objekt gesperrt.
Exception: BackingStoreException
public Preferences parent()
Liefert den Eltern-Knoten zurück.

Die Implementierung dieser Methode sperrt den Knoten mit dem internen Lock-Objekt, prüft, ob der Knoten nicht bereits zuvor gelöscht wurde und liefert anschließend den Eltern-Knoten zurück, mit dem der Knoten über den Konstruktor initialisiert wurde.
public void put(String key, String value)
Speichert das übergebene Schlüssel-Wert-Paar im Knoten.

Die Implementierung prüft zunächst, ob Schlüssel und Wert gültig sind. Anschließend wird der Knoten mit dem internen Lock-Objekt gesperrt und sichergestellt, dass der Knoten nicht zuvor gelöscht wurde, bevor die Methode putSpi(String,String) mit Schlüssel und Wert aufgerufen wird. Die registrierten PreferenceChangeListener werden danach über die geänderten Einstellungen informiert.
public void putBoolean(String key, boolean value)
Speichert den Wert zum übergebenen Schlüssel als boolean.

Die Implementierung konvertiert zunächst den übergebenen Wert über die Methode valueOf(boolean) der Klasse String und ruft mit dem Ergebnis put(String,String) auf.
public void putByteArray(String key, byte[] value)
Speichert den Wert zum übergebenen Schlüssel als Byte-Array.

Die Implementierung konvertiert zunächst den übergebenen Wert nach Base64 und ruft mit dem Ergebnis put(String,String) auf.
public void putDouble(String key, double value)
Speichert den Wert zum übergebenen Schlüssel als double.

Die Implementierung konvertiert zunächst den übergebenen Wert über die Methode toString(double) der Klasse Double und ruft mit dem Ergebnis put(String,String) auf.
public void putFloat(String key, float value)
Speichert den Wert zum übergebenen Schlüssel als float.

Die Implementierung konvertiert zunächst den übergebenen Wert über die Methode toString(float) der Klasse Float und ruft mit dem Ergebnis put(String,String) auf.
public void putInt(String key, int value)
Speichert den Wert zum übergebenen Schlüssel als int.

Die Implementierung konvertiert zunächst den übergebenen Wert über die Methode toString(int) der Klasse Integer und ruft mit dem Ergebnis put(String,String) auf.
public void putLong(String key, long value)
Speichert den Wert zum übergebenen Schlüssel als int.

Die Implementierung konvertiert zunächst den übergebenen Wert über die Methode toString(long) der Klasse Long und ruft mit dem Ergebnis put(String,String) auf.
protected abstract void putSpi(String key, String value)
Speichert das übergebene Schlüssel-Wert-Paar in diesem Knoten. Es wird sichergestellt, das Schlüssel und Wert gültige Werte haben und dieser Knoten nicht zuvor gelöscht wurde.

Vor dem Aufruf dieser Methode wird der Knoten mit dem internen Lock-Objekt gesperrt.
public void remove(String key)
Entfernt den übergebenen Schlüssel aus den Einstellungen dieses Knotens.

Die Implementierung sperrt den Knoten mit dem internen Lock-Objekt, prüft, ob der Knoten nicht zuvor gelöscht wurde und ruft removeSpi(String) auf. Anschließend werden alle registrierten PreferenceChangeListener übe die Änderung informiert.
public void removeNode()
Löscht diesen Knoten (und somit auch die untergeordneten Knoten) aus der Einstellung-Hierarchie).

Wenn es sich beim Knoten um einen Wurzel-Knoten handelt, wird eine Exception ausgelöst, da die Wurzel-Knoten nicht gelöscht werden können. Sonst wird der Knoten mit dem internen Lock-Objekt gesperrt und sichergestellt, dass alle Knoten des Teilbaums rekursiv in den Cache geladen werden. Hierzu wird intern für Knoten mit childrenNamesSpi() die Namen der Kind-Knoten ermittelt und für jeden noch nicht geladenen Knoten childSpi(String) aufgerufen. Danach wird removeNodeSpi() aufgerufen, der Knoten merkt sich, dass er gelöscht wurde und entfernt sich aus dem Cache des Eltern-Knoten. Anschließend werden alle NodeChangeListener über die Änderung informiert.
Exception: BackingStoreException
public void removeNodeChangeListener(NodeChangeListener ncl)
Deregistriert den übergebenen NodeChangeListener von diesem Knoten.
protected abstract void removeNodeSpi()
Löscht diesen Knoten und alle Einstellungen, die darin gespeichert sind. Wenn dieser Aufruf durchgeführt wird, hat der Knoten bereits keinen Kind-Knoten mehr, da untergeordnete Knoten automatisch rekursiv gelöscht werden, bevorremoveNodeSpi() in einem Knoten aufgerufen wird. Dadurch wird der Knote ungültig. Der Löschtvorgang muss nicht persistent gespeichert werden, bis ein Aufruf von flush() erfolgt.
Exception: BackingStoreException
public void removePreferenceChangeListener(PreferenceChangeListener pcl)
Deregistriert den übergebenen PreferenceChangeListener von diesem Knoten.
protected abstract void removeSpi(String key)
Löscht den übergebenen Schlüssel aus diesem Knoten. Es wird sichergestellt, dass key einen gültigen Wert hat und der Knoten nicht zuvor gelöscht wurde.

Vor Aufruf der Methode wird der Knoten mit dem internen Lock-Objekt gesperrt.
public void sync()
Synchronisiert den Knoten mit dem Persistenz-Mechanismus. Dadurch werden zwischengespeicherte, geänderte Knoten persistent gespeichert und extern geänderte Einstellungen neu geladen.

Die Implementierung dieser Methode sperrt den Knoten mit dem internen Lock-Objekt, ruft syncSpi() auf, hebt die Sperre auf und wiederholt diesen Vorgang rekursiv bei jedem zwischengespeicherten Kind-Knoten.
Exception: BackingStoreException
protected abstract void syncSpi()
Die Methode synchronisiert jeden im Cache zwischengepufferten Knoten mit dem Persistenz-Mechanismus. Die Methode wird für jeden einzelnen Knoten eines Teilbaums aufgerufen. Wenn der Persistenz-Mechanismus das effiziente speichern von Teilbäumen erlaubt, kann man die sync() entsprechend neu definieren, damit die syncSpi() nicht für jeden einzelnen Knoten aufgerufen wird.

Vor Aufruf dieser Methode wird der Knoten mit dem internen Lock-Objekt gesperrt.
Exception: BackingStoreException
public String toString()
Liefert den absoluten Pfad dieses Einstellung-Knotens zurück.


 Inhaltsverzeichnis   Vorhergehendes Paket   Seite Zurück   Seite Vor   Nächstes Paket   Paketübersicht   Index

Copyright © 2002 dpunkt.Verlag, Heidelberg. Alle Rechte vorbehalten.