Der vollständige Name von EL ist Expressionssprache (Ausdruckssprache), die eines der wichtigsten Merkmale von JSP2.0 ist. EL -Ausdrücke können verwendet werden, um auf Daten in der Anwendung zuzugreifen, um Java -Skripte auf der JSP -Seite zu beseitigen.
Syntax des EL -Ausdrucks
Ausdruck zum Beispiel kann x+y als {x+y} geschrieben werden
Schlüsselwörter in El
Im Folgenden finden Sie Schlüsselwörter in EL, die nicht als Bezeichner verwendet werden können:
und EQ, GT, wahr, Instanz oder, le, falsch, leer, nicht, lt, ge, null, div, mod
1. Einführung in El -Ausdrücke
Els vollständiger Name ist Ausdruckssprache. Els Hauptfunktionen:
1. Daten erhalten
EL -Ausdrücke werden hauptsächlich verwendet, um Skriptausdrücke auf JSP -Seiten zu ersetzen, um Java -Objekte abzurufen und Daten aus verschiedenen Arten von Webdomänen zu erhalten. (Objekte in einer bestimmten Webdomäne, Zugriff auf javabäische Eigenschaften, Zugriffslistensammlung, Zugriffskartesammlung, Zugriffsarray)
2. Durchführen von Operationen
Mit EL -Ausdrücken können Sie auf der JSP -Seite einige grundlegende relationale Operationen, logische Operationen und arithmetische Operationen ausführen, um einige einfache logische Operationen auf der JSP -Seite auszuführen. $ {user == null}
3.. Erhalten Sie gemeinsame Objekte für die Webentwicklung
EL -Ausdrücke definieren einige implizite Objekte. Mit diesen impliziten Objekten können Webentwickler leicht Referenzen auf häufig verwendete Webobjekte erhalten und damit Daten in diesen Objekten erhalten.
4. Rufen Sie Java -Methoden an
Mit EL -Ausdrücken können Benutzer benutzerdefinierte EL -Funktionen entwickeln, um Methoden von Java -Klassen über EL -Ausdrücke auf JSP -Seiten aufzurufen.
1.1. Daten erhalten
Verwenden Sie den EL -Ausdruck, um die Datensyntax zu erhalten: "$ {Identifier}"
Wenn die EL -Expressionsanweisung ausgeführt wird, wird die Methode von PageContext.FindAttribute aufgerufen, wobei die Kennung als Schlüsselwort verwendet wird, um das entsprechende Objekt aus den vier Feldern von Seite, Anforderung, Sitzung und Anwendung zu finden. Wenn es gefunden wird, gibt es das entsprechende Objekt zurück. Wenn es nicht gefunden wird, wird "" zurückgegeben (beachten Sie, dass es nicht null ist, sondern eine leere Zeichenfolge).
EL -Ausdrücke können leicht javabäische Eigenschaften oder Daten von Arrays, Sammlungen und Kartentypen erhalten.
Beispiel des EL -Ausdrucks, um Daten zu erhalten:
<%@page Language = "java" import = "java.util. import="me.gacl.domain.Address"%><!DOCTYPE HTML><html><head><title>el expression gets data</title></head><body><% request.setAttribute("name","Lonely Wolf");%><%--${name} is equivalent to pageContext.findAttribute("name") --%>Use EL Ausdruck, um Daten zu erhalten: $ {name} <hr> <!-Auf der JSP-Seite verwenden Sie den Ausdruck, um die Eigenschaften der Bean zu erhalten-> <% Person p = new Person (); P.Setage (); Anfrage. Bohne. . . . . . . . . Attribute von-> <% Person person = new Person (); Adressadresse = new adress (); Person.SetAddress (Adresse); Anfrage. Canglang "); Person p = new Person (); P.SetName (" White Tiger God-Kaiser "); Liste <Person> list = new ArrayList <Person> (); list.add (p) list.add (p); Anfrage. -> <c: foreach var = "Person" items = "$ {list}"> $ {Person.name} </c: foreach> <hr> <!-In der JSP-Seite verwenden Sie den EL-Ausdruck, um die Daten der Kartensammlung zu erhalten-> <% Map <String> MAP = New LinkedHasMap <String, String> (); map.put ("a", "aaaaxxx"); map.put ("b", "bbbb"); map.put ("c", "cccc"); map.put ("", "AAAA"); Anfrage. -->${map.c} ${map[""]}<hr><!-- Iterate Map collection--><c:forEach var="me" items="${map}">${me.key}=${me.value}<br/></c:forEach><hr></body></html> Der Betriebseffekt ist wie folgt:
1.2. Vorgänge ausführen
Syntax: $ {Operation Expression}, EL -Ausdruck unterstützt die folgenden Operatoren:
1. Relationale Operatoren
2. Logische Operatoren:
3. Leerer Bediener: Überprüfen Sie, ob das Objekt null ist (leer)
4. Binärer Ausdruck: $ {user! = Null? User.name: ""}
5. [] und. Betreiber
Beispiel für die Durchführung von Operationen unter Verwendung von EL -Ausdrücken:
<%@page Language = "java" import = "java.util. HTML><html><head><title>el expression operator</title></head><body><h>el expression performs four operations:</h>Addition operation: ${+}<br/>Subtraction operation: ${-}<br/>Multiple operation: ${*}<br/>Divide operation: ${/}<br/>H>el expression performs relationship Operationen: </h> <%-$ {user == null} und $ {user eq null}; Äquivalent-%> $ {user == null} <br/> $ {user eq null} <br/> $ {user eq null} <br/> EL-Ausdruck verwendet den leeren Operator, um zu überprüfen ArrayList <string> (); list.add ("gaCl"); list.add ("xDp"); request.setattribute ("list", list);%> <%-Verwenden Sie den leeren Operator, um zu überprüfen, ob das Objekt null (leer)-%> <c: wenn test = "$ {! Items = "$ {list}"> $ {str} <br/> </c: foreach> </c: if> <br/>%list <string> leerlist = null;%> <%-Verwenden Sie den leeren Operator, um zu überprüfen, ob das Objekt null ist Ausdrücke werden in EL -Ausdrücken </h> <% Session.setAttribute ("Benutzer", neuer Benutzer ("Lonely Ganglang")) verwendet;%> $ {user == null? "Entschuldigung, Sie sind nicht angemeldet": user.username} <br/> <h> el Ausdrucksdaten Echo </h> <% user user = new user (); user.setGender ("männlich"); // Data echo request.setAttribute ("user", user;%> <input type = "radio" name = "male" male "male" male "male" male "male" male "male" male "male" male "male" male "male" male "male" male "male" male "male" male "male" male "male" male "male" male "male" male "male" male "male" male ". $ {user.gender == 'männlich'? 'Checked': ''}> männlich <Eingabe type = "radio" name = "Geschlecht" value = "weiblich" $ {user.gels == 'weiblich'? 'Checked': ''}> weiblich <br/> </body> </html>Die Betriebsergebnisse sind wie folgt:
1.3. Erhalten Sie gemeinsame Objekte für die Webentwicklung
EL -Expressionssprache definiert 11 implizite Objekte. Die Verwendung dieser impliziten Objekte kann leicht einige gängige Objekte in der Webentwicklung erhalten und die Daten dieser Objekte lesen.
Syntax: $ {implizites Objektname}: Erhalten Sie einen Verweis auf das Objekt
Test 11 implizite Objekte in EL -Ausdrücken:
<%@ page Language = "java" import = "java.util. Objekt </title> </head> <body> <br/> -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- //map%>$ <pagescope.name} <br/> ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- //map% >$ <Besessionscope.user} <br/> ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- Dieser Ausdruck wird häufig für Daten echoes verwendet -> <form action value = "Register"> </Form> <br/> ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------. http: // localhost: /javaweb_el_study_/eldemo.jsp? Like = aaa & Like = bb -> $ {paramvalues.like []} $ {paramvalues.like []} <br/> -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- Beispielakzept-Codierung, Headervalues ["Akzeptieren"]-%> $ {Header ["Akzeptieren-codieren"]} <br/> ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ Ein Kartenobjekt, das alle HTTP -Anforderungs -Headerfelder speichert. Für einen Anforderungsparameter wird ein String [] -Array zurückgegeben. Zum Beispiel: Headervalues.accept gibt ein String [] -Array zurück. Headervalues.accept [] nimmt den ersten Wert im Array-%> $ {Headervalues.accept []} <br/> <%-$ {Headervalues.accept-Coding} heraus Wenn es im Kopf "-" wie Akzeptieren gibt, z. Headervalues ["Akzeptieren"] [] [] nimmt den ersten Wert in der Array-%> $ {Headervalues ["Akzeptieren-Codierung"] []} <br/> -------------------------------------------------------------------------------------------------------------------------------------------------------------- ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- -> $ {cookie.jsessionid.value} // Karte von allen speichern Cookies <br/> ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------/ --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- Konfigurieren Sie die Initialisierungsparameter in der Datei web.xml -> <context-param> <param-name> xxx </param-name> <param-value> yyyy </param-value> </context-param> <context-param> <param-name> root </param-name> <param-value>/javaweb_el_study _ </param-valu> </param-valu> ServletContext zum Speichern von Initialisierungsparametern -%> $ {initparam.xxx} <br/> $ {initparam.root} </body> </html> Der RegisterServlet -Code lautet wie folgt:
Paket me.gacl.web.controller; import Java.io.ioxception; import Javax.servlet.servletException; import Javax.servlet.http.httpServlet; import Javax.servlet.http.httpletrequest; erweitert httpServlet {/** Methoden zur Behandlung der Benutzerregistrierung*/public void dodget (httpServletRequest -Anforderung, HttpServletResponse -Antwort) löst ServletException aus, IoException {//, empfangen Sie Parameter String username = request. Request.SetAttribute ("Benutzername", Benutzername), um den Benutzernamen im Anforderungsobjekt* zu speichern Dopost (httpServletRequest -Anforderung, httpServletResponse -Antwort) löst ServletException, IOException {dagget (request, response);}} aus Die Testergebnisse sind wie folgt:
Beachten:
Beim Testen von Header und Headervalues, wenn es im Kopf "-" "-wie Akzeptanzkodierung, Header [" Akzeptieren "] und Headervalues [" Akzeptanzkodierung "]
Beim Testen von Cookies beispielsweise nimmt $ {cookie.key} ein Cookie -Objekt. Wenn Sie auf den Namen und den Wert des Cookies zugreifen, müssen Sie $ {cookie.key.name} oder $ {cookie.key.value} haben
1.4. Rufen Sie Java -Methoden mit EL an
Mit der EL -Expressionsyntax können Entwickler benutzerdefinierte Funktionen entwickeln, um Methoden von Java -Klassen aufzurufen. Syntax: $ {Präfix: Methode (Params)}
Das einzige, was im EL -Ausdruck genannt werden kann, ist die statische Methode der Java -Klasse. Die statische Methode dieser Java -Klasse muss in der TLD -Datei beschrieben werden, bevor sie durch den EL -Ausdruck aufgerufen werden kann.
EL -benutzerdefinierte Funktionen werden verwendet, um die Funktionen von EL -Ausdrücken zu erweitern, sodass EL -Ausdrücke Funktionen erfüllen können, die der normale Java -Programmcode ausfüllen kann.
1.5. EL -Funktionsentwicklungsschritte
Im Allgemeinen umfassen die Entwicklung und Anwendung von EL -benutzerdefinierten Funktionen die folgenden drei Schritte:
1. Schreiben Sie eine statische Methode einer Java -Klasse
2. Schreiben Sie eine TLD -Datei (Tag Library Descriptor) und beschreiben Sie benutzerdefinierte Funktionen in der TLD -Datei.
3.. Importieren und verwenden Sie benutzerdefinierte Funktionen auf der JSP -Seite
Beispiel: Entwicklung der EL -Funktion, um HTML -Tags zu entkommen
1. Schreiben Sie die HTML Escape -Verarbeitungswerkzeugklasse und fügen Sie statische Verarbeitungsmethoden hinzu, um HTML -Tags in der Werkzeugklasse zu entkommen:
Paket me.gacl.util;/*** @className: htmlfilter* @Description: HTML Escape Processing Tool Class* @Author: Lonely canglang* @Date: - morgend @Param -Nachrichteninhalt, um es zu entkommen (Inhalt [i]) {case '<' <': result.append ("<"); break; case'> ': result.append (">"); break; case' & ': result.append ("&"); case' "': result.append (" ");2. Schreiben Sie eine TLD-Datei (Tag Library Descriptor) in das Web-Inf-Verzeichnis und beschreiben Sie benutzerdefinierte Funktionen in der TLD-Datei.
Der Code der Elfunktion.tld lautet wie folgt:
<? xml Version = ".". coding = "utf-"?> <taglib Version = "." xmlns = "http://java.sun.com/xml/ns/jee" xmlns: xsi = "http://www.w.org//xmlschema-instance" xsi: schemalocation web-jsptaglibrary __. xsd "> <tlib-version>. -> <Uri>/Elfunction </uri> <!-<Funktion> Element wird verwendet, um eine EL-benutzerdefinierte Funktion zu beschreiben. -> <Funktionklasse> me.gacl.util.htmlfilter </function-class> <!-<Funktionsignatur> Untertagees Element wird verwendet, um die Signatur der statischen Methode in der Java-Klasse anzugeben. Die Methodensignatur muss den Rückgabewerttyp der Methode und den Typ jedes Parameters angeben, und jeder Parameter wird durch ein Komma getrennt. -> <Funktionsignatur> java.lang.String Filter (java.lang.String) </Funktionssignatur> </function> </taglib>
3.. Importieren und verwenden Sie benutzerdefinierte Funktionen auf der JSP -Seite
<%@ page Language = "java" import = "java.util. EL </title> </head> <body> <%-Aufrufen von Filtermethoden mit El-%> $ {fn: filter ("<a href = ''> Diand </a>")} </body> </html> Die Betriebsergebnisse sind wie folgt:
1.6. Dinge, die bei der Entwicklung der EL -Funktion zu beachten sind
Nach dem Schreiben der Tag-Bibliotheksbeschreibungsdatei müssen Sie sie in ein beliebiges Unterverzeichnis außer Klassen und LIB-Verzeichnissen im Verzeichnis <NEW-Anwendungen>/Web-inf oder im Web-Inf-Verzeichnis platzieren.
Das Element <Uri> in der TLD -Datei verwendet die URI, die die TLD -Datei angibt. Dieser URI muss verwendet werden, um die Datei der Tag -Bibliotheksbeschreibung in der JSP -Datei einzuführen.
Das <Funktion> -Element wird verwendet, um eine EL -benutzerdefinierte Funktion zu beschreiben, wobei:
Das untergeordnete Element <Name> wird verwendet, um den Namen der EL -benutzerdefinierten Funktion anzugeben.
Mit dem untergeordneten Element <Function-Class> wird der vollständige Java-Klasse-Name angeben.
Das untergeordnete Element <Funktionsignatur> untergeordnetes Element wird verwendet, um die Signatur einer statischen Methode in einer Java-Klasse anzugeben. Die Methodensignatur muss den Rückgabewerttyp der Methode und den Typ jedes Parameters angeben, und jeder Parameter wird durch ein Komma getrennt.
1.7. EL Vorsichtsmaßnahmen
EL -Ausdrücke sind eine Technik in der JSP 2.0 -Spezifikation. Wenn Sie El -Ausdrücke korrekt analysieren möchten, müssen Sie einen Webserver verwenden, der die Servlet2.4/jsp2.0 -Technologie unterstützt.
Hinweis: Einige Tomcat -Server können El -Ausdrücke nicht verwenden
(1) Upgrade auf Tomcat6
(2) add < %@ page iseligned = "false" %> zu jsp
1.8. EL Ausdrücke behalten Schlüsselwörter bei
Das sogenannte reservierte Wort bedeutet, dass bei der Benennung von Variablen die obigen Namen vermieden werden sollten, um Fehler während der Programmkompilierung zu vermeiden. Es gibt so viele Zusammenfassungen über den Inhalt von EL -Ausdrücken.
Der obige Inhalt liefert eine detaillierte Einführung in das relevante Wissen von Javaweb EL -Ausdrücken anhand von Beispielen. Ich hoffe, es wird Ihnen hilfreich sein. Gleichzeitig möchte ich Ihnen viel für Ihre Unterstützung für die Wulin.com -Website danken!