Expression Language (seit JSP2.0)

---

Der Konstrukt ${attribute} adressiert ein Attribut in einem der vier Scopes. Alles in der Form ${attribute.property} wird übersetzt in einen Konstrukt, bei dem attribute entweder ein EL implizites Objekt oder eine java.util.Map oder eine Bean als Attribut in einem der vier Scopes ist. Die rechte Seite wird als Property ausgewertet, also entweder als Schlüssel der Map oder als Bean-Property. Die rechte Seite darf keinen Java Identifier sein (damit der generierte Javacode compilierbar bleibt).

Folgende Objekte, die EL implicit objects, stehen für die Auswertung mit EL implizit bereit:

Name	Inhalt
pageContext	das PageContext Objekt
pageScope	Map aller Attribute des Page-Scope
requestScope	Map aller Request-Attribute
sessionScope	Map aller Session-Attribute
applicationScope	Map aller Attribute des ServletContext
param	Map der Request-Parameter
paramValues	Map der Request-Parameter als String[] (wenn diese mehrfach in der Form vorkommen)
header	Map der Header des Requests
headerValues	Map der Header des Requests als String[] (wenn es zu einem Namen mehr als ein Header gibt)
cookie	Map der Cookies der Seite
initParam	Map der Context Parameter

Das pageContext-Objekt erlaubt in EL den Zugriff auf request, session, application, page. Beispiele:

${pageContext.request.method} - Request-Methode
${cookie.meinkeks.value} - der Wert des Cookies ("meinkeks")
${initParam.email} - der Wert des Context-Parameters "email"
DD:
<context-param>
 <param-name>email</param-name>
 <param-value>a@b.com</param-value>
</context-param>
${paramValues.name[i]} - Requestparameter "name" mit Index i

Statt des '.'-Operators kann auch mit [] gearbeitet werden, in den Klammern sind auch EL-Ausdrücke erlaubt. Mit dem []-Operator lassen sich die Eigenschaften einer Map, Bean, List und Arrays adressieren. ${account.name} und ${account["name"]} ergeben also das gleiche Ergebnis. Ist das Attribut vom Typ List oder Array, wird eine Zahl als Parameter erwartet oder ein String, der sich in eine Zahl umwandeln lässt. ${account[feld[1]]} funktioniert also, wenn feld[1] zur Laufzeit ausgewertet werden kann. Ebenso ginge ${account[feld["1"]]}.

EL Funktionen

---

Um aus EL heraus Java-Methoden zu rufen braucht man:

1. eine Klasse mit einer öffentlichen, statischen Methode, die von der Containerlaufzeit gefunden wird:

   package a.b;
   public class ElFunction {
     public static String getInfo() {
       return "Some info";
     }
   }
   

2. einen Tag Library Descriptor (TLD), das ist eine Datei mit der Endung .tld:

   <?xml version="1.0" encoding="ISO-8859-1" ?>
   <!DOCTYPE taglib PUBLIC "-//Sun Microsystems, Inc.//DTD JSP Tag Library 1.2//EN" "http://java.sun.com/dtd/web-jsptaglibrary_1_2.dtd">
   <taglib xmlns="http://java.sun.com/xml/ns/j2ee"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee/web-jsptaglibrary_2_0.xsd"
       version="2.0">
    :
    <tlib-version>1.0</tlib-version>
    <short-name>Short Description</short-name>
    <uri>http://myfunction</uri>   // muss keine gültige url sein, nur eindeutig
    :
   <function>
    <name>myFunction</name>
    <function-class>a.b.ElFunction</function-class>
    <function-signature>
     java.lang.String getInfo()
    </function-signature>
   </function>
   :
   </taglib>
   

3. eine Taglib-Direktive in der JSP angeben und die EL Funktion rufen:

   <%@ taglib prefix="q" uri="http://myfunction" %>
   ...
   Foo Bar ${q:myFunction}
   ...
   

   Damit die Webanwendung das TLD-File findet muss es irgendwo unter WEB-INF abgelegt werden. Wird die Funktionalität als JAR zur Verfügung gestellt, dann in dem JAR irgendwo unter META-INF.
4. Mit einem Trick lassen sich auch EL Funktionen über Maps implementieren. Ausdrücke der Form

${foo.bar}
${foo['bar']}
..

5. werden ja übersetzt in etwas der Form

foo.get("bar");

6. wenn foo eine java.util.Map ist. Somit stellt man einfach eine Implementierung von java.util.Map bereit, deren get() das gewünschte Ergebnis liefert. Auf diese Weise lassen sich sogar Parameter übergeben.

EL Operatoren

---

Type	EL Operatoren
Arithmetische Operatoren	+, -, *, / div, % mod (Division durch Null ergibt 'INFINITY', Modulo gegen Null aber wirft AritmethicException!)
Logische Operatoren	&& and, || or, ! not
Relationale Operatoren	== eq, != ne, < lt, > gt, <= le, >= ge

EL reservierte Wörter

---

and, or, not, 
div, mod,
eq, ge, gt, le, lt, ne,  
empty, null,
true, false,
instanceof (wird noch nicht benutzt) 

Behandlung von Null-Werten

---

Bei der Behandlung von null Werten werden EL Ausdrücke werden 'gutmütig' ausgewertet, es wird keine NullPointerException geworfen sondern es erfolgt eine Standardinterpretation:

Kontext	interpretiert als
String	leerer String
boolean	false
Zahl	0

JSP EL Auswertung deaktivieren

---

Ist eine Interpretation von EL Ausdrücken nicht erwünscht, kann diese auch durch einen el-ignored Eintrag im DD der JSP unterdrückt werden:

<jsp-config>
  <jsp-property-group>
    <url-pattern>*.jsp</url-pattern>
    <el-ignored>
       true   // kann mit <%@ page isELIgnored="false" %> überschrieben werden
    </el-ignored>
  </jsp-property-group>
</jsp-config>