Dentro do arsenal de melhorias que vem com o Java EE 7, está uma revisão do API de da Linguagem de Expressões do Java, conhecida como Expression Language 3.
Especificada pela JSR-341, a coleção de melhorias para a API da EL inclui suporte a expressões lambda, atributos estáticos e acessos a métodos, assim como melhorias em processamento de coleções, e um modo de processamento autônomo (standalone).
Antes do Java EE 7, a Java Expression Language era um componente fortemente acoplado às APIs JSF e JSP. A JSR-341, entretanto, introduz a Java Expression Language como entidade distinta, desacoplada das APIs da camada de view do Java EE (embora permaneça interoperável com essa camada).
A API de EL agora oferece a possibilidade de invocar a EL de forma ad-hoc. Pode-se criar uma instância da nova classe ELProcessor e invocar seu método eval(). É passada uma String com o script a ser avaliado, e retornado o resultado que poderá ser usado como variável no escopo da aplicação Java.
ELProcessor el = new ELProcessor();
assert ((Integer)el.eval("a = [1, 2, 3]; a[1]")) == 2;
Além do modo autônomo, a JSR-341 traz aos desenvolvedores Java EE a possibilidade de escrever expressões lambda. Expressões lambda estão previstas para a próxima versão do Java, mas já se pode utilizar a sintaxe em scripts. Na última conferência do JavaOne, Kin-man Chung, líder da especificação da JSR-341 observou que o grupo de peritos da especificação foram consultados várias vezes pelos desenvolvedores do Projeto Lambda no Java 8. O objetivo foi garantir uma API comum e futura interoperabilidade entre a Java EL e o Java 8.
ELProcessor el = new ELProcessor();
assert ((Integer)(el.eval("((x,y) -> x+y)(4, 5)"))) == 9;
Para trabalhar com coleções, a nova API de streams da Java EL inclui operadores como forEach, reduce, filter, e map. Muitas das funcionalidades e conceitos introduzidos no processamento de coleções da EL estão também agendados para inclusão no Java 8. Mas por ora, os desenvolvedores podem ser beneficiar do mecanismo de streams lazy e eager e de expressões lambda como parte das melhorias trazidas pela JSR-341.
ELProcessor el = new ELProcessor();
List list = new ArrayList<>();
for (int i = 0; i < 100; i++) {
list.add(i);
}
el.defineBean("list", list);
List processedList = (List)el.eval("list.stream().filter( x -> x <= 3).map(x -> x * 5).toList()");
assert processedList.get(0) == list.get(0);
assert processedList.get(1) == list.get(5);
assert processedList.get(2) == list.get(10);
assert processedList.get(3) == list.get(15);
Outra novidade há muito esperada é o aperfeiçoamento da Java EL que permite acesso direto a atributos estáticos e métodos. Por padrão as classes java.lang* sejam pré-importadas em todos os scripts, mas agora desenvolvedores de scripts EL poderão acessar recursos estáticos de qualquer classe importada para o contexto do EL. Isso é feito através do recurso ELmanager em uma instância de ELProcessor.
ELProcessor el = new ELProcessor();
el.getELManager().importStatic("com.company.Class.STATIC_FIELD");
assert (el.eval("Math.random()") instanceof Double);
System.out.println(el.eval("STATIC_FIELD"));
As melhorias na Expression Language que são parte da JSR-341 deverão se mostrar de grande ajuda nas implementações de JSP e JSF. E o modo de processamento autônomo também deverá ser muito bem-vindo.
O tutorial do Java EE já tem versão atualizada para a nova EL.