Alternatives to java.util.Properties?

[Philip Shanks]

I wrote a MVC application that creates web reports from a database. I designed it in a way that allows me to add new reports simply by adding lines to a pair of properties files; one file has the title for each report, and one has the SQL statement for each report (matching keys). I find that this works well, except for one thing.
Because the Properties class is implemented as a hash, I have no control over the order when extracting the keys. I don't simply want to sort them, but would rather access them by order of appearance in the files.
Any good implementation suggestions for this? I suspect that an XML implementation would be a good approach, except that it seems like a lot of work (not to mention overkill) just to load a few configuration lines. There are currently no more than seven or eight key/value pairs per file, and this might grow to a dozen or so. There is also a properties file for my database connection parameters, but this works fine with the standard Properties implementation.
Thanks!
PCS

[Jim Yingst]

There are probably a number of other implementations of this sort of thing floating around, but here's one I made which uses JDK 1.4's LinkedHashMap and XML parsing:

import java.io.FileWriter;
import java.io.IOException;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.Map;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import org.w3c.dom.Document;
import org.w3c.dom.NamedNodeMap;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.xml.sax.SAXException;

public class OrderedProperties
{
  private Map map = new LinkedHashMap();
  
  public OrderedProperties() {}
  
  public String get(String key)
  {
    return (String) map.get(key);
  }
  
  public String get(String key, String defaultValue)
  {
    String value = (String) map.get(key);
    return value == null ? defaultValue : value;
  }
  
  public String set(String key, String value)
  {
    String prev = (String) map.put(key, value);
    return prev;
  }
  
  public Map getMap()
  {
    return map;
  }
  
  public void load(String fileName) throws IOException, ParserConfigurationException, SAXException
  {
    DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
    DocumentBuilder builder = factory.newDocumentBuilder();
    Document doc = builder.parse(fileName);
    NodeList elements = doc.getElementsByTagName("properties");
    for (int i = 0; i < elements.getLength(); i++)
    {
      Node element = elements.item(i);
      System.out.println("element[" + i + "] : " + element.getNodeName()); 
      NamedNodeMap attributes = element.getAttributes();
      for (int j = 0; j < attributes.getLength(); j++)
      {
        Node attr = attributes.item(j);
        map.put(attr.getNodeName(), attr.getNodeValue());
      }
    }
  }
  
  public void store(String fileName) throws IOException
  {
    FileWriter writer = new FileWriter(fileName);
    writer.write("<properties\n");
    for (Iterator it = map.entrySet().iterator(); it.hasNext(); )
    {
      Map.Entry entry = (Map.Entry) it.next();
      writer.write("\t" + entry.getKey() + "=\"" 
          + xmlEscape(entry.getValue().toString()) + "\"\n");
    }
    writer.write("/>\n");
    writer.close();
  }
  
  private static String xmlEscape(String input)
  {
    StringBuffer buffer = new StringBuffer();
    for (int i = 0, len = input.length(); i < len; i++)
    {
      char ch = input.charAt(i);
      switch (ch)
      {
        case '<':
          buffer.append("<");
          break;
        case '"':
          buffer.append(""");
          break;
        case '&':
          buffer.append("&");
          break;
        default:
          buffer.append(ch);
      }
    }
    return buffer.toString();
  }
  
  public String toString()
  {
    return "OrderedProperties: " + map;
  }
  
  public static void main(String[] s) throws Exception
  {
    OrderedProperties props = new OrderedProperties();
    props.load("properties.xml");
    System.out.println(props.get("key1"));
    props.set("new_key", "val");
    System.out.println(props.get("new_key"));
    System.out.println(props);
    props.store("properties2.xml");
  }
}

The main() method shows an example of use. A sample properties file looks like this:

<properties
  key1="val1"
  key2="val2"
  key3="val3"
  key4="weird chars like <>'"&"
/>

Modify as you wish...

[Philip Shanks]

Thanks for the hint to use a LinkedHashMap. I've decided to created my own OrderedProperties class based upon this data structure, but that will use the properties files I already have (plain text, "key=value" format) for backwards compatibility.
I am also going to incorporate Joshua Bloch's advice to "Favor composition over inheritance," which is Item 14 in "Effective Java."
I will be able to swap it right into my current project with minimal disruption.
PCS
[ November 07, 2002: Message edited by: Philip Shanks ]

[Thomas Paul]

Properties? How 20th century!
http://www.javaranch.com/newsletter/Oct2002/newsletteroct2002.jsp#preferences

[Philip Shanks]

The Preferences approach looks interesting, but seems to be geared ever so slightly more toward client-side applications.
My interest in this thread was to overcome the Hashtable behavior of the Properties class with minimal re-work to my existing applications that use the current Properties class.
Primarily, I did not like the way that the ordering of the Enumeration from propertyNames() method is dictated by the hashing function.
While it would be an easy thing to sort the keys alphabetically, I wanted to get the keys in their order of appearance in the properties file.
To this end, I have re-implemented the Properties class, based on the java.util.LinkedHashMap data structure. It is a work in progress, though, so I haven't yet implemented all of the methods, rules and behavior found in the original java.util.Properties class. For instance, I haven't yet implemented any capability for reading values that span multiple lines using continuation characters.
Among the liberties I am taking:

OrderedProperties contains a data structure, instead of extending one.

Property values must be Strings. This is enforced throughout.

I used the java.util.regex classes to parse the key/value lines.

I might implement an Iterator, which is preferred over Enumerations.

Given the greater flexibility that XML-based configuration files can afford, I will probably cut development of this class short. It is more of a coding exersize for me anyway, but it does meet a current need as well.
For the curious, here is the code. Of course, this is limited to Java 1.4 platforms, but that is not a problem for me. I have tested this code, and so far it works just as expected.

import java.io.*;
import java.util.*;
import java.util.regex.*;
public class OrderedProperties {
    
    private LinkedHashMap map;
    
    public OrderedProperties() {
        map = new LinkedHashMap();
    }
    
    public OrderedProperties(OrderedProperties defaults) {
        this();
        map.putAll(defaults.getMap());
    }
    
    private LinkedHashMap getMap() {
        return map;
    }
    
    public String getProperty(String key) {
        return (String) map.get(key);
    }
    
    public String getProperty(String key, String defaultValue) {
        if (map.containsKey(key)) {
            return this.getProperty(key);
        }
        return defaultValue;
    }
    
    public String setProperty(String key, String value) {
        return (String) map.put(key, value);
    }
    
    public void load(InputStream inStream) throws IOException {
        BufferedReader in = new BufferedReader(new InputStreamReader(inStream));
        Pattern comment = Pattern.compile("#.*");
        Pattern empty = Pattern.compile("^$");
        Pattern prop = Pattern.compile("[^=:]+[=:].*");
        Pattern delimiter = Pattern.compile("[=:]");
        StringBuffer buf;
        for (String line = in.readLine(); line != null; line = in.readLine()) {
            String key, value;
            buf = new StringBuffer(line);
            if (comment.matcher(buf).matches()) {
                continue;
            } else if (empty.matcher(buf).matches()) {
                continue;
            } else if (prop.matcher(buf).matches()) {
                String[] tokens = delimiter.split(buf);
                if (tokens.length > 0) {
                   key = tokens[0];
                   value = tokens[1];
                   map.put(key,value);
                }
            }
        }
    }
    
    public Enumeration propertyNames() {
        if (map.isEmpty())
            return null;
        return new OrderedProperties.KeyEnumerator(getMap());
    }
    
    private class KeyEnumerator implements Enumeration {
        Iterator it;
        private KeyEnumerator(LinkedHashMap map) {
            it = map.keySet().iterator();
        }
        
        public boolean hasMoreElements() {
            return it.hasNext();
        }
        
        public Object nextElement() {
            return it.next();
        }   
    }
}

PCS
[ November 07, 2002: Message edited by: Philip Shanks ]

[Aaron Nielsen]

Here is a very simple solution to getting you properties in the order they appear in the properties file, by giving them an order, instead of just implying there is order.
You could easily do the following in your properties file
key1=value a
key2=value b
key3=value c
Then you could just iterate through the key names in order using a counter.
int x=1;
while(myProperties.containsKey("key" + x)
{
something = myProperties.getProperty("key" + x);

x++;
}

[Jim Yingst]

Properties? How 20th century!
Thanks, Thomas. I knew I'd seen something about a more modern XML-based approach, but forgot where it was. Lots of cool new toys were in 1.4 - I didn't get around to playing with them all. My code was something I'd cooked up previously, and later modifed to use LinkedHashMap rather than HashMap.
Aaron - I suppose that would work, if you give up the ability to give the keys meaningful names that tell users what a given property actually does .

[Ashik Uzzaman]

Philip and Jim,
That's a pretty good thought. However, does this OrderProperties stuff overcome the limitation of multiple values for a single property in multiple lines constraint? For example, I have a file named "config.ini" that has some values like this ---
[xml_handlers]
handler = handleByTagName
handler = handleByAttribute
handler = handleByElelement
handler = handleByNode
I find java properties are not the way to deal this scenario and so going for a custimized collection consisting of a Map and a List to store all keys in Map and values in List. But if this could be dealt in your way then I would be very glad.
What do you think?

[John Lee]

hi:
please refer to:
Class Properties;
Class ContextProperties.