|
Java Expression Language (JEXL)JEXL is a library intended to facilitate the implementation of dynamic and scripting features in applications and frameworks written in Java.
JEXL implements an Expression Language based on some extensions to the JSTL Expression Language supporting most of the
constructs seen in shell-script or ECMAScript.
The library exposes a small footprint API - the core features fit in 3 classes and 10 methods - that can be used in various conditions:
JEXL name stands for Java EXpression Language, a simple expression language originally inspired by Apache Velocity and the Expression Language defined in the JavaServer Pages Standard Tag Library version 1.1 (JSTL) and JavaServer Pages version 2.0 (JSP). JEXL 2.0 added features inspired by Unified EL. The syntax is now close to a mix of ECMAScript and "shell-script" making it easy to master by technical operatives or consultants. The objects exposed and their behavior obviously need to be documented though... The API and the expression language exploit Java-beans naming patterns through introspection to expose property getters and setters. It also considers public class fields as properties and allows to invoke any accessible method. A Detailed ExampleTo create expressions and scripts, a JexlEngine is required. To instantiate one, a JexlBuilder is needed to describe the allowed JexlPermissions and JexlFeatures that will determine which classes and methods scripts can access and call and which syntactic elements scripts are allowed to use. Do not overlook this configuration aspect, especially the permissions since security of your application might depend on it. Once built, the JEXL engine should be stored, shared and reused. It is thread-safe ; so are the scripts during evaluation. When evaluating expressions, JEXL merges an JexlExpression or a JexlScript with a JexlContext. In its simplest form, a script is created using JexlEngine#createExpression(), passing a String containing valid JEXL syntax. A simple JexlContext can be created by instantiating a MapContext; a map of variables that will be internally wrapped can be optionally provided through its constructor. JEXL's intention is a tight integration with its hosting platform; the scripting syntax is very close to JScript but leverages (potentially) any public class or method that Java exposes. How tight and how rich this integration is up to you; deriving JEXL API classes - most notably JexlPermissions, JexlContext, JexlArithmetic - are the means to that end. The following example illustrate these aspects. It uses a specific set of permissions to allow using URI class and a tailored context to expose streams in a convenient manner. /** * A test around scripting streams. */ public class StreamTest { /** Our engine instance. */ private final JexlEngine jexl; public StreamTest() { // Restricting features; no loops, no side effects JexlFeatures features = new JexlFeatures() .loops(false) .sideEffectGlobal(false) .sideEffect(false); // Restricted permissions to a safe set but with URI allowed JexlPermissions permissions = new ClassPermissions(java.net.URI.class); // Create the engine jexl = new JexlBuilder().features(features).permissions(permissions).create(); } /** * A MapContext that can operate on streams. */ public static class StreamContext extends MapContext { /** * This allows using a JEXL lambda as a mapper. * @param stream the stream * @param mapper the lambda to use as mapper * @return the mapped stream */ public Stream<?> map(Stream<?> stream, final JexlScript mapper) { return stream.map( x -> mapper.execute(this, x)); } /** * This allows using a JEXL lambda as a filter. * @param stream the stream * @param filter the lambda to use as filter * @return the filtered stream */ public Stream<?> filter(Stream<?> stream, final JexlScript filter) { return stream.filter(x -> x =! null && TRUE.equals(filter.execute(this, x))); } } @Test public void testURIStream() throws Exception { // let's assume a collection of uris need to be processed and transformed to be simplified ; // we want only http/https ones, only the host part and forcing an https scheme List<URI> uris = Arrays.asList( URI.create("http://user@www.apache.org:8000?qry=true"), URI.create("https://commons.apache.org/releases/prepare.html"), URI.create("mailto:henrib@apache.org") ); // Create the test control, the expected result of our script evaluation List<?> control = uris.stream() .map(uri -> uri.getScheme().startsWith("http")? "https://" + uri.getHost() : null) .filter(x -> x != null) .collect(Collectors.toList()); Assert.assertEquals(2, control.size()); // Create scripts: // uri is the name of the variable used as parameter; the beans are exposed as properties // note the starts-with operator =^ // note that uri is also used in the back-quoted string that performs variable interpolation JexlScript mapper = jexl.createScript("uri.scheme =^ 'http'? `https://${uri.host}` : null", "uri"); // using the bang-bang / !! - JScript like - is the way to coerce to boolean in the filter JexlScript transform = jexl.createScript( "list.stream().map(mapper).filter(x -> !!x).collect(Collectors.toList())", "list"); // Execute scripts: JexlContext sctxt = new StreamContext(); // expose the static methods of Collectors; java.util.* is allowed by permissions sctxt.set("Collectors", Collectors.class); // expose the mapper script as a global variable in the context sctxt.set("mapper", mapper); Object transformed = transform.execute(sctxt, uris); Assert.assertTrue(transformed instanceof List<?>); Assert.assertEquals(control, transformed); } } Extensions to JSTL Expression LanguageJEXL attempts to bring some of the lessons learned by the Velocity community about expression languages in templating to a wider audience. Commons Jelly needed Velocity-ish method access, it just had to have it. It must be noted that JEXL is not a compatible implementation of EL as defined in JSTL 1.1 (JSR-052) or JSP 2.0 (JSR-152). For a compatible implementation of these specifications, see the Commons EL project. While JEXL 3.3 is now closer to JScript (without prototypes), its roots are the expression language defined in JSTL and its has improved upon its syntax in a few areas:
Related ResourcesJEXL is not a product of the Java Community Process (JCP), but it provides a similar expression syntax. For more information about JSP 2.0 EL and JSTL 1.1 EL:
VelocityApache Velocity implements a similar expression language. In particular the References section of the User Guide has some good information on properties and method which correlate directly to JEXL. Anyone Using It Yet? |