Suche…


Einführung

Das Eigenschaftenobjekt enthält ein Schlüssel- und ein Wertepaar als Zeichenfolge. Die Klasse java.util.Properties ist die Unterklasse von Hashtable.

Es kann verwendet werden, um den Eigenschaftswert basierend auf dem Eigenschaftsschlüssel abzurufen. Die Properties-Klasse stellt Methoden zum Abrufen von Daten aus der Eigenschaftendatei und zum Speichern von Daten in der Eigenschaftendatei bereit. Darüber hinaus kann es verwendet werden, um Eigenschaften des Systems zu erhalten.

Vorteil der Eigenschaftendatei

Eine Neukompilierung ist nicht erforderlich, wenn Informationen aus der Eigenschaftendatei geändert werden: Wenn Informationen geändert werden

Syntax

  • In einer Eigenschaftsdatei:
  • Schlüssel = Wert
  • #Kommentar

Bemerkungen

Ein Eigenschaftenobjekt ist eine Map, deren Schlüssel und Werte nach Konvention Strings sind. Obwohl die Methoden von Map für den Zugriff auf die Daten verwendet werden können, werden in der Regel stattdessen die typsicheren Methoden getProperty , setProperty und stringPropertyNames verwendet.

Eigenschaften werden häufig in Java-Eigenschaftendateien gespeichert, bei denen es sich um einfache Textdateien handelt. Ihr Format ist in der Properties.load-Methode ausführlich dokumentiert. In Summe:

  • Jeder Schlüssel / Wert - Paar eine Textzeile mit Leerzeichen ist, gleich ( = ) oder Doppelpunkt ( : ) zwischen dem Schlüssel und dem Wert. Das Gleiche oder der Doppelpunkt kann vor und nach dem Whitespace beliebig sein, was ignoriert wird.
  • Führende Leerzeichen werden immer ignoriert, abschließende Leerzeichen sind immer enthalten.
  • Ein Backslash kann verwendet werden, um beliebige Zeichen zu umgehen (außer Kleinbuchstaben u ).
  • Ein umgekehrter Schrägstrich am Ende der Zeile zeigt an, dass die nächste Zeile eine Fortsetzung der aktuellen Zeile ist. Wie bei allen Zeilen werden jedoch führende Leerzeichen in der Fortsetzungszeile ignoriert.
  • Genau wie im Java-Quellcode steht \u gefolgt von vier hexadezimalen Ziffern, für ein UTF-16-Zeichen.

Die meisten Frameworks, einschließlich der Java SE-eigenen Einrichtungen wie java.util.ResourceBundle, laden Eigenschaftsdateien als InputStreams. Beim Laden einer Eigenschaftsdatei aus einem InputStream darf diese Datei nur ISO 8859-1-Zeichen enthalten (d. H. Zeichen im Bereich 0–255). Alle anderen Zeichen müssen als \u escape dargestellt werden. Sie können jedoch eine Textdatei in beliebiger Kodierung schreiben und das native2ascii- Tool (das mit jedem JDK mitgeliefert wird) verwenden, um dieses Escape für Sie auszuführen .

Wenn Sie eine Eigenschaftendatei mit Ihrem eigenen Code laden, kann diese in beliebiger Kodierung vorliegen, sofern Sie einen Reader (z. B. einen InputStreamReader ) erstellen, der auf dem entsprechenden Zeichensatz basiert. Sie können die Datei dann mit load (Reader) anstelle der alten load (InputStream) -Methode laden.

Sie können Eigenschaften auch in einer einfachen XML-Datei speichern, sodass die Datei selbst die Kodierung definieren kann. Eine solche Datei kann mit der loadFromXML- Methode geladen werden. Die DTD, die die Struktur solcher XML-Dateien beschreibt, befindet sich unter http://java.sun.com/dtd/properties.dtd .

Eigenschaften laden

So laden Sie eine mit Ihrer Anwendung gebündelte Eigenschaftendatei:

public class Defaults {

    public static Properties loadDefaults() {
        try (InputStream bundledResource =
            Defaults.class.getResourceAsStream("defaults.properties")) {

            Properties defaults = new Properties();
            defaults.load(bundledResource);
            return defaults;
        } catch (IOException e) {
            // Since the resource is bundled with the application,
            // we should never get here.
            throw new UncheckedIOException(
                "defaults.properties not properly packaged"
                + " with application", e);
        }
    }

}

Eigenschaftsvorbehalt: Nachlaufende Leerzeichen

Sehen Sie sich diese beiden Property-Dateien an, die scheinbar völlig identisch sind:

Geben Sie hier die Bildbeschreibung ein

außer sie sind wirklich nicht identisch:

Geben Sie hier die Bildbeschreibung ein

(Screenshots stammen aus Notepad ++)

Da nachfolgenden Leerzeichen, um den Wert des erhaltenen lastName wäre "Smith" im ersten Fall und "Smith " im zweiten Fall.

Sehr selten erwarten Benutzer dies und können nur spekulieren, warum dies das Standardverhalten der Properties Klasse ist. Es ist jedoch einfach, eine erweiterte Version von Properties zu erstellen, die dieses Problem behebt. Die folgende Klasse, TrimmedProperties , macht genau das. Es ist ein Drop-In-Ersatz für die Standardeigenschaftenklasse.

import java.io.FileInputStream;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.Reader;
import java.util.Map.Entry;
import java.util.Properties;

/**
 * Properties class where values are trimmed for trailing whitespace if the
 * properties are loaded from a file.
 *
 * <p>
 * In the standard {@link java.util.Properties Properties} class trailing
 * whitespace is always preserved. When loading properties from a file such
 * trailing whitespace is almost always <i>unintentional</i>. This class fixes
 * this problem. The trimming of trailing whitespace only takes place if the
 * source of input is a file and only where the input is line oriented (meaning
 * that for example loading from XML file is <i>not</i> changed by this class).
 * For this reason this class is almost in all cases a safe drop-in replacement
 * for the standard <tt>Properties</tt>
 * class.
 *
 * <p>
 * Whitespace is defined here as any of space (U+0020) or tab (U+0009).
 * * 
 */
public class TrimmedProperties extends Properties {

    /**
     * Reads a property list (key and element pairs) from the input byte stream.
     * 
     * <p>Behaves exactly as {@link java.util.Properties#load(java.io.InputStream) }
     * with the exception that trailing whitespace is trimmed from property values
     * if <tt>inStream</tt> is an instance of <tt>FileInputStream</tt>.
     * 
     * @see java.util.Properties#load(java.io.InputStream) 
     * @param inStream the input stream.
     * @throws IOException if an error occurred when reading from the input stream.
     */
    @Override
    public void load(InputStream inStream) throws IOException {
        if (inStream instanceof FileInputStream) {
            // First read into temporary props using the standard way
            Properties tempProps = new Properties();
            tempProps.load(inStream);
            // Now trim and put into target
            trimAndLoad(tempProps);
        } else {
            super.load(inStream);
        }
    }

    /**
     * Reads a property list (key and element pairs) from the input character stream in a simple line-oriented format. 
     * 
     * <p>Behaves exactly as {@link java.util.Properties#load(java.io.Reader)}
     * with the exception that trailing whitespace is trimmed on property values
     * if <tt>reader</tt> is an instance of <tt>FileReader</tt>.
     * 
     * @see java.util.Properties#load(java.io.Reader) }
     * @param reader the input character stream.
     * @throws IOException if an error occurred when reading from the input stream.
     */
    @Override
    public void load(Reader reader) throws IOException {
        if (reader instanceof FileReader) {
            // First read into temporary props using the standard way
            Properties tempProps = new Properties();
            tempProps.load(reader);
            // Now trim and put into target
            trimAndLoad(tempProps);
        } else {
            super.load(reader);
        }
    }

    private void trimAndLoad(Properties p) {
        for (Entry<Object, Object> entry : p.entrySet()) {
            if (entry.getValue() instanceof String) {
                put(entry.getKey(), trimTrailing((String) entry.getValue()));
            } else {
                put(entry.getKey(), entry.getValue());
            }
        }
    }

    /**
     * Trims trailing space or tabs from a string.
     *
     * @param str
     * @return
     */
    public static String trimTrailing(String str) {
        if (str != null) {
            // read str from tail until char is no longer whitespace
            for (int i = str.length() - 1; i >= 0; i--) {
                if ((str.charAt(i) != ' ') && (str.charAt(i) != '\t')) {
                    return str.substring(0, i + 1);
                }
            }
        }
        return str;
    }
}

Eigenschaften als XML speichern

Eigenschaften in einer XML-Datei speichern

Die Art und Weise, in der Sie Eigenschaftsdateien als XML-Dateien speichern, ist der Art und Weise, wie Sie sie als .properties Dateien speichern würden, sehr ähnlich. Anstelle von store() Sie storeToXML() .

public void saveProperties(String location) throws IOException{
    // make new instance of properties
    Properties prop = new Properties();
    
    // set the property values
    prop.setProperty("name", "Steve");
    prop.setProperty("color", "green");
    prop.setProperty("age", "23");
    
    // check to see if the file already exists
    File file = new File(location);
    if (!file.exists()){
        file.createNewFile();
    }
    
    // save the properties
    prop.storeToXML(new FileOutputStream(file), "testing properties with xml");
}

Wenn Sie die Datei öffnen, sieht es so aus.

Screenshot der erstellten Datei

Eigenschaften aus einer XML-Datei laden

loadFromXML() diese Datei als properties zu laden, müssen Sie loadFromXML() anstelle von load() .propeties , die Sie mit regulären .propeties Dateien verwenden würden.

public static void loadProperties(String location) throws FileNotFoundException, IOException{
    // make new properties instance to load the file into
    Properties prop = new Properties();
    
    // check to make sure the file exists
    File file = new File(location);
    if (file.exists()){
        // load the file
        prop.loadFromXML(new FileInputStream(file));
        
        // print out all the properties
        for (String name : prop.stringPropertyNames()){
            System.out.println(name + "=" + prop.getProperty(name));
        }
    } else {
        System.err.println("Error: No file found at: " + location);
    }
}

Wenn Sie diesen Code ausführen, erhalten Sie Folgendes in der Konsole:

age=23
color=green
name=Steve


Modified text is an extract of the original Stack Overflow Documentation
Lizenziert unter CC BY-SA 3.0
Nicht angeschlossen an Stack Overflow