Java-Preferences-API

Einführung in die Java-Preferences-API der java.util.prefs.Preferences Klasse

Stand: 09/02/2018 – Version 0.2
< zurück zur Java-Programmierung-Übersicht >

Dieser Artikel basiert in der ersten Version auf eigenen Gedanken und dieser Quelle[1]. Oft ist es notwendig bestimmte Angaben eines Programms dauerhaft zu speichern. Diese Angaben stellen die grundlegendsten Einstellungen dar wie z.B welche Datenbank soll beim Programmstart verwendet werden. Alle weiteren Einstellungen könnte man aus der Datenbank laden doch hier geht es um die absoluten Basisdaten.

Grundsätzlich ist es ja bei den ersten Gedanken überhaupt kein Problem solche Angaben zu speichern, da gibt es viele Möglichkeiten. Zum einen einfach in eine Testdatei schreiben oder die alte Properties aus java.util.Properties[2]. Problematisch wird das ganze erst wenn wir uns Plattform-übergreifend bewegen. Hier beschäftigen wir uns aber erst einmal rein mit der java.util.prefs.Preferences [3] Klasse.

Die Preferences Klasse geht bei dem ganzen noch einen Schritt weiter, wir müssen uns als Entwickler gar nicht mehr darum kümmern wo diese Daten gespeichert werden, das erledigt für uns das jeweilige Betriebssystem. Unter Linux liegt es im ~/.java/ Verzeichnis und unter Windows je nach Version im Dokumenten-Ordner, Appdata oder auch der Registry. Dazu später mehr.

Von der o.g Quelle hole ich mal den dort vorliegenden Quelltext, übersetze die Kommentare und arbeite das ganze etwas auf. Zum Schluss gibt es das ganze fertig zum Download und zum ausprobieren. Jetzt eber erst einmal den original Quelltext:

import java.util.prefs.Preferences;

public class PreferenceTest {
  
    private Preferences prefs;

    public void setPreference()
    { 
        prefs = Preferences.userRoot().node("/data");
        
        String ID1 = "Test1";
        String ID2 = "Test2";
        String ID3 = "Test3";

        System.out.println(prefs.getBoolean(ID1, true));
        System.out.println(prefs.get(ID2, "Hello World"));
        System.out.println(prefs.getInt(ID3, 50));

        prefs.putBoolean(ID1, false);
        prefs.put(ID2, "Hello Europa");
        prefs.putInt(ID3, 45);

        prefs.remove(ID1);
    }

    public static void main(String[] args)
    {
        PreferenceTest test = new PreferenceTest();
        test.setPreference();
    }
}

Was passiert hier nun also?
Ich habe bewusst die Kommentare aus dem Code herausgelassen und hole es hier nun nach. Also:

Zeile 10:

Definieren wir einen „node“, wo die Daten gespeichert werden können. Es gibt da mehrere Möglichkeiten. Hier einfach nur als String in Form eines Pfades. Schau Dir die Klasse im javadoc [3] genauer an, es gibt noch andere Möglichkeiten die nodes zu definieren.

Der überwiegende Teil bezieht sich auf die Nutzerrechte. Globale und lokale Konfiguration als Stichwort.

Zeile 15-17:

Wir laden Werte testweise aus einer eventuell vorhandenen Konfiguration mit der Methode .get diese läd die Daten in eine Variable. Hinter dem Kommata können default-Werte eingetragen werden falls es die Daten oder den ganzen node nicht gibt.

Zeile 19-21:

Hier speichern wir die aktuellen Werte aus den Variablen in unsere Konfiguration.

Zeile 23:

Hier löschen wir testweise einen Wert aus dem node.

Wo werden die Daten gespeichert?

Genau das ist nun der Trick an der ganzen Sache. Wir müssen uns eben nicht darum kümmern WO diese Daten gespeichert werden. Überlassen wir das dem Betriebssystem wo der Container ausgeführt wird. Wie dies allerdings unter Windows und Ubuntu aussieht zeige ich eben an zwei Screenshots.

Ja genau, ein und der gleiche Code aber unter Linux wird dies unter ~/home/.java/.userPrefs/data/prefs.xml gespeichert und unter Windows in der Registry im Zweig HKEY_CURRENT_USER -> Software -> JavaSoft -> Prefs -> data

Wo dies genau gespeichert wird legen in Zeile 9 fest. Es lässt sich auch definieren das dies im System Zweig der Registry oder /etc/.java unter Linux gespeichert wird. Dazu muss der Container allerdings als Administrator oder root gestartet werden. Ich nehme an es ist verständlich worum es geht.

Eine komplette Liste, wo auf welchem System die nodes gespeichert werden, liefere ich nach aber dies sollte für Dich als Entwickler allerdings zweitrangig sein.

— Fortsetzung folgt …

Achja, ein Tipp am rande. Viele Anfänger tendieren dazu darauf zu bestehen das ihre Daten relativ zum Container gespeichert werden. Am besten in einem Unterverzeichnis unterhalb des Containers. Geht bitte davon ab, das ist nicht wirklich sinnvoll. Stellt euch vor jemand möchte euer Programm an einer globalen Stelle für alle Benutzer installieren. An dieser Stelle hätte der Benutzer der das Programm ausführt gar keine Schreibrechte. Für diesen Einsatz wäre also euer Programm unbrauchbar. Falls es wirklich unbedingt nötig sein sollte, musst Du Dir die Klasse java.util.Properties [2] anschauen die allerdings schon ein paar Jahre auf dem Buckel hat. Dazu gibt es bald noch einen eigenen Beitrag.

Du hast Fragen zur java.util.prefs.Preferences Klasse, Anmerkungen oder bist völlig anderer Meinung? Teile es bitte hier im Forum  mit.


Quellen:

  1.  http://www.vogella.com/tutorials/JavaPreferences/article.html
  2. https://docs.oracle.com/javase/7/docs/api/java/util/Properties.html
    https://docs.oracle.com/javase/8/docs/api/java/util/Properties.html
  3. https://docs.oracle.com/javase/8/docs/api/java/util/prefs/Preferences.html

 

 

 

JAVA: getText String in int umwandeln

Java-Typumwandlung

Type-Casting mit primitiven Datentypen

Folgendes kleine Problem: Wenn man mit text = textfeld.getText() den Inhalt eines Textfeldes abfragt, wird das Ergebnis in text als String zurückgegeben. Möchte man damit Berechnungen vornehmen funktioniert dies natürlich nicht.

Die Klasse Integer aus java.lang.Integer kann sehr schön einen String in int umwandeln mit zahl = Integer.parseInt(text);

Vor einem textfeld.setText( ergebniss ) muss man die Zahl natürlich wieder in einen String umwandeln. Dies kann sehr gut mit ergebniss = String.valueOf( zahl ); bewerkstelligt werden.

Codebeispiel:

String txt1 = textField1.getText();
String txt2 = textField2.getText();

int zahl1 = 0;
int zahl2 = 0;
int zahl3 = 0;
String ergebniss = "";

try{
    zahl1 = Integer.parseInt(txt1);
    zahl2 = Integer.parseInt(txt2);
    
    zahl3 = zahl1 + zahl2;
    
    ergebniss = String.valueOf( zahl3 );
    
}catch(NumberFormatException ex){
    //Fehlerbehandlung wenn es sich nicht um Zahlen handelt.

}
    
textField3.setText( ergebniss );

Noch fragen oder Anregunden?
Diskussion hier 

JAVA: .jar direkt ausführbar machen

Thema: Linux – Java – Windows – .jar

Normalerweise wird ein Java-Programm das zu einem .jar Archiv geschnürt ist folgender maßen ausgeführt: java -jar dateiname.jar Manchmal möchte man ein .jar Paket direkt ausführbar machen. Damit spart man sich ein shell Startskript das zB so aussehen könnte:

#!/bin/bash
"$JAVA_HOME"/bin/java -jar /pfad/zum/paket/programm.jar

Befindet sich das Startskript im gleichen Verzeichnis wie das programm.jar spart man sich den Pfad und ersetzt diesen gegen ./

Oft sieht man  java-Programme die man als solche gar nicht mehr erkennt oder mit der Endung .run

Solche Konstrukte stellt man wie folgt her:
Man nehme folgende Shellscript und speichert es als stub.sh

#!/bin/sh
MYSELF=`which "$0" 2>/dev/null`
[ $? -gt 0 -a -f "$0" ] && MYSELF="./$0"
java=java
if test -n "$JAVA_HOME"; then
    java="$JAVA_HOME/bin/java"
fi
exec "$java" $java_args -jar $MYSELF "$@"
exit 1

Anschließend kopiert man es in das gleiche Verzeichnis wie die .jar Datei, mache sie mit chmod +x deine.jar ausführbar und führe folgendes aus:

cat stub.sh deine.jar > dein_programm.run

Nun hast Du eine Datei namens dein_programm.run, dieses kannst Du wiederum mit chmod -x dein_programm.run ausführbar machen.

Jetzt wurde das Shellskript sowie die Java .jar zu einer Datei zusammengefügt und lässt sich problemlos starten. Es wird als Shellskript erkannt und lässt sich auch mit Doppelklick starten.

Für Windows gibt es dafür auch einen angeblich gut funktionierenden Wrapper Launch4j den ich allerdings nie selbst ausprobiert habe.

Viel Erfolg!