Proprietà Java in XML

Le proprietà Java sono state un elemento fondamentale dello sviluppo Java per molti anni. Ancora oggi, le proprietà Java sono utilizzate in framework e strumenti popolari come Spring Framework e Ant. La maggior parte delle proprietà Java che ho visto utilizzate frequentemente seguono il paradigma nome = valore provato e vero. Tuttavia, a partire da J2SE 5, è stato facile caricare (e salvare) proprietà in formato XML.

Nella mia esperienza, il tipico file delle proprietà ha un aspetto simile a quello mostrato di seguito.

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 ha semplificato il caricamento delle proprietà da XML (e l'archiviazione delle proprietà in XML). La documentazione API basata su Javadoc per la classe Properties discute entrambi i formati. Questa documentazione mostra la DTD utilizzata per definire la grammatica XML delle proprietà:

Il DTD ci mostra che le proprietà archiviate in XML devono avere come elemento radice richiesto da XML ben formato e possono avere zero o uno elementi nidificati in questo tag radice. Impariamo anche da questa DTD che sono consentiti da zero a molti nomi di elementi e che un entryelemento può contenere un corpo dati e un singolo attributo denominato key. Sulla base di questo DTD, potremmo scrivere manualmente un file di proprietà basato su XML compatibile, ma un modo ancora più semplice per vederne uno è leggere in un file di proprietà tradizionale di coppie nome / valore e memorizzarlo nuovamente in formato XML. Questo è esattamente ciò che fa la prossima classe Java, 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"); } } 

La classe mostrata sopra legge nel file delle proprietà elencato in precedenza e quindi lo riscrive in formato XML. Le righe di codice effettive che eseguono la maggior parte del lavoro sono in numero ridotto, ma le numerose eccezioni controllate associate all'input / output del file rendono la base del codice molto più grande.

Quando viene eseguito questo codice, viene generato il seguente output:

esempi-xml.properties

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

Questo file XML generato contiene le stesse coppie nome / valore del file delle proprietà tradizionali mostrato in precedenza, può essere letto come la versione tradizionale utilizzando Properties.loadFromXML e include il commento passato al metodo Properties.storeToXML.

Conclusione

È abbastanza semplice caricare le proprietà da XML e memorizzarle come XML. Tuttavia, l'XML è essenzialmente limitato allo stesso paradigma di coppie nome / valore dei file delle proprietà tradizionali. Pertanto, non siamo in grado di sfruttare la natura gerarchica di XML per utilizzare relazioni più complesse di una chiave (nome) per un valore. Il motivo principale per cui si potrebbe utilizzare il supporto di Java per le proprietà basate su XML è se XML fosse utilizzato per altri strumenti o framework e le proprietà in XML fossero più accessibili all'altro strumento o framework.

Questa storia, "Java Properties in XML" è stata originariamente pubblicata da JavaWorld.