7/31/22, 1:40 PM 6.

 Spring Expression Language (SpEL)

6. Spring Expression Language (SpEL)

6.1 Introduction
The Spring Expression Language (SpEL for short) is a powerful expression language that supports
querying and manipulating an object graph at runtime. The language syntax is similar to Unified EL
but offers additional features, most notably method invocation and basic string templating
functionality.

While there are several other Java expression languages available, OGNL, MVEL, and JBoss EL,
to name a few, the Spring Expression Language was created to provide the Spring community with
a single well supported expression language that can be used across all the products in the Spring
portfolio. Its language features are driven by the requirements of the projects in the Spring
portfolio, including tooling requirements for code completion support within the eclipse based
SpringSource Tool Suite. That said, SpEL is based on a technology agnostic API allowing other
expression language implementations to be integrated should the need arise.

While SpEL serves as the foundation for expression evaluation within the Spring portfolio, it is not
directly tied to Spring and can be used independently. In order to be self contained, many of the
examples in this chapter use SpEL as if it were an independent expression language. This requires
creating a few bootstrapping infrastructure classes such as the parser. Most Spring users will not
need to deal with this infrastructure and will instead only author expression strings for evaluation.
An example of this typical use is the integration of SpEL into creating XML or annotated based
bean definitions as shown in the section Expression support for defining bean definitions.

This chapter covers the features of the expression language, its API, and its language syntax. In
several places an Inventor and Inventor's Society class are used as the target objects for
expression evaluation. These class declarations and the data used to populate them are listed at
the end of the chapter.

6.2 Feature Overview
The expression language supports the following functionality

Literal expressions

Boolean and relational operators

Regular expressions

Class expressions

Accessing properties, arrays, lists, maps

Method invocation

Relational operators

Assignment

Calling constructors

Bean references

Array construction

Inline lists
https://docs.spring.io/spring-framework/docs/3.0.x/reference/expressions.html 1/4
7/31/22, 1:40 PM 6. Spring Expression Language (SpEL)

Ternary operator

Variables

User defined functions

Collection projection

Collection selection

Templated expressions

6.3 Expression Evaluation using Spring's Expression

Interface
This section introduces the simple use of SpEL interfaces and its expression language. The
complete language reference can be found in the section Language Reference.

The following code introduces the SpEL API to evaluate the literal string expression 'Hello World'.

ExpressionParser parser = new SpelExpressionParser();

Expression exp = parser.parseExpression("'Hello World'");

String message = (String) exp.getValue();

The value of the message variable is simply 'Hello World'.

The SpEL classes and interfaces you are most likely to use are located in the
packages org.springframework.expression and its sub packages and spel.support.

The interface  ExpressionParser is responsible for parsing an expression string. In this example the
expression string is a string literal denoted by the surrounding single quotes. The
interface  Expression  is responsible for evaluating the previously defined expression string. There
are two exceptions that can be thrown,  ParseException  and  EvaluationException  when calling
'parser.parseExpression' and 'exp.getValue' respectively.

SpEL supports a wide range of features, such as calling methods, accessing properties, and
calling constructors.

As an example of method invocation, we call the 'concat' method on the string literal.

ExpressionParser parser = new SpelExpressionParser();

Expression exp = parser.parseExpression("'Hello World'.concat('!')");

String message = (String) exp.getValue();

The value of message is now 'Hello World!'.

As an example of calling a JavaBean property, the String property 'Bytes' can be called as shown
below.

ExpressionParser parser = new SpelExpressionParser();

// invokes 'getBytes()'

Expression exp = parser.parseExpression("'Hello World'.bytes");

byte[] bytes = (byte[]) exp.getValue();

SpEL also supports nested properties using standard 'dot' notation, i.e. prop1.prop2.prop3 and the
setting of property values
https://docs.spring.io/spring-framework/docs/3.0.x/reference/expressions.html 2/4
7/31/22, 1:40 PM 6. Spring Expression Language (SpEL)

Public fields may also be accessed.

ExpressionParser parser = new SpelExpressionParser();

// invokes 'getBytes().length'

Expression exp = parser.parseExpression("'Hello World'.bytes.length");

int length = (Integer) exp.getValue();

The String's constructor can be called instead of using a string literal.

ExpressionParser parser = new SpelExpressionParser();

Expression exp = parser.parseExpression("new String('hello world').toUpperCase()");

String message = exp.getValue(String.class);

Note the use of the generic method  public <T> T getValue(Class<T> desiredResultType). Using this
method removes the need to cast the value of the expression to the desired result type.
An  EvaluationException will be thrown if the value cannot be cast to the type  T or converted using
the registered type converter.

The more common usage of SpEL is to provide an expression string that is evaluated against a
specific object instance (called the root object). There are two options here and which to choose
depends on whether the object against which the expression is being evaluated will be changing
with each call to evaluate the expression. In the following example we retrieve the  name  property
from an instance of the Inventor class.

// Create and set a calendar

GregorianCalendar c = new GregorianCalendar();

c.set(1856, 7, 9);

// The constructor arguments are name, birthday, and nationality.

Inventor tesla = new Inventor("Nikola Tesla", c.getTime(), "Serbian");

ExpressionParser parser = new SpelExpressionParser();

Expression exp = parser.parseExpression("name");

EvaluationContext context = new StandardEvaluationContext(tesla);

String name = (String) exp.getValue(context);

In the last line, the value of the string variable 'name' will be set to "Nikola Tesla". The class
StandardEvaluationContext is where you can specify which object the "name" property will be
evaluated against. This is the mechanism to use if the root object is unlikely to change, it can
simply be set once in the evaluation context. If the root object is likely to change repeatedly, it can
be supplied on each call to getValue, as this next example shows:

/ Create and set a calendar

GregorianCalendar c = new GregorianCalendar();

c.set(1856, 7, 9);

// The constructor arguments are name, birthday, and nationality.

Inventor tesla = new Inventor("Nikola Tesla", c.getTime(), "Serbian");

ExpressionParser parser = new SpelExpressionParser();

Expression exp = parser.parseExpression("name");

String name = (String) exp.getValue(tesla);

In this case the inventor tesla has been supplied directly to getValue and the expression evaluation
infrastructure creates and manages a default evaluation context internally - it did not require one to
be supplied.

https://docs.spring.io/spring-framework/docs/3.0.x/reference/expressions.html 3/4
7/31/22, 1:40 PM 6. Spring Expression Language (SpEL)

The StandardEvaluationContext is relatively expensive to construct and during repeated usage it

builds up cached state that enables subsequent expression evaluations to be performed more
quickly. For this reason it is better to cache and reuse them where possible, rather than construct a
new one for each expression evaluation.

In some cases it can be desirable to use a configured evaluation context and yet still supply a
different root object on each call to getValue. getValue allows both to be specified on the same call.
In these situations the root object passed on the call is considered to override any (which maybe
null) specified on the evaluation context.

Note
In standalone usage of SpEL there is a need to create the parser, parse
expressions and perhaps provide evaluation contexts and a root context object.
However, more common usage is to provide only the SpEL expression string as
part of a configuration file, for example for Spring bean or Spring Web Flow
definitions. In this case, the parser, evaluation context, root object and any
predefined variables are all set up implicitly, requiring the user to specify
nothing other than the expressions.

As a final introductory example, the use of a boolean operator is shown using the Inventor object in
the previous example.

Expression exp = parser.parseExpression("name == 'Nikola Tesla'");

boolean result = exp.getValue(context, Boolean.class); // evaluates to true

6.3.1 The EvaluationContext interface

The interface  EvaluationContext  is used when evaluating an expression to resolve properties,
methods, fields, and to help perform type conversion. The out-of-the-box
implementation,  StandardEvaluationContext, uses reflection to manipulate the object,
caching java.lang.reflect's Method, Field, and Constructor instances for increased performance.

The StandardEvaluationContext is where you may specify the root object to evaluate against via the
method  setRootObject()  or passing the root object into the constructor. You can also specify
variables and functions that will be used in the expression using the
methods setVariable() and registerFunction(). The use of variables and functions are described in
the language reference sections  Variables  and  Functions. The  StandardEvaluationContext  is also
where you can register custom  ConstructorResolvers,  MethodResolvers, and  PropertyAccessors to
extend how SpEL evaluates expressions. Please refer to the JavaDoc of these classes for more
details.

https://docs.spring.io/spring-framework/docs/3.0.x/reference/expressions.html 4/4