Reemplazo de cadenas en java, similar a una plantilla de velocidad

¿Existe algún Stringmecanismo de reemplazo en Java, donde pueda pasar objetos con un texto, y reemplaza la cadena a medida que ocurre?
Por ejemplo, el texto es:

Hello ${user.name},
    Welcome to ${site.name}. 

Los objetos que tengo son "user"y "site". Quiero reemplazar las cadenas dadas en el interior ${}con sus valores equivalentes de los objetos. Esto es lo mismo que reemplazamos objetos en una plantilla de velocidad.

Utilizar StringSubstitutordesde Apache Commons Text.

https://commons.apache.org/proper/commons-text/

Lo hará por ti (y su código abierto ...)

 Map<String, String> valuesMap = new HashMap<String, String>();
 valuesMap.put("animal", "quick brown fox");
 valuesMap.put("target", "lazy dog");
 String templateString = "The ${animal} jumped over the ${target}.";
 StringSubstitutor sub = new StringSubstitutor(valuesMap);
 String resolvedString = sub.replace(templateString);

Eche un vistazo a la java.text.MessageFormatclase, MessageFormat toma un conjunto de objetos, los formatea y luego inserta las cadenas formateadas en el patrón en los lugares apropiados.

Object[] params = new Object[]{"hello", "!"};
String msg = MessageFormat.format("{0} world {1}", params);

Mi forma preferida es String.format()porque es un delineador y no requiere bibliotecas de terceros:

String message = String.format("Hello! My name is %s, I'm %s.", name, age); 

Lo uso regularmente, por ejemplo, en mensajes de excepción como:

throw new Exception(String.format("Unable to login with email: %s", email));

Sugerencia: puede ingresar tantas variables como desee porque format()usa Varargs

Reuní una pequeña implementación de prueba de esto. La idea básica es llamar formaty pasar la cadena de formato, un mapa de objetos y los nombres que tienen localmente.

El resultado de lo siguiente es:

Mi perro se llama fido y Jane Doe es su dueña.

public class StringFormatter {

    private static final String fieldStart = "\\$\\{";
    private static final String fieldEnd = "\\}";

    private static final String regex = fieldStart + "([^}]+)" + fieldEnd;
    private static final Pattern pattern = Pattern.compile(regex);

    public static String format(String format, Map<String, Object> objects) {
        Matcher m = pattern.matcher(format);
        String result = format;
        while (m.find()) {
            String[] found = m.group(1).split("\\.");
            Object o = objects.get(found[0]);
            Field f = o.getClass().getField(found[1]);
            String newVal = f.get(o).toString();
            result = result.replaceFirst(regex, newVal);
        }
        return result;
    }

    static class Dog {
        public String name;
        public String owner;
        public String gender;
    }

    public static void main(String[] args) {
        Dog d = new Dog();
        d.name = "fido";
        d.owner = "Jane Doe";
        d.gender = "him";
        Map<String, Object> map = new HashMap<String, Object>();
        map.put("d", d);
        System.out.println(
           StringFormatter.format(
                "My dog is named ${d.name}, and ${d.owner} owns ${d.gender}.", 
                map));
    }
}

Nota: Esto no se compila debido a excepciones no controladas. Pero hace que el código sea mucho más fácil de leer.

Además, no me gusta que tenga que construir el mapa usted mismo en el código, pero no sé cómo obtener los nombres de las variables locales mediante programación. La mejor manera de hacerlo es recordar poner el objeto en el mapa tan pronto como lo cree.

El siguiente ejemplo produce los resultados que desea de su ejemplo:

public static void main(String[] args) {
    Map<String, Object> map = new HashMap<String, Object>();
    Site site = new Site();
    map.put("site", site);
    site.name = "StackOverflow.com";
    User user = new User();
    map.put("user", user);
    user.name = "jjnguy";
    System.out.println(
         format("Hello ${user.name},\n\tWelcome to ${site.name}. ", map));
}

_{También debo mencionar que no tengo idea de qué es Velocity, así que espero que esta respuesta sea relevante.}

Aquí hay un resumen de cómo podría hacer esto. Debería ser relativamente sencillo implementarlo como código real.

1. Cree un mapa de todos los objetos a los que se hará referencia en la plantilla.
2. Utilice una expresión regular para buscar referencias de variables en la plantilla y reemplácelas con sus valores (consulte el paso 3). La clase Matcher será útil para buscar y reemplazar.
3. Divida el nombre de la variable en el punto. user.namese convertiría en usery name. Busque useren su mapa para obtener el objeto y use la reflexión para obtener el valor del nameobjeto. Suponiendo que sus objetos tengan captadores estándar, buscará un método getNamey lo invocará.

Hay un par de implementaciones de lenguaje de expresión que hacen esto por usted, podrían ser preferibles a usar su propia implementación a medida que sus requisitos crezcan, consulte, por ejemplo, JUEL y MVEL.

Me gusta y he utilizado con éxito MVEL en al menos un proyecto.

Consulte también la publicación de Stackflow JSTL / JSP EL (lenguaje de expresión) en un contexto no JSP (independiente)

No hay nada fuera de la caja que sea comparable a la velocidad, ya que la velocidad se escribió para resolver exactamente ese problema. Lo más cercano que puede intentar es buscar en el formateador

http://cupi2.uniandes.edu.co/site/images/recursos/javadoc/j2se/1.5.0/docs/api/java/util/Formatter.html

Sin embargo, hasta donde yo sé, el formateador se creó para proporcionar opciones de formato similares a C en Java, por lo que es posible que no te rasque exactamente lo que te pica, pero puedes probar :).

Yo uso GroovyShell en Java para analizar la plantilla con Groovy GString:

Binding binding = new Binding();
GroovyShell gs = new GroovyShell(binding);
// this JSONObject can also be replaced by any Java Object
JSONObject obj = new JSONObject();
obj.put("key", "value");
binding.setProperty("obj", obj)
String str = "${obj.key}";
String exp = String.format("\"%s\".toString()", str);
String res = (String) gs.evaluate(exp);
// value
System.out.println(str);