Java Language
Preferencias

Para seleccionar el nodo /com/mycompany/myapp :

1. Por convención, basado en el paquete de una clase:

   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. Por camino relativo:

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

   El uso de una ruta relativa (una ruta que no comienza con una / ) hará que la ruta se resuelva en relación con el nodo principal en el que se resuelve. Por ejemplo, el siguiente ejemplo devolverá el nodo de la ruta /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. Por camino absoluto:

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

   El uso de una ruta absoluta en el nodo raíz no será diferente de usar una ruta relativa. La diferencia es que, si se llama en un subnodo, la ruta se resolverá en relación con el nodo raíz.

   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
   

Coordinar las preferencias de acceso a través de múltiples instancias de aplicaciones

Todas las instancias de Preferences siempre son seguras para subprocesos en los subprocesos de una única Máquina Virtual de Java (JVM). Debido a que las Preferences se pueden compartir en múltiples JVM, existen métodos especiales que se ocupan de sincronizar los cambios en las máquinas virtuales.

Si tiene una aplicación que se supone que se ejecuta solo en una instancia , no se requiere sincronización externa .

Si tiene una aplicación que se ejecuta en varias instancias en un solo sistema y, por lo tanto, el acceso a las Preferences debe coordinarse entre las JVM del sistema, entonces se puede usar el método sync() de cualquier nodo de Preferences para garantizar que se realicen cambios en el nodo de Preferences visible para otras JVM en el 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();
}

Preferencias de exportación

Preferences nodos de Preferences se pueden exportar a un documento XML que representa ese nodo. El árbol XML resultante se puede importar de nuevo. El documento XML resultante recordará si se exportó desde el usuario o las Preferences sistema.

Para exportar un solo nodo, pero no sus nodos secundarios :

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

Para exportar un solo nodo con sus nodos hijos :

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

Importando preferencias

Preferences nodos de Preferences se pueden importar desde un documento XML. La importación debe utilizarse junto con la funcionalidad de exportación de Preferences , ya que crea los documentos XML correspondientes correctos.

Los documentos XML recordarán si se exportaron desde el usuario o las Preferences sistema. Por lo tanto, se pueden importar de nuevo en sus respectivos árboles de Preferences , sin que tenga que averiguar o saber de dónde vienen. La función estática descubrirá automáticamente si el documento XML se exportó desde el usuario o las Preferences sistema y los importará automáticamente en el árbol desde el que se exportaron.

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

Eliminar oyentes de eventos

Los escuchas de eventos pueden eliminarse nuevamente de cualquier nodo de Properties , pero la instancia del oyente debe mantenerse alrededor para eso.

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 mismo se aplica para NodeChangeListener .

Obteniendo valores de preferencias

Un valor de un nodo de Preferences puede ser del tipo String , boolean , byte[] , double , float , int o long . Todas las invocaciones deben proporcionar un valor predeterminado, en caso de que el valor especificado no esté presente en el 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);

Configuración de valores de preferencias

Para almacenar un valor en el nodo Preferences , se putXXX() uno de los métodos putXXX() . Un valor de un nodo de Preferences puede ser del 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 preferencias

Preferences se pueden usar para almacenar la configuración del usuario que refleja la configuración personal de la aplicación del usuario, por ejemplo, la fuente de su editor, si prefieren que la aplicación se inicie en modo de pantalla completa, si marcó la casilla de verificación "No volver a mostrar esto" y demás. como eso.

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