O nome completo de El é a linguagem de expressão (linguagem de expressão), que é um dos recursos mais importantes do JSP2.0. As expressões de EL podem ser usadas para acessar dados no aplicativo para eliminar os scripts Java na página JSP.
Sintaxe da expressão de EL
Expressão, por exemplo, x+y pode ser escrita como {x+y}
Palavras -chave em El
A seguir, as palavras -chave no EL, que não podem ser usadas como identificadores:
e, Eq, GT, True, Instância, OR, Le, False, vazio, não, LT, GE, NULL, DIV, Mod
1. Introdução às expressões de EL
O nome completo de El é a linguagem de expressão. As funções principais de El:
1. Obtenha dados
As expressões de EL são usadas principalmente para substituir as expressões de script nas páginas JSP para recuperar objetos Java e obter dados de vários tipos de domínios da Web. (Objetos em um determinado domínio da web, acessar as propriedades Javabean, coleta de listas de acesso, coleta de mapas de acesso, matriz de acesso)
2. Execute operações
Usando expressões EL, você pode executar algumas operações relacionais básicas, operações lógicas e operações aritméticas na página JSP para concluir algumas operações lógicas simples na página JSP. $ {user == null}
3. Obtenha objetos comuns para o desenvolvimento da Web
Expressões de EL definem alguns objetos implícitos. Usando esses objetos implícitos, os desenvolvedores da Web podem obter facilmente referências a objetos da Web comumente usados, obtendo dados nesses objetos.
4. Ligue para os métodos java
As expressões de EL permitem que os usuários desenvolvam funções EL personalizadas para chamar métodos de aulas de Java por meio de expressões EL nas páginas JSP.
1.1. Obter dados
Use a expressão de EL para obter a sintaxe de dados: "$ {identificador}"
Quando a instrução EL Expression for executada, o método PageContext.findattribute será chamado, usando o identificador como palavra -chave para encontrar o objeto correspondente dos quatro campos de página, solicitação, sessão e aplicativo. Se for encontrado, ele retornará o objeto correspondente. Se não for encontrado, retornará "" (observe que não é nulo, mas uma string vazia).
As expressões de EL podem obter facilmente as propriedades Javabean ou obter dados de matrizes, coleções e tipos de mapas.
Exemplo de expressão de EL para obter dados:
<%@Page Language = "java" import = "java.util. import = "me.gacl.domain.address"%> <! Doctype html> <html> <head> <title> el expressão recebe dados </ititure> </ad Head> <body> <%request.setAttribute (name "," solene Wolf ");%> <%-$ {name} é equivalente a PageCenti" Dados: $ {nome} <hr> <!-Na página JSP, use a expressão de EL para obter as propriedades do feijão-> <% Pessoa p = new Person (); p.setage (); request.setAttribute ("Pessoa", P); PELEATE ELS ATRESENTS <! . . . . . . . . Atributos de-> <% pessoa pessoa = new pessoa (); endereço endereço = novo endereço (); pessoa. Canglang "); pessoa p = new Person (); p.setName (" Imperador de Deus do Tigre Branco "); List <Soper> list = new ArrayList <Pesso> (); list.add (p); list.add (P); Pedido.SetAttribute (" List ", List);%> <!-Tome os dados especificados! -> <c: foreach var = "pessoa" itens = "$ {list}"> $ {Person.name} </c: foreach> <hr> <!-Na página jsp, use a expressão EL para obter os dados da coleção de mapas-> <% map <string, string> map = new LinkedHashMap <String, String> (); map.put ("A", "aaaaxxx"); map.put ("b", "bbbb"); map.put ("c", "cccc"); map.put ("", "AAAA"); -> $ {map.c} $ {map [""]} <hr> <!-itera coleta de mapas-> <c: foreach var = "me" itens = "$ {map}"> $ {me.key} = $ {me.value} <br/> </c: foreach O efeito de operação é o seguinte:
1.2. Executar operações
Sintaxe: $ {Operação Expressão}, El Expression suporta os seguintes operadores:
1. Operadores relacionais
2. Operadores lógicos:
3. Operador vazio: verifique se o objeto é nulo (vazio)
4. Expressão binária: $ {user! = Null? User.name: ""}
5. [] e. operadores
Exemplo de execução de operações usando expressões EL:
<%@Page Language = "java" import = "java.util. Html> <html> <head> <title> o operador de expressão </ititle> </ad Head> <body> <h> EL Expressão executa quatro operações: </h> operação de adição: $ {+} <br/> Operação de subtração: $ {-} <br/> operação múltipla: $ {*} <br/> Divide: $ {-} <br/> operação múltipla: $ {*} <br/> Operações: </h> <%-$ {user == null} e $ {user eq null}; Equivalente-%> $ {user == null} <br/> $ {user eq null} <br/> $ {user eq null} <br/> EL Expression usa o operador vazio para verificar se o objeto é nulo (vazio) </h> <% list <sting> list = new) ArrayList <String> (); list.add ("gacl"); list.add ("xdp"); request.setAttribute ("list", list);%> <%-use o operador vazio para verificar se o objeto é nulo (vazio)-%> <c: se test = "$ {! Itens = "$ {list}"> $ {str} <br/> </c: foreach> </c: if> <br/>%list <string> emppylist = null;%> <%-use o operador vazio para verificar se o objeto é nulo (vazio)-%> <c: se testar = "$ {vazio (esvaziar) Consulte </c: se> <br/> <h> expressões binárias são usadas em expressões el </h> <% session.setAttribute ("user", novo usuário ("solitário ganglang");%> $ {user == null? "Desculpe, você não está conectado": user.username} <br/> <h> el> Expression Data Echo </h> <% user user = new user (); user.setGender ("masculino"); // eco de dados request.setAttribute ("user", usuário);%> <input Type = "Radio" name = "Gender" $ {user.gnder == 'masculino'?Os resultados da operação são os seguintes:
1.3. Obtenha objetos comuns para o desenvolvimento da Web
A linguagem de expressão de EL define 11 objetos implícitos. O uso desses objetos implícitos pode obter facilmente alguns objetos comuns no desenvolvimento da Web e ler os dados desses objetos.
Sintaxe: $ {Nome do objeto implícito}: Obtenha uma referência ao objeto
Teste 11 Objetos implícitos nas expressões EL:
<%@ Page Language = "java" import = "java.util.*" PageEncoding = "utf-"%> <! Objeto </title> </head> <body> <br/> ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- //map%>$ {pagescope.name} <br/> ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- //map%>$ {sessionscope.user} <br/> -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- Essa expressão é frequentemente usada em ecos de dados -> <formulário = "$ {PagEContext.Request.ContextPath}/servlet/RegisterServlet" Method = "post"> <input type = "text" name = "userName" value = "$ {param.username}"> <input type = "submarina" Value = "Register"> </morm> <br/> -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- http: // localhost: /javaweb_el_study_/eldemo.jsp? like = aaa & like = bb -> $ {paramvalues.like []} $ {paramvalues.like []} <br/>---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- , for Exemplo de aceitação de aceitação, HeadValues ["aceitar-se-codificação"]-%> $ {header ["aceitar-codificação"]} <br/> ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- Um objeto de mapa que armazena todos os campos de cabeçalho de solicitação HTTP. Para um parâmetro de solicitação, ele retorna uma matriz String []. Por exemplo: headavalues.accept retorna uma matriz de string []. HeadValues.accept [] Recebe o primeiro valor na matriz-%> $ {headservalues.accept []} <br/> <%-$ {headservalues.accept-coding} Ao escrever dessa maneira, um erro será relatado ao testar os cabeçalhos. Se houver "-" no cabeçalho, como codificação de aceitação, HeadValues ["aceitar-codificação"] HeadValues ["aceitar-codificação"] [] retorna uma matriz de string []. Headservalues ["Acepcodinging"] [] [] retira o primeiro valor no Array-%> $ {headerservalues ["Acepcodinging"] []} <br/> ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ -> $ {cookie.jsessionId.value} // Salvar mapa de todos Cookies <br/> -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- Configurar parâmetros de inicialização no arquivo web.xml -> <Context-Param> <amam-name> xxx </param-name> <amam-value> yyyy </param-value> </context-paparam> <context-param> <amam-name> root </param-name> <amam-value>/javaweb_study _xtretle% Parâmetros -%> $ {initParam.xxx} <br/> $ {initparam.root} </body> </html> O Código do RegisterServlet é o seguinte:
package 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.HttpServletResponse;public class RegisterServlet estende HttPServlet {/** Métodos para lidar com o registro do usuário*/public void Doget (solicitação HttpServletRequest, httpServletResponse resposta) lança servletexception, ioexception {//, receba parameter string userName = request.GeParameter ("usenamem");/*** request.setAttribute ("nome de usuário", nome de usuário) para armazenar o nome de usuário no objeto de solicitação* No entanto, na página Eldemo.jsp, você pode usar $ {param.username} para obter o valor do parâmetro de usernome no objeto de solicitação*/requestRequestEngher ("/elDemoOP.JSPs. Solicitação, HttpServletResponse Response) lança servletexception, ioexception {Doget (solicitação, resposta);}} Os resultados dos testes são os seguintes:
Perceber:
Ao testar o cabeçalho e os headers, se houver "-" no cabeçalho, como aceitar o codificação, cabeçalho ["aceitar-codificação"] e headerservalues ["aceitar-codificação"]
Ao testar cookies, por exemplo, $ {cookie.key} leva um objeto de cookie. Se você acessar o nome e o valor do cookie, deve ter $ {cookie.key.name} ou $ {cookie.key.value}
1.4. Ligue para os métodos Java usando El
A sintaxe da expressão de EL permite que os desenvolvedores desenvolvam funções personalizadas para chamar métodos de classes Java. Sintaxe: $ {prefix: método (params)}
A única coisa que pode ser chamada na expressão de EL é o método estático da classe Java. O método estático desta classe Java precisa ser descrito no arquivo TLD antes que ele possa ser chamado pela expressão de EL.
As funções personalizadas do EL são usadas para estender as funções das expressões EL, permitindo que as expressões de EL concluam funções que o código do programa Java comum pode concluir.
1.5. Etapas de desenvolvimento de funções de EL
De um modo geral, o desenvolvimento e a aplicação das funções personalizadas do EL incluem as três etapas a seguir:
1. Escreva um método estático de uma classe Java
2. Escreva um arquivo de descritor da biblioteca de tags (TLD) e descreva funções personalizadas no arquivo TLD.
3. Importar e usar funções personalizadas na página JSP
Exemplo: Desenvolvendo a função EL para escapar das tags HTML
1. Escreva a classe de ferramentas de processamento de escape HTML e adicione métodos de processamento estático para escapar das tags HTML na classe de ferramentas, como segue:
pacote me.gacl.util;/*** @className: htmlfilter* @description: html escape Processing Tool Class* @author: solly canglang* @date: - morning :: **/public class Metod. @Param Mensagem Conteúdo para escapar* @return Content após escape*/ public static string filter (string message) {if (message == null) return (null); char content [] = new char [message.length ()]; message.getchars (message.length (), content,); stringbuffer i); (content [i]) {case '<': resultado.append ("<"); quebra; case '>': resultado.append (">"); quebra; case '&': resultado.append ("&"); quebra; case '"': resultado.ppend (" "); Break; default: resultado.Append (content [i]);}}}}}}2. Escreva um arquivo de descritor da biblioteca de tags (TLD) no diretório Web-Inf e descreva funções personalizadas no arquivo TLD.
O código de elfunction.tld é o seguinte:
<? xml versão = "." coding = "utf-"?> <taglib versão = "." 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>. -> <eri>/elfunction </uri> <!-<function> O elemento é usado para descrever uma função personalizada do EL-> <function> <cription> html tag Escape Processing Method </cription> <!-<name> Child Element é usado para especificar o nome da função do EL Custom-> <nome> </name> <!-<! -> <funct-Class> me.gacl.util.htmlfilter </funct-class> <!-<function-signature> O elemento filho é usado para especificar a assinatura do método estático na classe Java. A assinatura do método deve indicar o tipo de valor de retorno do método e o tipo de cada parâmetro, e cada parâmetro é separado por uma vírgula. -> <Function-Signature> java.lang.string filtro (java.lang.string) </ninction-signature> </function> </agglib>
3. Importar e usar funções personalizadas na página JSP
<%@ Page Language = "java" import = "java.util.*" PageEncoding = "utf-"%> <%-Introdução da biblioteca de funções personalizadas-%> <%@ taglib uri = "/elfunction" prefix = "fn"%> <! El </ititle> </head> <body> <%-chamando métodos de filtro usando el-%> $ {fn: filter ("<a href = '' '> Diand </a>")} </body> </html> Os resultados da operação são os seguintes:
1.6. Coisas a serem observadas ao desenvolver a função el
Depois de gravar o arquivo de descrição da biblioteca de tags, você precisa colocá-lo em qualquer subdiretório, exceto classes e diretórios LIB no diretório <Web Application>/Web-Inf ou no diretório Web-Inf.
O elemento <uri> no arquivo TLD usa o URI que especifica o arquivo TLD. Este URI precisa ser usado para introduzir o arquivo de descrição da biblioteca de tags no arquivo JSP.
O elemento <function> é usado para descrever uma função personalizada do EL, onde:
O elemento <nome> é usado para especificar o nome da função EL Custom.
O elemento filho da <-Class> é usado para especificar o nome completo da classe Java.
O elemento filho da <Function-Signature> é usado para especificar a assinatura de um método estático em uma classe Java. A assinatura do método deve indicar o tipo de valor de retorno do método e o tipo de cada parâmetro, e cada parâmetro é separado por uma vírgula.
1.7. PRECAUÇÕES EL
As expressões de EL são uma técnica na especificação JSP 2.0. Portanto, se você deseja analisar corretamente as expressões, precisará usar um servidor da Web que suporta a tecnologia servlet2.4/jsp2.0.
Nota: Alguns servidores Tomcat não podem usar expressões EL
(1) Atualizar para Tomcat6
(2) Adicione < %@ página iselignored = "false" %> ao jsp
1.8. Expressões de EL mantêm palavras -chave
A chamada palavra reservada significa que, ao nomear variáveis, os nomes acima devem ser evitados para evitar erros durante a compilação do programa. Existem muitos resumos sobre o conteúdo das expressões de EL.
O conteúdo acima fornece introdução detalhada ao conhecimento relevante das expressões Javaweb El através de exemplos. Espero que seja útil para você. Ao mesmo tempo, gostaria de agradecer muito pelo seu apoio ao site do Wulin.com!