Propriétés Java en XML

Les propriétés Java sont un élément essentiel du développement Java depuis de nombreuses années. Même aujourd'hui, les propriétés Java sont utilisées dans des frameworks et des outils populaires tels que Spring Framework et Ant. La plupart des propriétés Java que j'ai vues utilisées suivent fréquemment le paradigme éprouvé nom = valeur. Cependant, depuis J2SE 5, il est facile de charger (et d'enregistrer) les propriétés au format XML.

D'après mon expérience, le fichier de propriétés typique ressemble à celui montré ci-dessous.

examples.properties

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/ 

J2SE 5 a facilité le chargement des propriétés à partir de XML (et le stockage des propriétés dans XML). La documentation de l'API basée sur Javadoc pour la classe Properties traite des deux formats. Cette documentation montre la DTD utilisée pour définir la grammaire XML Properties:

La DTD nous montre que les propriétés stockées dans XML doivent avoir comme élément racine requis d'un XML bien formé et peuvent avoir zéro ou un élément imbriqué dans cette balise racine. Nous apprenons également de cette DTD que zéro à plusieurs noms d'éléments sont autorisés et qu'un entryélément peut contenir un corps de données et un seul attribut nommé key. Sur la base de cette DTD, nous pourrions écrire à la main un fichier de propriétés XML compatible, mais un moyen encore plus simple d'en voir un est de lire dans un fichier de propriétés traditionnel de paires nom / valeur et de le stocker au format XML. C'est exactement ce que fait la prochaine classe Java, PropertiesExamples .

PropriétésExamples.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"); } } 

La classe indiquée ci-dessus lit le fichier de propriétés répertorié précédemment, puis le réécrit au format XML. Les lignes de code réelles qui effectuent la plupart du travail sont peu nombreuses, mais les nombreuses exceptions vérifiées associées à l'entrée / sortie du fichier rendent la base de code beaucoup plus grande.

Lorsque ce code est exécuté, la sortie suivante est générée:

examples-xml.properties

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

Ce fichier XML généré contient les mêmes paires nom / valeur que le fichier de propriétés traditionnel présenté précédemment, peut être lu comme la version traditionnelle à l'aide de Properties.loadFromXML et inclut le commentaire qui a été transmis à la méthode Properties.storeToXML.

Conclusion

Il est assez simple de charger des propriétés à partir de XML et de les stocker au format XML. Cependant, le XML est essentiellement limité au même paradigme de paires nom / valeur que les fichiers de propriétés traditionnels. Par conséquent, nous ne pouvons pas tirer parti de la nature hiérarchique de XML pour utiliser des relations plus complexes qu'une clé (nom) à une valeur. La principale raison pour laquelle on peut utiliser la prise en charge de Java pour les propriétés XML est si XML était utilisé pour d'autres outils ou frameworks et si les propriétés XML étaient plus accessibles à l'autre outil ou framework.

Cette histoire, "Propriétés Java en XML" a été initialement publiée par JavaWorld.