Java Language
voorkeuren

Om het /com/mycompany/myapp knooppunt te selecteren:

1. Volgens afspraak, op basis van het pakket van een 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. Op relatief pad:

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

   Als u een relatief pad gebruikt (een pad dat niet begint met een / ), wordt het pad opgelost ten opzichte van het bovenliggende knooppunt waarop het is opgelost. In het volgende voorbeeld wordt bijvoorbeeld het knooppunt van het pad /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. Op absoluut pad:

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

   Het gebruik van een absoluut pad op het hoofdknooppunt verschilt niet van het gebruik van een relatief pad. Het verschil is dat, als het op een subknooppunt wordt aangeroepen, het pad ten opzichte van het hoofdknooppunt wordt opgelost.

   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
   

Coördinerende voorkeuren toegang over meerdere applicatie-instanties

Alle instanties van Preferences zijn altijd thread-safe over de threads van een enkele Java Virtual Machine (JVM). Omdat Preferences kunnen worden gedeeld over meerdere JVM's, zijn er speciale methoden voor het synchroniseren van wijzigingen tussen virtuele machines.

Als u een toepassing hebt die alleen in één exemplaar moet worden uitgevoerd, is geen externe synchronisatie vereist.

Als u een toepassing hebt die in meerdere exemplaren op één systeem wordt uitgevoerd en daarom de toegang van Preferences moet worden gecoördineerd tussen de JVM's op het systeem, dan kan de methode sync() van elk knooppunt Preferences worden gebruikt om te zorgen dat wijzigingen in het knooppunt Preferences zijn zichtbaar voor andere JVM's op het systeem:

// 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();
}

Voorkeuren exporteren

Preferences kunnen worden geëxporteerd naar een XML-document dat dat knooppunt vertegenwoordigt. De resulterende XML-structuur kan opnieuw worden geïmporteerd. De resulterende XML-document zal herinneren of het werd geëxporteerd vanuit de gebruiker of het systeem Preferences .

Om een enkel knooppunt te exporteren, maar niet de onderliggende knooppunten :

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();
}

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) {}
    }
}

Om een enkel knooppunt met zijn onderliggende knooppunten te exporteren:

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();
}

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) {}
    }
}

Voorkeuren importeren

Preferences kunnen worden geïmporteerd uit een XML-document. Importeren is bedoeld om te worden gebruikt in combinatie met de exportfunctionaliteit van Preferences , omdat hiermee de juiste bijbehorende XML-documenten worden gemaakt.

De XML-documenten zullen herinneren of zij werden uitgevoerd door de gebruiker of het systeem Preferences . Daarom kunnen ze opnieuw in hun respectieve Preferences worden geïmporteerd, zonder dat u hoeft te achterhalen of waar ze vandaan komen. De statische functie wordt automatisch erachter te komen of het XML-document van de gebruiker of het systeem werd geëxporteerd Preferences en zal ze automatisch te importeren in de boom werden ze uit geëxporteerd.

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();
}

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) {}
    }
}

Gebeurtenisluisteraars verwijderen

Luisteraars van gebeurtenissen kunnen weer uit elk knooppunt Properties worden verwijderd, maar daarvoor moet de instantie van de luisteraar worden bewaard.

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);

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);

Hetzelfde geldt voor NodeChangeListener .

Voorkeurswaarden verkrijgen

Een waarde van een Preferences kan van het type String , boolean , byte[] , double , float , int of long . Alle aanroepen moeten een standaardwaarde bieden, voor het geval dat de opgegeven waarde niet aanwezig is in het knooppunt Preferences .

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);

Voorkeuren instellen

Als u een waarde in het knooppunt Preferences wilt opslaan, wordt een van de methoden putXXX() gebruikt. Een waarde van een Preferences kan van het type String , boolean , byte[] , double , float , int of 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);

Voorkeuren gebruiken

Preferences kunnen worden gebruikt om gebruikersinstellingen op te slaan die de persoonlijke applicatie-instellingen van een gebruiker weerspiegelen, bijv. Hun editorlettertype, of ze liever hebben dat de applicatie op volledig scherm wordt gestart, of dat ze een "niet meer tonen" aanvinkvakje en dergelijke aanvinken zoals dat.

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);
        }
    }
}