Le nom complet d'El est le langage d'expression (langage d'expression), qui est l'une des caractéristiques les plus importantes de JSP2.0. Les expressions EL peuvent être utilisées pour accéder aux données de l'application pour éliminer les scripts Java dans la page JSP.
Syntaxe de l'expression EL
Expression par exemple, x + y peut être écrit comme {x + y}
Mots-clés dans El
Voici les mots clés dans EL, qui ne peuvent pas être utilisés comme identifiants:
et, eq, gt, vrai, instanceof, ou, le, false, vide, pas, lt, ge, null, div, mod
1. Introduction aux expressions EL
Le nom complet d'El est le langage d'expression. Fonctions principales d'El:
1. Obtenez des données
Les expressions EL sont principalement utilisées pour remplacer les expressions de script dans les pages JSP pour récupérer des objets Java et obtenir des données à partir de différents types de domaines Web. (Objets dans un certain domaine Web, Access Javabean Properties, Collection de liste d'accès, collection de cartes d'accès, tableau d'accès)
2. Effectuer des opérations
En utilisant les expressions EL, vous pouvez effectuer des opérations relationnelles de base, des opérations logiques et des opérations arithmétiques dans la page JSP pour effectuer des opérations logiques simples dans la page JSP. $ {user == null}
3. Obtenez des objets communs pour le développement Web
Les expressions EL définissent certains objets implicites. En utilisant ces objets implicites, les développeurs Web peuvent facilement obtenir des références à des objets Web couramment utilisés, obtenant ainsi des données dans ces objets.
4. Appelez les méthodes Java
Les expressions EL permettent aux utilisateurs de développer des fonctions EL personnalisées pour appeler les méthodes de classes Java via les expressions EL dans les pages JSP.
1.1. Obtenir des données
Utilisez l'expression El pour obtenir la syntaxe des données: "$ {identifiant}"
Lorsque l'instruction El Expression est exécutée, la méthode PageContext.FindAttribute sera appelée, en utilisant l'identifiant comme mot-clé pour trouver l'objet correspondant des quatre champs de page, de demande, de session et d'application. S'il est trouvé, il renverra l'objet correspondant. S'il n'est pas trouvé, il reviendra "" (notez qu'il n'est pas nul, mais une chaîne vide).
Les expressions EL peuvent facilement obtenir des propriétés Javabean ou obtenir des données de tableaux, de collections et de types de cartes.
Exemple d'expression EL pour obtenir des données:
<%@ page language="java" import="java.util.*" pageEncoding="UTF-"%><%@taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %><%@page import="me.gacl.domain.Person"%><%@page import = "me.gacl.domain.address"%> <! doctype html> <html> <ead> <itle> el expression obtient des données </title> </ad> <pody> <% request.setAttribute ("name", "Lonely Wolf"); %> Données: $ {name} <hr> <! - Dans la page JSP, utilisez l'expression El pour obtenir les propriétés du bean -> <% personne p = new Person (); p.Setage (); request.setAttribute ("Person", p);%> Utiliser l'expression El pour obtenir les propriétés de l'expression Bean: $ {Person.age} <hr> <! . . . . . . . . Attributs de -> <% Person Person = new Person (); adresse Adresse = new Address (); Person.SetAddress (Adresse); request.setAttribute ("Person", Person);%> $ {Person.address.name} <hr> <! - Dans la page JSP, utilisez l'expression EL pour obtenir les données de la position spécifiée dans la collection de listes -> <% Personne P = New Person (); CanGlang "); personne p = new Person (); p.SetName (" White Tiger God Emperor "); list <onon> list = new ArrayList <onon> (); list.add (p); list.add (p); request.setAttribute (" list ", list);%> <! - Prenez les données de la liste spécifiée de la liste -> $ {list [].. -> <c: foreach var = "personne" items = "$ {list}"> $ {personne.name} </c: foreach> <hr> <! - Dans la page JSP, utilisez l'expression el pour obtenir les données de la collection de cartes -> <% map <string, string> map = new LinkedHashmap <String, String> (); map.put ("a", "aaaaxxx"); map.put ("b", "bbbb"); map.put ("c", "cccc"); map.put ("", "aaaa"); request.setAttribute ("map", map);%> <! -> $ {map.c} $ {map [""]} <hr> <! - Iterate Map Collection -> <c: foreach var = "me" items = "$ {map}"> $ {me.key} = $ {me.value} <br/> </ c: forach> <hr> </ / body> </html> L'effet de fonctionnement est le suivant:
1.2. Exécuter les opérations
Syntaxe: $ {Operation Expression}, El Expression prend en charge les opérateurs suivants:
1. Opérateurs relationnels
2. Opérateurs logiques:
3. Opérateur vide: Vérifiez si l'objet est nul (vide)
4. Expression binaire: $ {utilisateur! = Null? User.name: ""}
5. [] Et. opérateurs
Exemple d'exécution d'opérations à l'aide d'expressions EL:
<% @ page Language = "java" import = "java.util. *" pageencoding = "utf -"%> <% @ taglib uri = "http://java.sun.com/jsp/jstl/core" prefix = "c"%> <% @ page import = "me.gacl.domain.user"%> <! doctype doctype HTML> <HTML> <A-HEAD> <TITLE> EL Expression Opérateur </TITAL> </ Head> <Body> <H> EL L'expression effectue quatre opérations: </h> Opération d'addition: $ {+} <br/> Soustraction Opération: $ {-} <br/> Fonctionnement multiple: $ {*} <br/> Fonctionnement de division: $ {/} <br/> H> El Expression Relation Effective Relations opérations: </h> <% - $ {user == null} et $ {user eq null}; Équivalent -%> $ {user == null} <br/> $ {user eq null} <br/> $ {user eq null} <br/> el expression utilise l'opérateur vide pour vérifier si l'objet est null (vide) </h> <% list <string> list = new ArrayList <String> (); list.add ("gacl"); list.add ("xdp"); request.setAttribute ("list", list);%> <% - utilisez l'opérateur vide pour vérifier si l'objet est nul (vide) -%> <c: if test = "$ {! Vide (list)}"> <c: Foreach var = "Str" Items = "$ {list}"> $ {str} <br/> </c: foreach> </ c: if> <br/>% list <string> videList = null;%> <% - Utilisez l'opérateur vide pour vérifier si l'objet est null (vide) -%> <c: if test = "$ {vide (videList)}"> désolé, il n'y a pas de données que vous voulez voir </ c: Les expressions sont utilisées dans EL Expressions </H> <% session.setAttribute ("utilisateur", nouvel utilisateur ("Lonely Ganglang"));%> $ {user == null? "Désolé, vous n'êtes pas connecté": user.Username} <br/> <h> el Expression Data echo </ h> <% User utilisateur = new user (); user.setgender ("mâle"); // data echo request.setattribute ("user", user);%> <intry type = "radio" name = "gender" value = "male" " $ {user.gender == 'mâle'? 'Checked': ''}> mâle <input type = "radio" name = "Gender" value = "feme" $ {user.gender == 'feme "?Les résultats de l'opération sont les suivants:
1.3. Obtenir des objets communs pour le développement Web
El Expression Language définit 11 objets implicites. L'utilisation de ces objets implicites peut facilement obtenir des objets communs dans le développement Web et lire les données de ces objets.
Syntaxe: $ {nom d'objet implicite}: Obtenez une référence à l'objet
Test 11 objets implicites dans les expressions EL:
<% @ page linguistique = "java" import = "java.util. *" pageencoding = "utf -"%> <! doctype html> <html> <adread> <itle> el implicit Objet </Title> </-head> <body> <br/> --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- //map%>$$ {pagescope.name} <br/> --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- //map%>$$ {ssesionscope.user} <br/> --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- Cette expression est souvent utilisée sur les échos de données -> <formulaire forme = "$ {pagecontext.request.contextPath} / servlet / registreservlet" metheth = "post"> <input type = "text" name = "username" value = "$ {param.username}"> <entrée type = "soumis" Value = "Registre"> </ Form> <br/> ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- http: // localhost: /javaweb_el_study_/eldemo.jsp? like = aaa & like = bb -> $ {paramvalues.like []} $ {paramvalues.like []} <br/> --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- Exemple d'acceptation de codage, headerValues["Accept-Encoding"]--%>${header["Accept-Encoding"]}<br/>-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- Un objet MAP qui stocke tous les champs d'en-tête de demande HTTP. Pour un paramètre de demande, il renvoie un tableau de chaîne []. Par exemple: Headervalues.Accept Renvoie un tableau de chaîne []. Headervalues.Accept [] supprime la première valeur dans le tableau -%> $ {Herevalues.Accept []} <br/> <% - $ {Herevalues.Accept-Encoding} Lors de l'écriture de cette façon, une erreur sera signalée lors du test de Headrand. S'il y a "-" dans l'en-tête, comme le codage d'acceptation, Headervalues ["Accept-Encoding"] Headservalues ["Accept-Encoding"] [] Renvoie un tableau de chaîne []. Headservalues ["Accept-Encoding"] [] [] supprime la première valeur dans le Array -%> $ {Headervalues ["Accept-Encoding"] []} <br/> ------------------------------------------------------------------------------------------------------------------------------------------------- ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- -> $ {cookie.jSessionId.value} // Enregistrer la carte de tous cookies<br/>------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- Configurer les paramètres d'initialisation dans le fichier web.xml -> <context-param> <param-name> xxx </ param-name> <param-valie> yyyy </ param-valeur> </ context-param> <ftext-param> <param-name> root </ param-name> <param-valie> / javaweb_el_study _ </ param-value> </param> -%> <% Paramètres d'initialisation -%> $ {initparam.xxx} <br/> $ {initparam.root} </ body> </html> Le code de Registerservlet est le suivant:
Package Me.gacl.web.Controller; Import Java.io.ioException; Importer Javax.servlet.servletException; Importer Javax.servlet.http.httpservlet; Importer Javax.servlet.http.httServletReSerSerSerSerSerSerger étend httpsservlet {/ * * Méthodes pour gérer l'enregistrement des utilisateurs * / public void doGet (httpservletRequest request, httpservletResponse réponse) lance le servletException, ioException {//, recevoir un paramètre userName = request.getParamètre ("username"); / ***, sauter en arrière vers /lDemo.jsp request.setAttribute ("nom d'utilisateur", nom d'utilisateur) Pour stocker le nom d'utilisateur dans l'objet de demande * Cependant, dans la page eldemo.jsp, vous pouvez utiliser $ {param.username} pour obtenir la valeur du paramètre de nom d'utilisateur dans l'objet de la demande * / request.getRequestDispatcher ("/ eldemo.jsp"). Request, HttpServletResponse Response) lève ServletException, ioException {doGet (demande, réponse);}} Les résultats des tests sont les suivants:
Avis:
Lors du test de l'en-tête et de l'assistance, s'il y a "-" dans l'en-tête, comme le codage d'acceptation, l'en-tête ["Accept-Encoding"] et Headrservalues ["Accept-Encoding"]
Lors du test des cookies, par exemple, $ {cookie.key} prend un objet cookie. Si vous accédez au nom et à la valeur du cookie, vous devez avoir $ {cookie.key.name} ou $ {cookie.key.value}
1.4. Appelez les méthodes Java en utilisant El
La syntaxe El Expression permet aux développeurs de développer des fonctions personnalisées pour appeler des méthodes de classes Java. Syntaxe: $ {préfixe: méthode (params)}
La seule chose qui peut être appelée dans l'expression EL est la méthode statique de la classe Java. La méthode statique de cette classe Java doit être décrite dans le fichier TLD avant de pouvoir être appelé par l'expression EL.
Les fonctions personnalisées EL sont utilisées pour étendre les fonctions des expressions EL, permettant aux expressions EL de remplir les fonctions que le code de programme Java ordinaire peut compléter.
1.5. Étapes de développement des fonctions el
D'une manière générale, le développement et l'application des fonctions personnalisées EL comprennent les trois étapes suivantes:
1. Écrivez une méthode statique d'une classe Java
2. Écrivez un fichier de descripteur de bibliothèque de balises (TLD) et décrire les fonctions personnalisées dans le fichier TLD.
3. Importez et utilisez des fonctions personnalisées dans la page JSP
Exemple: Développement de la fonction EL pour échapper aux balises HTML
1. Écrivez la classe d'outils de traitement HTML Escape et ajoutez des méthodes de traitement statiques pour échapper aux balises HTML dans la classe d'outils, comme suit:
Package me.gacl.util; / *** @classname: htmlfilter * @description: html Escape Processing Tool class * @author: Lonely CanGlang * @Date: - Morning :: ** / public class htmlfilter {/ *** @Method: Filter * @description: Htmlfil Contenu pour échapper * @return Contenu après Escape * / Public Static String Filter (String Message) {if (message == null) return (null); char contenu [] = new Char [message.length ()]; message.getchars (, message.length (), contenu,); stringBuffer result = new StringBuffer (contenu.Length +); pour (int i =; i <i <Lengthy {case '<': result.append ("<"); casse; case '>': result.append (">"); break; case '&': result.append ("&"); break; case '"': result.append (" "); Break2. Écrivez un fichier de descripteur de bibliothèque de balises (TLD) dans le répertoire Web-inf et décrire les fonctions personnalisées dans le fichier TLD.
Le code d'Elfonction.tld est le suivant:
<? xml version = "." Encoding = "UTF -"?> <Taglib version = "." xmlns = "http://java.sun.com/xml/ns/jee" xmlns: xsi = "http://www.w.org//xmlschema-instance" xsi: schemalocation = "http://java.sun.com/xml/ns/Jee web-jsptaglibrary __. xsd "> <tlib-version>. </ tlib-Version> <frut-name> el function </ short-name> <! - Un uri de référence pour une bibliothèque de fonctions el personnalisée peut être cité comme ceci dans une page jsp: <% @ taglib uri =" / elfonction "préfix =" fn "%> -> <uri> / elfonction </urri> <! - <Fonction> L'élément est utilisé pour décrire une fonction El personnalisée -> <ponction> <description> HTML TAGE ESAPET Method </, Description> <! - <name> L'élément enfant est utilisé pour spécifier le nom de la fonction El personnalisée -> <name> Filter </name> <! - <Fonction-Class> L'élément enfant est utilisé pour spécifier le Java Class Java Complete Java -> <fonction-classe> me.gacl.util.htmlfilter </ function-class> <! - <function-signature> L'élément enfant est utilisé pour spécifier la signature de la méthode statique dans la classe Java. La signature de la méthode doit indiquer le type de valeur de retour de la méthode et le type de chaque paramètre, et chaque paramètre est séparé par une virgule. -> <function-signature> java.lang.string filter (java.lang.string) </punction-signature> </ function> </gaglib>
3. Importez et utilisez des fonctions personnalisées dans la page JSP
<%@ page language="java" import="java.util.*" pageEncoding="UTF-"%><%--Introducing EL custom function library--%><%@taglib uri="/ELFunction" prefix="fn" %><!DOCTYPE HTML><html><head><title>Calling Java methods using El </title> </ head> <body> <% - appelant des méthodes de filtre en utilisant el -%> $ {fn: filter ("<a href = ''> diand </a>")} </body> </html> Les résultats de l'opération sont les suivants:
1.6. Choses à noter lors du développement de la fonction EL
Après avoir écrit le fichier de description de la bibliothèque de balises, vous devez le placer dans n'importe quel sous-répertoire, sauf les classes et les répertoires lib dans le répertoire <web application> / web-inf ou dans le répertoire Web-infr.
L'élément <URI> du fichier TLD utilise l'uri qui spécifie le fichier TLD. Cet URI doit être utilisé pour introduire le fichier de description de la bibliothèque de balises dans le fichier JSP.
L'élément <fonction> est utilisé pour décrire une fonction EL personnalisée, où:
L'élément enfant <nom> est utilisé pour spécifier le nom de la fonction EL Custom.
L'élément d'enfant <-Class>> est utilisé pour spécifier le nom complet de la classe Java.
L'élément d'enfant <function-signature> est utilisé pour spécifier la signature d'une méthode statique dans une classe Java. La signature de la méthode doit indiquer le type de valeur de retour de la méthode et le type de chaque paramètre, et chaque paramètre est séparé par une virgule.
1.7. El Précautions
Les expressions EL sont une technique dans la spécification JSP 2.0. Par conséquent, si vous souhaitez analyser correctement les expressions EL, vous devez utiliser un serveur Web qui prend en charge la technologie Servlet2.4 / JSP2.0.
Remarque: certains serveurs Tomcat ne peuvent pas utiliser les expressions EL
(1) passer à Tomcat6
(2) Ajouter <% @ page iselignored = "false"%> à jsp
1.8. Les expressions EL conservent les mots clés
Le mot soi-disant réservé signifie que lors des variables de nommage, les noms ci-dessus doivent être évités pour éviter les erreurs pendant la compilation du programme. Il y a tellement de résumés sur le contenu des expressions EL.
Le contenu ci-dessus fournit une introduction détaillée aux connaissances pertinentes des expressions Javaweb EL à travers des exemples. J'espère que cela vous sera utile. En même temps, je voudrais vous remercier beaucoup pour votre soutien pour le site Web de Wulin.com!