Java design pattern to keep a method name in a property file

Question

I have property file(key/value) pair from where I currently read a value against a key and display that value as it is in the UI .

The complexity have increased,Now the value is more dynamic based on some formula. The formula includes a variable parameter whose value I will get at run time.

Is there any java design pattern to design this scenario .

I was thinking to put a method name in the property file against a key.

Now I will read the key and fetch the method name . This method will calculate the value for that particular key.

Please let me know your suggestion

Answer 1

Is there any java design pattern to design this scenario .

I don't know if there is a pattern.

---

If I understand your question right I can explain what I do usually.

• Insert localizable strings in my properties values
  I usually use #number#
• Replace it later when variables are resolved

Little example:

messages.properties

name.of.key = sum of #0# + #1# = #2#

Then I read the value from and replace the #num# with appropiated values (NOTE: here is in the same method for shortenes, but I use an external replace method):

public void printSum(int n1, int n2) {
    String myString = messageSource("name.of.key", Locale.getDefault(), null, null));
    myString.replace("#0#", String.valueOf(n1));
    myString.replace("#1#", String.valueOf(n2));
    myString.replace("#2#", String.valueOf(n1+n2));
    System.out.println(myString);
}

OUTPUT printSum(1,2);

sum of 1 + 2 = 3

Answer 2

Use Java built-in JavaScript engine to evaluate expressions. To match the spirit more closely, you can use JSON for properties.

If security is important, you need to provide the class filter. It can be very simple and restrictive as you only need to evaluate trivial expressions. The example on class filter can be found here.

Answer 3

Looks like the ANTLR would make here a great fit.

It is a parser generator. You give it grammar as an input and in return it provides you with a parser.

You can use the parser to transform the textual formula into a parsed tree representation. After that, you can run a visitor to evaluate each of the nodes. You just write some simple function to implement the behavior, such as:

public Double visitAdd(AntlrNode left, AntlrNode right) {
    Double left = visit(left);
    Double right = viist(right);

    return left + right;
}

The grammar is very close to the familiar BNF notation. You just describe how your formula strings are. For example:

formula : left '+' right;
left: Number;
right: Number;
Number: [0-9]+;

Answer 4

You can use the strategy pattern putting the method/algorithm name in the property file:

public interface IFormula{
    public int formula(int a, int b);
}
public class Sum implements IFormula{
    public int formula(int a, int b){
        return a+b;
    }
}

Then you can select the method getting the name from a property file:

public static Strategy getStrategy(Name name) {
    switch (name) {
        case SUM:
            return new Sum();
        ...
    }
}

Answer 5

Another solution is to refactor your map so that the value type is a functional interface whose method accepts an arbitrary parameter. For example:

@FunctionalInterface
interface ValueType<R> {
    R eval(Object param);
}

This solution (or a variant of it) would enable you to associate a lambda with your keys rather than a fixed value. The performance of a lambda ought to be much better than a run-time parser while still affording you the flexibility to make the associated value depend upon a run-time argument.

This solution should also be less vulnerable to injection attacks than a solution based on run-time parsing.

Answer 6

Since you seem to want a name for the pattern... the pattern is called: Domain Specific Language.

And again if you want to remain in the realms of abstract patterns and design you can peruse Martin Fowlers discussion on the topic at length.

Needless to say their are a metric ton of tools that solve the above pattern (including some of the answers here).

The other pattern which I highly recommend you NOT do is use a general purpose language that has an evaluator (ie Javascript, EL, Groovy, etc). This generally has security issues and performance issues (of course there are exceptions).