Java Language
Einstellungen

algorithm Android HTML javafx JavaScript MySQL Regular Expressions spring spring-boot SQL
Suche…


Ereignis-Listener hinzufügen

Es gibt zwei Arten von Ereignissen, die von einem Preferences Objekt NodeChangeEvent : PreferenceChangeEvent und NodeChangeEvent .

PreferenceChangeEvent

Ein PreferenceChangeEvent wird bei jeder Änderung eines Schlüssel-Wert-Paars des Knotens von einem Properties Objekt ausgegeben. PreferenceChangeEvent s kann mit einem PreferenceChangeListener abgehört werden:

Java SE 8 
preferences.addPreferenceChangeListener(evt -> {
    String newValue = evt.getNewValue();
    String changedPreferenceKey = evt.getKey();
    Preferences changedNode = evt.getNode();
});
Java SE 8 
preferences.addPreferenceChangeListener(new PreferenceChangeListener() {
    @Override
    public void preferenceChange(PreferenceChangeEvent evt) {
        String newValue = evt.getNewValue();
        String changedPreferenceKey = evt.getKey();
        Preferences changedNode = evt.getNode();
    }
});

Dieser Listener hört nicht auf geänderte Schlüsselwertpaare untergeordneter Knoten.

NodeChangeEvent

Dieses Ereignis wird ausgelöst, wenn ein untergeordneter Knoten eines Properties hinzugefügt oder entfernt wird. 

preferences.addNodeChangeListener(new NodeChangeListener() {
    @Override
    public void childAdded(NodeChangeEvent evt) {
        Preferences addedChild = evt.getChild();
        Preferences parentOfAddedChild = evt.getParent();
    }

    @Override
    public void childRemoved(NodeChangeEvent evt) {
        Preferences removedChild = evt.getChild();
        Preferences parentOfRemovedChild = evt.getParent();
    }
});

Unterknoten der Voreinstellungen abrufen

Preferences repräsentieren immer einen bestimmten Knoten in einem gesamten Preferences , wie folgt: 

/userRoot
├── com
│   └── mycompany
│       └── myapp
│           ├── darkApplicationMode=true
│           ├── showExitConfirmation=false
│           └── windowMaximized=true
└── org
    └── myorganization
        └── anotherapp
            ├── defaultFont=Helvetica
            ├── defaultSavePath=/home/matt/Documents
            └── exporting
                ├── defaultFormat=pdf
                └── openInBrowserAfterExport=false

So wählen Sie den Knoten /com/mycompany/myapp :

  1. Konvention basierend auf dem Paket einer Klasse: 

    package com.mycompany.myapp;

// ...

// Because this class is in the com.mycompany.myapp package, the node
// /com/mycompany/myapp will be returned.
Preferences myApp = Preferences.userNodeForPackage(getClass());

  2. Durch relativen Pfad: 

    Preferences myApp = Preferences.userRoot().node("com/mycompany/myapp");

    Wenn Sie einen relativen Pfad verwenden (ein Pfad, der nicht mit einem / beginnt), wird der Pfad relativ zum übergeordneten Knoten aufgelöst, auf dem er aufgelöst wird. Das folgende Beispiel gibt beispielsweise den Knoten des Pfads /one/two/three/com/mycompany/myapp : 

    Preferences prefix = Preferences.userRoot().node("one/two/three");
Preferences myAppWithPrefix = prefix.node("com/mycompany/myapp");
// prefix          is /one/two/three
// myAppWithPrefix is /one/two/three/com/mycompany/myapp

  3. Über den absoluten Pfad: 

    Preferences myApp = Preferences.userRoot().node("/com/mycompany/myapp");

    Die Verwendung eines absoluten Pfads auf dem Wurzelknoten unterscheidet sich nicht von der Verwendung eines relativen Pfads. Der Unterschied besteht darin, dass der Pfad relativ zu dem Wurzelknoten aufgelöst wird, wenn er auf einem Unterknoten aufgerufen wird. 

    Preferences prefix = Preferences.userRoot().node("one/two/three");
Preferences myAppWitoutPrefix = prefix.node("/com/mycompany/myapp");
// prefix            is /one/two/three
// myAppWitoutPrefix is /com/mycompany/myapp

Koordinieren Sie den Zugriff auf Einstellungen auf mehrere Anwendungsinstanzen

Alle Instanzen von Preferences sind immer Thread-sicher in den Threads einer einzelnen Java Virtual Machine (JVM). Da Preferences mehreren JVMs gemeinsam genutzt werden können, gibt es spezielle Methoden, um Änderungen zwischen virtuellen Maschinen zu synchronisieren.

Wenn Sie eine Anwendung haben, die nur in einer Instanz ausgeführt werden soll , ist keine externe Synchronisierung erforderlich.

Wenn Sie eine Anwendung, die auf einem einzigen System in mehreren Instanzen ausgeführt wird und daher Preferences zugreifen muss zwischen den JVMs auf dem System koordiniert werden, dann ist die sync() Verfahren nach Preferences können Knoten verwendet werden , um Änderungen an den , um sicherzustellen , Preferences Knoten sind sichtbar für andere JVMs im System: 

// Warning: don't use this if your application is intended
// to only run a single instance on a machine once
// (this is probably the case for most desktop applications)
try {
    preferences.sync();
} catch (BackingStoreException e) {
    // Deal with any errors while saving the preferences to the backing storage
    e.printStackTrace();
}

Einstellungen exportieren

Preferences können in ein XML-Dokument exportiert werden, das diesen Knoten darstellt. Die resultierende XML-Struktur kann erneut importiert werden. Das resultierende XML - Dokument wird sich erinnern , ob es von den Benutzer oder System exportiert wurde Preferences .

So exportieren Sie einen einzelnen Knoten, jedoch nicht seine untergeordneten Knoten :

Java SE 7 
try (OutputStream os = ...) {
    preferences.exportNode(os);
} catch (IOException ioe) {
    // Exception whilst writing data to the OutputStream
    ioe.printStackTrace();
} catch (BackingStoreException bse) {
    // Exception whilst reading from the backing preferences store
    bse.printStackTrace();
}
Java SE 7 
OutputStream os = null;
try {
    os = ...;
    preferences.exportSubtree(os);
} catch (IOException ioe) {
    // Exception whilst writing data to the OutputStream
    ioe.printStackTrace();
} catch (BackingStoreException bse) {
    // Exception whilst reading from the backing preferences store
    bse.printStackTrace();
} finally {
    if (os != null) {
        try {
            os.close();
        } catch (IOException ignored) {}
    }
}

So exportieren Sie einen einzelnen Knoten mit seinen untergeordneten Knoten :

Java SE 7 
try (OutputStream os = ...) {
    preferences.exportNode(os);
} catch (IOException ioe) {
    // Exception whilst writing data to the OutputStream
    ioe.printStackTrace();
} catch (BackingStoreException bse) {
    // Exception whilst reading from the backing preferences store
    bse.printStackTrace();
}
Java SE 7 
OutputStream os = null;
try {
    os = ...;
    preferences.exportSubtree(os);
} catch (IOException ioe) {
    // Exception whilst writing data to the OutputStream
    ioe.printStackTrace();
} catch (BackingStoreException bse) {
    // Exception whilst reading from the backing preferences store
    bse.printStackTrace();
} finally {
    if (os != null) {
        try {
            os.close();
        } catch (IOException ignored) {}
    }
}

Präferenzen importieren

Preferences können aus einem XML-Dokument importiert werden. Importieren soll in Verbindung mit der Exportfunktionalität von Preferences , da die richtigen XML-Dokumente erstellt werden.

Die XML - Dokumente werden sich erinnern , ob sie von den Benutzer oder System exportiert wurden Preferences . Daher können sie erneut in ihre jeweiligen Preferences importiert werden, ohne dass Sie herausfinden müssen, woher sie stammen. Die statische Funktion wird automatisch feststellen, ob das XML - Dokument aus den Benutzer oder System exportiert wurde Preferences und wird sie automatisch importieren in den Baum , den sie aus exportiert wurden.

Java SE 7 
try (InputStream is = ...) {
    // This is a static call on the Preferences class
    Preferences.importPreferences(is);
} catch (IOException ioe) {
    // Exception whilst reading data from the InputStream
    ioe.printStackTrace();
} catch (InvalidPreferencesFormatException ipfe) {
    // Exception whilst parsing the XML document tree
    ipfe.printStackTrace();
}
Java SE 7 
InputStream is = null;
try {
    is = ...;
    // This is a static call on the Preferences class
    Preferences.importPreferences(is);
} catch (IOException ioe) {
    // Exception whilst reading data from the InputStream
    ioe.printStackTrace();
} catch (InvalidPreferencesFormatException ipfe) {
    // Exception whilst parsing the XML document tree
    ipfe.printStackTrace();
} finally {
    if (is != null) {
        try {
            is.close();
        } catch (IOException ignored) {}
    }
}

Ereignis-Listener entfernen

Ereignis-Listener können wieder von jedem Properties werden, aber die Instanz des Listeners muss dafür in der Nähe bleiben.

Java SE 8 
Preferences preferences = Preferences.userNodeForPackage(getClass());

PreferenceChangeListener listener = evt -> {
    System.out.println(evt.getKey() + " got new value " + evt.getNewValue());
};
preferences.addPreferenceChangeListener(listener);

//
// later...
//

preferences.removePreferenceChangeListener(listener);
Java SE 8 
Preferences preferences = Preferences.userNodeForPackage(getClass());

PreferenceChangeListener listener = new PreferenceChangeListener() {
    @Override
    public void preferenceChange(PreferenceChangeEvent evt) {
        System.out.println(evt.getKey() + " got new value " + evt.getNewValue());
    }
};
preferences.addPreferenceChangeListener(listener);

//
// later...
//

preferences.removePreferenceChangeListener(listener);

Gleiches gilt für NodeChangeListener .

Präferenzwerte abrufen

Ein Wert eines Preferences Knotens kann vom Typ String , boolean , byte[] , double , float , int oder long . Alle Beschwörungen müssen einen Standardwert zur Verfügung stellen, falls der angegebene Wert nicht in dem ist Preferences Knoten. 

Preferences preferences = Preferences.userNodeForPackage(getClass());

String someString = preferences.get("someKey", "this is the default value");
boolean someBoolean = preferences.getBoolean("someKey", true);
byte[] someByteArray = preferences.getByteArray("someKey", new byte[0]);
double someDouble = preferences.getDouble("someKey", 887284.4d);
float someFloat = preferences.getFloat("someKey", 38723.3f);
int someInt = preferences.getInt("someKey", 13232);
long someLong = preferences.getLong("someKey", 2827637868234L);

Voreinstellungen festlegen

Um einen Wert im Knoten " Preferences zu speichern, wird eine der putXXX() Methoden verwendet. Ein Wert eines Preferences Knotens kann vom Typ String , boolean , byte[] , double , float , int oder long . 

Preferences preferences = Preferences.userNodeForPackage(getClass());

preferences.put("someKey", "some String value");
preferences.putBoolean("someKey", false);
preferences.putByteArray("someKey", new byte[0]);
preferences.putDouble("someKey", 187398123.4454d);
preferences.putFloat("someKey", 298321.445f);
preferences.putInt("someKey", 77637);
preferences.putLong("someKey", 2873984729834L);

Präferenzen verwenden

Preferences können verwendet werden, um Benutzereinstellungen zu speichern, die die persönlichen Anwendungseinstellungen eines Benutzers widerspiegeln, z. B. die Schriftart des Editors, ob die Anwendung lieber im Vollbildmodus gestartet werden soll, ob sie das Kontrollkästchen "Nicht mehr anzeigen" und andere Dinge aktiviert haben so wie das. 

public class ExitConfirmer {
    private static boolean confirmExit() {
        Preferences preferences = Preferences.userNodeForPackage(ExitConfirmer.class);
        boolean doShowDialog = preferences.getBoolean("showExitConfirmation", true); // true is default value

        if (!doShowDialog) {
            return true;
        }

        //
        // Show a dialog here...
        //
        boolean exitWasConfirmed = ...; // whether the user clicked OK or Cancel
        boolean doNotShowAgain = ...; // get value from "Do not show again" checkbox

        if (exitWasConfirmed && doNotShowAgain) {
            // Exit was confirmed and the user chose that the dialog should not be shown again
            // Save these settings to the Preferences object so the dialog will not show again next time
            preferences.putBoolean("showExitConfirmation", false);
        }

        return exitWasConfirmed;
    }

    public static void exit() {
        if (confirmExit()) {
            System.exit(0);
        }
    }
}


Modified text is an extract of the original Stack Overflow Documentation
Lizenziert unter CC BY-SA 3.0
Nicht angeschlossen an Stack Overflow