Start - Publikationen - Wissen - TOGAF - Impressum -

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
  5. ${foo.bar}
    ${foo['bar']}
    ..
    
  6. werden ja übersetzt in etwas der Form
  7. foo.get("bar");
    
  8. 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>
copyright © 2002-2018 | Dr. Christian Dürr | prozesse-und-systeme.de | all rights reserved