El nombre completo del lenguaje de expresión EL (lenguaje de expresión), que es una de las características más importantes de JSP2.0. Las expresiones EL se pueden usar para acceder a los datos en la aplicación para eliminar los scripts Java en la página JSP.
Sintaxis de la expresión de EL
Expresión, por ejemplo, x+y se puede escribir como {x+y}
Palabras clave en El
Las siguientes son palabras clave en EL, que no se pueden usar como identificadores:
y, eq, gt, verdadero, instancia, o, le, falso, vacío, no, lt, ge, null, div, mod
1. Introducción a EL Expresiones
El nombre completo de El es el lenguaje de expresión. Funciones principales de El:
1. Obtener datos
Las expresiones EL se utilizan principalmente para reemplazar las expresiones de script en las páginas JSP para recuperar objetos Java y obtener datos de varios tipos de dominios web. (Objetos en un determinado dominio web, acceder a las propiedades de Javabean, colección de listas de acceso, colección de mapas de acceso, matriz de acceso)
2. Realizar operaciones
Usando EL Expresiones, puede realizar algunas operaciones relacionales básicas, operaciones lógicas y operaciones aritméticas en la página JSP para completar algunas operaciones lógicas simples en la página JSP. $ {user == null}
3. Obtenga objetos comunes para el desarrollo web
Las expresiones EL definen algunos objetos implícitos. Usando estos objetos implícitos, los desarrolladores web pueden obtener fácilmente referencias a objetos web de uso común, obteniendo así datos en estos objetos.
4. Llame a Java Métodos
Las expresiones EL permiten a los usuarios desarrollar funciones EL personalizadas para llamar a los métodos de las clases de Java a través de las expresiones EL en las páginas JSP.
1.1. Obtener datos
Use EL Expression para obtener la sintaxis de datos: "$ {identificador}"
Cuando se ejecuta la instrucción EL de expresión, se llamará al método PageContext.FindAttribute, utilizando el identificador como la palabra clave para encontrar el objeto correspondiente en los cuatro campos de la página, la solicitud, la sesión y la aplicación. Si se encuentra, devolverá el objeto correspondiente. Si no se encuentra, devolverá "" (Tenga en cuenta que no es nulo, sino una cadena vacía).
Las expresiones EL pueden obtener fácilmente las propiedades de Javabean u obtener datos de matrices, colecciones y tipos de mapas.
Ejemplo de expresión EL para obtener datos:
<%@ 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> <toad> <title> El Expression obtiene datos </title> </head> <body> <%request.setTtribute ("nombre", "lonely wolf");%> <%-$ {name} es equivalente a pagecontex Datos: $ {name} <hr> <!-En la página JSP, use EL Expression para obtener los atributos de Bean-> <% Person P = New Person (); P.Setage (); request.SetAttribute ("Person", P);%> Use El Expression para obtener los atributos de los atributos: $ {persona. . . . . . . . . Atributos de-> <% persona persona = nueva persona (); dirección dirección = nueva dirección (); persona.setaddress (dirección); request.setAttribute ("persona", persona);%> $ {persona.address.name} <hr> <!-En la página jsp, use la expresión el para obtener los datos en la posición especificada en la recopilación de la lista-> <% persona p = nueva persona (); Canglang "); persona p = nueva persona (); p.setName (" White Tiger God Emperor "); list <Oll> list = new ArrayList <Oll> (); list.add (p); list.add (p); request.setTattribute (" list ", list);%> <!-Tome los datos en la ubicación especificada de la lista-> $ {list []. Name} <! -> <c: foreach var = "persona" elementos = "$ {list}"> $ {persona.name} </c: foreach> <hr> <!-En la página JSP, use la expresión de El para obtener los datos de la colección de mapas-> <% map <string, string> map = new = new Linkedhashmap <string, string> (); map.put ("a", "aaaaaxxx"); map.put ("b", "bbbb"); map.put ("c", "cccc"); map.put ("", "aaaa"); request.setattribute ("map", map);%> <!- obtenga los datos de la colección de mapas basadas en la colección de mapas basadas en la colección de tecla -> $ {map.c} $ {map [""]} <hr> <!-Collection de mapas iterate-> <c: foreach var = "me" elementos = "$ {map}"> $ {me.key} = $ {me.value} <br/> </c: foreach> <hr> </body> </html> El efecto de operación es el siguiente:
1.2. Ejecutar operaciones
Sintaxis: $ {Operation Expression}, El Expression admite los siguientes operadores:
1. Operadores relacionales
2. Operadores lógicos:
3. Operador vacío: verifique si el objeto es nulo (vacío)
4. Expresión binaria: $ {user! = Null? User.name: ""}
5. [] Y. operadores
Ejemplo de operaciones de realización utilizando EL expresiones:
<%@page lenguaje = "java" import = "java.util.*" PageEncoding = "utf-"%> <%@taglib uri = "http://java.sun.com/jsp/jstl/core" prefix = "c"%> <%@page import = "me.gacl.domain.user"%> <! doctypeee Html> <html> <fead> <title> El operador de expresión de El </title> </head> <body> <h> El Express realiza cuatro operaciones: </h> Operación de adición: $ {+} <br/> operación de subtracción: $ {-} <br/> Operación múltiple: $ {*} <br/> Operación dividida: $ {/} <br/> H> EL Expresión Operaciones: </h> <%-$ {user == null} y $ {user eq null}; Equivalente-%> $ {user == null} <br/> $ {user eq null} <br/> $ {user eq null} <br/> El expresión usa el operador vacío para verificar si el objeto está nulo (vacío) </h> <% list <string> list = new> nuevo = nuevo list = new> new> nuevo ArrayList <String> (); list.add ("gaCl"); list.add ("xdp"); request.setAttribute ("list", list);%> <%-use el operador vacío para verificar si el objeto es nulo (vacío)-%> <c: si test = "$ {! Vacía (lista)}"> <c: foreach var = "str" Elementos = "$ {list}"> $ {str} <br/> </c: foreach> </c: if> <br/>%list <string> vacylist = null;%> <%-use el operador vacío para verificar si el objeto es nulo (vacía)-%> <c: if test = "$ {vacía (vacilista)}" Lo siento, no hay datos que desee que usted desee que usted desee que usted desee que usted desee que usted desee que usted desee que usted desee que usted desee que usted desee que usted desee Consulte </c: if> <br/> <h> Las expresiones binarias se utilizan en EL expresiones </h> <% session.setAttribute ("usuario", nuevo usuario ("ganglang solitario"));%> $ {user == null? "Lo siento, no ha iniciado sesión": user.username} <br/> <h> El expresión data de expresión echo </h> <% user user = new user (); user.setgender ("masculino"); // data echo request.setAttribute ("user", user);%> <input type = "radio" name = "valor" valor = "masculino" "masculino" " $ {user.gender == 'masculino'? 'Checked': ''}> macho <input type = "radio" name = "gender" value = "femenino" $ {user.gender == 'femenino'? 'verificado': ''}> femenino <br/> </body> </html>Los resultados de la operación son los siguientes:
1.3. Obtener objetos comunes para el desarrollo web
El lenguaje de expresión EL define 11 objetos implícitos. El uso de estos objetos implícitos puede obtener fácilmente algunos objetos comunes en el desarrollo web y leer los datos de estos objetos.
Sintaxis: $ {nombre de objeto implícito}: Obtenga una referencia al objeto
Prueba 11 objetos implícitos en EL expresiones:
<%@ page lenguaje = "java" import = "java.util.*" PageEncoding = "Utf-"%> <! DocType html> <html> <fead> <title> El implícito objeto </title> </head> <body> <br/> ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- ------------------------------------------------------------------------------------------- //map%>$ =pagescope.name} <br/> --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- --------------------------------------------------------------------------------------------------- //map%>$ =sessionscope.user} <br/> ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ --------------------------------------------------------------------------------------------------- Esta expresión se usa a menudo en los ecoes de datos -> <Form Action = "$ {PageContext.Request.ContextPath}/Servlet/RegisterServlet" Method = "Post"> <input type = "text" name = "username" valor = "$ {param.username}"> <input type = "someter" value = "registrar"> </form> <br/> --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- ------------------------------------------------------------------------------------------- http: // localhost: /Javaweb_el_study_/eldemo.jsp? Mean <br/> ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- Ejemplo de aceptación de aceptación, headerValues["Accept-Encoding"]--%>${header["Accept-Encoding"]}<br/>-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- --------------------------------------------------------------------------------------------------- Un objeto de mapa que almacena todos los campos de encabezado de solicitud HTTP. Para un parámetro de solicitud, devuelve una matriz de cadena []. Por ejemplo: Headervalues.accept devuelve una matriz de cadena []. Headervalues.accept [] elimina el primer valor en la matriz-%> $ {Headervalues.accept []} <br/> <%-$ {Headervalues.accept-entering} Al escribir de esta manera, se informará un error al probar los avalores de aves de aviso. Si hay "-" en el encabezado, como la aceptación de la codificación, los avalores ["aceptar"] los avalues ["aceptación de aceptación"] [] devuelve una matriz de cadena []. Headervalues ["Aceptar-codificación"] [] [] elimina el primer valor en el Array-%> $ {Headervalues ["Aceptar-Engoding"] []} <br/> -------------------------------------------------------------------------------------------------------------------------------------------- ----------------------------------------------------------------------------------------------- -> $ {cookie.jsessionid.value} // Guardar mapa de todos Cookies <br/> ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ ------------------------------------------------------------------------------------------- Configurar los parámetros de inicialización en el archivo web.xml -> <context-param> <amamname> xxx </param-name> <amam-value> aayyy </param-value> </textel-param> <context-param> <amamname> root </param-name> <amam-value>/javaweb_el_study _ </marc param-value> </context-param>-%> <%- Parámetros de inicialización -%> $ {initParam.xxx} <br/> $ {initParam.root} </body> </html> El Código de RegisterServlet es el siguiente:
paquete me.gacl.web.controller; import java.io.ioException; import javax.servlet.servletException; import javax.servlet.http.httpservlet; import javax.servlet.http.httpservletRequest; import javax.servlet.http.htpservletTrepelSeSponseRes extiende httpservlet {/** métodos para manejar el registro del usuario*/public void doget (httpservletRequest solicitud, httpServletResponse Respuesta) lanza ServletException, ioException {//, recibe la cadena de parámetros Username = request.getParameter ("UserName");/***, saltar a /eldemo.jspel, no use la página, no use request.SetAttribute ("UserName", UserName) para almacenar el nombre de usuario en el objeto de solicitud* Sin embargo, en la página ElDemo.jsp, puede usar $ {param.username} para obtener el valor del parámetro de nombre de usuario en el objeto de solicitud*/request.getRequestDispAcher ("/eldemo.jsp"). Solicitud, respuesta httpservletResponse) lanza ServletException, ioException {doget (solicitud, respuesta);}} Los resultados de la prueba son los siguientes:
Aviso:
Al probar el encabezado y los avalores, si hay "-" en el encabezado, como la aceptación de la aceptación, el encabezado ["Aceptación"] y los avalores ["Aceptar"]]
Al probar cookies, por ejemplo, $ {cookie.key} toma un objeto de cookie. Si accede al nombre y al valor de la cookie, debe tener $ {cookie.key.name} o $ {cookie.key.value}
1.4. Llame a los métodos Java utilizando EL
EL Expression Syntax permite a los desarrolladores desarrollar funciones personalizadas para llamar a los métodos de las clases de Java. Sintaxis: $ {prefijo: método (params)}
Lo único que se puede llamar en la expresión EL es el método estático de la clase Java. El método estático de esta clase Java debe describirse en el archivo TLD antes de que pueda ser llamado por la expresión EL.
Las funciones personalizadas se utilizan para extender las funciones de las expresiones EL, lo que permite que EL expresiones complete las funciones que puede completar el código del programa Java ordinario.
1.5. Pasos de desarrollo de la función EL
En términos generales, el desarrollo y la aplicación de las funciones personalizadas incluyen los siguientes tres pasos:
1. Escribe un método estático de una clase Java
2. Escriba un archivo de descriptor de biblioteca de etiquetas (TLD) y describa las funciones personalizadas en el archivo TLD.
3. Importar y usar funciones personalizadas en la página JSP
Ejemplo: Desarrollo de la función EL para escapar de las etiquetas HTML
1. Escriba la clase de herramienta de procesamiento de escape HTML y agregue métodos de procesamiento estático para escapar de las etiquetas HTML en la clase de herramientas, de la siguiente manera:
paquete me.gacl.util;/*** @classname: htmlfilter* @Description: Html Escape Processing Tool Clase* @Author: Lonely CANGLANG* @DATE: - Morning :: **/public class htmlfilter {/*** @method: Filter* @Description: Methode static, etiquetado Html Escudo para escapar* @return content después de escapar*/ public static string filtre (string message) {if (message == null) return (null); char content [] = new char [message.length ()]; message.getchars (, mensaje.length (), content,); stringBuffer resultado = new StringBuffer (content.lengthy+); '<': result.append ("<"); break; case '>': result.append (">"); break; case '&': result.append ("&"); break; case '"': result.append ("); break; default: result.append (content [i]);}} return (result.toString ();}}}}}}2. Escriba un archivo de descriptor de biblioteca de etiquetas (TLD) en el directorio web-INF y describe las funciones personalizadas en el archivo TLD.
El código de elfunction.tld es el siguiente:
<? xml versión = "." encoding = "utf-"?> <taglib versión = "." xmlns = "http://java.sun.com/xml/ns/jee" xmlns: xsi = "http://www.w.org//xmlschemainstance" xsi: schemalocation = "http://java.sun.com/xml/ns/jeee web-jsptaglibrary __. xsd "> <tlib-version>. </tlib-version> <tort-name> el function </ short-name> <!-Uri de referencia para una biblioteca de funciones El El ElectEn se puede citar de esta -> <Uri>/elfunction </sii> <!-<sole> El elemento se usa para describir una función personalizada-> <función> <Scuion> HTML Tag Escape Processing Method </cription> <!-<name> El elemento infantil se usa para especificar el nombre de la función EL personalizada-> <name> Filtro </name> <!-<sefunte-Class> El elemento infantil se usa para especificar el nombre de clase Java Java -> <funional-class> me.gacl.util.htmlfilter </funional-class> <!-<signature> El elemento infantil se usa para especificar la firma del método estático en la clase Java. La firma del método debe indicar el tipo de valor de retorno del método y el tipo de cada parámetro, y cada parámetro está separado por una coma. -> <funional-Signature> java.lang.String Filter (java.lang.string) </function-Signature> </function> </taglib>
3. Importar y usar funciones personalizadas en la página JSP
<%@ page lenguaje = "java" import = "java.util.*" pageEncoding = "utf-"%> <%-Introducción de la biblioteca de funciones personalizadas-%> <%@ taglib uri = "/elfunction" prefix = "fn"%> <! DOCTYPE HTML> <html> <foad> <foad> <title> llamando a Java Métodos usando Java usando Java Usando El </title> </head> <body> <%-llamando métodos de filtro usando el-%> $ {fn: filtre ("<a href = ''> diand </a>")} </body> </html> Los resultados de la operación son los siguientes:
1.6. Cosas a tener en cuenta al desarrollar la función EL
Después de escribir el archivo de descripción de la biblioteca de etiquetas, debe colocarlo en el directorio <Sto web Application>/Web-INF o cualquier subdirectorios, excepto clases y directorios LIB en el directorio Web-INF.
El elemento <URI> en el archivo TLD utiliza el URI que especifica el archivo TLD. Este URI debe usarse para introducir el archivo de descripción de la biblioteca de etiquetas en el archivo JSP.
El elemento <sole> se usa para describir una función personalizada, donde:
El elemento <name> Child se usa para especificar el nombre de la función personalizada.
El elemento infantil <sole-class> se usa para especificar el nombre completo de la clase Java.
El elemento <signature> Child se utiliza para especificar la firma de un método estático en una clase Java. La firma del método debe indicar el tipo de valor de retorno del método y el tipo de cada parámetro, y cada parámetro está separado por una coma.
1.7. El precauciones
Las expresiones EL son una técnica en la especificación JSP 2.0. Por lo tanto, si desea analizar correctamente las expresiones EL, debe usar un servidor web que admita la tecnología Servlet2.4/JSP2.0.
Nota: Algunos servidores Tomcat no pueden usar EL Expresiones
(1) Actualice a Tomcat6
(2) Agregar < %@ página isElignored = "falso" %> a JSP
1.8. EL expresiones retiene palabras clave
La llamada palabra reservada significa que al nombrar variables, se deben evitar los nombres anteriores para evitar errores durante la compilación del programa. Hay tantos resúmenes sobre el contenido de las expresiones EL.
El contenido anterior proporciona una introducción detallada al conocimiento relevante de las expresiones de Javaweb El a través de ejemplos. Espero que te sea útil. Al mismo tiempo, me gustaría agradecerle mucho por su apoyo al sitio web de Wulin.com.