Java:如何在不实现接口(interface)的情况下独立评估 EL 表达式(在任何 Web 框架之外)？

Question

我想在我的应用程序中使用 EL。但我找不到任何方法。我通常最终需要一些我没有实现的接口(interface)。

我有一个对象映射，我想要一个像 Hello, ${person.name} 这样的字符串表达式被评估为一个字符串。

我如何使用 Commons EL、javax.el、OGNL 等实现这一点？必须是一个独立的库。

我知道 Java: using EL outside J2EE ，并看过JSTL/JSP EL (Expression Language) in a non JSP (standalone) context .这不是我要找的。

我正在寻找的是要添加的依赖项的示例，然后是如何初始化将具有的解析器:

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

让我做:

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

我需要它来使用一些合理的值(value)，例如""在 null而不是抛出 NPE 左右。

Answer 1

有很多 EL 引擎，其中大多数实现了 Java 表达式语言 API。

• Commons EL ( http://jakarta.apache.org/commons/el/ ) 永远存在的 JSP EL API 的实现。这个库可以在许多 JSP 容器(例如 Tomcat)中找到，或者用作许多供应商的 J2EE 服务器的基础。

• OGNL ( http://commons.apache.org/proper/commons-ognl/ ) 当今最具表现力的 EL 之一，广泛用于 WebWork (Struts 2) 和 Tapestry。

• MVEL ( https://github.com/mvel/mvel ) EL 的新成员，它是 MVFlex/Valhalla 项目的一部分。功能看起来更符合 OGNL 提供的方法调用和一些有趣的正则表达式支持。

• (统一)表达语言(https://jcp.org/aboutJava/communityprocess/final/jsr341/index.html 和 http://jcp.org/en/jsr/detail?id=245) 标准表达式语言首先在 Java EE 5 (EL 2.1) 中引入，并在 Java EE 6 (EL 2.2) 和 Java EE 7 (EL 3.0) 中得到增强。 Glassfish 项目提供的引用实现 - Unified Expression Language .

• JEXL ( http://jakarta.apache.org/commons/jexl/ ) 基于 Velocity 解析器的实现。因此，它更像是一种有限的模板解决方案，包含方法调用等内容。

Source

现在我使用 BeanUtils 完成了这段代码 - 丑陋但有效。

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