Java Language
Preferenze

Per selezionare il nodo /com/mycompany/myapp :

1. Per convenzione, in base al pacchetto di una classe:

   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. Per percorso relativo:

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

   L'utilizzo di un percorso relativo (un percorso che non inizia con a / ) causerà la risoluzione del percorso rispetto al nodo genitore su cui è stato risolto. Ad esempio, il seguente esempio restituirà il nodo del percorso /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. Per via assoluta:

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

   L'utilizzo di un percorso assoluto sul nodo radice non sarà diverso dall'utilizzo di un percorso relativo. La differenza è che, se chiamato su un sub-nodo, il percorso sarà risolto rispetto al nodo radice.

   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
   

Accesso alle preferenze di coordinamento tra più istanze di applicazioni

Tutte le istanze di Preferences sono sempre thread-safe attraverso i thread di una singola Java Virtual Machine (JVM). Poiché le Preferences possono essere condivise tra più JVM, esistono metodi speciali che gestiscono la sincronizzazione delle modifiche tra macchine virtuali.

Se si dispone di un'applicazione che deve essere eseguita solo in una singola istanza , non è richiesta alcuna sincronizzazione esterna .

Se si dispone di un'applicazione che viene eseguita in più istanze su un singolo sistema e quindi l'accesso alle Preferences deve essere coordinato tra le JVM sul sistema, allora il metodo sync() di qualsiasi nodo Preferences può essere usato per assicurare che le modifiche al nodo Preferences siano visibile ad altre JVM sul sistema:

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

Esportare le preferenze

Preferences nodi di Preferences possono essere esportati in un documento XML che rappresenta quel nodo. L'albero XML risultante può essere nuovamente importato. Il documento XML risultante ricorderà se è stato esportato dall'utente o dalle Preferences sistema.

Per esportare un singolo nodo, ma non i suoi nodi figli :

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

Per esportare un singolo nodo con i relativi nodi figlio :

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

Importazione delle preferenze

Preferences nodi delle Preferences possono essere importati da un documento XML. L'importazione è pensata per essere utilizzata insieme alla funzionalità di esportazione delle Preferences , poiché crea i documenti XML corrispondenti corretti.

I documenti XML ricorderanno se sono stati esportati dall'utente o dalle Preferences sistema. Pertanto, possono essere importati nuovamente nei loro rispettivi alberi delle Preferences , senza che tu debba capire o sapere da dove provengono. La funzione statica rileva automaticamente se il documento XML è stato esportato dall'utente o dalle Preferences sistema e le importerà automaticamente nella struttura da cui sono state esportate.

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

Rimozione dei listener di eventi

I listener di eventi possono essere rimossi nuovamente da qualsiasi nodo Properties , ma l'istanza del listener deve essere mantenuta per questo.

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

Lo stesso vale per NodeChangeListener .

Ottenere i valori delle preferenze

Un valore di un nodo Preferences può essere di tipo String , boolean , byte[] , double , float , int o long . Tutte le invocazioni devono fornire un valore predefinito, nel caso in cui il valore specificato non sia presente nel nodo 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);

Impostazione dei valori delle preferenze

Per memorizzare un valore nel nodo Preferences , viene utilizzato uno dei metodi putXXX() . Un valore di un nodo Preferences può essere di tipo String , boolean , byte[] , double , float , int o 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);

Usando le preferenze

Preferences possono essere utilizzate per memorizzare le impostazioni dell'utente che riflettono le impostazioni dell'applicazione personale dell'utente, ad esempio il carattere del loro editor, se preferiscono che l'applicazione sia avviata in modalità a schermo intero, se hanno spuntato la casella di controllo "non mostrare più" e come quello.

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