Ao contrário dos elementos de diretiva JSP, os elementos de ação JSP funcionam durante a fase de processamento da solicitação. Os elementos de ação JSP são escritos na sintaxe XML.
Use ações JSP para inserir arquivos dinamicamente, reutilizar componentes JavaBean, redirecionar usuários para outras páginas e gerar código HTML para plug-ins Java.
Existe apenas uma sintaxe para elementos de ação e ela está em conformidade com o padrão XML:
<jsp:action_name atributo="valor" />
Os elementos de ação são basicamente funções predefinidas. A especificação JSP define uma série de ações padrão, que usam JSP como prefixo. Os elementos de ação padrão disponíveis são os seguintes:
| gramática | descrever |
|---|---|
| jsp: incluir | Importe um arquivo quando a página for solicitada. |
| jsp:useBean | Encontre ou instancie um JavaBean. |
| jsp:setProperty | Defina propriedades JavaBean. |
| jsp:getProperty | Produza as propriedades de um JavaBean. |
| jsp: encaminhar | Envie a solicitação para uma nova página. |
| jsp: plugin | Gera tags OBJECT ou EMBED para plug-ins Java dependendo do tipo de navegador. |
| jsp:elemento | Definir elementos XML dinâmicos |
| jsp:atributo | Defina atributos de elementos XML definidos dinamicamente. |
| jsp:corpo | Define o conteúdo de um elemento XML definido dinamicamente. |
| jsp:texto | Usando modelos que escrevem texto em páginas e documentos JSP |
Todos os elementos de ação possuem dois atributos: atributo id e atributo escopo.
atributo de identificação:
O atributo id é o identificador exclusivo do elemento action e pode ser referenciado na página JSP. O valor id criado pelo elemento action pode ser chamado por meio de PageContext.
atributo de escopo:
Este atributo é usado para identificar o ciclo de vida do elemento de ação. O atributo id está diretamente relacionado ao atributo scope, e o atributo scope define a vida útil do objeto id associado. O atributo scope tem quatro valores possíveis: (a) página, (b) solicitação, (c) sessão e (d) aplicativo.
O elemento de ação <jsp:include> é usado para incluir arquivos estáticos e dinâmicos. Esta ação insere o arquivo especificado na página que está sendo gerada. O formato da sintaxe é o seguinte:
<jsp:include page="URL relativo" flush="true" />
A diretiva include foi introduzida antes. Ela introduz arquivos quando o arquivo JSP é convertido em um Servlet. A ação jsp:include aqui é diferente.
A seguir está uma lista de propriedades relacionadas à ação include.
| propriedade | descrever |
|---|---|
| página | O endereço URL relativo contido na página. |
| liberar | Propriedade booleana que define se o cache deve ser liberado antes de incluir o recurso. |
Abaixo definimos dois arquivos date.jsp e main.jsp, o código é o seguinte:
código do arquivo date.jsp:
<p> Data de hoje: <%= (new java.util.Date()).toLocaleString()%></p>
Código do arquivo main.jsp:
<html><head><title>Exemplo de ação de inclusão</title></head><body><center><h2>Exemplo de ação de inclusão</h2><jsp:include page="date.jsp" flush ="true" /></center></body></html>
Agora coloque os dois arquivos acima no diretório raiz do servidor e acesse o arquivo main.jsp. Os resultados exibidos são os seguintes:
A ação de inclusão ExemploData de hoje: 12 de setembro de 2013 14:54:22
A ação jsp:useBean é usada para carregar um JavaBean que será usado na página JSP.
Este recurso é muito útil porque nos permite aproveitar a reutilização de componentes Java evitando a perda da conveniência que distingue JSP de Servlets.
A sintaxe mais simples para a ação jsp:useBean é:
<jsp:useBean id="nome" />
Após o carregamento da classe, podemos modificar e recuperar as propriedades do bean por meio das ações jsp:setProperty e jsp:getProperty.
A seguir está uma lista de propriedades relacionadas à ação useBean.
| propriedade | descrever |
|---|---|
| aula | Especifique o nome completo do pacote do bean. |
| tipo | Especifica o tipo que fará referência à variável de objeto. |
| beanName | Especifique o nome do Bean por meio do método instantiate() de java.beans.Beans. |
Antes de dar exemplos específicos, vamos primeiro dar uma olhada nos elementos de ação jsp:setProperty e jsp:getProperty:
jsp:setProperty é usado para definir as propriedades do objeto Bean instanciado. Existem duas maneiras de usá-lo. Primeiro, você pode usar jsp:setProperty fora (atrás) do elemento jsp:useBean, assim:
<jsp:useBean id="meuNome" ... />...<jsp:setProperty name="meuNome" property="someProperty" .../>
Neste momento, quer jsp:useBean encontre um Bean existente ou crie uma nova instância de Bean, jsp:setProperty será executado. O segundo uso é colocar jsp:setProperty dentro do elemento jsp:useBean, conforme mostrado abaixo:
<jsp:useBean id="meuNome" ... >... <jsp:setProperty name="meuNome" property="someProperty" .../></jsp:useBean>
Neste momento, jsp:setProperty só será executado ao criar uma nova instância do Bean. Se uma instância existente for usada, jsp:setProperty não será executado.
| propriedade | descrever |
|---|---|
| nome | O atributo name é obrigatório. Indica em qual Bean a propriedade deve ser configurada. |
| propriedade | O atributo de propriedade é obrigatório. Indica qual propriedade definir. Há um uso especial: se o valor da propriedade for "*", significa que todos os parâmetros de solicitação cujos nomes correspondam aos nomes das propriedades do Bean serão passados para o método de conjunto de propriedades correspondente. |
| valor | O atributo value é opcional. Esta propriedade é usada para especificar o valor da propriedade Bean. Os dados da string serão convertidos automaticamente em números, booleanos, booleanos, bytes, bytes, caracteres e caracteres por meio do método valueOf padrão na classe de destino. Por exemplo, valores de atributos do tipo booleano e booleano (como "true") são convertidos por Boolean.valueOf, e valores de atributos do tipo int e Integer (como "42") são convertidos por Integer.valueOf. Valor e parâmetro não podem ser usados ao mesmo tempo, mas qualquer um deles pode ser usado. |
| parâmetro | parâmetro é opcional. Ele especifica qual parâmetro de solicitação é usado como valor da propriedade Bean. Caso a requisição atual não possua parâmetros, nada será feito e o sistema não passará null para o método set da propriedade Bean. Portanto, você pode deixar o bean fornecer o próprio valor da propriedade padrão e somente modificar o valor da propriedade padrão quando o parâmetro de solicitação especificar explicitamente um novo valor. |
A ação jsp:getProperty extrai o valor da propriedade Bean especificada, converte-o em uma string e, em seguida, gera-o. O formato da sintaxe é o seguinte:
<jsp:useBean id="meuNome" ... />...<jsp:getProperty name="meuNome" property="someProperty" .../>
A tabela a seguir contém as propriedades associadas a getProperty:
| propriedade | descrever |
|---|---|
| nome | O nome da propriedade Bean a ser recuperada. O feijão deve ser definido. |
| propriedade | Indica que o valor da propriedade Bean deve ser extraído |
Nos exemplos a seguir usamos Beans:
/* Arquivo: TestBean.java */package action; public class TestBean { private String message = "Nenhuma mensagem especificada"; public String getMessage() { return(message } public void setMessage(String message) { this.message = mensagem; }}Compile o exemplo acima e gere o arquivo TestBean.class Copie o arquivo para o diretório onde o servidor armazena oficialmente as classes Java, em vez do diretório reservado para classes que podem ser carregadas automaticamente após a modificação (como: C:apache-tomcat). -7.0.2 webappsWEB-INFclassesaction, a variável CLASSPATH deve conter este caminho). Por exemplo, para Java Web Server, os beans e todas as classes usadas pelos beans devem ser colocados no diretório classes ou encapsulados em arquivos jar e colocados no diretório lib, mas não devem ser colocados em servlets. A seguir está um exemplo muito simples. Sua função é carregar um Bean e então definir/ler sua propriedade de mensagem.
Agora vamos chamar o bean no arquivo main.jsp:
<html><head><title>Usando JavaBeans em JSP</title></head><body><center><h2>Usando JavaBeans em JSP</h2> <jsp:useBean id="test" /> < jsp:setProperty name="test" property="message" value="Olá JSP..." /> <p>Recebi mensagem....</p> <jsp:getProperty name="test" property="message "/> </center></body></html>
Execute o arquivo acima e a saída será a seguinte:
Usando JavaBeans em JSPMensagem obtida....Olá JSP...
A ação jsp:forward encaminha a solicitação para outra página. A tag jsp:forward possui apenas um atributo, page. O formato da sintaxe é o seguinte:
<jsp:forward page="URL relativa" />
A seguir estão os atributos associados ao encaminhamento:
| propriedade | descrever |
|---|---|
| página | O atributo page contém um URL relativo. O valor da página pode ser fornecido diretamente ou calculado dinamicamente durante a solicitação. Pode ser uma página JSP ou um Servlet Java. |
Usamos dois arquivos nos exemplos a seguir: date.jsp e main.jsp.
O código do arquivo date.jsp é o seguinte:
<p> Data de hoje: <%= (new java.util.Date()).toLocaleString()%></p>
Código do arquivo main.jsp:
<html><head><title>O exemplo de ação de encaminhamento</title></head><body><center><h2>O exemplo de ação de encaminhamento</h2><jsp:forward page="date.jsp" / </center></body>
Agora coloque os dois arquivos acima no diretório raiz do servidor e acesse o arquivo main.jsp. Os resultados exibidos são os seguintes:
Data de hoje: 12 de setembro de 2010 14:54:22
A ação jsp:plugin é utilizada para inserir os elementos OBJECT ou EMBED necessários para executar o Java Applet através do plug-in Java, dependendo do tipo de navegador.
Se o plug-in necessário não existir, ele fará download do plug-in e, em seguida, executará o componente Java. Um componente Java pode ser um applet ou um JavaBean.
A ação do plugin possui vários atributos correspondentes aos elementos HTML usados para formatar componentes Java. O elemento param pode ser usado para passar parâmetros para Applet ou Bean.
A seguir está um exemplo típico de uso do elemento de ação do plugin:
<jsp:plugin type="applet" codebase="dirname" code="MyApplet.class" > <jsp:param name="fontcolor" value="red" /> <jsp:param name="background" value=" preto" /> <jsp:fallback> Não foi possível inicializar o plug-in Java </jsp:fallback> </jsp:plugin>
Se estiver interessado, você pode tentar usar um applet para testar o elemento de ação jsp:plugin O elemento <fallback> é um novo elemento. Quando o componente falha, uma mensagem de erro é enviada ao usuário.
Os elementos de ação <jsp:element>, <jsp:attribute>, <jsp:body> definem elementos XML dinamicamente. Dinâmico é muito importante, o que significa que os elementos XML são gerados dinamicamente em tempo de compilação, em vez de estáticos.
O exemplo a seguir define elementos XML dinamicamente:
<%@page idioma="java" contentType="text/html"%><html xmlns="http://www.w3c.org/1999/xhtml" xmlns:jsp="http://java.sun. com/JSP/Page"><head><title>Gerar elemento XML</title></head><body><jsp:element name="xmlElement"><jsp:attribute name="xmlElementAttr"> Valor para o atributo</jsp:attribute><jsp:body> Corpo para elemento XML</jsp:body></jsp:element></body></html>
O código HTML gerado durante a execução é o seguinte:
<html xmlns="http://www.w3c.org/1999/xhtml" xmlns:jsp="http://java.sun.com/JSP/Page"> <head><title>Gerar elemento XML</ title></head><body><xmlElement xmlElementAttr="Valor para o atributo"> Corpo do elemento XML</xmlElement></body></html>
O elemento de ação <jsp:text> permite o uso de modelos para escrever texto em páginas e documentos JSP. O formato da sintaxe é o seguinte:
<jsp:text>Dados do modelo</jsp:text>
O modelo de texto acima não pode conter outros elementos, mas apenas texto e expressões EL (Nota: as expressões EL serão introduzidas nos capítulos subsequentes). Observe que em arquivos XML você não pode usar expressões como ${whatever > 0} porque o símbolo > é ilegal. Você pode usar a expressão ${whatever gt 0} ou o valor incorporado em uma seção CDATA.
<jsp:text><![CDATA[<br>]]></jsp:text>
Se você precisar declarar DOCTYPE em XHTML, deverá usar o elemento de ação <jsp:text>. Um exemplo é o seguinte:
<jsp:text><![CDATA[<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "DTD/xhtml1-strict.dtd">]]></jsp:text>< head><title>jsp:ação de texto</title></head><body><books><book><jsp:text> Bem-vindo ao JSP Programação</jsp:text></book></books></body></html>
Você pode tentar o exemplo acima para ver a diferença nos resultados de execução usando <jsp:text> e não usando este elemento de ação.