Java: Comment évaluer une expression EL - autonome (en dehors de tout framework web) sans mise en œuvre d'interfaces?

Je voudrais utiliser EL dans mon application. Mais je ne trouve pas de tutoriel. Je finissent généralement besoin d'une interface pour laquelle je n'ai pas de mise en œuvre.

J'ai une carte des objets, et je veux une expression de chaîne comme Bonjour, ${person.name} être évalué à une chaîne.

Comment puis-je réaliser que, en utilisant l'une des Communes d'EL, javax.el, OGNL, ou un tel? Doit être une bibliothèque autonome.

Et je savoir Java: utilisation de EL en dehors J2EE, et ont vu JSTL/JSP EL (Expression Language) dans un non JSP (autonome) contexte. Ce n'est pas ce que je cherche.

Ce que je cherche, c'est un exemple de ce que la dépendance à ajouter, puis comment initialiser un analyseur qui aura:

private static String evaluateEL( String expr, Map<String, String> properties );

et me permettent de faire:

String greet = evaluateEL("Hello ${person.name}", 
     new HashMap(){{
       put("person", new Person("Ondra"));
     }}
);

Et j'en ai besoin pour utiliser certaines valeur rationnelle, par exemple "" sur null au lieu de lancer des entrées en phase nationale.

Bien que pas exactement EL, FreeMarker a une syntaxe similaire et de fonctionnalités.
Aussi Vitesse a une syntaxe similaire que EL.
OGNL peut-être, mais leur site ne fonctionne pas de l'ATM.

OriginalL'auteur Ondra Žižka | 2013-06-10

  1. 14

    Il y a tout un tas de EL moteurs, dont plus de mettre en œuvre l'Expression de Java API de Langage.

    • Communes EL (http://jakarta.apache.org/commons/el/)
      La mise en œuvre de la JSP EL API qui a toujours existé. Cette bibliothèque peut être trouvé dans de nombreux récipients de JSP (Tomcat par exemple) ou servir de base à l'intérieur de nombreux fournisseurs de serveurs J2EE.

    • OGNL (http://www.ognl.org/)
      L'un des plus expressifs ELs aujourd'hui disponibles et largement utilisés avec WebWork (Struts 2) et la Tapisserie.

    • MVEL (https://github.com/mvel/mvel)
      Un nouveau venu à EL qui fait partie de la MVFlex/Valhalla projet. Caractéristiques de regarder plus en ligne avec OGNL de l'offre avec l'invocation de méthode et quelques intéressantes support des expressions régulières.

    • (Unifiée) Langage d'Expression (https://jcp.org/aboutJava/communityprocess/final/jsr341/index.html et http://jcp.org/en/jsr/detail?id=245)
      Standard expression de la langue d'abord introduit dans Java EE 5 (EL 2.1) et renforcée dans Java EE 6 (EL 2.2) et Java EE 7 (EL 3.0). L'implémentation de référence disponible à partir de Glassfish projet -
      Unifiée Langage D'Expression      .

    • JEXL (http://jakarta.apache.org/commons/jexl/)
      Une mise en œuvre basé sur la Vitesse de l'analyseur. De ce fait, il agit plus comme un limitées de template solution avec des choses comme l'invocation de méthode.

    Source

    Pour l'instant j'ai fini avec ce code à l'aide BeanUtils - laid, mais fonctionne.

    import java.lang.reflect.InvocationTargetException;
import java.util.Map;
import java.util.NoSuchElementException;
import java.util.StringTokenizer;
import org.apache.commons.beanutils.PropertyUtils;
import org.apache.commons.lang.StringUtils;
import org.slf4j.LoggerFactory;
public static class SimpleEvaluator implements IExprLangEvaluator {
private static final org.slf4j.Logger log = LoggerFactory.getLogger( SimpleEvaluator.class );
@Override
public String evaluateEL( String template, Map<String, String> properties ) {
StringTokenizer st = new StringTokenizer( template );
String text = st.nextToken("${");
StringBuilder sb = new StringBuilder();
//Parse the template: "Hello ${person.name} ${person.surname}, ${person.age}!"
do{
try {
sb.append(text);
if( ! st.hasMoreTokens() )
break;
//"${foo.bar[a]"
String expr  = st.nextToken("}");
//"foo.bar[a].baz"
expr = expr.substring(2);
//"foo"
String var = StringUtils.substringBefore( expr, ".");
Object subject = properties.get( var );
//"bar[a].baz"
String propPath = StringUtils.substringAfter( expr, ".");
sb.append( resolveProperty( subject, propPath ) );
text = st.nextToken("${");
text = text.substring(1);
} catch( NoSuchElementException ex ){
//Unclosed ${
log.warn("Unclosed ${ expression, missing } : " + template);
}
} while( true );
return sb.toString();
}
//BeanUtils
private String resolveProperty( Object subject, String propPath ) {
if( subject == null ) return "";
if( propPath == null || propPath.isEmpty() ) return subject.toString();
try {
return "" + PropertyUtils.getProperty( subject, propPath );
} catch(     IllegalAccessException | InvocationTargetException | NoSuchMethodException ex ) {
log.warn("Failed resolving '" + propPath + "' on " + subject + ":\n    " + ex.getMessage(), ex);
return "";
}
}
}//class SimpleEvaluator

    OriginalL'auteur Ondra Žižka

  2. 3

    J'en ai trouvé un à http://juel.sourceforge.net/guide/start.html .
    Toujours pas exactement 1-liner, mais à proximité.

    ExpressionFactory factory = new de.odysseus.el.ExpressionFactoryImpl();
de.odysseus.el.util.SimpleContext context = new de.odysseus.el.util.SimpleContext();
context.setVariable("foo", factory.createValueExpression("bar", String.class));
ValueExpression e = factory.createValueExpression(context, "Hello ${foo}!", String.class);
System.out.println(e.getValue(context)); //--> Hello, bar!

    Maven deps:

        <!-- Expression language -->
<dependency>
<groupId>de.odysseus.juel</groupId>
<artifactId>juel-api</artifactId>
<version>2.2.7</version>
</dependency>
<dependency>
<groupId>de.odysseus.juel</groupId>
<artifactId>juel-impl</artifactId>
<version>2.2.7</version>
<type>jar</type>
</dependency>
    Utilisation <artifactId>juel-impl</artifactId>, sinon, vous avez deux tendances contradictoires EL-Api.
    Basé sur le commentaire que j'ai changé artifactId de juel à juel-impl, mais sans le tester.
    J'ai mis à jour les versions. Ressemble à la JUEL impl a changé groupId à de.odysseus.juel.

    OriginalL'auteur Ondra Žižka