Java-Eigenschaften in XML

Java-Eigenschaften sind seit vielen Jahren ein fester Bestandteil der Java-Entwicklung. Noch heute werden Java-Eigenschaften in gängigen Frameworks und Tools wie Spring Framework und Ant verwendet. Die meisten Java-Eigenschaften, die ich häufig verwendet habe, folgen dem bewährten Paradigma name = value. Seit J2SE 5 ist es jedoch einfach, Eigenschaften im XML-Format zu laden (und zu speichern).

Nach meiner Erfahrung sieht die typische Eigenschaftendatei ungefähr so ​​aus, wie sie als nächstes gezeigt wird.

Beispiele.Eigenschaften

url.blog.dustin=//marxsoftware.blogspot.com/ url.javaworld=//www.javaworld.com/ url.coloradosoftwaresummit=//www.softwaresummit.com/ url.otn=//www.oracle.com/technology/index.html url.rmoug=//www.rmoug.org/ 

Mit J2SE 5 war es einfach, Eigenschaften aus XML zu laden (und Eigenschaften in XML zu speichern). In der Javadoc-basierten API-Dokumentation für die Properties-Klasse werden beide Formate erläutert. Diese Dokumentation zeigt die DTD, die zum Definieren der XML-Grammatik für Eigenschaften verwendet wird:

Die DTD zeigt uns, dass in XML gespeicherte Eigenschaften das für wohlgeformtes XML erforderliche Stammelement haben müssen und dass in diesem Stamm-Tag null oder ein Element verschachtelt sein kann. Aus dieser DTD lernen wir auch, dass null bis viele Elementnamen zulässig sind und dass ein entryElement einen Datenkörper und ein einzelnes Attribut mit dem Namen enthalten kann key. Basierend auf dieser DTD könnten wir eine kompatible XML-basierte Eigenschaftendatei von Hand schreiben. Eine noch einfachere Möglichkeit, eine zu sehen, besteht darin, eine herkömmliche Eigenschaftendatei mit Name / Wert-Paaren einzulesen und sie wieder im XML-Format zu speichern. Genau das macht die nächste Java-Klasse, PropertiesExamples .

PropertiesExamples.java

package dustin.properties; import java.io.FileInputStream; import java.io.FileNotFoundException; import java.io.FileOutputStream; import java.io.IOException; import java.io.OutputStream; import java.util.Properties; public class PropertiesExamples { /** No-arguments constructor. */ public PropertiesExamples() {} /** * Get traditional properties in name=value format. * * @param filePathAndName Path and name of properties file (without the * .properties extension). * @return Properties read in from provided file. */ public Properties loadTraditionalProperties( final String filePathAndName) { final Properties properties = new Properties(); try { final FileInputStream in = new FileInputStream(filePathAndName); properties.load(in); in.close(); } catch (FileNotFoundException fnfEx) { System.err.println("Could not read properties from file " + filePathAndName); } catch (IOException ioEx) { System.err.println( "IOException encountered while reading from " + filePathAndName); } return properties; } /** * Store provided properties in XML format. * * @param sourceProperties Properties to be stored in XML format. * @param out OutputStream to which to write XML formatted properties. */ public void storeXmlProperties( final Properties sourceProperties, final OutputStream out) { try { sourceProperties.storeToXML(out, "This is easy!"); } catch (IOException ioEx) { System.err.println("ERROR trying to store properties in XML!"); } } /** * Store provided properties in XML format to provided file. * * @param sourceProperties Properties to be stored in XML format. * @param pathAndFileName Path and name of file to which XML-formatted * properties will be written. */ public void storeXmlPropertiesToFile( final Properties sourceProperties, final String pathAndFileName) { try { FileOutputStream fos = new FileOutputStream(pathAndFileName); storeXmlProperties(sourceProperties, fos); fos.close(); } catch (FileNotFoundException fnfEx) { System.err.println("ERROR writing to " + pathAndFileName); } catch (IOException ioEx) { System.err.println( "ERROR trying to write XML properties to file " + pathAndFileName); } } /** * Runs main examples. * * @param arguments Command-line arguments; none anticipated. */ public static void main(final String[] arguments) { final PropertiesExamples me = new PropertiesExamples(); final Properties inputProperties = me.loadTraditionalProperties("examples.properties"); me.storeXmlPropertiesToFile(inputProperties, "examples-xml.properties"); } } 

Die oben gezeigte Klasse liest die zuvor aufgeführte Eigenschaftendatei ein und schreibt sie dann wieder im XML-Format aus. Die tatsächlichen Codezeilen, die den größten Teil der Arbeit erledigen, sind klein, aber die vielen geprüften Ausnahmen, die mit der Eingabe / Ausgabe von Dateien verbunden sind, machen die Codebasis viel größer.

Wenn dieser Code ausgeführt wird, wird die folgende Ausgabe generiert:

examples-xml.properties

  This is easy! //www.softwaresummit.com/ //www.rmoug.org/ //marxsoftware.blogspot.com/ //www.javaworld.com/ //www.oracle.com/technology/index.html  

Diese generierte XML-Datei enthält dieselben Name / Wert-Paare wie die zuvor gezeigte herkömmliche Eigenschaftendatei, kann wie die herkömmliche Version mit Properties.loadFromXML eingelesen werden und enthält den Kommentar, der an die Properties.storeToXML-Methode übergeben wurde.

Fazit

Es ist ziemlich einfach, Eigenschaften aus XML zu laden und als XML zu speichern. Das XML ist jedoch im Wesentlichen auf dasselbe Paradigma von Name / Wert-Paaren wie herkömmliche Eigenschaftendateien beschränkt. Daher können wir die hierarchische Natur von XML nicht nutzen, um Beziehungen zu verwenden, die komplexer sind als ein Schlüssel (Name) zu einem Wert. Der Hauptgrund, warum Java die Unterstützung für XML-basierte Eigenschaften nutzen könnte, besteht darin, dass XML für andere Tools oder Frameworks verwendet wurde und die Eigenschaften in XML für das andere Tool oder Framework besser zugänglich waren.

Diese Geschichte "Java-Eigenschaften in XML" wurde ursprünglich von JavaWorld veröffentlicht.