Lenguaje de expresiones de Spring

Una gran funcionalidad que podemos utilizar en nuestras aplicaciones Spring, es el Lenguaje de expresiones de Spring, SpEL. Este sistema de expresiones soporta queries y manipulaciones en tiempo de ejecución.

Este sistema de expresiones va a contribuir a definir patrones o expresiones para variables.

El lenguaje de expresiones de Spring, nos va a permitir inyectar propiedades en los Beans en tiempo de ejecución, tanto para XML como para Java, de manera automática o programática.

Tipos y operadores con SpEL

A continuación podemos ver algunos tipos y operadores que soporta el lenguaje de expresiones de Spring

Tipo	Operador
Aritmético	+, -, *, /, %, ^, div, mod
Relacional	<, >, ==, !=, <=, >=, lt, gt, eq, ne, le, ge
Lógico	and, or, not, &&, ||, !
Condicional	?:
Patrón	matches

Tipos de Operadores

Cuando queremos hacer o definir una expresión haciendo uso de SpEL necesitamos que comience por # y con llaves, es decir, #{loquesea}.

Operador relacional y Lógico

El lenguaje de expresiones de Spring, SpEL nos permite hacer uso de operadores relacionales y lógicos. Estos operadores tienen alias que podrán ser aplicados, por ejemplo, en lugar de usar < o > podemos usar gt o lt.

Vamos a ver algunos ejemplos:

@Value("#{10 == 1}") 
private boolean isFalse;

@Value("#{10 == 10}") 
private boolean isFalse;

@Value("#{10 != 10}") 
private boolean notEqual;

@Value("#{10 eq 10}")
private boolean equalAlphabetic;

@Value("#{100 < 100}") 
private boolean lessThan;

@Value("#{10 lt 10}")
private boolean lessThanAlphabetic;

@Value("#{5 ge 5}") 
private boolean greaterThanOrEqualAlphabetic;

Operador aritmético

SpEL nos permite realizar todo tipo de operaciones aritméticas por ejemplo:

@Value("#{1 + 1}") // --> 2
private double add; 

@Value("#{'Hola ' + 'Mundo'}") // "Hola Mundo"
private String helloWorld; 

@Value("#{1 - 1}") // 0
private double subtract;

@Value("#{10 / 2}") // 5 you can use div
private double dividir;

@Value("#{35 % 10}") // 5 you can use mod
private double modulo;

@Value("#{2 ^ 2}") // 4
private double exp;

Los operadores aritméticos nos permiten múltiples posibilidades para poder realizar diferentes y variadas operaciones.

Operadores condicionales

En el lenguaje de Expresiones de Spring, SpEL, vamos a poder hacer uso de operadores condicionales para establecer diferentes valores en función de alguna condición.

Por ejemplo podemos hacer uso del operador condicional o ternario de la siguiente manera:

@Value("#{100 > 20 ? 'z' : 'c'}")
private String condition;

También podemos hacer uso de este operador para ver si un valor llega a null y en ese caso establecer otra propiedad. De esta manera evitaremos null pointer en nuestro código al cargar alguna propiedad.

@Value("#{myCar.color!= null ? myCar.color : 'yellow'}")
private String color;

Hacer uso de SpEL para cargar objetos de una lista o de mapas

Es muy útil hacer uso de SpEL para cargar una propiedad de una lista o un mapa en concreto que hemos cargado en un fichero de configuración o hemos definido en una clase.

@Component("car")
public class Car{
    private List<String> cars= new LinkedList<>();
    private Map<String, String> carsByColor= new HashMap<>();

    public WorkersHolder() {
        cars.add("Mustang");

        carsByBrand.put("Mustang", "Yellow");
    }

}

@Value("#{car.carsByColor['Mustang']}") 
private Integer color;

@Value("#{car.cars.size()}")
private Integer cars;

Uso de expresiones regulares con SpEL

Podemos hacer uso de expresiones regulares mediante el lenguaje de expresiones de Spring, en el que através de un patrón podemos ver si hace match con esa expresión:

@Value("#{'100' matches '\\d+' }") 
private boolean isNumeric; //true

@Value("#{'asdf' matches '\\d+' }") 
private boolean isNumeric; //false

Haciendo uso de SpelExpressionParser de manera programática

Gracias a todas las configuraciones automáticas que nos da Spring, la manera más común de hacer uso de SpEL suele ser de manera automática. Pero para aquellos casos en los que necesitemos hacerlo de manera programática también podemos hacer uso de SpEL.

Introducción a ExpressionParser

El objetivo de ExpressionParser es analizar las cadenas de expresión. Por ejemplo:

ExpressionParser expressionParser = new SpelExpressionParser();
Expression expression = expressionParser.parseExpression("'whatever'");
String result = (String) expression.getValue();

En el caso anterior analizamos el litereal whatever como una expresión. Haciendo uso de SpEL podemos llamar a constructores o propiedades. Por ejemplo podemos hacer uso de getValue().

Expression expression = expressionParser.parseExpression("'whatever'.length()");
Integer result = (Integer) expression.getValue();

Hacer set de un valor con ExpressionParser

Por ejemplo podemos hacer uso de ConversionService del core de Spring para crear conversores propios entre tipos. ConversionService nos va a permitir hacer uso de genéricos.

Car car = new Car();
car.setModel("Mustang");
car.setColor("Yellow");

Workshop workshop= new Workshop ();
workshop.getCars().add(car);

StandardEvaluationContext context = new StandardEvaluationContext(workshop);

ExpressionParser expressionParser = new SpelExpressionParser();
expressionParser.parseExpression("cars[0].model").setValue(context, "Megane");

Otras funcionalidades de ExpressionParser

Otra de las funcionalidades que podemos obtener al hacer uso de ExpressionParser es la de realizar configuraciones con SpelParserConfiguration. Por ejemplo podemos realizar una configuración para que al añadir un objeto en un array, no falle si este es nulo y que se incremente a la siguiente posición:

SpelParserConfiguration config = new SpelParserConfiguration(true, true);
StandardEvaluationContext context = new StandardEvaluationContext(car);

ExpressionParser expressionParser = new SpelExpressionParser(config);
expressionParser.parseExpression("brands[0]").setValue(context, brand);

Brand brand = car.getBrands().get(0)

El resultado será el elemento añadido al principio del array. Con el parseExpression que hemos realizado se añade a la posición 0 y evitamos el null.

Conclusión

En esta entrada hemos visto mediante algún ejemplo como el Lenguaje de Expresiones de Spring, también conocido como SpEL nos va a facilitar diferentes configuraciones de nuestros beans a través de expresiones.

De esta manera podremos realizar en tiempo de ejecución cargas y configuraciones en función de determinados patrones y expresiones.