Java Language
Préférences

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


Ajouter des écouteurs d'événement

Il existe deux types d'événements émis par un Preferences objet: PreferenceChangeEvent et NodeChangeEvent .

PreferenceChangeEvent

Un PreferenceChangeEvent est émis par un objet Properties chaque fois que l'une des paires clé-valeur du nœud change. PreferenceChangeEvent s peut être écouté avec PreferenceChangeListener :

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

Cet écouteur n'écoutera pas les paires clé-valeur modifiées des nœuds enfants.

NodeChangeEvent

Cet événement sera déclenché chaque fois qu'un nœud enfant d'un nœud Properties est ajouté ou supprimé. 

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

Obtenir des sous-noeuds de préférences

Preferences objets de Preferences représentent toujours un nœud spécifique dans une arborescence de Preferences entière, un peu comme ceci: 

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

Pour sélectionner le noeud /com/mycompany/myapp :

  1. Par convention, basée sur le package d'une 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. Par chemin relatif: 

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

    L'utilisation d'un chemin relatif (un chemin ne commençant pas par / ) entraînera la résolution du chemin par rapport au nœud parent sur lequel il est résolu. Par exemple, l'exemple suivant renvoie le noeud du chemin /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. Par chemin absolu: 

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

    L'utilisation d'un chemin absolu sur le nœud racine ne sera pas différente de l'utilisation d'un chemin relatif. La différence est que, s'il est appelé sur un sous-nœud, le chemin sera résolu par rapport au nœud racine. 

    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

Accès aux préférences de coordination sur plusieurs instances d'application

Toutes les instances de Preferences sont toujours thread-safe sur les threads d'une seule machine virtuelle Java (JVM). Comme les Preferences peuvent être partagées entre plusieurs machines virtuelles, il existe des méthodes spéciales qui traitent de la synchronisation des modifications entre les machines virtuelles.

Si vous avez une application qui est censée s'exécuter dans une seule instance , aucune synchronisation externe n'est requise.

Si une application s'exécute dans plusieurs instances sur un seul système et que, par conséquent, l'accès aux Preferences doit être coordonné entre les JVM sur le système, la méthode sync() de tout noeud Preferences peut être utilisée pour garantir que les modifications apportées au noeud Preferences visible aux autres JVM sur le système: 

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

Préférences d'exportation

Preferences nœuds de Preferences peuvent être exportés dans un document XML représentant ce nœud. L'arborescence XML résultante peut être importée à nouveau. Le document XML résultant se souviendra s'il a été exporté à partir des Preferences de l'utilisateur ou du système.

Pour exporter un seul noeud, mais pas ses noeuds enfants :

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

Pour exporter un seul noeud avec ses noeuds enfants :

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

Importation de préférences

Preferences nœuds de Preferences peuvent être importés à partir d'un document XML. L'importation est destinée à être utilisée avec la fonctionnalité d'exportation de Preferences , car elle crée les documents XML correspondants.

Les documents XML se souviendront s'ils ont été exportés à partir des Preferences de l'utilisateur ou du système. Par conséquent, ils peuvent être importés à nouveau dans leurs arborescences de Preferences respectives, sans que vous ayez à comprendre ou à savoir d'où ils viennent. La fonction statique détectera automatiquement si le document XML a été exporté à partir des Preferences de l'utilisateur ou du système et les importera automatiquement dans l'arborescence à partir de laquelle ils ont été exportés.

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

Suppression des écouteurs d'événements

Les écouteurs d'événements peuvent être supprimés à nouveau à partir de n'importe quel noeud Properties , mais l'instance de l'écouteur doit être conservée pour cela.

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

La même chose s'applique pour NodeChangeListener .

Obtenir des valeurs de préférences

Une valeur d'un noeud Preferences peut être du type String , boolean , byte[] , double , float , int ou long . Toutes les invocations doivent fournir une valeur par défaut, au cas où la valeur spécifiée ne serait pas présente dans le noeud 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);

Définition des valeurs de préférences

Pour stocker une valeur dans le noeud Preferences , l'une des méthodes putXXX() est utilisée. Une valeur d'un noeud Preferences peut être du type String , boolean , byte[] , double , float , int ou 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);

Utiliser les préférences

Preferences peuvent être utilisées pour stocker les paramètres utilisateur reflétant les paramètres d'application personnels d'un utilisateur, par exemple sa police d'éditeur, si elles préfèrent que l'application soit lancée en mode plein écran, si elles ont coché une case à cocher comme ça. 

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
Sous licence CC BY-SA 3.0
Non affilié à Stack Overflow