Formatting a string in Java using class attributes

I have a class with an attribute and getter method:

public Class MyClass
{
  private String myValue = "foo";

  public String getMyValue();
}

I would like to be able to use the value of foo in a formatted string as such:

String someString = "Your value is {myValue}."
String result = Formatter.format(someString, new MyClass())开发者_如何学编程;
// result is now "Your value is foo."

That is, I would like to have some function like .format above which takes a format string specifying properties on some object, and an instance with those properties, and formats the string accordingly.

Is it possible to do accomplish this feat in Java?

---

you could use JUEL for this. it's an implementation of the Java Expression Language. the code is rather compact and looks like this:

ExpressionFactory factory = new ExpressionFactoryImpl();

// create a context and add a Person object to the context, this variable will be used
// in the property replacement
// objects of type Person have two fields: firstName and lastName

SimpleContext context = new SimpleContext();
Person person = new Person("John", "Doe");
context.setVariable("person", factory.createValueExpression(person, Person.class));

// create the expression

String expr = "My name is ${person.firstName} ${person.lastName}";
ValueExpression e = factory.createValueExpression(context, expr, String.class);

// evaluate the expression
System.out.println(e.getValue(context));

which prints 'My name is John Doe'

note that it's also possible to use an expression like this: '${firstName}' instead of '${person.firstName}', but then you will have to write and provide a custom resolver (javax.el.ELResolver) for the variable and property resolution

---

(My other answer's probably only useful if you're already using struts.)

Similar to sdb's answer, there is apache JEXL.

The UnifiedJEXL class provides template-like functionality, so you can write (as shown in javadocs):

JexlEngine jexl = new JexlEngine();
UnifiedJEXL ujexl = new UnifiedJEXL(jexl);
UnifiedJEXL.Expression expr = ujexl.parse("Hello ${user}");
String hello = expr.evaluate(context, expr).toString();

(The expr not only looks strange being passed as a parameter to a method on itself, but is indeed not needed as a parameter)

The context setup is shown earlier in the same page:

// Create a context and add data
JexlContext jc = new MapContext();
jc.set("foo", new Foo() );

You'll also need either commons-logging, or you can configure JEXL to use your own logger.

---

So to get close to what you asked, you can create:

public class Formatter {
    public static String format(String format, Object ... inputs) {
        JexlContext context = new MapContext();
        for (int i=0;i<inputs.length;i++) {
            context.set("_" + (i+1), inputs[i] );
        }
        JexlEngine jexl = new JexlEngine();
        UnifiedJEXL ujexl = new UnifiedJEXL(jexl);
        UnifiedJEXL.Expression expr = ujexl.parse(format);
        return expr.evaluate(context).toString();
    }
}

and call it with

String someString = "Your value is ${_1.myValue}.";
String result = Formatter.format(someString, new MyClass());

At which point, result is "Your value is foo."

---

It's in theory possible with a stackbased parser to determine the valueholders in the string, in combination with reflection (or better, a Javabean inspection API, such as Commons BeanUtils) to get the bean property values.

Unfortunately no ready-made nor 3rd party API comes to mind, if you were looking for that. It's an interesting question however.

---

You could create one with struts2/xwork/OGNL, similar to the below (copied from an email from Vlad)

public static String translateOgnl(String message, Map<Object, Object> args) {
    OgnlValueStack stack = new OgnlValueStack();
    stack.push(args);
    return TextParseUtil.translateVariables(message, stack);
}

The javadocs for TextParseUtil.translateVariables() say

Converts all instances of ${...} in expression to the value returned by a call to ValueStack.findValue(java.lang.String). If an item cannot be found on the stack (null is returned), then the entire variable ${...} is not displayed, just as if the item was on the stack but returned an empty string.