Placeholders in property files

Please could you tell me if a class exists that can take two property files and merge them together using Ant build script style placeholders? E.g.:

Dynamic property file:
item1.path={environment.start.path}\{location}\item1
item2.path={environment.start.path}\{location}\item2

Placeholder values property file:
environment.start.path=MyDevServer
location=uk

After the placeholders have been expanded, item1.path would be:
MyDevServer\uk\item1

item2.path would be:
MyDevServer\uk\item2

Thanks

Why yes, there is such a class. In fact, I've written it myself last month

It's not that hard to write it yourself, using java.util.regex.Pattern. I've used a Properties object in the background, and the getProperty method is the only thing that requires some work.

private Properties properties = new Properties();

private Pattern pattern = Pattern.compile("\\{.*?\\}"); // in short: {, followed by any character, followed by the first }

public String getProperty(String key)
{
    String raw = properties.getProperty(key);
    if (raw == null)
    {
        return raw;
    }
    Matcher matcher = pattern.matcher(raw);
    StringBuilder value = new StringBuilder(raw.length());
    int index = 0;
    while (matcher.find())
    {
        int start = matcher.start();
        int end = matcher.end();
        String template = raw.substring(start + 1, end - 1); // + 1 and - 1 to cut off the { and }
        String templateVal = getProperty(template); // recursive call
        if (templateVal == null)
        {
            // don't replace
            // index is the end of the last template, so add anything from there to the end of the current template
            value.append(raw.substring(index, end));
        }
        else
        {
            // index is the end of the last template, so add anything between that template and the current template
            value.append(raw.substring(index, start));
            // add the substituted value
            value.append(templateVal);
        }
        index = end;
    }
    // end the remained
    value.append(raw.substring(index));
    return value.toString();
}

public String getProperty(String key, String def)
{
    return (properties.containsKey(key) ? get(key) : def);
}

matcher.find() will find the next occurrance of a template (see the pattern comment), or return false if there are no more occurrances.

I don't know of any library that is all set up to do exactly this for you, but you could accomplish something like it relatively simply using the java.text.MessageFormat class.

[ Edit: Rob was too fast for me! ]

I just thought of something. Instead of creating a new class and keeping an internal Properties object, you can subclass Properties itself. My code more or less remains the same, except replace every call to "propertiesXXX" to "super.XXX".

Also beware that you don't get circular references. For instance, the following will throw a StackOverflowError:

After noticing that flaw in my own code, of course I fixed it:

public String getProperty(String key)
{
    return getProperty(key, new HashMap&lt;String,String&gt;());
}

private String getProperty(String key, Map&lt;String,String&gt; templates)
{
    if (templates.containsKey(key))
    {
        // already tried to replace it before, so there either is a circular
        // reference or the value has already been resolved
        return templates.get(key);
    }
    String raw = super.getProperty(key);
    if (raw == null)
    {
        return raw;
    }
    // put with null first, later replace
    templates.put(key, null);
    Pattern pattern = getPattern();
    int startLen = templateStart.length();
    int endLen = templateEnd.length();
    Matcher matcher = pattern.matcher(raw);
    StringBuilder value = new StringBuilder(raw.length());
    int index = 0;
    while (matcher.find())
    {
        int start = matcher.start();
        int end = matcher.end();
        String template = raw.substring(start + startLen, end - endLen);
        String templateVal = getProperty(template, templates);
        if (templateVal == null)
        {
            // don't replace
            value.append(raw.substring(index, end));
        }
        else
        {
            value.append(raw.substring(index, start));
            value.append(templateVal);
        }
        index = end;
    }
    value.append(raw.substring(index));
    String result = value.toString();
    templates.put(key, result);
    return result;
}

The output of that example code I wrote before is now this:

It can't replace {Template 1} again, so it gives up and just shows the template name. It will also be faster if a template would be evaluated more than once; now it only evaluates it once per call to getProperty(String), and uses that same value for each occurrance within the same call.

Thanks for your responses. I'll try this out.