Java Language
Inställningar

algorithm Android HTML javafx JavaScript MySQL Regular Expressions spring spring-boot SQL
Sök…


Lägga till evenemangets lyssnare

Det finns två typer av händelser som avges av ett Preferences : PreferenceChangeEvent och NodeChangeEvent .

PreferenceChangeEvent

Ett PreferenceChangeEvent släpps ut av ett Properties objekt varje gång en av nodens nyckelvärde-par ändras. PreferenceChangeEvent s kan lyssnas på med en 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();
    }
});

Den här lyssnaren lyssnar inte på ändrade nyckelvärdespar av barnnoder.

NodeChangeEvent

Denna händelse kommer att avfyras när en barnnod i en Properties nod läggs till eller tas bort. 

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

Skaffa undernoder av inställningar

Preferences representerar alltid en specifik nod i ett helt Preferences , typ av så här: 

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

För att välja noden /com/mycompany/myapp :

  1. Enligt konvention, baserat på paketet i en klass: 

    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. Av relativ väg: 

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

    Om du använder en relativ sökväg (en sökväg som inte börjar med a / ) kommer det att lösa banan i förhållande till den överordnade noden den löses på. Till exempel kommer följande exempel att returnera noden för sökvägen /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. Av absolut väg: 

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

    Att använda en absolut sökväg på rotnoden skiljer sig inte från att använda en relativ sökväg. Skillnaden är att om den anropas till en undernod kommer banan att lösas relativt rotnoden. 

    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

Samordna preferenser åtkomst över flera applikationsinstanser

Alla instanser av Preferences är alltid trådsäkra över trådarna på en enda Java Virtual Machine (JVM). Eftersom Preferences kan delas över flera JVM, finns det speciella metoder som hanterar synkronisering av förändringar mellan virtuella maskiner.

Om du har en applikation som endast ska köras i en enda instans krävs ingen extern synkronisering .

Om du har en applikation som körs i flera instanser på ett enda system och därför måste Preferences koordineras mellan JVM: erna på systemet, kan sync() för alla Preferences användas för att säkerställa att ändringar i Preferences är synlig för andra JVM: er på systemet: 

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

Exportera inställningar

Preferences kan exporteras till ett XML-dokument som representerar den noden. Det resulterande XML-trädet kan importeras igen. Den resulterande XML-dokument kommer ihåg om det exporterades från användar- eller Preferences .

Så här exporterar du en enda nod, men inte dess underordnade noder :

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

Så här exporterar du en enda nod med sina barnnoder :

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

Importerar preferenser

Preferences kan importeras från ett XML-dokument. Importering är tänkt att användas i samband med Exportfunktionaliteten i Preferences , eftersom det skapar rätt motsvarande XML-dokument.

De XML-dokument kommer att minnas om de exporterades från användar- eller Preferences . Därför kan de importeras till sina respektive Preferences igen, utan att du behöver ta reda på eller veta var de kommer ifrån. Den statiska funktionen automatiskt ta reda på om XML-dokumentet exporterades från användar- eller Preferences och kommer automatiskt att importera dem till trädet de exporterades från.

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

Ta bort evenemangets lyssnare

Event lyssnare kan tas bort igen från alla Properties , men lyssnarens instans måste hållas kvar för det.

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

Detsamma gäller för NodeChangeListener .

Få preferensvärden

Ett värde på en Preferences kan vara av typen String , boolean , byte[] , double , float , int eller long . Alla kallelser måste tillhandahålla ett standardvärde, om det angivna värdet inte finns i noden 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);

Ställa in preferensvärden

För att lagra ett värde i noden Preferences används en av putXXX() -metoderna. Ett värde på en Preferences kan vara av typen String , boolean , byte[] , double , float , int eller 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);

Med hjälp av preferenser

Preferences kan användas för att lagra användarinställningar som återspeglar en användares personliga applikationsinställningar, t.ex. deras redigeringssnitt, oavsett om de föredrar att applikationen ska startas i helskärmsläge, om de markerade kryssrutan "Visa inte detta igen" och saker sådär. 

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
Licensierat under CC BY-SA 3.0
Inte anslutet till Stack Overflow