English | 简体中文 | 繁體中文 | Русский язык | Français | Español | Português | Deutsch | 日本語 | 한국어 | Italiano | بالعربية
Diferentes dos elementos de instrução JSP, os elementos de ação JSP entram em vigor no estágio de processamento de solicitações. Os elementos de ação JSP são escritos em sintaxe XML.
Utilizando ações JSP, é possível inserir dinamicamente arquivos, reutilizar componentes de JavaBean, redirecionar usuários para outras páginas, e gerar código HTML para Java Plugin.
Os elementos de ação têm apenas uma sintaxe, que é compatível com o padrão XML:
<jsp:action_name attribute="value"> />
Os elementos de ação são basicamente funções pré-definidas, a especificação JSP define uma série de ações padrão, que usam JSP como prefixo, e os elementos de ação padrão disponíveis são os seguintes:
| Sintaxe | Descrição |
|---|---|
| jsp:include | Inclui um arquivo ao solicitar a página. |
| jsp:useBean | Procura ou exemplo de um JavaBean. |
| jsp:setProperty | Define a propriedade de um JavaBean. |
| jsp:getProperty | Imprime a propriedade de um JavaBean. |
| jsp:forward | Redireciona a solicitação para uma nova página. |
| jsp:plugin | Gera o marcador OBJECT ou EMBED para o Java Plugin com base no tipo do navegador. |
| jsp:element | Define o elemento XML dinamicamente. |
| jsp:attribute | Define o atributo do elemento XML dinamicamente definido. |
| jsp:body | Define o conteúdo do elemento XML dinamicamente definido. |
| jsp:text | Modelo de texto usado para escrever texto em páginas JSP e documentos. |
Todos os elementos de ação têm duas propriedades: id e scope.
Propriedade id:
A propriedade id é o identificador único do elemento de ação e pode ser referenciado na página JSP. O valor de id criado pelo elemento de ação pode ser chamado através do PageContext.
Propriedade scope:
Esta propriedade é usada para identificar o ciclo de vida do elemento de ação. A propriedade id está diretamente relacionada à propriedade scope, que define a durabilidade do objeto associado ao id. A propriedade scope tem quatro valores possíveis: (a) page, (b) request, (c) session e (d) application.
O elemento de ação <jsp:include> é usado para incluir arquivos estáticos e dinâmicos. A ação insere o arquivo especificado no página que está sendo gerada. O formato de sintaxe é o seguinte:
<jsp:include page="endereço URL relativo" flush="true"> />
Já foi introduzido o comando include, que é introduzido no arquivo ao converter o arquivo JSP em Servlet, enquanto a ação jsp:include aqui é diferente, a inserção do arquivo ocorre no momento da solicitação da página.
A seguir está a lista de atributos relacionados à ação include.
| Propriedade | Descrição |
|---|---|
| page | Endereço URL relativo contido na página. |
| flush | Atributo booleano, define se o cache deve ser atualizado antes de incluir os recursos. |
A seguir, definimos dois arquivos. date.jsp e main.jspO código é conforme mostrado a seguir:
O código do arquivo date.jsp é:
<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%> <p> A data de hoje é: <%= (new java.util.Date()).toLocaleString() %> </p>
Código do arquivo main.jsp:
<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%> !DOCTYPE html> <html> <head> <meta charset="utf-8"> <title>Site de Tutoriais Básicos(oldtoolbag.com)</title> </head> <body> <h2>Exemplo de ação include</h2> <jsp:include page="date.jsp" flush="true" /> </body> </html>
Agora coloque os dois arquivos na raiz do servidor e acesse o arquivo main.jsp. O resultado será o seguinte:
Exemplo de ação include A data de hoje é: 2016-6-25 14:08:17
jsp:useBean A ação é usada para carregar um JavaBean que será usado na página JSP.
Esta função é muito útil, pois permite que possamos explorar as vantagens da reutilização de componentes Java.
A sintaxe mais simples da ação jsp:useBean é:
<jsp:useBean id="name" />
Após a carga da classe, podemos modificar e recuperar as propriedades do bean através das ações jsp:setProperty e jsp:getProperty.
A seguir está a lista de atributos relacionados à ação useBean.
| Propriedade | Descrição |
|---|---|
| class | Especifica o nome completo do pacote do Bean. |
| type | Especifica o tipo de variável que será referenciada pelo objeto. |
| beanName | Especifica o nome do Bean através do método instantiate() da classe java.beans.Beans. |
Antes de fornecer exemplos específicos, vamos primeiro olhar para os elementos de ação jsp:setProperty e jsp:getProperty:
A jsp:setProperty é usada para configurar as propriedades de um objeto Bean já exemploizado, existem duas formas de uso. Primeiro, você pode usar a jsp:setProperty fora do elemento jsp:useBean (depois), conforme mostrado a seguir:
<jsp:useBean id="myName" ... /> ... <jsp:setProperty name="myName" property="someProperty" ...>/>
Neste momento, independentemente de jsp:useBean ter encontrado um Bean existente ou ter criado um exemplo de Bean novo, a jsp:setProperty será executada. A segunda forma de uso é inserir a jsp:setProperty dentro do elemento jsp:useBean, conforme mostrado a seguir:
<jsp:useBean id="myName" ... > ... <jsp:setProperty name="myName" property="someProperty" ...>/> </jsp:useBean>
Neste momento, a jsp:setProperty só será executada quando um novo exemplo de Bean for criado, se estiver usando um exemplo existente, a jsp:setProperty não será executada.
A ação jsp:setProperty possui os seguintes quatro atributos, conforme a tabela a seguir:
| Propriedade | Descrição |
|---|---|
| name | A propriedade name é obrigatória. Ela representa qual Bean será configurado. |
| property | A propriedade property é obrigatória. Ela representa qual propriedade deve ser configurada. Há um uso especial: se o valor de property for "}}*"indica que todos os parâmetros de solicitação cujos nomes correspondem aos nomes e propriedades do Bean serão passados para os métodos set das propriedades correspondentes. |
| value | A propriedade value é opcional. Esta propriedade é usada para especificar o valor da propriedade do Bean. Os dados de string são automaticamente convertidos para números, boolean, Boolean, byte, Byte, char, Character no destino da classe através do método valueOf padrão. Por exemplo, os valores de propriedades do tipo boolean e Boolean (como "true") são convertidos através de Boolean.valueOf, os valores de propriedades do tipo int e Integer (como "42"）é convertido através de Integer.valueOf. value e param não podem ser usados ao mesmo tempo, mas pode-se usar qualquer um dos dois. |
| param | O parâmetro é opcional. Ele especifica qual parâmetro de solicitação usar como valor da propriedade do Bean. Se a solicitação atual não tiver parâmetros, nada acontece, o sistema não passa null para o método set da propriedade do Bean. Portanto, você pode permitir que o Bean forneça valores padrão de propriedade, que serão alterados apenas quando o parâmetro de solicitação especificar um novo valor. |
A ação <jsp:getProperty> extrai o valor da propriedade do Bean especificado, converte para uma string e então imprime. O formato de sintaxe é o seguinte:
<jsp:useBean id="myName" ... /> ... <jsp:getProperty name="myName" property="someProperty" .../>
A tabela a seguir lista as propriedades associadas a getProperty:
| Propriedade | Descrição |
|---|---|
| name | O nome da propriedade do Bean a ser pesquisada. O Bean deve estar definido. |
| property | indica o valor da propriedade do Bean a ser extraído |
Neste exemplo, usamos Bean:
package com.w3codebox.main;
public class TestBean {
private String message = "基础教程网";
public String getMessage() {
return(message);
}
public void setMessage(String message) {
this.message = message;
}
}Compilar o exemplo acima do arquivo TestBean.java :
$javac TestBean.java
Após a compilação, um arquivo será gerado no diretório atual. TestBean.class arquivo, Copia este arquivo para o diretório atual do projeto JSP: WebContent/WEB-INF/classes/com/w3codebox/mainabaixo ( com/w3codebox/Caminho do pacote main, não há necessidade de criar manualmente).
A seguir está uma imagem da estrutura de diretórios no Eclipse:
A seguir está um exemplo muito simples, cuja função é carregar um Bean e configurar/Ler sua propriedade message.
Agora vamos chamar este Bean no arquivo main.jsp:
<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%> !DOCTYPE html> <html> <head> <meta charset="utf-8"> <title>Site de Tutoriais Básicos(oldtoolbag.com)</title> </head> <body> <h2>Exemplo de uso de JavaBean pelo JSP</h2> <jsp:useBean id="test"> /> <jsp:setProperty name="test"> property="message" value="Tutorial básico..." /> <p>Informações de saída....</p> <jsp:getProperty name="test" property="message"> /> </body> </html>
Acesso do navegador, execução dos seguintes arquivos, saída conforme mostrado a seguir:
A ação <jsp:forward> redireciona a solicitação para outra página. A tag <jsp:forward> possui apenas uma propriedade: page. O formato de sintaxe é o seguinte:
<jsp:forward page="URL relativo à página"> />
A seguir estão as propriedades associadas ao forward:
| Propriedade | Descrição |
|---|---|
| page | A propriedade page contém um URL relativo. O valor de page pode ser fornecido diretamente ou calculado dinamicamente durante a solicitação, podendo ser uma página JSP ou um Servlet Java. |
Neste exemplo, usamos dois arquivos: date.jsp e main.jsp.
O código do arquivo date.jsp é o seguinte:
<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%> <p> A data de hoje é: <%= (new java.util.Date()).toLocaleString() %> </p>
Código do arquivo main.jsp:
<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%> !DOCTYPE html> <html> <head> <meta charset="utf-8"> <title>Site de Tutoriais Básicos(oldtoolbag.com)</title> </head> <body> <h2>Exemplo de ação forward</h2> <jsp:forward page="date.jsp"> /> </body> </html>
Agora coloque os dois arquivos na raiz do servidor e acesse o arquivo main.jsp. O resultado será o seguinte:
A data de hoje é: 2016-6-25 14:37:25
O comando <jsp:plugin> é usado para inserir os elementos OBJECT ou EMBED necessários para executar Java Applets através de plugins do navegador.
Se o plugin necessário não existir, ele baixará o plugin e executará o componente Java. O componente Java pode ser um applet ou um JavaBean.
O plugin tem várias propriedades correspondentes a elementos HTML para formatar o componente Java. O elemento param pode ser usado para passar parâmetros para Applet ou Bean.
A seguir está um exemplo típico do uso do elemento de ação plugin:
<jsp:plugin type="applet" codebase="dirname" code="MyApplet.class" width="60" height="80"> <jsp:param name="fontcolor" value="red" /> <jsp:param name="background" value="black" /> <jsp:fallback> Impossível inicializar o Java Plugin </jsp:fallback> </jsp:plugin>
Se você tiver interesse, pode tentar usar applet para testar o elemento de ação jsp:plugin, o elemento <fallback> é um novo elemento que envia mensagens de erro para o usuário quando o componente falha.
<jsp:element> 、 <jsp:attribute> 、 <jsp:body>ação elemento define dinamicamente elementos XML. Dinâmico é muito importante, o que significa que os elementos XML são gerados dinamicamente durante a compilação, não estaticamente.
A seguir, há um exemplo que define dinamicamente elementos XML:
<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%> !DOCTYPE html> <html> <head> <meta charset="utf-8"> <title>Site de Tutoriais Básicos(oldtoolbag.com)</title> </head> <body> <jsp:element name="xmlElement"> <jsp:attribute name="xmlElementAttr"> valor do atributo </jsp:attribute> <jsp:body> corpo do elemento XML </jsp:body> </jsp:element> </body> </html>
O navegador acessa a seguinte página e exibe o resultado conforme mostrado a seguir:
O elemento de ação <jsp:text> permite usar modelos de template para escrever texto em páginas JSP e documentos, a sintaxe é a seguinte:
Modelo de dados <jsp:text>/jsp:text
O modelo de texto acima não pode conter elementos repetidos, pode conter apenas texto e expressões EL (notas: as expressões EL serão introduzidas em capítulos posteriores). Observe que você não pode usar expressões como ${whatever > 0} em arquivos XML, porque o símbolo > é ilegal. Você pode usar a expressão ${whatever gt 0} ou valor anexado em uma parteCDATA.
<jsp:text><![CDATA[<br>]]></jsp:text
Se você precisar declarar DOCTYPE no XHTML, deve usar o elemento de ação <jsp:text>, exemplo a seguir:
<jsp:text><![CDATA[<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "DTD/xhtml1-strict.dtd">]]> </jsp:text <head><title>jsp:text action</title></head> <body> <books><book><jsp:text> Bem-vindo ao Programação JSP </jsp:text></book></books> </body> </html>
Você pode experimentar a diferença entre usar <jsp:text> e não usar o elemento de ação.