Tags de ação JSP

Por: James Hartmann James Hartmann
Hours Atualização do

⚡ Resumo Inteligente

As tags de ação JSP usam sintaxe XML para controlar o comportamento do mecanismo de servlet, permitindo que os desenvolvedores incluam arquivos, encaminhem solicitações e trabalhem com JavaFeijões e incorporação de conteúdo dinâmico durante o processamento da solicitação.

  • 🏷️ Conjunto padrão: Onze tags de ação padrão lidam com inclusões, encaminhamentos, beans, plugins e saída XML.
  • 📜 Sintaxe XML: As tags de ação seguem um formato XML rigoroso e são reavaliadas a cada requisição.
  • 🔗 Integração de Beans: jsp:useBean, jsp:setProperty e jsp:getProperty gerenciam JavaCiclo de vida e propriedades do feijão.
  • ✅ Fluxo da página: jsp:include mescla recursos; jsp:forward transfere o processamento da requisição para outra página.
  • 🧪 XML dinâmico: jsp:body, jsp:attribute, jsp:text e jsp:output geram estruturas XML dinamicamente.
  • 🤖 Modernização da IA: Assistentes de IA ajudam a refatorar código JSP legado para frameworks modernos.
Saiba Mais

Tags de ação JSP

O que é uma tag de ação JSP?

As tags de ação JSP usam construções de sintaxe XML para controlar o comportamento do mecanismo de servlet. Os desenvolvedores podem inserir um arquivo dinamicamente e reutilizá-lo. JavaOs componentes Bean redirecionam o usuário para outra página e executam operações semelhantes em tempo de execução por meio de tags de ação JSP, como `include` e `forward`. Ao contrário das diretivas, as tags de ação são reavaliadas a cada acesso à página, o que as torna ideais para comportamentos dinâmicos durante o processamento de requisições.

Sintaxe:

<jsp:action_name attribute="value" />

Neste tutorial sobre tags de ação padrão do JSP, você aprenderá como cada tag de ação funciona, o que ela faz e como aplicá-la em um arquivo JSP real.

Lista das tags de ação mais usadas em JSP

Existem 11 tipos de tags de ação padrão em JSP, e aqui está a lista completa delas.

Nome da tag de ação Sintaxe Descrição
jsp:useBean Usado para invocar e usar beans na página JSP.
jsp: include <jsp:include page=”page URL” flush=”true/false” /> Inclui outro arquivo JSP no arquivo atual durante o processamento da solicitação.
jsp:setProperty Define a propriedade de um bean.
jsp:getProperty Recupera a propriedade de um bean e a converte em uma string para saída.
jsp: encaminhar Encaminha a solicitação para outro JSP ou página estática.
jsp: plugin Introduz Java componentes como applets ou beans em JSP e gera tags automaticamente.
jsp:corpo Define elementos XML que são gerados dinamicamente durante o processamento de solicitações.
jsp:texto texto modelo Usado para inserir texto de modelo em páginas JSP, contendo apenas texto e expressões EL.
jsp: param Passa parâmetros dentro da ação jsp:plugin para adicionar dados extras.
jsp:atributo Define atributos XML que são gerados dinamicamente.
jsp:saída Especifica a declaração XML ou DOCTYPE a ser usada na saída.

Agora que você tem a lista completa, vamos explorar cada uma dessas tags de ação JSP individualmente, com a sintaxe e um exemplo prático.

Tag de ação jsp:useBean

  • Este nome de ação é usado quando você deseja usar JavaFeijões na página JSP.
  • Com essa tag, você pode facilmente invocar um bean e reutilizar componentes do lado do servidor.

Sintaxe de jsp:useBean:

<jsp:useBean id="" class="" />

Aqui, `id` especifica o identificador deste bean e `class` é o caminho completo da classe do bean.

Exemplo:

<%@ page language="java" contentType="text/html; charset=ISO-8859-1"
    pageEncoding="ISO-8859-1"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
<title>Action JSP1</title>
</head>
<body>
<jsp:useBean id="name" class="demotest.DemoClass">
</body>
</html>

Explicação do código:

Code Linha 10: No código acima, você usa o “id do bean” e o “caminho de classe” do bean.

jsp:include Tag de ação

  • O `jsp:include` é usado para inserir um arquivo JSP em outro arquivo durante o processamento da requisição, de forma semelhante à inclusão de um arquivo JSP. instruções.
  • Ele é adicionado durante a fase de processamento da requisição, o que significa que o conteúdo incluído é avaliado cada vez que a página é solicitada.

Sintaxe de jsp:include:

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

Exemplo:

Em Action_jsp2 (Code Na linha 10), estamos incluindo um arquivo date.jsp.

<%@ page language="java" contentType="text/html; charset=ISO-8859-1"
    pageEncoding="ISO-8859-1"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
<title>Date Guru JSP</title>
</head>
<body>
<jsp:include page="date.jsp" flush="true" />
</body>
</html>

Data.jsp

<%@ page language="java" contentType="text/html; charset=ISO-8859-1"
    pageEncoding="ISO-8859-1"%> 
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
<title>Insert title here</title>
</head>
<body>
<p>
Today's date: <%= new java.util.Date().toLocaleString()%>
</p>
</body>
</html>

Explicação do código:

Action_jsp2.jsp

Code Linha 10: No primeiro arquivo, estamos incluindo o arquivo date.jsp em action_jsp2.jsp.

Data.jsp:

Code Linha 11: Estamos imprimindo a data de hoje na linha de código 11 do arquivo date.jsp.

Ao executar o código, a seguinte saída será obtida.

jsp: include

Saída:

  • Exibe a data e a hora de hoje, pois o arquivo de data está incluído na página JSP principal.

ARTIGOS RELACIONADOS

Tag de ação jsp:setProperty

  • Essa ação padrão em JSP é usada para definir a propriedade do bean.
  • Você precisa definir um bean antes de configurar a propriedade.

Sintaxe:

<jsp:setProperty name="" property="" >

Aqui, o nome define o bean cuja propriedade está sendo definida, e `property` é a propriedade que você deseja definir. Você também pode definir os atributos `value` e `param`. O valor não é obrigatório e define o valor que será atribuído à propriedade. `param` é o nome do parâmetro da requisição que será usado para obter o valor. O exemplo de `setProperty` será demonstrado abaixo com `getProperty`.

Tag de ação jsp:getProperty

  • Essa ação é usada para obter a propriedade do bean.
  • Converte a propriedade em uma string e, finalmente, a insere na saída.

Sintaxe:

<jsp:getProperty name="" property="" >

Aqui, o nome é o bean do qual a propriedade deve ser recuperada, e o bean deve estar definido. O atributo `property` é o nome da propriedade do bean a ser recuperada.

Exemplo de setProperty e getProperty:

TestBean.java:

package demotest;

import java.io.Serializable;

public class TestBean implements Serializable{
	
	private String msg = "null";
	
	public String getMsg() {
		return msg;
	}
	
	public void setMsg(String msg) {
		this.msg = msg;
	}
}

Action_jsp3.jsp

<%@ page language="java" contentType="text/html; charset=ISO-8859-1"
    pageEncoding="ISO-8859-1"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
<title>Guru Action 3</title>
</head>
<body>
<jsp:useBean id="GuruTest" class="demotest.TestBean" />
<jsp:setProperty name="GuruTest" property="msg" value="GuruTutorial" />
<jsp:getProperty name="GuruTest" property="msg" />
</body>
</html>

Explicação do código:

TestBean.java:

Code Linha 5TestBean implementa a classe Serializable. É uma classe bean com getters e setters no código.

Code Linha 7Aqui, estamos considerando a variável de string privada msg como “nula”.

Code Linha 9-14Aqui estamos usando os métodos getters e setters da variável “msg”.

Action_jsp3.jsp

Code Linha 10: Aqui estamos usando a tag “useBean”, que especifica o bean (TestBean) que deve ser usado nesta classe JSP.

Code Linha 11: Aqui estamos definindo o valor da propriedade msg para o bean TestBean como “GuruTutorial".

Code Linha 12: Aqui, usando getProperty, estamos obtendo o valor da propriedade msg para o bean TestBean (GuruTutorial), que é mostrado na saída.

Ao executar o código acima, você obtém a seguinte saída:

jsp:getProperty

Saída:

Neste exemplo, usando TestBean, estamos definindo a propriedade “msg” usando setProperty e obtendo o valor da propriedade usando getProperty como “GuruTutorial".

jsp:forward Tag de ação

A tag de ação jsp:forward é usada para encaminhar a solicitação para outro JSP ou qualquer página estática.

Aqui a solicitação pode ser encaminhada sem parâmetros ou com parâmetros.

Sintaxe:

<jsp:forward page="value">

Aqui o valor representa para onde a solicitação deve ser encaminhada.

Exemplo:

Action_jsp41.jsp

<%@ page language="java" contentType="text/html; charset=ISO-8859-1"
    pageEncoding="ISO-8859-1"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
<title>Guru Action JSP1</title>
</head>
<body>
<jsp:forward page="jsp_action_42.jsp" />
</body>
</html>

Jsp_action_42.jsp

Guru Action JSP2</title>
</head>
<body>
<a>This is after forward page</a>
</body>
</html>

Explicação do código:

Action_jsp41.jsp

Code Linha 10: Aqui estamos usando a ação JSP de encaminhamento para direcionar a solicitação para a página mencionada no atributo, ou seja, jsp_action_42.jsp.

Jsp_action_42.jsp

Code Linha 10: Ao chamarmos o arquivo action_jsp41.jsp, a requisição é encaminhada para esta página e obtemos como resultado a mensagem "This is after forward page".

Ao executarmos o código acima, obtemos a seguinte saída.

jsp: encaminhar

Saída:

Chamamos action_jsp41.jsp, mas a solicitação é encaminhada para jsp_action_42.jsp, e obtemos a saída dessa página como "This is after forward page".

jsp:plugin Tag de ação

  • É usado para apresentar Java componentes em JSP, onde o Java Os componentes podem ser tanto um applet quanto um bean.
  • Ele detecta o navegador e adiciona ou inserir tags no arquivo.

Sintaxe:

<jsp:plugin type="applet/bean" code="objectcode" codebase="objectcodebase">
  • Aqui, o tipo especifica um objeto ou um bean.
  • Code Especifica o nome da classe do applet ou bean.
  • Codebase contém a base URL que contém arquivos de classes.

jsp:param Tag de ação

  • Este é um objeto filho do objeto plugin descrito acima.
  • Deve conter uma ou mais ações para fornecer parâmetros adicionais.

Sintaxe:

<jsp:params>
<jsp:param name="val" value="val"/ >
</jsp:params>

Exemplo de plugin e parâmetro:

Action_jsp5.jsp

<%@ page language="java" contentType="text/html; charset=ISO-8859-1"
    pageEncoding="ISO-8859-1"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
<title>Action guru jsp5</title>
</head>
<body>
<jsp:plugin type="bean" code="Student.class" codebase="demotest.Student">
  <jsp:params>
     <jsp:param name="id" value="5" />
     <jsp:param name="name" value="guru" />
  </jsp:params>
</jsp:plugin>
</body>
</html>

Aluno.java

package demotest; 

import java.io.Serializable;

public class Student implements Serializable {
	
	public String getName () { 
		return name; 
	}
	public void setName (String name) {
		this.name = name;
	}
	public int getId() { 
		return id; 
	} 
	public void setId (int id) { 
		this.id = id; 
	} 
	private String name = "null"; 
	private int id = 0;
	
}

Explicação do código:

Action_jsp5.jsp

Code Linha 10: Aqui estamos usando o objeto jsp:plugin, que utiliza três atributos.

  • Tipo – neste caso, é feijão.
  • Code – nome do arquivo.
  • Codebase – caminho com o nome do pacote.

Code Linha 11-14: Aqui estamos utilizando o objeto jsp:params, que contém um objeto filho param com os atributos name e value, e estamos definindo os valores de id e name nesses atributos.

Aluno.java

Code 7-17: Estamos usando getters e setters para as variáveis ​​id e name.

Code 19-20: Estamos inicializando as variáveis ​​id e nome.

Aqui, obteremos a saída no caso em que os valores definidos para o parâmetro forem usados ​​no bean Student. Nesse caso, não teremos nenhuma saída, pois estamos apenas definindo e obtendo valores para o parâmetro, mas não os imprimindo em nenhum lugar.

jsp:body Tag de ação

  • Esta tag é usada para definir o XML dinamicamente, onde o elementos Pode ser gerado durante o momento da requisição, em vez do momento da compilação.
  • Define o XML, que é gerado dinamicamente como um corpo de elemento.

Sintaxe:

<jsp:body></jsp:body>

Aqui, escrevemos a tag do corpo XML dentro dessas tags.

jsp:attribute Tag de ação

  • Essa tag é usada para definir o XML dinamicamente, onde os elementos podem ser gerados durante o momento da requisição, em vez de durante a compilação.
  • Define o atributo do XML que será gerado dinamicamente.

Sintaxe:

<jsp:attribute></jsp:attribute>

Aqui escrevemos a tag de atributo do XML.

Exemplo de corpo e atributo:

Action_jsp6.jsp

<%@ page language="java" contentType="text/html; charset=ISO-8859-1"
    pageEncoding="ISO-8859-1"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
<title>Action Guru JSP6</title>
</head>
<body>
<jsp:element name="GuruXMLElement">
<jsp:attribute name="GuruXMLattribute">
Value
</jsp:attribute>
<jsp:body>Guru XML</jsp:body>
</jsp:element>
</body>
</html>

Explicação do código:

Code Linha 10: Aqui estamos definindo um elemento, que é gerado dinamicamente como XMLe seu nome será GuruElemento XML.

Code Linha 11-13: Aqui estamos definindo um atributo, que será um atributo XML do XML gerado dinamicamente.

Code Linha 14: Aqui temos a ação do corpo, onde estamos escrevendo o corpo XML, que será gerado dinamicamente.

Ao executar o código acima, você obtém a seguinte saída:

jsp:atributo

Saída:

Aqui obtemos o resultado da tag `body` do XML gerado.

jsp:texto Tag de ação

  • É utilizado para inserir texto de modelo em páginas JSP.
  • Seu corpo não contém nenhum outro elemento e contém apenas texto e expressões EL.

Sintaxe:

<jsp:text>template text</jsp:text>

Aqui, "texto do modelo" refere-se apenas ao texto do modelo (que pode ser qualquer texto genérico que precise ser impresso em JSP) ou a qualquer outro texto. expressão EL.

Exemplo:

Action_jsp7.jsp

<%@ page language="java" contentType="text/html; charset=ISO-8859-1"
    pageEncoding="ISO-8859-1"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
<title>Guru Action JSP7</title>
</head>
<body>
<jsp:text>Guru Template Text</jsp:text>
</body>
</html>

Explicação do código:

Code Linha 10: Aqui estamos usando o objeto de texto para imprimir o texto do modelo.

Ao executar o código acima, você obtém a seguinte saída.

jsp:texto

Saída:

Nós estamos conseguindo Guru Texto modelo, que é inserido dentro do objeto de ação de texto.

jsp:output Tag de ação

  • Especifica a declaração XML ou a declaração DOCTYPE do JSP.
  • A declaração XML e o DOCTYPE são declarados na saída.

Sintaxe:

<jsp:output doctype-root-element="" doctype-system="">

Aqui, `doctype-root-element` indica o elemento raiz do documento XML no DOCTYPE. `doctype-system` indica o doctype gerado na saída e fornece um literal de sistema.

Exemplo:

<%@ page language="java" contentType="text/html; charset=ISO-8859-1"
    pageEncoding="ISO-8859-1"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
<title>Action Guru JSP8</title>
</head>
<body>
<jsp:output doctype-root-element="html PUBLIC" doctype-system="http://www.w3.org/TR/html4/loose.dtd"/>
</body>
</html>

Explicação do código:

Code Linha 10: Aqui, estamos usando o objeto de ação de saída para gerar um DOCTYPE, e internamente ele será gerado neste formato:

Não haverá nenhuma saída visível para isso, pois será gerado internamente.

Perguntas Frequentes

As tags de ação JSP são elementos no estilo XML que controlam o comportamento do mecanismo de servlet durante o processamento de requisições. Elas permitem que os desenvolvedores incluam arquivos, encaminhem requisições e usem JavaIncorpore beans, applets e gere dinamicamente saída XML dentro de uma página JSP.

As diretivas são processadas uma única vez durante a tradução da página e afetam a estrutura geral da página. As tags de ação são reavaliadas a cada solicitação, o que as torna adequadas para comportamentos dinâmicos, como inclusão de conteúdo, encaminhamento de solicitações e interação com outros elementos. JavaFeijões em tempo de execução.

Use `jsp:include` quando precisar mesclar conteúdo de outra página na resposta atual, como cabeçalhos ou rodapés. Use `jsp:forward` quando o controle deve ser transferido completamente para outro recurso e a página atual não deve produzir mais nenhuma saída.

jsp:useBean instancia ou localiza um JavaBean em um escopo específico. O método `jsp:setProperty` atribui um valor a uma propriedade do bean, e o método `jsp:getProperty` lê o valor da propriedade e o escreve como uma string na resposta, permitindo uma separação clara entre a apresentação e a lógica do bean.

Os atributos `jsp:body` e `jsp:attribute` definem corpos e atributos dinâmicos de elementos XML. O atributo `jsp:text` escreve texto literal de modelo e expressões EL, e o atributo `jsp:output` controla a declaração XML ou o DOCTYPE produzido quando o JSP renderiza sua resposta.

A IA é integrada em aplicações JSP e JEE por meio de chamadas REST para APIs de modelagem, assistentes de bate-papo incorporados e widgets de recomendação renderizados em páginas JSP. A IA também auxilia na geração de código JSP padrão, sugere o uso de tags de ação e valida a conexão de beans durante o desenvolvimento.

Sim. Ferramentas com inteligência artificial analisam código JSP legado, identificam padrões de tags de ação e propõem refatorações para frameworks modernos como Spring MVC, Thymeleaf ou REST, além de aplicações de página única. Elas também geram testes de migração, relatórios de dependências e planos de refatoração passo a passo.

Resuma esta postagem com: