Question

I am designing a simple library that deals with properties files.

I noticed that since JRE 1.5 the class Properties defines methods like:

public synchronized void loadFromXML(InputStream in)
public void storeToXML(OutputStream os, String comment)

I am questioning the fact that this is a real enhancement in the API of this class. Properties files have been, since JRE 1.5 text based files, and the newly introduced XML format is not adding anything to the functionalities, other than the possibility to use a different forma which is

1. more verbose
2. more complex (to understand, to change, to parse)
3. more inefficient (it uses dom internally to parse into an hastable: it consumes more memory, it requires helper classes in the implementation, and most likely is also slower)
4. more fragile (xml requires escaping of characters <>&”‘ while properties only need to escape backslashes, since it also supports Java backslash escaping)
5. it breaks backward compatibility of the programs using it, since users running JDK 1.4 won’t be able to read xml properties. (ok, who cares…)

So I fail to understand the reason behind why engineers in Sun added this feature.

The question is:

Does anybody finds some advantage of using an XML-based properties files over a traditional text based one?

I need to evaluate this problem, since I don’t want to add a useless feature to my simple library that I cited before.

Did you ever used an XML-based properties file over a Java Properties file? And why?

Note: same question can be made for Log4J xml file format, but at least Log4J xml format adds nesting ability and some sort of syntax which has some meaning, and I do understand that. But with this xml format for properties, I don’t.

Answer 1

If staying within the Java environment, using a Java properties file works great. Even if you expect other programming languages to interact with your library, you’ll probably be ok with a ‘regular’ properties file. However, for hierarchical data, XML is the standard. The reason you may want to support this change, and possibly the reason why Sun included it, is that other programming languages have extensive libraries for parsing XML files for hierarchical data.

The reason I’m answering is because I have actually used this feature before! But not for a great reason. In one program I’m working on now, I’ve found it easiest to keep a set of data in a properties object and I output the object to XML so that it can later be read by Python. At the moment, the data is further manipulated in a Python script and more children are added to the XML file. Without being able to output easily to XML, this would be a little more painful.
If I had the time, I wouldn’t bother outputting to XML though. The main reason I’m using the Python code that takes in the XML is because somebody else wrote it and I’m temporarily using it until I have the time to reevaluate that section of my program and re-code it.

So there’s a reason for using the XML! It isn’t a good one, but it’s a reason.
I imagine there are other cases like this where having the properties outputted as an XML aids in compatibility with other languages, since most languages have a robust XML parsing library and it makes it easier to manipulate hierarchical data. And in scientific programming, it seems you rarely get the luxury of sticking to one language.