JSP - Ações

Neste capítulo, discutiremos Ações em JSP. Essas ações usam construções na sintaxe XML para controlar o comportamento do mecanismo de servlet. Você pode inserir um arquivo dinamicamente, reutilizar componentes JavaBeans, encaminhar o usuário para outra página ou gerar HTML para o plug-in Java.

Existe apenas uma sintaxe para o elemento Action, uma vez que está em conformidade com o padrão XML -

<jsp:action_name attribute = "value" />

Os elementos de ação são basicamente funções predefinidas. A tabela a seguir lista as ações JSP disponíveis -

S.No. Sintaxe e propósito
1

jsp:include

Inclui um arquivo no momento em que a página é solicitada.
2

jsp:useBean

Encontra ou instancia um JavaBean.
3

jsp:setProperty

Define a propriedade de um JavaBean.
4

jsp:getProperty

Insere a propriedade de um JavaBean na saída.
5

jsp:forward

Encaminha o solicitante para uma nova página.
6

jsp:plugin

Gera código específico do navegador que cria uma tag OBJECT ou EMBED para o plug-in Java.
7

jsp:element

Define elementos XML dinamicamente.
8

jsp:attribute

Define o atributo do elemento XML definido dinamicamente.
9

jsp:body

Define o corpo do elemento XML definido dinamicamente.
10

jsp:text

Usado para escrever texto de modelo em páginas e documentos JSP.

Atributos Comuns

Existem dois atributos que são comuns a todos os elementos de ação: o id atributo e o scope atributo.

Atributo de id

O atributo id identifica exclusivamente o elemento Action e permite que a ação seja referenciada dentro da página JSP. Se a Action criar uma instância de um objeto, o valor id pode ser usado para referenciá-lo por meio do objeto implícito PageContext.

Atributo de escopo

Este atributo identifica o ciclo de vida do elemento Action. O atributo id e o atributo scope estão diretamente relacionados, pois o atributo scope determina a vida útil do objeto associado ao id. O atributo scope tem quatro valores possíveis:(a) page, (b)request, (c)sessione (d) application.

A ação <jsp: include>

Esta ação permite inserir arquivos na página que está sendo gerada. A sintaxe é semelhante a esta -

<jsp:include page = "relative URL" flush = "true" />

Ao contrário do include , que insere o arquivo no momento em que a página JSP é traduzida em um servlet, esta ação insere o arquivo no momento em que a página é solicitada.

A tabela a seguir lista os atributos associados à ação incluir -

S.No. Atributo e descrição
1

page

O URL relativo da página a ser incluída.
2

flush

O atributo booleano determina se o recurso incluído tem seu buffer liberado antes de ser incluído.

Exemplo

Vamos definir os dois arquivos a seguir (a)date.jsp e (b) main.jsp como segue -

A seguir está o conteúdo do date.jsp arquivo -

<p>Today's date: <%= (new java.util.Date()).toLocaleString()%></p>

A seguir está o conteúdo do main.jsp arquivo -

<html>
   <head>
      <title>The include Action Example</title>
   </head>
   
   <body>
      <center>
         <h2>The include action Example</h2>
         <jsp:include page = "date.jsp" flush = "true" />
      </center>
   </body>
</html>

Vamos agora manter todos esses arquivos no diretório raiz e tentar acessar main.jsp. Você receberá a seguinte saída -

 
       
The include action Example
 Today's date: 12-Sep-2010 14:54:22

A ação <jsp: useBean>

o useBeana ação é bastante versátil. Ele primeiro procura por um objeto existente utilizando as variáveis ​​id e escopo. Se um objeto não for encontrado, ele tenta criar o objeto especificado.

A maneira mais simples de carregar um bean é a seguinte -

<jsp:useBean id = "name" class = "package.class" />

Depois que uma classe de bean é carregada, você pode usar jsp:setProperty e jsp:getProperty ações para modificar e recuperar as propriedades do bean.

A tabela a seguir lista os atributos associados à ação useBean -

S.No. Atributo e descrição
1

class

Designa o nome completo do pacote do bean.
2

type

Especifica o tipo de variável que fará referência ao objeto.
3

beanName

Fornece o nome do bean conforme especificado pelo método instantiate () da classe java.beans.Beans.

Vamos agora discutir o jsp:setProperty e a jsp:getProperty ações antes de dar um exemplo válido relacionado a essas ações.

A ação <jsp: setProperty>

o setPropertyação define as propriedades de um Bean. O Bean deve ter sido definido previamente antes desta ação. Existem duas maneiras básicas de usar a ação setProperty -

Você pode usar jsp:setProperty depois, mas fora de um jsp:useBean elemento, conforme fornecido abaixo -

<jsp:useBean id = "myName" ... />
...
<jsp:setProperty name = "myName" property = "someProperty" .../>

Neste caso, o jsp:setProperty é executado independentemente se um novo bean foi instanciado ou um bean existente foi encontrado.

Um segundo contexto no qual jsp: setProperty pode aparecer está dentro do corpo de um jsp:useBean elemento, conforme fornecido abaixo -

<jsp:useBean id = "myName" ... >
   ...
   <jsp:setProperty name = "myName" property = "someProperty" .../>
</jsp:useBean>

Aqui, o jsp: setProperty é executado apenas se um novo objeto foi instanciado, não se um existente foi encontrado.

A tabela a seguir lista os atributos associados ao setProperty ação -

S.No. Atributo e descrição
1

name

Designa o bean cuja propriedade será definida. O Bean deve ter sido definido previamente.
2

property

Indica a propriedade que você deseja definir. Um valor de "*" significa que todos os parâmetros de solicitação cujos nomes correspondem aos nomes de propriedade do bean serão passados ​​para os métodos configuradores apropriados.
3

value

O valor que deve ser atribuído à propriedade fornecida. O valor do parâmetro é nulo ou o parâmetro não existe, a ação setProperty é ignorada.
4

param

O atributo param é o nome do parâmetro de solicitação cujo valor a propriedade deve receber. Você não pode usar valor e parâmetro, mas não é permitido usar nenhum deles.

A ação <jsp: getProperty>

o getProperty action é usado para recuperar o valor de uma determinada propriedade e convertê-lo em uma string e, finalmente, inseri-lo na saída.

A ação getProperty possui apenas dois atributos, sendo que ambos são obrigatórios. A sintaxe da ação getProperty é a seguinte -

<jsp:useBean id = "myName" ... />
...
<jsp:getProperty name = "myName" property = "someProperty" .../>

A tabela a seguir lista os atributos necessários associados ao getProperty ação -

S.No. Atributo e descrição
1

name

O nome do Bean que possui uma propriedade a ser recuperada. O Bean deve ter sido definido previamente.
2

property

O atributo property é o nome da propriedade Bean a ser recuperada.

Exemplo

Vamos definir um bean de teste que será usado posteriormente em nosso exemplo -

/* File: TestBean.java */
package action;
 
public class TestBean {
   private String message = "No message specified";
 
   public String getMessage() {
      return(message);
   }
   public void setMessage(String message) {
      this.message = message;
   }
}

Compile o código acima para o TestBean.class arquivo e certifique-se de que copiou o TestBean.class em C:\apache-tomcat-7.0.2\webapps\WEB-INF\classes\action pasta e o CLASSPATH variável também deve ser definida para esta pasta -

Agora use o seguinte código em main.jspArquivo. Isso carrega o bean e define / obtém um parâmetro String simples -

<html>
   
   <head>
      <title>Using JavaBeans in JSP</title>
   </head>
   
   <body>
      <center>
         <h2>Using JavaBeans in JSP</h2>
         <jsp:useBean id = "test" class = "action.TestBean" />
         <jsp:setProperty name = "test"  property = "message" 
            value = "Hello JSP..." />
            
         <p>Got message....</p>
         <jsp:getProperty name = "test" property = "message" />
      </center>
   </body>
</html>

Vamos agora tentar acessar main.jsp, ele exibiria o seguinte resultado -

 
       
Using JavaBeans in JSP
 Got message.... Hello JSP...

A ação <jsp: forward>

o forward action termina a ação da página atual e encaminha a solicitação para outro recurso, como uma página estática, outra página JSP ou um Servlet Java.

A seguir está a sintaxe do forward ação -

<jsp:forward page = "Relative URL" />

A tabela a seguir lista os atributos necessários associados à ação de encaminhamento -

S.No. Atributo e descrição
1

page

Deve consistir em uma URL relativa de outro recurso, como uma página estática, outra página JSP ou um Servlet Java.

Exemplo

Vamos reutilizar os dois arquivos a seguir (a) date.jsp e (b) main.jsp como segue -

A seguir está o conteúdo do date.jsp arquivo -

<p>Today's date: <%= (new java.util.Date()).toLocaleString()%></p>

A seguir está o conteúdo do main.jsp arquivo -

<html>
   <head>
      <title>The include Action Example</title>
   </head>
   
   <body>
      <center>
         <h2>The include action Example</h2>
         <jsp:forward page = "date.jsp" />
      </center>
   </body>
</html>

Vamos agora manter todos esses arquivos no diretório raiz e tentar acessar main.jsp. Isso exibiria um resultado parecido com o abaixo.

Aqui, ele descartava o conteúdo da página principal e exibia apenas o conteúdo da página encaminhada.


        Today's date: 12-Sep-2010 14:54:22

A ação <jsp: plugin>

o pluginação é usada para inserir componentes Java em uma página JSP. Ele determina o tipo de navegador e insere o<object> ou <embed> tags conforme necessário.

Se o plug-in necessário não estiver presente, ele baixa o plug-in e, em seguida, executa o componente Java. O componente Java pode ser um Applet ou um JavaBean.

A ação do plug-in possui vários atributos que correspondem a tags HTML comuns usadas para formatar componentes Java. o<param> elemento também pode ser usado para enviar parâmetros para o Applet ou Bean.

A seguir está a sintaxe típica de uso da ação do 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>
      Unable to initialize Java Plugin
   </jsp:fallback>
 
</jsp:plugin>

Você pode tentar esta ação usando algum miniaplicativo se estiver interessado. Um novo elemento, o<fallback> , pode ser usado para especificar uma string de erro a ser enviada ao usuário no caso de falha do componente.

The <jsp:element> Action


The <jsp:attribute> Action


The <jsp:body> Action

o <jsp:element>, <jsp:attribute> e <jsp:body>ações são usadas para definir elementos XML dinamicamente. A palavra dinamicamente é importante, porque significa que os elementos XML podem ser gerados no momento da solicitação, em vez de estaticamente no momento da compilação.

A seguir está um exemplo simples para definir elementos XML dinamicamente -

<%@page language = "java" contentType = "text/html"%>
<html xmlns = "http://www.w3c.org/1999/xhtml"
   xmlns:jsp = "http://java.sun.com/JSP/Page">
   
   <head><title>Generate XML Element</title></head>
   
   <body>
      <jsp:element name = "xmlElement">
         <jsp:attribute name = "xmlElementAttr">
            Value for the attribute
         </jsp:attribute>
         
         <jsp:body>
            Body for XML element
         </jsp:body>
      
      </jsp:element>
   </body>
</html>

Isso produziria o seguinte código HTML em tempo de execução -

<html xmlns = "http://www.w3c.org/1999/xhtml" xmlns:jsp = "http://java.sun.com/JSP/Page">
   <head><title>Generate XML Element</title></head>
   
   <body>
      <xmlElement xmlElementAttr = "Value for the attribute">
         Body for XML element
      </xmlElement>
   </body>
</html>

A ação <jsp: text>

o <jsp:text>ação pode ser usada para escrever o texto do modelo em páginas e documentos JSP. A seguir está a sintaxe simples para esta ação -

<jsp:text>Template data</jsp:text>

O corpo do modelo não pode conter outros elementos; ele só pode conter texto e expressões EL (Observação - as expressões EL são explicadas em um capítulo subsequente). Observe que em arquivos XML, você não pode usar expressões como${whatever > 0}, porque os sinais de maior que são ilegais. Em vez disso, use ogt forma, como ${whatever gt 0} ou uma alternativa é incorporar o valor em um CDATA seção.

<jsp:text><![CDATA[<br>]]></jsp:text>

Se você precisar incluir um DOCTYPE declaração, por exemplo para XHTML, você também deve usar o <jsp:text> elemento da seguinte forma -

<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>  
         Welcome to JSP Programming
      </jsp:text></book></books>
   </body>
</html>

Experimente o exemplo acima com e sem <jsp:text> açao.

ja/tutorial
es/tutorial
de/tutorial
fr/tutorial
th/tutorial
pt/tutorial
ru/tutorial
vi/tutorial
it/tutorial
ko/tutorial
tr/tutorial
id/tutorial
pl/tutorial
hi/tutorial
japost
espost
depost
frpost
thpost
ptpost
rupost
vipost
itpost
kopost
trpost
idpost
plpost
hipost

© Copyright 2021 - 2024 | All Rights Reserved