Java Language
Preferencje

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


Dodawanie detektorów zdarzeń

Istnieją dwa typy zdarzeń emitowanych przez Preferences obiektu: PreferenceChangeEvent i NodeChangeEvent .

PreferenceChangeEvent

PreferenceChangeEvent jest emitowany przez obiekt Properties każdym razem, gdy zmienia się jedna z par klucz-wartość-węzła. PreferenceChangeEvent s można nasłuchiwać za pomocą 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();
    }
});

Ten detektor nie będzie nasłuchiwał zmienionych par klucz-wartość węzłów potomnych.

NodeChangeEvent

To zdarzenie będzie uruchamiane za każdym razem, gdy węzeł potomny węzła Properties zostanie dodany lub usunięty. 

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

Uzyskiwanie podwęzłów preferencji

Obiekty Preferences zawsze reprezentują określony węzeł w całym drzewie Preferences , podobnie jak to: 

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

Aby wybrać węzeł /com/mycompany/myapp :

  1. Zgodnie z konwencją, w oparciu o pakiet klasy: 

    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. Według ścieżki względnej: 

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

    Użycie ścieżki względnej (ścieżki nie rozpoczynającej się od / ) spowoduje, że ścieżka zostanie rozstrzygnięta względem węzła nadrzędnego, na którym jest ona rozstrzygana. Na przykład poniższy przykład zwróci węzeł ścieżki /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. Drogą bezwzględną: 

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

    Użycie ścieżki bezwzględnej w węźle głównym nie będzie różnić się od użycia ścieżki względnej. Różnica polega na tym, że jeśli zostanie wywołana w pod-węźle, ścieżka zostanie rozstrzygnięta względem węzła głównego. 

    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

Dostęp do preferencji koordynacyjnych w wielu instancjach aplikacji

Wszystkie wystąpienia Preferences są zawsze bezpieczne dla wątków w wątkach pojedynczej wirtualnej maszyny Java (JVM). Ponieważ Preferences mogą być współużytkowane przez wiele maszyn JVM, istnieją specjalne metody radzenia sobie z synchronizacją zmian między maszynami wirtualnymi.

Jeśli masz aplikację, która ma działać tylko w jednej instancji , synchronizacja zewnętrzna nie jest wymagana.

Jeśli masz aplikację, która działa w wielu instancjach w jednym systemie i dlatego dostęp do Preferences musi być koordynowany między JVM w systemie, wówczas można użyć metody sync() dowolnego węzła Preferences aby zapewnić, że zmiany w węźle Preferences są widoczne dla innych JVM w systemie: 

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

Eksportowanie preferencji

Węzły Preferences można wyeksportować do dokumentu XML reprezentującego ten węzeł. Powstałe drzewo XML można ponownie zaimportować. Wynikowy dokument XML zapamięta, czy został wyeksportowany z Preferences użytkownika czy systemu.

Aby wyeksportować pojedynczy węzeł, ale nie jego węzły potomne :

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

Aby wyeksportować pojedynczy węzeł z jego węzłami potomnymi :

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

Importowanie preferencji

Węzły Preferences można importować z dokumentu XML. Importowanie powinno być stosowane w połączeniu z funkcją eksportowania Preferences , ponieważ tworzy prawidłowe odpowiednie dokumenty XML.

Dokumenty XML zapamiętują, czy zostały wyeksportowane z Preferences użytkownika czy systemu. Dlatego można je ponownie zaimportować do odpowiednich drzew Preferences , bez konieczności zastanawiania się i skąd pochodzą. Funkcja statyczna automatycznie wykryje, czy dokument XML został wyeksportowany od użytkownika lub Preferences systemowych i automatycznie zaimportuje go do drzewa, z którego zostały wyeksportowane.

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

Usuwanie detektorów zdarzeń

Detektory zdarzeń można ponownie usunąć z dowolnego węzła Properties , ale w tym celu należy zachować instancję detektora.

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

To samo dotyczy NodeChangeListener .

Uzyskiwanie wartości preferencji

Wartość węzła Preferences może być typu String , boolean , byte[] , double , float , int lub long . Wszystkie wywołania muszą zawierać wartość domyślną, w przypadku gdy określona wartość nie jest obecna w węźle 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);

Ustawianie wartości preferencji

Aby zapisać wartość w węźle Preferences , używana jest jedna z metod putXXX() . Wartość węzła Preferences może być typu String , boolean , byte[] , double , float , int lub 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);

Korzystanie z preferencji

Preferences mogą być używane do przechowywania ustawień użytkownika odzwierciedlających osobiste ustawienia aplikacji użytkownika, np. Czcionkę edytora, to, czy wolą, aby aplikacja była uruchamiana w trybie pełnoekranowym, czy zaznaczyły pole wyboru „nie pokazuj tego ponownie” i inne rzeczy tak. 

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
Licencjonowany na podstawie CC BY-SA 3.0
Nie związany z Stack Overflow