String pattern matching - method needs improving

The function getTokenValues is actually a pattern matching function. It just uses a different syntax than the pattern format of java.util.regex.

I suggest you to convert your pattern string (the one with $ signs) into a valid Pattern.

${1}/andThen/${2}/followedBy/${3}

becomes

(.+?)/andThen/(.+?)/followedBy/(.+?)

And then you can use Pattern.matcher to find the content of the groups. There is still one thing missing : the fact that the numbering of the original pattern is lost. For that, you can parse the original pattern string to extract those numbers, to create a mapping table.

When you convert your pattern string into a Pattern, be careful to escape the substrings between the $ using Pattern.quote().

I don't know if this solution would be an improvement of yours, but it's an alternative to consider.

Edit

The implementation of my solution :

Map<String, String> getTokenValues(String pattern, String str) {
    Map<String, String> res = new HashMap<String, String>();
    List<String> identifiers = new ArrayList<String>();

    Pattern dollarRgx = Pattern.compile("\\$\\{([0-9]+?)\\}");
    Matcher dollarMatcher = dollarRgx.matcher(pattern);
    StringBuilder convRgxBd = new StringBuilder();
    int lastEnd = 0;
    while(dollarMatcher.find()) {
        String before = pattern.substring(lastEnd, dollarMatcher.start());
        convRgxBd.append(Pattern.quote(before));
        convRgxBd.append("(.+?)");
        lastEnd = dollarMatcher.end();
        identifiers.add(dollarMatcher.group(1));
    }
    String after = pattern.substring(lastEnd, pattern.length());
    convRgxBd.append(Pattern.quote(after));

    Pattern convRgx = Pattern.compile(convRgxBd.toString());
    Matcher convMatcher = convRgx.matcher(str);
    if(convMatcher.matches()) {
        for(int i = 0; i < convMatcher.groupCount(); i++) {
            String id = identifiers.get(i);
            res.put(id, convMatcher.group(i+1));
        }
    }

    return res;
}

Just a side note: You could avoid the (String) casting if you used a Map (a HashMap, for example) instead of Properties. Properties has a design flaw: it should not extend Hashtable.

Effetcive Java, 2nd Edition mentions it in its Item 16: Favor composition over inheritance:

In the case of Properties, the designers intended that only strings be allowed as keys and values, but direct access to the underlying Hashtable allows this invariant to be violated. Once this invariant is violated, it is no longer possible to use other parts of the Properties API (load and store). By the time this problem was discovered, it was too late to correct it because clients depended on the use of nonstring keys and values.

Here is an alternate implementation based on @barjak's idea:

private static final String NON_GROUP_REGEX = ".*?";
private static final String GROUP_REGEX = "(.*?)";

public Map<String, String> getTokenValues2(final String template, final String input) {
    final Map<String, String> result = new LinkedHashMap<String, String>();

    final List<String> variableNames = getVariableNames(template);
    // TODO: check duplicated variables here

    for (final String variableName: variableNames) {
        final String value = getValueForVariable(template, input, variableName);
        result.put(variableName, value);
    }
    return result;
}

private List<String> getVariableNames(final String template) {
    final List<String> result = new ArrayList<String>();
    final Matcher matcher = NUMERIC_VARIABLES.matcher(template);
    while (matcher.find()) {
        final String variableName = matcher.group(1);
        result.add(variableName);
    }
    return result;
}

private String getValueForVariable(final String template, final String input, 
        final String variableName) {
    final String variableRegex = createVariableRegex(template, variableName);
    final Matcher variableMatcher = Pattern.compile(variableRegex).matcher(input);
    if (!variableMatcher.matches()) {
        throw new IllegalStateException("template: " + template + ", input: " 
                + input + ", variableName " + variableName);
    }
    final String value = variableMatcher.group(1);
    return value;
}

private String createVariableRegex(String template, 
        final String groupMatcherVariableName) {
    template = replaceNumericVariableToGroupMatcher(template, groupMatcherVariableName);
    template = replaceNumericVariablesToNonGroupMatchers(template);
    return template;
}

private String replaceNumericVariablesToNonGroupMatchers(final String template) {
    return NUMERIC_VARIABLES.matcher(template)
        .replaceAll(Matcher.quoteReplacement(NON_GROUP_REGEX));
}

private String replaceNumericVariableToGroupMatcher(final String template, 
        final String variableName) {
    final Pattern variableNamePattern = Pattern.compile(Pattern
        .quote("${" + variableName + "}"));
    final String quotedVariableNameReplacementRegexp = 
        Matcher.quoteReplacement(GROUP_REGEX);
    return variableNamePattern.matcher(template)
        .replaceFirst(quotedVariableNameReplacementRegexp);
}