El EL es usado en varias tecnologías de JavaEE, tales como JSF, JSP y CDI. Además lo podemos encontrar en entornos stand-alone. Lo que veremos ahora solo es cuando se ejecuta en contenedores Java EE.
Las expresiones nos permite acceder a los datos de los componentes JavaBean. Como sabemos, un JavaBean (no confundir con Enterprise JavaBean) debe tener el siguiente formato:
- Las propiedades deben accederse usando los métodos con prefijo
setpara poner un valor ygetpara obtener un valor. Para los valores boolean se puede utilizargetois, el resultado es el mismo. - Después del prefijo, debe comenzar el nombre con mayúscula
- Los métodos
setsolo deben tener un único parámetro - Los métodos
getno deben tener ningún parámetro. - Los métodos son
public
public void setNombre(String nombre){
//...
}
public String getNombre(){
//...
}
public boolean isActivo(){
//...
}
Y para accederlo desde un EL, simplemente se utiliza el nombre sin el prefijo, pero comenzando con minúsculas
<c:if test="#{sessionScope.persona.activo}">
Hola #{sessionScope.persona.nombre}
...
</c:if>
Para abreviar, el EL proporciona una manera simple - usando expresiones - para realizar las siguientes tareas:
- Leer dinámicamente datos almacenados en los componentes JavaBeans, diversas estructuras de datos y objetos implícitos
- Escribir dinámicamente datos, tales como entradas de formularios a componentes JavaBeans.
- Invocar arbitrariamente métodos públicos y estáticos.
- Realizar operaciones aritméticas, lógicas y de cadena.
- Construir colecciones de objetos y realizar operaciones en colecciones.
Sintaxis de evaluación de expresiones
Existen dos maneras para evaluar una expresión:
- De manera inmediata
- De manera diferida.
La manera inmediata se hace cuando se necesita que el valor del componente bean se escriba directamente cuando construye la página. Para ello se utiliza la sintaxis
${}<c:out value="${persona.nombre}" />
La manera diferida se utiliza cuando el valor a obtener debe pasar por todo el ciclo de vida. Se pueden utilizar para:
- Leer y escribir datos
- Utilizar expresiones de método
<h:inputText value="#{persona.nombre}" />
<h:outputText value="#{persona.calcularRenta(tasa.ingreso)}" />
Referenciando expresiones
Para mostrar o manejar las expresiones de objetos, se hace simplemente (como se vió hasta ahora) con la declaración tal cual
#{persona.nombre}
también podemos invocar a la misma propiedad usando corchetes:
#{persona["nombre"]}
Con esto, como podrás imaginar, podrías invocar a cada propiedad de una manera dinámica
#{persona[campoActual]}
Donde
campoActual es una variable de tipo String que contiene el nombre del campo a mostrar.
#{ valor == objeto.campo }
Si tenemos una clase enum:
public enum Estado {
activo,enProceso,suspendido,terminado
}
.. también podemos invocarlo desde la expresión:
#{ estado == estado.activo }
Los arreglos también se pueden acceder usando un índice entre corchetes
#{cliente.pedidos[1]}
También podemos manipular mapas (
java.util.Map). Supongamos que la propiedad pedidos es un java.util.Map con el key de tipo String, y queremos acceder al pedido con key "teclado". Estas dos líneas hacen lo mismo:#{cliente.pedido["teclado"]}
#{cliente.pedido.teclado}
Es decir, manipula los maps como si fueran propiedades de un objeto.
Lambda
También podemos usar las expresiones Lambda. A pesar que son parte de Java SE 8, se pueden usar en expresiones EL de Java EE 7 con Java SE 7.Para probar las expresiones lambda en Java SE debemos agregar la biblioteca respectiva a nuestro proyecto. Por ello - para efectos de este ejemplo - agregaremos la siguiente dependencia a nuestro proyecto Maven.
<dependency>
<groupId>org.glassfish</groupId>
<artifactId>javax.el</artifactId>
<version>[3.0-b03,)</version>
</dependency>
<dependency>
<groupId>javax</groupId>
<artifactId>javaee-api</artifactId>
<version>7.0</version>
<scope>provided</scope>
</dependency>
Y usaremos el paquete
javax.el.*. Para nuestro ejemplo usaremos el siguiente código: void eval(String input) {
System.out.println("\n====");
System.out.println("Cadena EL: " + input);
Object ret = elp.eval(input); //aquí evaluamos el contenido
System.out.println("Valor obtenido: " + ret);
}
Las expresiones Lambda usan el operador flecha (
->). Los identificadores que se encuentran a la izquierda del operador son llamados parámetros lambda. El cuerpo, que se encuentra a la derecha del operador, pueden ser expresiones EL. Los parámetros lambda pueden estar envueltos en signos de paréntesis, y pueden ser omitidos si solo tienen un parámetro.x -> x+1 (x,y) -> x + y () -> 64
Las expresiones lambda pueden ser utilizadas como una función, y se pueden invocar inmediatamente:
((x,y)-> x + y)(3,4)
.. e imprime 7
También se pueden usar en conjunción con un asignamiento, separados por un punto y coma (;)
v = (x,y) -> x + y; v(3,4)
v es la función lambda creada, y después se invoca con v(3,4)
Operaciones con colecciones
EL permite operaciones de colecciones de objetos: conjuntos (set), listas y mapas. Permite la creación dinámica de colecciones de objetos, los cuales pueden ser manipulados por streams y pipelines.
Al igual que las expresiones lambda, las operaciones sobre colecciones de objetos son parte de Java SE 8, pero podemos usar estas expresiones EL en Java EE 7 sobre Java SE 7.
Veamos: así creamos un par de conjuntos (set):
{1,2,3}
{"Ana","Beto","Carlos"}
Para construir una lista, es como sigue... además podemos hacer que una lista contenga diferentes tipos:
["Abraham","Bart","Carl"] [1,"dos",[tres,cuatro]]
Las variables
tres y cuatro deben existir
void run() {
eval("nums={1,2,3}");
eval("noms={'Ana','Beto','Carlos'}");
eval("noms2=['Abraham','Bart','Carl']");
eval("tres=3;cuatro='4'");
eval("lista=['Abraham','Bart','Carl']");
eval("lista2=[1,'dos',[tres,cuatro]]");
}
Ok, ok, he mostrado el EL en un Java SE, pero la idea es mostrar en un JSF. Aquí va el ejemplo. Primer código:
<?xml version='1.0' encoding='UTF-8' ?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml"
xmlns:h="http://xmlns.jcp.org/jsf/html">
<h:head>
<title>Ejemplos de EL</title>
</h:head>
<h:body>
<h1>Ejemplos de EL</h1>
${lista= [512,128,65] }
</h:body>
</html>
Y cuando se ejecuta, aparece...
Todo bien, todo normal. Ahora con la ayuda de nuestro super IDE NetBeans, a la variable que acabamos de crear vamos a ordenarlo. Vean qué pasa cuando escribimos el nombre de la variable
lista seguido del punto (.)
<?xml version='1.0' encoding='UTF-8' ?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml"
xmlns:h="http://xmlns.jcp.org/jsf/html">
<h:head>
<title>Ejemplos de EL</title>
</h:head>
<h:body>
<h1>Ejemplos de EL</h1>
${lista= [512,128,65].stream().sorted().toList() }
</h:body>
</html>
Y el resultado es lo esperado:
Operadores
Son los clásicos que conocemos
- Aritméticos:
+, -, *, /, div, %, mod, -(signo negativo) - Concatenación de cadenas:
+= - Lógicos:
and, &&, or, ||, not, ! - Relacional:
==, eq, !=, ne, <, lt, >, gt, <=, ge, >=, le - Si es vacío: El operador
emptydetermina si una lista está vacía o un objeto es nulo - Condicional:
A ? B : C(Lo mismo que en Java SE) - Lambda:
->(ya lo conocemos) - Asignación:
= - Punto y coma:
;
Bibliografía
Me basé en el siguiente tutorial 9 Expression Language, y para más detalle sobre esta especificación, visitar la página del JSR 341 http://www.jcp.org/en/jsr/detail?id=341
Si te gustó, hazlo saber.. y si crees que es útil, compártelo. Es gratis