O que são JavaServer Pages?

JavaServer Pages (JSP) é uma tecnologia para desenvolver páginas da Web que oferece suporte a conteúdo dinâmico. Isso ajuda os desenvolvedores a inserir o código Java em páginas HTML, fazendo uso de tags JSP especiais, a maioria das quais começa com <% e termina com%>.

Um componente JavaServer Pages é um tipo de servlet Java projetado para cumprir a função de uma interface de usuário para um aplicativo da web Java. Os desenvolvedores da Web escrevem JSPs como arquivos de texto que combinam código HTML ou XHTML, elementos XML e ações e comandos JSP incorporados.

Usando JSP, você pode coletar dados de usuários por meio de formulários de página da Web, apresentar registros de um banco de dados ou de outra fonte e criar páginas da Web dinamicamente.

As tags JSP podem ser usadas para uma variedade de propósitos, como recuperar informações de um banco de dados ou registrar preferências do usuário, acessar componentes JavaBeans, passar o controle entre páginas e compartilhar informações entre solicitações, páginas, etc.

Por que usar JSP?

JavaServer Pages muitas vezes têm o mesmo propósito que programas implementados usando o Common Gateway Interface (CGI). Mas o JSP oferece várias vantagens em comparação com o CGI.

• O desempenho é significativamente melhor porque o JSP permite a incorporação de elementos dinâmicos nas próprias páginas HTML em vez de ter arquivos CGI separados.

• JSP são sempre compilados antes de serem processados ​​pelo servidor, ao contrário do CGI / Perl que requer que o servidor carregue um interpretador e o script de destino cada vez que a página é solicitada.

• JavaServer Pages são construídos sobre a API Java Servlets, então, como Servlets, JSP também tem acesso a todas as APIs Java Enterprise poderosas, incluindo JDBC, JNDI, EJB, JAXP, etc.

• As páginas JSP podem ser usadas em combinação com servlets que tratam da lógica de negócios, o modelo suportado por mecanismos de modelo de servlet Java.

Por fim, JSP é parte integrante do Java EE, uma plataforma completa para aplicativos de classe empresarial. Isso significa que o JSP pode desempenhar um papel desde os aplicativos mais simples até os mais complexos e exigentes.

Vantagens do JSP

A tabela a seguir lista as outras vantagens do uso de JSP em relação a outras tecnologias -

vs. Active Server Pages (ASP)

As vantagens do JSP são duplas. Primeiro, a parte dinâmica é escrita em Java, não em Visual Basic ou em outra linguagem específica da MS, por isso é mais poderosa e fácil de usar. Em segundo lugar, é portátil para outros sistemas operacionais e servidores Web não Microsoft.

vs. Servlets puros

É mais conveniente escrever (e modificar!) HTML regular do que ter muitas instruções println que geram o HTML.

vs. Server-Side Includes (SSI)

O SSI realmente se destina apenas a inclusões simples, não a programas "reais" que usam dados de formulário, fazem conexões de banco de dados e assim por diante.

vs. JavaScript

JavaScript pode gerar HTML dinamicamente no cliente, mas dificilmente pode interagir com o servidor web para realizar tarefas complexas como acesso a banco de dados e processamento de imagens, etc.

x HTML estático

O HTML normal, é claro, não pode conter informações dinâmicas.

O que vem a seguir?

Eu o orientaria passo a passo para configurar seu ambiente para iniciar com JSP. Presumo que você tenha uma boa experiência com a programação Java para prosseguir com o aprendizado de JSP.

Se você não conhece a linguagem de programação Java, recomendamos que consulte nosso Tutorial Java para entender a programação Java.

Um ambiente de desenvolvimento é onde você deve desenvolver seus programas JSP, testá-los e finalmente executá-los.

Este tutorial irá guiá-lo para configurar seu ambiente de desenvolvimento JSP que envolve as seguintes etapas -

Configurando o Java Development Kit

Esta etapa envolve o download de uma implementação do Java Software Development Kit (SDK) e a configuração da variável de ambiente PATH apropriadamente.

Você pode baixar o SDK do site Java da Oracle - Java SE Downloads .

Depois de baixar sua implementação Java, siga as instruções fornecidas para instalar e configurar a configuração. Finalmente defina oPATH and JAVA_HOME variáveis ​​de ambiente para se referir ao diretório que contém java e javac, tipicamente java_install_dir/bin e java_install_dir respectivamente.

Se você estiver executando o Windows e instalar o SDK em C:\jdk1.5.0_20, você precisa adicionar a seguinte linha em seu C:\autoexec.bat Arquivo.

set PATH = C:\jdk1.5.0_20\bin;%PATH%
set JAVA_HOME = C:\jdk1.5.0_20

Alternativamente, em Windows NT/2000/XP, você também pode clicar com o botão direito em My Computer, selecione Properties, então Advanced, Seguido por Environment Variables. Em seguida, você atualizaria o valor de PATH e pressionaria o botão OK.

No Unix (Solaris, Linux, etc.), se o SDK estiver instalado em /usr/local/jdk1.5.0_20 e usar o shell C, você colocará o seguinte em seu .cshrc Arquivo.

setenv PATH /usr/local/jdk1.5.0_20/bin:$PATH
setenv JAVA_HOME /usr/local/jdk1.5.0_20

Alternativamente, se você usar um Integrated Development Environment (IDE) gostar Borland JBuilder, Eclipse, IntelliJ IDEA, ou Sun ONE Studio, compile e execute um programa simples para confirmar se o IDE sabe onde você instalou o Java.

Configurando o servidor web: Tomcat

Vários servidores da Web que suportam o desenvolvimento de JavaServer Pages e Servlets estão disponíveis no mercado. Alguns servidores web podem ser baixados gratuitamente e o Tomcat é um deles.

Apache Tomcat é uma implementação de software de código aberto das tecnologias JavaServer Pages e Servlet e pode atuar como um servidor autônomo para testar JSP e Servlets, e pode ser integrado ao Apache Web Server. Aqui estão as etapas para configurar o Tomcat em sua máquina -

• Baixe a última versão do Tomcat de https://tomcat.apache.org/.

• Depois de fazer o download da instalação, descompacte a distribuição binária em um local conveniente. Por exemplo, emC:\apache-tomcat-5.5.29 on windows, or /usr/local/apache-tomcat-5.5.29 no Linux / Unix e criar CATALINA_HOME variável de ambiente apontando para esses locais.

O Tomcat pode ser iniciado executando os seguintes comandos na máquina Windows -

%CATALINA_HOME%\bin\startup.bat
 
or
 
C:\apache-tomcat-5.5.29\bin\startup.bat

O Tomcat pode ser iniciado executando os seguintes comandos na máquina Unix (Solaris, Linux, etc.) -

$CATALINA_HOME/bin/startup.sh
 
or
 
/usr/local/apache-tomcat-5.5.29/bin/startup.sh

Após uma inicialização bem-sucedida, os aplicativos da web padrão incluídos com o Tomcat estarão disponíveis visitando http://localhost:8080/.

Após a execução, você receberá a seguinte saída -

Mais informações sobre como configurar e executar o Tomcat podem ser encontradas na documentação incluída aqui, bem como no site do Tomcat - https://tomcat.apache.org/.

O Tomcat pode ser interrompido executando os seguintes comandos na máquina Windows -

%CATALINA_HOME%\bin\shutdown
or

C:\apache-tomcat-5.5.29\bin\shutdown

O Tomcat pode ser interrompido executando os seguintes comandos na máquina Unix (Solaris, Linux, etc.) -

$CATALINA_HOME/bin/shutdown.sh

or

/usr/local/apache-tomcat-5.5.29/bin/shutdown.sh

Configurando CLASSPATH

Como os servlets não fazem parte da plataforma Java, Standard Edition, você deve identificar as classes de servlet para o compilador.

Se você estiver executando o Windows, você precisa colocar as seguintes linhas em seu C:\autoexec.bat Arquivo.

set CATALINA = C:\apache-tomcat-5.5.29
set CLASSPATH = %CATALINA%\common\lib\jsp-api.jar;%CLASSPATH%

Alternativamente, em Windows NT/2000/XP, você também pode clicar com o botão direito em My Computer, selecione Properties, então Advanced, então Environment Variables. Em seguida, você atualizaria o valor CLASSPATH e pressionaria o botão OK.

No Unix (Solaris, Linux, etc.), se você estiver usando o shell C, você deve colocar as seguintes linhas em seu .cshrc Arquivo.

setenv CATALINA = /usr/local/apache-tomcat-5.5.29
setenv CLASSPATH $CATALINA/common/lib/jsp-api.jar:$CLASSPATH

NOTE - Supondo que seu diretório de desenvolvimento seja C:\JSPDev (Windows) ou /usr/JSPDev (Unix), então você precisaria adicionar esses diretórios também em CLASSPATH.

O servidor da web precisa de um mecanismo JSP, ou seja, um contêiner para processar páginas JSP. O contêiner JSP é responsável por interceptar solicitações de páginas JSP. Este tutorial usa o Apache, que possui um contêiner JSP integrado para suportar o desenvolvimento de páginas JSP.

Um contêiner JSP funciona com o servidor Web para fornecer o ambiente de tempo de execução e outros serviços de que um JSP precisa. Ele sabe como entender os elementos especiais que fazem parte dos JSPs.

O diagrama a seguir mostra a posição do contêiner JSP e dos arquivos JSP em um aplicativo da web.

Processamento JSP

As etapas a seguir explicam como o servidor da web cria a página da web usando JSP -

• Como em uma página normal, seu navegador envia uma solicitação HTTP ao servidor da web.

• O servidor da web reconhece que a solicitação HTTP é para uma página JSP e a encaminha para um mecanismo JSP. Isso é feito usando a página URL ou JSP que termina com.jsp ao invés de .html.

• O mecanismo JSP carrega a página JSP do disco e a converte em um conteúdo de servlet. Essa conversão é muito simples, na qual todo o texto do modelo é convertido em instruções println () e todos os elementos JSP são convertidos em código Java. Este código implementa o comportamento dinâmico correspondente da página.

• O mecanismo JSP compila o servlet em uma classe executável e encaminha a solicitação original para um mecanismo servlet.

• Uma parte do servidor da web chamada mecanismo de servlet carrega a classe Servlet e a executa. Durante a execução, o servlet produz uma saída em formato HTML. A saída é passada para o servidor da web pelo mecanismo de servlet dentro de uma resposta HTTP.

• O servidor da web encaminha a resposta HTTP para o seu navegador em termos de conteúdo HTML estático.

• Finalmente, o navegador da web lida com a página HTML gerada dinamicamente dentro da resposta HTTP exatamente como se fosse uma página estática.

Todas as etapas mencionadas acima podem ser vistas no diagrama a seguir -

Normalmente, o mecanismo JSP verifica se um servlet para um arquivo JSP já existe e se a data de modificação no JSP é mais antiga que o servlet. Se o JSP for mais antigo do que seu servlet gerado, o contêiner JSP assume que o JSP não mudou e que o servlet gerado ainda corresponde ao conteúdo do JSP. Isso torna o processo mais eficiente do que com outras linguagens de script (como PHP) e, portanto, mais rápido.

Portanto, de certa forma, uma página JSP é apenas outra maneira de escrever um servlet sem precisar ser um gênio da programação Java. Exceto para a fase de tradução, uma página JSP é tratada exatamente como um servlet regular.

Neste capítulo, discutiremos o ciclo de vida do JSP. A chave para entender a funcionalidade de baixo nível do JSP é entender o ciclo de vida simples que eles seguem.

Um ciclo de vida JSP é definido como o processo desde sua criação até a destruição. Isso é semelhante a um ciclo de vida do servlet com uma etapa adicional que é necessária para compilar um JSP no servlet.

Caminhos seguidos por JSP

A seguir estão os caminhos seguidos por um JSP -

• Compilation
• Initialization
• Execution
• Cleanup

As quatro fases principais de um ciclo de vida JSP são muito semelhantes ao Ciclo de vida do servlet. As quatro fases foram descritas abaixo -

Compilação JSP

Quando um navegador pede um JSP, o mecanismo JSP primeiro verifica se é necessário compilar a página. Se a página nunca foi compilada ou se o JSP foi modificado desde a última compilação, o mecanismo JSP compila a página.

O processo de compilação envolve três etapas -

• Analisando o JSP.
• Transformando o JSP em um servlet.
• Compilando o servlet.

Inicialização JSP

Quando um contêiner carrega um JSP, ele invoca o jspInit()antes de atender a quaisquer solicitações. Se você precisar executar a inicialização específica de JSP, substitua ojspInit() método -

public void jspInit(){
   // Initialization code...
}

Normalmente, a inicialização é executada apenas uma vez e como com o método init do servlet, você geralmente inicializa conexões de banco de dados, abre arquivos e cria tabelas de pesquisa no método jspInit.

Execução JSP

Esta fase do ciclo de vida JSP representa todas as interações com pedidos até que o JSP seja destruído.

Sempre que um navegador solicita um JSP e a página foi carregada e inicializada, o mecanismo JSP invoca o _jspService() método no JSP.

O método _jspService () leva um HttpServletRequest e um HttpServletResponse como seus parâmetros da seguinte forma -

void _jspService(HttpServletRequest request, HttpServletResponse response) {
   // Service handling code...
}

o _jspService()método de um JSP é chamado com base na solicitação. Ele é responsável por gerar a resposta para essa solicitação e esse método também é responsável por gerar respostas para todos os sete métodos HTTP, ou seja,GET, POST, DELETEetc.

Limpeza JSP

A fase de destruição do ciclo de vida JSP representa quando um JSP está sendo removido do uso por um contêiner.

o jspDestroy()método é o equivalente JSP do método destroy para servlets. Substitua jspDestroy quando precisar executar qualquer limpeza, como liberar conexões de banco de dados ou fechar arquivos abertos.

O método jspDestroy () tem a seguinte forma -

public void jspDestroy() {
   // Your cleanup code goes here.
}

Neste capítulo, discutiremos a sintaxe em JSP. Vamos entender o uso básico da sintaxe simples (ou seja, elementos) envolvida com o desenvolvimento JSP.

Elementos de JSP

Os elementos do JSP foram descritos abaixo -

The Scriptlet

Um scriptlet pode conter qualquer número de instruções da linguagem JAVA, declarações de variáveis ​​ou métodos ou expressões que sejam válidas na linguagem de script de página.

A seguir está a sintaxe do Scriptlet -

<% code fragment %>

Você pode escrever o equivalente em XML da sintaxe acima da seguinte maneira -

<jsp:scriptlet>
   code fragment
</jsp:scriptlet>

Qualquer texto, tags HTML ou elementos JSP que você escrever deve estar fora do scriptlet. A seguir está o exemplo simples e primeiro para JSP -

<html>
   <head><title>Hello World</title></head>
   
   <body>
      Hello World!<br/>
      <%
         out.println("Your IP address is " + request.getRemoteAddr());
      %>
   </body>
</html>

NOTE - Supondo que o Apache Tomcat esteja instalado em C: \ apache-tomcat-7.0.2 e seu ambiente seja configurado de acordo com o tutorial de configuração do ambiente.

Vamos manter o código acima no arquivo JSP hello.jsp e colocar este arquivo em C:\apache-tomcat7.0.2\webapps\ROOTdiretório. Navegue pelo mesmo usando URLhttp://localhost:8080/hello.jsp. O código acima irá gerar o seguinte resultado -

Declarações JSP

Uma declaração declara uma ou mais variáveis ​​ou métodos que você pode usar no código Java posteriormente no arquivo JSP. Você deve declarar a variável ou método antes de usá-lo no arquivo JSP.

A seguir está a sintaxe para declarações JSP -

<%! declaration; [ declaration; ]+ ... %>

Você pode escrever o equivalente em XML da sintaxe acima da seguinte maneira -

<jsp:declaration>
   code fragment
</jsp:declaration>

A seguir está um exemplo para declarações JSP -

<%! int i = 0; %> 
<%! int a, b, c; %> 
<%! Circle a = new Circle(2.0); %>

Expressão JSP

Um elemento de expressão JSP contém uma expressão de linguagem de script que é avaliada, convertida em uma String e inserida onde a expressão aparece no arquivo JSP.

Como o valor de uma expressão é convertido em uma String, você pode usar uma expressão em uma linha de texto, esteja ou não marcada com HTML, em um arquivo JSP.

O elemento de expressão pode conter qualquer expressão que seja válida de acordo com a Especificação da linguagem Java, mas você não pode usar um ponto-e-vírgula para encerrar uma expressão.

A seguir está a sintaxe da expressão JSP -

<%= expression %>

Você pode escrever o equivalente em XML da sintaxe acima da seguinte maneira -

<jsp:expression>
   expression
</jsp:expression>

O exemplo a seguir mostra uma expressão JSP -

<html> 
   <head><title>A Comment Test</title></head> 
   
   <body>
      <p>Today's date: <%= (new java.util.Date()).toLocaleString()%></p>
   </body> 
</html>

O código acima irá gerar o seguinte resultado -

Today's date: 11-Sep-2010 21:24:25

Comentários JSP

O comentário JSP marca o texto ou as instruções que o contêiner JSP deve ignorar. Um comentário JSP é útil quando você deseja ocultar ou "comentar" uma parte de sua página JSP.

A seguir está a sintaxe dos comentários JSP -

<%-- This is JSP comment --%>

O exemplo a seguir mostra os Comentários JSP -

<html> 
   <head><title>A Comment Test</title></head> 
   
   <body> 
      <h2>A Test of Comments</h2> 
      <%-- This comment will not be visible in the page source --%> 
   </body> 
</html>

O código acima irá gerar o seguinte resultado -

A Test of Comments

Há um pequeno número de construções especiais que você pode usar em vários casos para inserir comentários ou caracteres que, de outra forma, seriam tratados de maneira especial. Aqui está um resumo -

S.No.	Sintaxe e propósito
1	<%-- comment --%> Um comentário JSP. Ignorado pelo mecanismo JSP.
2	<!-- comment --> Um comentário HTML. Ignorado pelo navegador.
3	<\% Representa estático <% literal.
4	%\> Representa%> literal estático.
5	\' Uma aspa simples em um atributo que usa aspas simples.
6	\" Aspas duplas em um atributo que usa aspas duplas.

Diretivas JSP

Uma diretiva JSP afeta a estrutura geral da classe de servlet. Geralmente tem o seguinte formato -

<%@ directive attribute="value" %>

Existem três tipos de tag diretiva -

S.No.	Diretriz e descrição
1	<%@ page ... %> Define atributos dependentes de página, como linguagem de script, página de erro e requisitos de buffer.
2	<%@ include ... %> Inclui um arquivo durante a fase de tradução.
3	<%@ taglib ... %> Declara uma biblioteca de tags, contendo ações personalizadas, usadas na página

Explicaríamos a diretiva JSP em um capítulo separado JSP - Diretivas

Ações JSP

Uso de ações JSP constructsna 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 plugin 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.

Explicaríamos as ações JSP em um capítulo separado JSP - Ações

Objetos JSP Implícitos

JSP suporta nove variáveis ​​definidas automaticamente, que também são chamadas de objetos implícitos. Essas variáveis ​​são -

S.No.	Objeto e descrição
1	request Isto é o HttpServletRequest objeto associado à solicitação.
2	response Isto é o HttpServletResponse objeto associado à resposta ao cliente.
3	out Isto é o PrintWriter objeto usado para enviar saída ao cliente.
4	session Isto é o HttpSession objeto associado à solicitação.
5	application Isto é o ServletContext objeto associado ao contexto do aplicativo.
6	config Isto é o ServletConfig objeto associado à página.
7	pageContext Isso encapsula o uso de recursos específicos do servidor, como melhor desempenho JspWriters.
8	page Isso é simplesmente um sinônimo para thise é usado para chamar os métodos definidos pela classe de servlet traduzida.
9	Exception o Exception objeto permite que os dados de exceção sejam acessados ​​por JSP designado.

Explicaríamos os Objetos Implícitos JSP em um capítulo separado JSP - Objetos Implícitos .

Declarações de controle-fluxo

Você pode usar todas as APIs e blocos de construção de Java em sua programação JSP, incluindo instruções de tomada de decisão, loops, etc.

Declarações de tomada de decisão

o if...else bloco começa como um Scriptlet comum, mas o Scriptlet é fechado em cada linha com o texto HTML incluído entre as tags Scriptlet.

<%! int day = 3; %> 
<html> 
   <head><title>IF...ELSE Example</title></head> 
   
   <body>
      <% if (day == 1 || day == 7) { %>
         <p> Today is weekend</p>
      <% } else { %>
         <p> Today is not weekend</p>
      <% } %>
   </body> 
</html>

O código acima irá gerar o seguinte resultado -

Today is not weekend

Agora olhe para o seguinte switch...case bloco que foi escrito um pouco diferente usando out.println() e dentro do Scriptletas -

<%! int day = 3; %> 
<html> 
   <head><title>SWITCH...CASE Example</title></head> 
   
   <body>
      <% 
         switch(day) {
            case 0:
               out.println("It\'s Sunday.");
               break;
            case 1:
               out.println("It\'s Monday.");
               break;
            case 2:
               out.println("It\'s Tuesday.");
               break;
            case 3:
               out.println("It\'s Wednesday.");
               break;
            case 4:
               out.println("It\'s Thursday.");
               break;
            case 5:
               out.println("It\'s Friday.");
               break;
            default:
               out.println("It's Saturday.");
         }
      %>
   </body> 
</html>

O código acima irá gerar o seguinte resultado -

It's Wednesday.

Demonstrações de Loop

Você também pode usar três tipos básicos de blocos de loop em Java: for, while, and do…while blocos em sua programação JSP.

Vejamos o seguinte for exemplo de loop -

<%! int fontSize; %> 
<html> 
   <head><title>FOR LOOP Example</title></head> 
   
   <body>
      <%for ( fontSize = 1; fontSize <= 3; fontSize++){ %>
         <font color = "green" size = "<%= fontSize %>">
            JSP Tutorial
      </font><br />
      <%}%>
   </body> 
</html>

O código acima irá gerar o seguinte resultado -

JSP Tutorial 


 JSP Tutorial 


 JSP Tutorial 

O exemplo acima pode ser escrito usando o while loop da seguinte forma -

<%! int fontSize; %> 
<html> 
   <head><title>WHILE LOOP Example</title></head> 
   
   <body>
      <%while ( fontSize <= 3){ %>
         <font color = "green" size = "<%= fontSize %>">
            JSP Tutorial
         </font><br />
         <%fontSize++;%>
      <%}%>
   </body> 
</html>

O código acima irá gerar o seguinte resultado -

JSP Tutorial 

 JSP Tutorial 

 JSP Tutorial

Operadores JSP

JSP oferece suporte a todos os operadores lógicos e aritméticos suportados pelo Java. A tabela a seguir lista todos os operadores com a precedência mais alta aparecem na parte superior da tabela, aqueles com a mais baixa aparecem na parte inferior.

Em uma expressão, os operadores de precedência superior serão avaliados primeiro.

Categoria	Operador	Associatividade
Postfix	() []. (operador ponto)	Da esquerda para direita
Unário	++ - -! ~	Direita para esquerda
Multiplicativo	* /%	Da esquerda para direita
Aditivo	+ -	Da esquerda para direita
Mudança	>> >>> <<	Da esquerda para direita
Relacional	>> = <<=	Da esquerda para direita
Igualdade	==! =	Da esquerda para direita
E bit a bit	E	Da esquerda para direita
XOR bit a bit	^	Da esquerda para direita
OR bit a bit	|	Da esquerda para direita
E lógico	&&	Da esquerda para direita
OR lógico	||	Da esquerda para direita
Condicional	?:	Direita para esquerda
Tarefa	= + = - = * = / =% = >> = << = & = ^ = | =	Direita para esquerda
Vírgula	,	Da esquerda para direita

Literais JSP

A linguagem de expressão JSP define os seguintes literais -

• Boolean - verdadeiro e falso

• Integer - como em Java

• Floating point - como em Java

• String- com aspas simples e duplas; "tem escape como \", 'tem escape como \' e \ tem escape como \\.

• Null - nulo

Neste capítulo, discutiremos as diretivas em JSP. Essas diretivas fornecem orientações e instruções para o contêiner, informando-o sobre como lidar com certos aspectos do processamento JSP.

Uma diretiva JSP afeta a estrutura geral da classe de servlet. Geralmente tem o seguinte formato -

<%@ directive attribute = "value" %>

As diretivas podem ter vários atributos que você pode listar como pares de valores-chave e separados por vírgulas.

Os espaços em branco entre o símbolo @ e o nome da diretiva, e entre o último atributo e o%> de fechamento, são opcionais.

Existem três tipos de tag diretiva -

S.No.	Diretriz e descrição
1	<%@ page ... %> Define atributos dependentes de página, como linguagem de script, página de erro e requisitos de buffer.
2	<%@ include ... %> Inclui um arquivo durante a fase de tradução.
3	<%@ taglib ... %> Declara uma biblioteca de tags, contendo ações personalizadas, usadas na página

JSP - A diretiva da página

o pagediretiva é usada para fornecer instruções para o contêiner. Essas instruções pertencem à página JSP atual. Você pode codificar diretivas de página em qualquer lugar em sua página JSP. Por convenção, as diretivas de página são codificadas na parte superior da página JSP.

A seguir está a sintaxe básica da diretiva da página -

<%@ page attribute = "value" %>

Você pode escrever o equivalente em XML da sintaxe acima da seguinte maneira -

<jsp:directive.page attribute = "value" />

Atributos

A tabela a seguir lista os atributos associados à diretiva da página -

S.No.	Atributo e propósito
1	buffer Especifica um modelo de buffer para o fluxo de saída.
2	autoFlush Controla o comportamento do buffer de saída do servlet.
3	contentType Define o esquema de codificação de caracteres.
4	errorPage Define a URL de outro JSP que relata exceções de tempo de execução não verificadas do Java.
5	isErrorPage Indica se esta página JSP é um URL especificado pelo atributo errorPage de outra página JSP.
6	extends Especifica uma superclasse que o servlet gerado deve estender.
7	import Especifica uma lista de pacotes ou classes para uso no JSP como a instrução de importação Java faz para classes Java.
8	info Define uma string que pode ser acessada com o servlet getServletInfo() método.
9	isThreadSafe Define o modelo de encadeamento para o servlet gerado.
10	language Define a linguagem de programação usada na página JSP.
11	session Especifica se a página JSP participa ou não de sessões HTTP
12	isELIgnored Especifica se a expressão EL na página JSP será ignorada ou não.
13	isScriptingEnabled Determina se os elementos de script têm permissão para uso.

Verifique para obter mais detalhes relacionados a todos os atributos acima na Diretiva de Página .

A incluir diretiva

o includediretiva é usada para incluir um arquivo durante a fase de tradução. Essa diretiva informa ao contêiner para mesclar o conteúdo de outros arquivos externos com o JSP atual durante a fase de tradução. Você pode codificar oinclude diretivas em qualquer lugar em sua página JSP.

A forma de uso geral desta diretiva é a seguinte -

<%@ include file = "relative url" >

O nome do arquivo na diretiva de inclusão é, na verdade, um URL relativo. Se você apenas especificar um nome de arquivo sem um caminho associado, o compilador JSP assumirá que o arquivo está no mesmo diretório que seu JSP.

Você pode escrever o equivalente em XML da sintaxe acima da seguinte maneira -

<jsp:directive.include file = "relative url" />

Para obter mais detalhes relacionados à diretiva de inclusão, verifique a Diretiva de inclusão .

A diretiva taglib

A API JavaServer Pages permite definir tags JSP customizadas que se parecem com tags HTML ou XML e uma biblioteca de tags é um conjunto de tags definidas pelo usuário que implementam o comportamento personalizado.

o taglib A diretiva declara que sua página JSP usa um conjunto de tags customizadas, identifica a localização da biblioteca e fornece meios para identificar as tags customizadas em sua página JSP.

A diretiva taglib segue a sintaxe fornecida abaixo -

<%@ taglib uri="uri" prefix = "prefixOfTag" >

Aqui o uri o valor do atributo é resolvido para um local que o contêiner entende e o prefix atributo informa um contêiner quais bits de marcação são ações personalizadas.

Você pode escrever o equivalente em XML da sintaxe acima da seguinte maneira -

<jsp:directive.taglib uri = "uri" prefix = "prefixOfTag" />

Para mais detalhes relacionados à diretiva taglib, verifique a Diretiva Taglib .

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 plugin 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)session, e (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 plugin 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 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.

Neste capítulo, discutiremos os objetos implícitos em JSP. Esses objetos são os objetos Java que o JSP Container disponibiliza aos desenvolvedores em cada página e o desenvolvedor pode chamá-los diretamente sem ser declarado explicitamente. Objetos JSP Implícitos também são chamadospre-defined variables.

A tabela a seguir lista os nove objetos implícitos que JSP suporta -

S.No.	Objeto e descrição
1	request Isto é o HttpServletRequest objeto associado à solicitação.
2	response Isto é o HttpServletResponse objeto associado à resposta ao cliente.
3	out Isto é o PrintWriter objeto usado para enviar saída ao cliente.
4	session Isto é o HttpSession objeto associado à solicitação.
5	application Isto é o ServletContext objeto associado ao contexto do aplicativo.
6	config Isto é o ServletConfig objeto associado à página.
7	pageContext Isso encapsula o uso de recursos específicos do servidor, como melhor desempenho JspWriters.
8	page Isso é simplesmente um sinônimo para thise é usado para chamar os métodos definidos pela classe de servlet traduzida.
9	Exception o Exception objeto permite que os dados de exceção sejam acessados ​​por JSP designado.

O objeto do pedido

O objeto de solicitação é uma instância de um javax.servlet.http.HttpServletRequestobjeto. Cada vez que um cliente solicita uma página, o mecanismo JSP cria um novo objeto para representar essa solicitação.

O objeto de solicitação fornece métodos para obter as informações do cabeçalho HTTP, incluindo dados de formulário, cookies, métodos HTTP etc.

Podemos cobrir um conjunto completo de métodos associados ao objeto de solicitação em um capítulo subsequente - JSP - Solicitação do cliente .

O objeto de resposta

O objeto de resposta é uma instância de um javax.servlet.http.HttpServletResponseobjeto. Assim como o servidor cria o objeto de solicitação, ele também cria um objeto para representar a resposta ao cliente.

O objeto de resposta também define as interfaces que lidam com a criação de novos cabeçalhos HTTP. Através deste objeto, o programador JSP pode adicionar novos cookies ou carimbos de data, códigos de status HTTP, etc.

Cobriremos um conjunto completo de métodos associados ao objeto de resposta em um capítulo subsequente - JSP - Resposta do servidor .

O objeto fora

O objeto implícito é uma instância de um javax.servlet.jsp.JspWriter objeto e é usado para enviar conteúdo em uma resposta.

O objeto JspWriter inicial é instanciado de forma diferente dependendo se a página está armazenada em buffer ou não. O buffer pode ser facilmente desligado usando obuffered = 'false' atributo da diretiva da página.

O objeto JspWriter contém a maioria dos mesmos métodos que o java.io.PrintWriterclasse. No entanto, JspWriter possui alguns métodos adicionais projetados para lidar com o armazenamento em buffer. Ao contrário do objeto PrintWriter, JspWriter lançaIOExceptions.

A tabela a seguir lista os métodos importantes que usaremos para escrever boolean char, int, double, object, Stringetc.

S.No.	Método e Descrição
1	out.print(dataType dt) Imprimir um valor de tipo de dados
2	out.println(dataType dt) Imprima um valor de tipo de dados e termine a linha com um novo caractere de linha.
3	out.flush() Lave o riacho.

O objeto da sessão

O objeto da sessão é uma instância de javax.servlet.http.HttpSession e se comporta exatamente da mesma maneira que os objetos de sessão se comportam em Servlets Java.

O objeto de sessão é usado para rastrear a sessão do cliente entre as solicitações do cliente. Cobriremos o uso completo do objeto de sessão em um capítulo subsequente - JSP - Rastreamento de Sessão .

O objeto do aplicativo

O objeto do aplicativo é um wrapper direto em torno do ServletContext objeto para o Servlet gerado e, na realidade, uma instância de um javax.servlet.ServletContext objeto.

Este objeto é uma representação da página JSP em todo o seu ciclo de vida. Este objeto é criado quando a página JSP é inicializada e será removido quando a página JSP for removida pelojspDestroy() método.

Ao adicionar um atributo ao aplicativo, você pode garantir que todos os arquivos JSP que constituem o seu aplicativo da web tenham acesso a ele.

Verificaremos o uso do Objeto Aplicativo no capítulo JSP - Contador de Acessos .

O objeto de configuração

O objeto de configuração é uma instanciação de javax.servlet.ServletConfig e é um invólucro direto em torno do ServletConfig objeto para o servlet gerado.

Este objeto permite que o programador JSP acesse os parâmetros de inicialização do mecanismo Servlet ou JSP, como os caminhos ou locais de arquivo, etc.

Os seguintes config método é o único que você pode usar, e seu uso é trivial -

config.getServletName();

Isso retorna o nome do servlet, que é a string contida no <servlet-name> elemento definido no WEB-INF\web.xml Arquivo.

O objeto pageContext

O objeto pageContext é uma instância de um javax.servlet.jsp.PageContextobjeto. O objeto pageContext é usado para representar a página JSP inteira.

Este objeto tem o objetivo de ser um meio de acessar informações sobre a página, evitando a maioria dos detalhes de implementação.

Este objeto armazena referências aos objetos de solicitação e resposta para cada solicitação. oapplication, config, sessione os objetos out são derivados acessando os atributos deste objeto.

O objeto pageContext também contém informações sobre as diretivas emitidas para a página JSP, incluindo as informações de buffer, o errorPageURL e o escopo da página.

A classe PageContext define vários campos, incluindo PAGE_SCOPE, REQUEST_SCOPE, SESSION_SCOPE, e APPLICATION_SCOPE, que identificam os quatro escopos. Ele também suporta mais de 40 métodos, cerca de metade dos quais são herdados dojavax.servlet.jsp.JspContext class.

Um dos métodos importantes é removeAttribute. Este método aceita um ou dois argumentos. Por exemplo,pageContext.removeAttribute ("attrName") remove o atributo de todos os escopos, enquanto o código a seguir apenas o remove do escopo da página -

pageContext.removeAttribute("attrName", PAGE_SCOPE);

O uso de pageContext pode ser verificado no capítulo JSP - Upload de Arquivo .

O objeto da página

Este objeto é uma referência real à instância da página. Pode ser considerado um objeto que representa toda a página JSP.

O objeto da página é realmente um sinônimo direto para o this objeto.

O objeto de exceção

O objeto de exceção é um wrapper contendo a exceção lançada da página anterior. Normalmente é usado para gerar uma resposta apropriada à condição de erro.

Cobriremos o uso completo deste objeto no capítulo JSP - Tratamento de Exceções .

Neste capítulo, discutiremos a solicitação do cliente em JSP. Quando um navegador solicita uma página da web, ele envia muitas informações ao servidor da web. Essas informações não podem ser lidas diretamente porque viajam como parte do cabeçalho da solicitação HTTP. Você pode verificar o protocolo HTTP para obter mais informações sobre isso.

A tabela a seguir lista as informações importantes do cabeçalho que vêm do navegador. Esta informação é freqüentemente usada em programação web -

S.No.	Cabeçalho e Descrição
1	Accept Este cabeçalho especifica o MIMEtipos que o navegador ou outros clientes podem manipular. Valores deimage/png ou image/jpeg são as duas possibilidades mais comuns.
2	Accept-Charset Este cabeçalho especifica os conjuntos de caracteres que o navegador pode usar para exibir as informações. Por exemplo,ISO-8859-1.
3	Accept-Encoding Este cabeçalho especifica os tipos de codificação que o navegador sabe como lidar. Valores degzip ou compress são as duas possibilidades mais comuns.
4	Accept-Language Este cabeçalho especifica os idiomas preferidos do cliente, caso o servlet possa produzir resultados em mais de um idioma. Por exemploen, en-us, ruetc.
5	Authorization Esse cabeçalho é usado pelos clientes para se identificarem ao acessar páginas da web protegidas por senha.
6	Connection Este cabeçalho indica se o cliente pode lidar com conexões HTTP persistentes. As conexões persistentes permitem que o cliente ou outro navegador recupere vários arquivos com uma única solicitação. Um valor deKeep-Alive significa que conexões persistentes devem ser usadas.
7	Content-Length Este cabeçalho é aplicável apenas a POST solicita e fornece o tamanho dos dados POST em bytes.
8	Cookie Este cabeçalho retorna cookies aos servidores que os enviaram anteriormente ao navegador.
9	Host Este cabeçalho especifica o host e a porta conforme fornecidos no URL original.
10	If-Modified-Since Este cabeçalho indica que o cliente deseja a página apenas se ela tiver sido alterada após a data especificada. O servidor envia um código 304 que significaNot Modified cabeçalho se nenhum resultado mais recente estiver disponível.
11	If-Unmodified-Since Este cabeçalho é o reverso de If-Modified-Since; ele especifica que a operação deve ser bem-sucedida apenas se o documento for mais antigo que a data especificada.
12	Referer Este cabeçalho indica o URL das páginas da web de referência. Por exemplo, se você estiver na página 1 e clicar em um link para a página 2, o URL da página 1 será incluído no cabeçalho do Referer quando o navegador solicitar a página 2.
13	User-Agent Este cabeçalho identifica o navegador ou outro cliente que faz a solicitação e pode ser usado para retornar conteúdo diferente para diferentes tipos de navegadores.

O objeto HttpServletRequest

O objeto de solicitação é uma instância de um javax.servlet.http.HttpServletRequestobjeto. Cada vez que um cliente solicita uma página, o mecanismo JSP cria um novo objeto para representar essa solicitação.

O objeto de solicitação fornece métodos para obter informações do cabeçalho HTTP, incluindo form data, cookies, HTTP methodsetc.

A tabela a seguir lista os métodos importantes que podem ser usados ​​para ler o cabeçalho HTTP em seu programa JSP. Esses métodos estão disponíveis com o objeto HttpServletRequest, que representa a solicitação do cliente ao servidor da web.

S.No.	Método e Descrição
1	Cookie[] getCookies() Retorna uma matriz contendo todos os objetos Cookie que o cliente enviou com esta solicitação.
2	Enumeration getAttributeNames() Retorna uma Enumeração contendo os nomes dos atributos disponíveis para esta solicitação.
3	Enumeration getHeaderNames() Retorna uma enumeração de todos os nomes de cabeçalho que esta solicitação contém.
4	Enumeration getParameterNames() Retorna uma enumeração de objetos String contendo os nomes dos parâmetros contidos nesta solicitação.
5	HttpSession getSession() Retorna a sessão atual associada a esta solicitação ou, se a solicitação não tiver uma sessão, cria uma.
6	HttpSession getSession(boolean create) Retorna a HttpSession atual associada a esta solicitação ou, se não houver sessão atual e criar for verdadeiro, retorna uma nova sessão.
7	Locale getLocale() Retorna o Locale preferido no qual o cliente aceitará o conteúdo, com base no cabeçalho Accept-Language.
8	Object getAttribute(String name) Retorna o valor do atributo nomeado como um objeto ou nulo se nenhum atributo com o nome fornecido existir.
9	ServletInputStream getInputStream() Recupera o corpo da solicitação como dados binários usando um ServletInputStream.
10	String getAuthType() Retorna o nome do esquema de autenticação usado para proteger o servlet, por exemplo, "BASIC" ou "SSL", ou nulo se o JSP não estiver protegido.
11	String getCharacterEncoding() Retorna o nome da codificação de caracteres usada no corpo desta solicitação.
12	String getContentType() Retorna o tipo MIME do corpo da solicitação ou nulo se o tipo não for conhecido.
13	String getContextPath() Retorna a parte do URI da solicitação que indica o contexto da solicitação.
14	String getHeader(String name) Retorna o valor do cabeçalho da solicitação especificada como uma String.
15	String getMethod() Retorna o nome do método HTTP com o qual esta solicitação foi feita, por exemplo, GET, POST ou PUT.
16	String getParameter(String name) Retorna o valor de um parâmetro de solicitação como String ou nulo se o parâmetro não existe.
17	String getPathInfo() Retorna qualquer informação de caminho extra associada ao URL que o cliente enviou quando fez esta solicitação.
18	String getProtocol() Retorna o nome e a versão do protocolo usado pela solicitação.
19	String getQueryString() Retorna a string de consulta contida no URL da solicitação após o caminho.
20	String getRemoteAddr() Retorna o endereço de protocolo da Internet (IP) do cliente que enviou a solicitação.
21	String getRemoteHost() Retorna o nome totalmente qualificado do cliente que enviou a solicitação.
22	String getRemoteUser() Retorna o login do usuário que fez esta solicitação, se o usuário foi autenticado, ou nulo se o usuário não foi autenticado.
23	String getRequestURI() Retorna a parte do URL desta solicitação do nome do protocolo até a string de consulta na primeira linha da solicitação HTTP.
24	String getRequestedSessionId() Retorna o ID da sessão especificado pelo cliente.
25	String getServletPath() Retorna a parte da URL desta solicitação que chama o JSP.
26	String[] getParameterValues(String name) Retorna uma matriz de objetos String contendo todos os valores do parâmetro de solicitação fornecido ou nulo se o parâmetro não existir.
27	boolean isSecure() Retorna um booleano indicando se a solicitação foi feita usando um canal seguro, como HTTPS.
28	int getContentLength() Retorna o comprimento, em bytes, do corpo da solicitação e disponibilizado pelo fluxo de entrada, ou -1 se o comprimento não for conhecido.
29	int getIntHeader(String name) Retorna o valor do cabeçalho da solicitação especificada como um int.
30	int getServerPort() Retorna o número da porta na qual esta solicitação foi recebida.

Exemplo de solicitação de cabeçalho HTTP

A seguir está o exemplo que usa getHeaderNames() método de HttpServletRequestpara ler as informações do cabeçalho HTTP. Este método retorna uma Enumeração que contém as informações do cabeçalho associadas à solicitação HTTP atual.

Assim que tivermos uma Enumeração, podemos fazer um loop para baixo da Enumeração da maneira padrão. Vamos usar ohasMoreElements() método para determinar quando parar e o nextElement() método para obter o nome de cada nome de parâmetro.

<%@ page import = "java.io.*,java.util.*" %>

<html>
   <head>
      <title>HTTP Header Request Example</title>
   </head>

   <body>
      <center>
         <h2>HTTP Header Request Example</h2>
         
         <table width = "100%" border = "1" align = "center">
            <tr bgcolor = "#949494">
               <th>Header Name</th>
               <th>Header Value(s)</th>
            </tr>
            <%
               Enumeration headerNames = request.getHeaderNames();
               while(headerNames.hasMoreElements()) {
                  String paramName = (String)headerNames.nextElement();
                  out.print("<tr><td>" + paramName + "</td>\n");
                  String paramValue = request.getHeader(paramName);
                  out.println("<td> " + paramValue + "</td></tr>\n");
               }
            %>
         </table>
      </center>
   
   </body>
</html>

Vamos agora colocar o código acima em main.jsp e tente acessá-lo.

Exemplo de solicitação de cabeçalho HTTP

Nome do cabeçalho	Valor (es) do cabeçalho
aceitar	* / *
aceitar linguagem	en-us
agente de usuário	Mozilla / 4.0 (compatível; MSIE 7.0; Windows NT 5.1; Trident / 4.0; InfoPath.2; MS-RTC LM 8)
aceitar codificação	gzip, deflate
hospedeiro	localhost: 8080
conexão	Mantenha vivo
cache-control	sem cache

Você pode tentar trabalhar em todos os métodos de maneira semelhante.

Neste capítulo, discutiremos a resposta do servidor em JSP. Quando um servidor Web responde a uma solicitação HTTP, a resposta geralmente consiste em uma linha de status, alguns cabeçalhos de resposta, uma linha em branco e o documento. Uma resposta típica fica assim -

HTTP/1.1 200 OK
Content-Type: text/html
Header2: ...
...
HeaderN: ...
   (Blank Line)
<!doctype ...>

<html>
   <head>...</head>
   <body>
      ...
   </body>
</html>

A linha de status consiste na versão HTTP (HTTP/1.1 in the example), um código de status (200 in the example), e uma mensagem muito curta correspondente ao código de status (OK in the example).

A seguir está um resumo dos cabeçalhos de resposta HTTP 1.1 mais úteis que retornam ao navegador do servidor da web. Esses cabeçalhos são frequentemente usados ​​em programação web -

S.No.	Cabeçalho e Descrição
1	Allow Este cabeçalho especifica os métodos de solicitação (GET, POST, etc.) que o servidor suporta.
2	Cache-Control Este cabeçalho especifica as circunstâncias nas quais o documento de resposta pode ser armazenado em cache com segurança. Pode ter valorespublic, private ou no-cache etc. Público significa que o documento pode ser armazenado em cache, Privado significa que o documento é para um único usuário e só pode ser armazenado em caches privados (não compartilhados) e sem cache significa que o documento nunca deve ser armazenado em cache.
3	Connection Este cabeçalho instrui o navegador se deve usar conexões HTTP persistentes ou não. Um valor declose instrui o navegador a não usar conexões HTTP persistentes e keep-alive significa usar conexões persistentes.
4	Content-Disposition Este cabeçalho permite solicitar que o navegador peça ao usuário para salvar a resposta no disco em um arquivo com o nome fornecido.
5	Content-Encoding Este cabeçalho especifica a forma como a página foi codificada durante a transmissão.
6	Content-Language Este cabeçalho indica o idioma no qual o documento foi escrito. Por exemplo,en, en-us, ru, etc.
7	Content-Length Este cabeçalho indica o número de bytes na resposta. Essas informações são necessárias apenas se o navegador estiver usando uma conexão HTTP persistente (keep-alive).
8	Content-Type Este cabeçalho dá o MIME (Multipurpose Internet Mail Extension) tipo de documento de resposta.
9	Expires Este cabeçalho especifica a hora em que o conteúdo deve ser considerado desatualizado e, portanto, não deve mais ser armazenado em cache.
10	Last-Modified Este cabeçalho indica quando o documento foi alterado pela última vez. O cliente pode então armazenar em cache o documento e fornecer uma data por umIf-Modified-Since cabeçalho da solicitação em solicitações posteriores.
11	Location Esse cabeçalho deve ser incluído em todas as respostas que possuem um código de status na casa dos 300s. Isso notifica o navegador do endereço do documento. O navegador se reconecta automaticamente a este local e recupera o novo documento.
12	Refresh Este cabeçalho especifica em quanto tempo o navegador deve solicitar uma página atualizada. Você pode especificar o tempo em segundos após o qual uma página seria atualizada.
13	Retry-After Este cabeçalho pode ser usado em conjunto com um 503 (Service Unavailable) resposta para dizer ao cliente quando ele pode repetir seu pedido.
14	Set-Cookie Este cabeçalho especifica um cookie associado à página.

O objeto HttpServletResponse

O objeto de resposta é uma instância de um javax.servlet.http.HttpServletResponse object. Assim como o servidor cria o objeto de solicitação, ele também cria um objeto para representar a resposta ao cliente.

O objeto de resposta também define as interfaces que lidam com a criação de novos cabeçalhos HTTP. Por meio deste objeto, o programador JSP pode adicionar novos cookies ou carimbos de data, códigos de status HTTP etc.

Os métodos a seguir podem ser usados ​​para definir o cabeçalho de resposta HTTP em seu programa de servlet. Esses métodos estão disponíveis com o objeto HttpServletResponse . Este objeto representa a resposta do servidor.

S.No.	Método e Descrição
1	String encodeRedirectURL(String url) Codifica o URL especificado para uso no sendRedirect ou, se a codificação não for necessária, retorna o URL inalterado.
2	String encodeURL(String url) Codifica o URL especificado incluindo o ID da sessão nele ou, se a codificação não for necessária, retorna o URL inalterado.
3	boolean containsHeader(String name) Retorna um booleano indicando se o cabeçalho de resposta nomeado já foi definido.
4	boolean isCommitted() Retorna um booleano indicando se a resposta foi confirmada.
5	void addCookie(Cookie cookie) Adiciona o cookie especificado à resposta.
6	void addDateHeader(String name, long date) Adiciona um cabeçalho de resposta com o nome e valor de data fornecidos.
7	void addHeader(String name, String value) Adiciona um cabeçalho de resposta com o nome e valor fornecidos.
8	void addIntHeader(String name, int value) Adiciona um cabeçalho de resposta com o nome e valor inteiro fornecidos.
9	void flushBuffer() Força qualquer conteúdo do buffer a ser gravado no cliente.
10	void reset() Limpa todos os dados existentes no buffer, bem como o código de status e cabeçalhos.
11	void resetBuffer() Limpa o conteúdo do buffer subjacente na resposta sem limpar cabeçalhos ou código de status.
12	void sendError(int sc) Envia uma resposta de erro ao cliente usando o código de status especificado e limpando o buffer.
13	void sendError(int sc, String msg) Envia uma resposta de erro ao cliente usando o status especificado.
14	void sendRedirect(String location) Envia uma resposta de redirecionamento temporária ao cliente usando o URL do local de redirecionamento especificado.
15	void setBufferSize(int size) Define o tamanho do buffer preferido para o corpo da resposta.
16	void setCharacterEncoding(String charset) Define a codificação de caracteres (conjunto de caracteres MIME) da resposta enviada ao cliente, por exemplo, para UTF-8.
17	void setContentLength(int len) Define o comprimento do corpo do conteúdo na resposta Em servlets HTTP; este método também define o cabeçalho HTTP Content-Length.
18	void setContentType(String type) Define o tipo de conteúdo da resposta que está sendo enviada ao cliente, se a resposta ainda não foi confirmada.
19	void setDateHeader(String name, long date) Define um cabeçalho de resposta com o nome e valor de data fornecidos.
20	void setHeader(String name, String value) Define um cabeçalho de resposta com o nome e valor fornecidos.
21	void setIntHeader(String name, int value) Define um cabeçalho de resposta com o nome e valor inteiro fornecidos.
22	void setLocale(Locale loc) Define a localidade da resposta, se a resposta ainda não foi confirmada.
23	void setStatus(int sc) Define o código de status para esta resposta.

Exemplo de resposta de cabeçalho HTTP

O exemplo a seguir usaria setIntHeader() método para definir Refresh cabeçalho para simular um relógio digital -

<%@ page import = "java.io.*,java.util.*" %>

<html>
   
   <head>
      <title>Auto Refresh Header Example</title>
   </head>
   
   <body>
      <center>
         <h2>Auto Refresh Header Example</h2>
         <%
            // Set refresh, autoload time as 5 seconds
            response.setIntHeader("Refresh", 5);
            
            // Get current time
            Calendar calendar = new GregorianCalendar();
            
            String am_pm;
            int hour = calendar.get(Calendar.HOUR);
            int minute = calendar.get(Calendar.MINUTE);
            int second = calendar.get(Calendar.SECOND);
            
            if(calendar.get(Calendar.AM_PM) == 0) 
               am_pm = "AM";
            else
               am_pm = "PM";
               String CT = hour+":"+ minute +":"+ second +" "+ am_pm;
               out.println("Current Time is: " + CT + "\n");
         %>
      </center>
   
   </body>
</html>

Agora coloque o código acima em main.jspe tente acessá-lo. Isso exibirá a hora atual do sistema a cada 5 segundos, conforme a seguir. Execute o JSP. Você receberá a seguinte saída: -

 
       
Auto Refresh Header Example
 Current Time is: 9:44:50 PM 
      

Você pode tentar trabalhar com os outros métodos de maneira semelhante.

Neste capítulo, discutiremos os códigos de status Http em JSP. O formato da solicitação HTTP e as mensagens de resposta HTTP são semelhantes e terão a seguinte estrutura -

• Uma linha de status inicial + CRLF (Retorno de carro + Alimentação de linha, ou seja, nova linha)

• Zero ou mais linhas de cabeçalho + CRLF

• Uma linha em branco, ou seja. um CRLF

• Um corpo de mensagem opcional como arquivo, dados de consulta ou saída de consulta.

Por exemplo, um cabeçalho de resposta do servidor se parece com o seguinte -

HTTP/1.1 200 OK
Content-Type: text/html
Header2: ...
...
HeaderN: ...
   (Blank Line)
<!doctype ...>

<html>
   <head>...</head>
   
   <body>
      ...
   </body>
</html>

A linha de status consiste no HTTP version (HTTP/1.1 in the example), um código de status (200 no exemplo) e uma mensagem muito curta correspondente ao código de status (OK in the example).

A tabela a seguir lista os códigos de status HTTP e as mensagens associadas que podem ser retornadas do servidor da Web -

Código	mensagem	Descrição
100	Continuar	Apenas uma parte da solicitação foi recebida pelo servidor, mas desde que não tenha sido rejeitada, o cliente deve continuar com a solicitação
101	Protocolos de troca	O servidor muda de protocolo.
200	Está bem	O pedido está OK
201	Criada	A solicitação está concluída e um novo recurso é criado
202	Aceitaram	A solicitação foi aceita para processamento, mas o processamento não foi concluído.
203	Informação não oficial
204	Sem conteúdo
205	Redefinir conteúdo
206	Conteúdo Parcial
300	Escolhas múltiplas	Uma lista de links; o usuário pode selecionar um link e ir para aquele local. Máximo de cinco endereços.
301	Movido Permanentemente	A página solicitada foi movida para um novo url.
302	Encontrado	A página solicitada foi movida temporariamente para um novo url.
303	Veja outro	A página solicitada pode ser encontrada em um URL diferente.
304	Não modificado
305	Usar proxy
306	Não utilizado	Este código foi usado em uma versão anterior. Não é mais usado, mas o código está reservado.
307	Redirecionamento temporário	A página solicitada foi movida temporariamente para um novo url.
400	Pedido ruim	O servidor não entendeu a solicitação.
401	Não autorizado	A página solicitada precisa de um nome de usuário e uma senha.
402	Pagamento Requerido	Você não pode usar este código ainda.
403	Proibido	O acesso é proibido à página solicitada
404	Não encontrado	O servidor não pode encontrar a página solicitada.
405	Método não permitido	O método especificado na solicitação não é permitido.
406	Não aceitável	O servidor só pode gerar uma resposta que não seja aceita pelo cliente.
407	Autenticação proxy necessária	Você deve se autenticar com um servidor proxy antes que esta solicitação possa ser atendida.
408	Solicitar tempo limite	A solicitação demorou mais do que o servidor estava preparado para aguardar.
409	Conflito	A solicitação não pôde ser concluída devido a um conflito.
410	Se foi	A página solicitada não está mais disponível.
411	Comprimento Requerido	O "Content-Length" não está definido. O servidor não aceitará a solicitação sem ele.
412	A pré-condição falhou	A pré-condição fornecida na solicitação avaliada como falsa pelo servidor.
413	Solicitar Entidade Muito Grande	O servidor não aceitará a solicitação porque a entidade da solicitação é muito grande.
414	Request-url muito longo	O servidor não aceitará a solicitação porque o url é muito longo. Isso ocorre quando você converte uma solicitação "post" em uma solicitação "get" com uma longa informação de consulta.
415	Tipo de mídia não suportado	O servidor não aceitará a solicitação porque o tipo de mídia não é compatível.
417	A expectativa falhou
500	Erro do Servidor Interno	O pedido não foi concluído. O servidor encontrou uma condição inesperada.
501	Não implementado	O pedido não foi concluído. O servidor não oferece suporte à funcionalidade necessária.
502	Gateway ruim	O pedido não foi concluído. O servidor recebeu uma resposta inválida do servidor upstream.
503	Serviço indisponível	O pedido não foi concluído. O servidor está temporariamente sobrecarregado ou inativo.
504	Tempo limite do gateway	O gateway atingiu o tempo limite.
505	Versão HTTP não suportada	O servidor não suporta o "http protocol" versão.

Métodos para definir o código de status HTTP

Os métodos a seguir podem ser usados ​​para definir o Código de status HTTP em seu programa de servlet. Esses métodos estão disponíveis com o objeto HttpServletResponse .

S.No.	Método e Descrição
1	public void setStatus ( int statusCode ) Este método define um código de status arbitrário. O método setStatus aceita um int (o código de status) como argumento. Se sua resposta incluir um código de status especial e um documento, ligue parasetStatusantes de realmente retornar qualquer conteúdo com o PrintWriter .
2	public void sendRedirect(String url) Este método gera uma resposta 302 junto com um cabeçalho Location fornecendo a URL do novo documento.
3	public void sendError(int code, String message) Este método envia um código de status (geralmente 404) junto com uma mensagem curta que é formatada automaticamente dentro de um documento HTML e enviada ao cliente.

Exemplo de código de status HTTP

O exemplo a seguir mostra como um código de erro 407 é enviado ao navegador do cliente. Depois disso, o navegador mostraria "Need authentication!!!" mensagem.

<html>
   <head>
      <title>Setting HTTP Status Code</title>
   </head>
   
   <body>
      <%
         // Set error code and reason.
         response.sendError(407, "Need authentication!!!" );
      %>
   </body>
</html>

Você receberá a seguinte saída -

HTTP Status 407 - Need authentication!!!
type Status report
message Need authentication!!!
description The client must first authenticate itself with the proxy (Need authentication!!!).
Apache Tomcat/5.5.29

Para se familiarizar com os códigos de status HTTP, tente definir códigos de status diferentes e suas descrições.

Neste capítulo, discutiremos o Processamento de Formulários em JSP. Você deve ter se deparado com muitas situações em que precisa passar algumas informações de seu navegador para o servidor da web e, finalmente, para seu programa de back-end. O navegador usa dois métodos para passar essas informações ao servidor da web. Esses métodos são o Método GET e o Método POST.

Os métodos no processamento de formulários

Vamos agora discutir os métodos de Processamento de Formulários.

Método GET

O método GET envia as informações codificadas do usuário anexadas à solicitação de página. A página e as informações codificadas são separadas por? personagem da seguinte forma -

http://www.test.com/hello?key1=value1&key2=value2

O método GET é o método padrão para passar informações do navegador para o servidor web e produz uma longa string que aparece no seu navegador Location:box. Recomenda-se que o método GET seja melhor não usado. se você tiver senha ou outras informações confidenciais para passar para o servidor.

O método GET tem limitação de tamanho: only 1024 characters can be in a request string.

Esta informação é passada usando QUERY_STRING header e estará acessível por meio da variável de ambiente QUERY_STRING, que pode ser tratada usando getQueryString() e getParameter() métodos do objeto de solicitação.

Método POST

Um método geralmente mais confiável de passar informações para um programa de back-end é o método POST.

Este método empacota as informações exatamente da mesma maneira que o método GET, mas em vez de enviá-las como uma string de texto após um? no URL, ele o envia como uma mensagem separada. Esta mensagem chega ao programa de backend na forma de entrada padrão que você pode analisar e usar para seu processamento.

JSP lida com este tipo de solicitações usando getParameter() método para ler parâmetros simples e getInputStream() método para ler o fluxo de dados binários vindo do cliente.

Leitura de dados de formulário usando JSP

JSP lida com a análise de dados de formulário automaticamente usando os seguintes métodos, dependendo da situação -

• getParameter() - Você liga request.getParameter() método para obter o valor de um parâmetro de formulário.

• getParameterValues() - Chame este método se o parâmetro aparecer mais de uma vez e retornar vários valores, por exemplo, caixa de seleção.

• getParameterNames() - Chame esse método se quiser uma lista completa de todos os parâmetros na solicitação atual.

• getInputStream() - Chame este método para ler o fluxo de dados binários vindo do cliente.

Exemplo de método GET usando URL

A seguinte URL passará dois valores para o programa HelloForm usando o método GET.

http://localhost:8080/main.jsp?first_name=ZARA&last_name=ALI

Abaixo está o main.jspPrograma JSP para lidar com a entrada fornecida pelo navegador da web. Vamos usar ogetParameter() método que torna muito fácil acessar as informações passadas -

<html>
   <head>
      <title>Using GET Method to Read Form Data</title>
   </head>
   
   <body>
      <h1>Using GET Method to Read Form Data</h1>
      <ul>
         <li><p><b>First Name:</b>
            <%= request.getParameter("first_name")%>
         </p></li>
         <li><p><b>Last  Name:</b>
            <%= request.getParameter("last_name")%>
         </p></li>
      </ul>
   
   </body>
</html>

Agora digite http://localhost:8080/main.jsp?first_name=ZARA&last_name=ALI no seu navegador Location:box. Isso irá gerar o seguinte resultado -

Usando o método GET para ler os dados do formulário First Name: ZARA Last Name: TODOS

Exemplo de método GET usando formulário

A seguir está um exemplo que passa dois valores usando o FORM HTML e o botão de envio. Vamos usar o mesmo JSP main.jsp para lidar com essa entrada.

<html>
   <body>
      
      <form action = "main.jsp" method = "GET">
         First Name: <input type = "text" name = "first_name">
         <br />
         Last Name: <input type = "text" name = "last_name" />
         <input type = "submit" value = "Submit" />
      </form>
      
   </body>
</html>

Mantenha este HTML em um arquivo Hello.htm e coloque-o em <Tomcat-installation-directory>/webapps/ROOT directory. Quando você acessariahttp://localhost:8080/Hello.htm, você receberá a seguinte saída.

Exemplo de método POST usando formulário

Vamos fazer uma pequena modificação no JSP acima para lidar com os métodos GET e POST. Abaixo está omain.jsp Programa JSP para lidar com a entrada fornecida pelo navegador da web usando os métodos GET ou POST.

De fato, não há mudança no JSP acima porque a única maneira de passar parâmetros é alterada e nenhum dado binário está sendo passado para o programa JSP. Os conceitos relacionados ao manuseio de arquivos serão explicados em um capítulo separado, onde precisamos ler o fluxo de dados binários.

<html>
   <head>
      <title>Using GET and POST Method to Read Form Data</title>
   </head>
   
   <body>
      <center>
      <h1>Using POST Method to Read Form Data</h1>
      
      <ul>
         <li><p><b>First Name:</b>
            <%= request.getParameter("first_name")%>
         </p></li>
         <li><p><b>Last  Name:</b>
            <%= request.getParameter("last_name")%>
         </p></li>
      </ul>
   
   </body>
</html>

A seguir está o conteúdo do Hello.htm arquivo -

<html>
   <body>
      
      <form action = "main.jsp" method = "POST">
         First Name: <input type = "text" name = "first_name">
         <br />
         Last Name: <input type = "text" name = "last_name" />
         <input type = "submit" value = "Submit" />
      </form>
      
   </body>
</html>

Vamos agora manter main.jsp e hello.htm em <Tomcat-installationdirectory>/webapps/ROOT directory. Quando você acessahttp://localhost:8080/Hello.htm, você receberá a seguinte saída.

Tente inserir o nome e o sobrenome e clique no botão enviar para ver o resultado em sua máquina local onde o tomcat está sendo executado.

Com base nas informações fornecidas, você receberá resultados semelhantes aos dos exemplos acima.

Passando Dados da Caixa de Seleção para o Programa JSP

As caixas de seleção são usadas quando mais de uma opção deve ser selecionada.

A seguir está um exemplo HTML code, CheckBox.htm, para um formulário com duas caixas de seleção.

<html>
   <body>
      
      <form action = "main.jsp" method = "POST" target = "_blank">
         <input type = "checkbox" name = "maths" checked = "checked" /> Maths
         <input type = "checkbox" name = "physics"  /> Physics
         <input type = "checkbox" name = "chemistry" checked = "checked" /> Chemistry
         <input type = "submit" value = "Select Subject" />
      </form>
      
   </body>
</html>

O código acima irá gerar o seguinte resultado -

A seguir está o programa JSP main.jsp para lidar com a entrada fornecida pelo navegador da web para o botão da caixa de seleção.

<html>
   <head>
      <title>Reading Checkbox Data</title>
   </head>
   
   <body>
      <h1>Reading Checkbox Data</h1>
      
      <ul>
         <li><p><b>Maths Flag:</b>
            <%= request.getParameter("maths")%>
         </p></li>
         <li><p><b>Physics Flag:</b>
            <%= request.getParameter("physics")%>
         </p></li>
         <li><p><b>Chemistry Flag:</b>
            <%= request.getParameter("chemistry")%>
         </p></li>
      </ul>
   
   </body>
</html>

O programa acima irá gerar o seguinte resultado -

Reading Checkbox Data

      
 
       
Maths Flag :: on
 
       
Physics Flag:: null
 
       
Chemistry Flag:: on
 
      

Lendo todos os parâmetros do formulário

A seguir está um exemplo genérico que usa getParameterNames()método de HttpServletRequest para ler todos os parâmetros de formulário disponíveis. Este método retorna uma Enumeração que contém os nomes dos parâmetros em uma ordem não especificada.

Assim que tivermos uma Enumeração, podemos fazer um loop para baixo da Enumeração da maneira padrão, usando o hasMoreElements() método para determinar quando parar e usar o nextElement() método para obter cada nome de parâmetro.

<%@ page import = "java.io.*,java.util.*" %>

<html>
   <head>
      <title>HTTP Header Request Example</title>
   </head>

   <body>
      <center>
         <h2>HTTP Header Request Example</h2>
         <table width = "100%" border = "1" align = "center">
            <tr bgcolor = "#949494">
               <th>Param Name</th>
               <th>Param Value(s)</th>
            </tr>
            <%
               Enumeration paramNames = request.getParameterNames();
               while(paramNames.hasMoreElements()) {
                  String paramName = (String)paramNames.nextElement();
                  out.print("<tr><td>" + paramName + "</td>\n");
                  String paramValue = request.getHeader(paramName);
                  out.println("<td> " + paramValue + "</td></tr>\n");
               }
            %>
         </table>
      </center>
   
   </body>
</html>

A seguir está o conteúdo do Hello.htm -

<html>
   <body>
      
      <form action = "main.jsp" method = "POST" target = "_blank">
         <input type = "checkbox" name = "maths" checked = "checked" /> Maths
         <input type = "checkbox" name = "physics"  /> Physics
         <input type = "checkbox" name = "chemistry" checked = "checked" /> Chem
         <input type = "submit" value = "Select Subject" />
      </form>
   
   </body>
</html>

Agora tente chamar JSP usando o Hello.htm acima; isso geraria um resultado parecido com o abaixo com base na entrada fornecida -

Lendo todos os parâmetros do formulário

Nome Param	Valor (es) de parâmetro
Matemáticas	em
química	em

Você pode tentar o JSP acima para ler os dados de qualquer outro formulário que contenha outros objetos como caixa de texto, botão de rádio ou lista suspensa, etc.

Neste capítulo, discutiremos Filtros em JSP. Filtros Servlet e JSP são classes Java que podem ser usadas na Programação Servlet e JSP para os seguintes propósitos -

• Para interceptar solicitações de um cliente antes que eles acessem um recurso no back end.

• Para manipular as respostas do servidor antes de serem enviadas de volta ao cliente.

Existem vários tipos de filtros sugeridos pelas especificações -

• Filtros de autenticação
• Filtros de compressão de dados
• Filtros de criptografia
• Filtros que acionam eventos de acesso a recursos
• Filtros de conversão de imagem
• Filtros de registro e auditoria
• Filtros de cadeia MIME-TYPE
• Filtros de tokenização
• Filtros XSL / T que transformam conteúdo XML

Os filtros são implantados no arquivo descritor de implantação web.xmle, em seguida, mapeie para nomes de servlet ou JSP ou padrões de URL no descritor de implementação de seu aplicativo. O arquivo descritor de implantação web.xml pode ser encontrado no diretório <Tomcat-installation-directory> \ conf .

Quando o contêiner JSP inicia seu aplicativo da web, ele cria uma instância de cada filtro que você declarou no descritor de implementação. Os filtros são executados na ordem em que são declarados no descritor de implantação.

Métodos de filtro de servlet

Um filtro é simplesmente uma classe Java que implementa o javax.servlet.Filterinterface. A interface javax.servlet.Filter define três métodos -

S.No.	Método e Descrição
1	public void doFilter (ServletRequest, ServletResponse, FilterChain) Este método é chamado pelo contêiner cada vez que um par de solicitação / resposta é passado pela cadeia devido a uma solicitação do cliente por um recurso no final da cadeia.
2	public void init(FilterConfig filterConfig) Este método é chamado pelo contêiner da web para indicar a um filtro que ele está sendo colocado em serviço.
3	public void destroy() Este método é chamado pelo contêiner da web para indicar a um filtro que ele está sendo retirado de serviço.

Exemplo de filtro JSP

O exemplo a seguir mostra como imprimir o endereço IP do cliente e a data e hora atual, cada vez que acessaria qualquer arquivo JSP. Este exemplo lhe dará uma compreensão básica do Filtro JSP, mas você pode escrever aplicativos de filtro mais sofisticados usando o mesmo conceito -

// Import required java libraries
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
import java.util.*;
 
// Implements Filter class
public class LogFilter implements Filter  {
   public void  init(FilterConfig config) throws ServletException {
      // Get init parameter 
      String testParam = config.getInitParameter("test-param"); 
 
      //Print the init parameter 
      System.out.println("Test Param: " + testParam); 
   }
   public void  doFilter(ServletRequest request, ServletResponse response, FilterChain chain) 
      throws java.io.IOException, ServletException {
      
      // Get the IP address of client machine.   
      String ipAddress = request.getRemoteAddr();
      
      // Log the IP address and current timestamp.
      System.out.println("IP "+ ipAddress + ", Time "+ new Date().toString());
      
      // Pass request back down the filter chain
      chain.doFilter(request,response);
   }
   public void destroy( ) {
      /* Called before the Filter instance is removed 
      from service by the web container*/
   }
}

Compilar LogFilter.java da maneira usual e coloque o seu LogFilter.class arquivo em <Tomcat-installation-directory>/webapps/ROOT/WEB-INF/classes.

Mapeamento de filtro JSP em Web.xml

Os filtros são definidos e, em seguida, mapeados para um URL ou nome de arquivo JSP, da mesma forma que o Servlet é definido e, em seguida, mapeado para um padrão de URL em web.xmlArquivo. Crie a seguinte entrada para a tag de filtro no arquivo descritor de implantaçãoweb.xml

<filter>
   <filter-name>LogFilter</filter-name>
   <filter-class>LogFilter</filter-class>
   
   <init-param>
      <param-name>test-param</param-name>
      <param-value>Initialization Paramter</param-value>
   </init-param>
</filter>

<filter-mapping>
   <filter-name>LogFilter</filter-name>
   <url-pattern>/*</url-pattern>
</filter-mapping>

O filtro acima será aplicado a todos os servlets e JSP porque especificamos /*em nossa configuração. Você pode especificar um servlet específico ou o caminho JSP se desejar aplicar o filtro em alguns servlets ou apenas JSP.

Agora tente chamar qualquer servlet ou JSP e você verá o log gerado no log do seu servidor web. Você pode usarLog4J logger para fazer login acima, faça o login em um arquivo separado.

Usando vários filtros

Seu aplicativo da web pode definir vários filtros diferentes com uma finalidade específica. Considere, você define dois filtros AuthenFilter e LogFilter . O resto do processo permanecerá conforme explicado acima, exceto que você precisa criar um mapeamento diferente conforme mencionado abaixo -

<filter>
   <filter-name>LogFilter</filter-name>
   <filter-class>LogFilter</filter-class>
   
   <init-param>
      <param-name>test-param</param-name>
      <param-value>Initialization Paramter</param-value>
   </init-param>
</filter>
 
<filter>
   <filter-name>AuthenFilter</filter-name>
   <filter-class>AuthenFilter</filter-class>
   <init-param>
      <param-name>test-param</param-name>
      <param-value>Initialization Paramter</param-value>
   </init-param>
</filter>
 
<filter-mapping>
   <filter-name>LogFilter</filter-name>
   <url-pattern>/*</url-pattern>
</filter-mapping>
 
<filter-mapping>
   <filter-name>AuthenFilter</filter-name>
   <url-pattern>/*</url-pattern>
</filter-mapping>

Ordem de aplicação de filtros

A ordem dos elementos de mapeamento de filtro em web.xml determina a ordem em que o contêiner da web aplica o filtro ao servlet ou JSP. Para inverter a ordem do filtro, você só precisa reverter os elementos de mapeamento do filtro noweb.xml Arquivo.

Por exemplo, o exemplo acima aplicará o LogFilter primeiro e, em seguida, aplicará AuthenFilter a qualquer servlet ou JSP; o exemplo a seguir inverterá a ordem -

<filter-mapping>
   <filter-name>AuthenFilter</filter-name>
   <url-pattern>/*</url-pattern>
</filter-mapping>
 
<filter-mapping>
   <filter-name>LogFilter</filter-name>
   <url-pattern>/*</url-pattern>
</filter-mapping>

Neste capítulo, discutiremos o Tratamento de Cookies em JSP. Cookies são arquivos de texto armazenados no computador cliente e são mantidos para vários fins de rastreamento de informações. JSP suporta cookies HTTP de forma transparente usando tecnologia de servlet subjacente.

Existem três etapas envolvidas na identificação e retorno de usuários -

• O script de servidor envia um conjunto de cookies para o navegador. Por exemplo, nome, idade ou número de identificação, etc.

• O navegador armazena essas informações na máquina local para uso futuro.

• Na próxima vez que o navegador enviar qualquer solicitação ao servidor da web, ele enviará essas informações de cookies para o servidor e o servidor usará essas informações para identificar o usuário ou também para alguma outra finalidade.

Este capítulo o ensinará como definir ou redefinir cookies, como acessá-los e como excluí-los usando programas JSP.

A anatomia de um biscoito

Os cookies são geralmente definidos em um cabeçalho HTTP (embora o JavaScript também possa definir um cookie diretamente em um navegador). Um JSP que define um cookie pode enviar cabeçalhos parecidos com este -

HTTP/1.1 200 OK
Date: Fri, 04 Feb 2000 21:03:38 GMT
Server: Apache/1.3.9 (UNIX) PHP/4.0b3
Set-Cookie: name = xyz; expires = Friday, 04-Feb-07 22:03:38 GMT; 
   path = /; domain = tutorialspoint.com
Connection: close
Content-Type: text/html

Como você pode ver, o Set-Cookie header contém a name value pair, a GMT date, a path e a domain. O nome e o valor serão codificados por URL. oexpires campo é uma instrução para o navegador "forget" o cookie após a data e hora fornecidas.

Se o navegador estiver configurado para armazenar cookies, ele manterá essas informações até a data de expiração. Se o usuário apontar o navegador para qualquer página que corresponda ao caminho e domínio do cookie, ele reenviará o cookie ao servidor. Os cabeçalhos do navegador podem ser parecidos com isto -

GET / HTTP/1.0
Connection: Keep-Alive
User-Agent: Mozilla/4.6 (X11; I; Linux 2.2.6-15apmac ppc)
Host: zink.demon.co.uk:1126

Accept: image/gif, */*
Accept-Encoding: gzip
Accept-Language: en
Accept-Charset: iso-8859-1,*,utf-8
Cookie: name = xyz

Um script JSP terá acesso aos cookies por meio do método de solicitação request.getCookies()que retorna uma matriz de objetos Cookie .

Métodos de cookies servlet

A tabela a seguir lista os métodos úteis associados ao objeto Cookie que você pode usar ao manipular cookies em JSP -

S.No.	Método e Descrição
1	public void setDomain(String pattern) Este método define o domínio ao qual o cookie se aplica; por exemplo, tutorialspoint.com.
2	public String getDomain() Este método obtém o domínio ao qual o cookie se aplica; por exemplo, tutorialspoint.com.
3	public void setMaxAge(int expiry) Este método define quanto tempo (em segundos) deve decorrer antes que o cookie expire. Se você não definir isso, o cookie durará apenas a sessão atual.
4	public int getMaxAge() Este método retorna a idade máxima do cookie, especificada em segundos, por padrão, -1 indicando que o cookie irá persistir até o navegador desligar.
5	public String getName() Este método retorna o nome do cookie. O nome não pode ser alterado após a criação.
6	public void setValue(String newValue) Este método define o valor associado ao cookie.
7	public String getValue() Este método obtém o valor associado ao cookie.
8	public void setPath(String uri) Este método define o caminho ao qual este cookie se aplica. Se você não especificar um caminho, o cookie será retornado para todos os URLs no mesmo diretório da página atual, bem como para todos os subdiretórios.
9	public String getPath() Este método obtém o caminho ao qual este cookie se aplica.
10	public void setSecure(boolean flag) Este método define o valor booleano que indica se o cookie deve ser enviado apenas por conexões criptografadas (ou seja, SSL).
11	public void setComment(String purpose) Este método especifica um comentário que descreve a finalidade de um cookie. O comentário é útil se o navegador apresentar o cookie ao usuário.
12	public String getComment() Este método retorna o comentário que descreve a finalidade deste cookie, ou null se o cookie não tiver comentários.

Configurando Cookies com JSP

Definir cookies com JSP envolve três etapas -

Etapa 1: Criação de um objeto Cookie

Você chama o construtor Cookie com um nome de cookie e um valor de cookie, sendo que ambos são strings.

Cookie cookie = new Cookie("key","value");

Lembre-se de que nem o nome nem o valor devem conter espaço em branco ou qualquer um dos seguintes caracteres -

[ ] ( ) = , " / ? @ : ;

Etapa 2: definir a idade máxima

Você usa setMaxAgepara especificar por quanto tempo (em segundos) o cookie deve ser válido. O código a seguir irá configurar um cookie por 24 horas.

cookie.setMaxAge(60*60*24);

Etapa 3: enviar o cookie para os cabeçalhos de resposta HTTP

Você usa response.addCookie para adicionar cookies no cabeçalho de resposta HTTP da seguinte forma

response.addCookie(cookie);

Exemplo

Vamos modificar nosso exemplo de formulário para definir os cookies para o nome e o sobrenome.

<%
   // Create cookies for first and last names.      
   Cookie firstName = new Cookie("first_name", request.getParameter("first_name"));
   Cookie lastName = new Cookie("last_name", request.getParameter("last_name"));
   
   // Set expiry date after 24 Hrs for both the cookies.
   firstName.setMaxAge(60*60*24); 
   lastName.setMaxAge(60*60*24); 
   
   // Add both the cookies in the response header.
   response.addCookie( firstName );
   response.addCookie( lastName );
%>

<html>
   <head>
      <title>Setting Cookies</title>
   </head>
   
   <body>
      <center>
         <h1>Setting Cookies</h1>
      </center>
      <ul>
         <li><p><b>First Name:</b>
            <%= request.getParameter("first_name")%>
         </p></li>
         <li><p><b>Last  Name:</b>
            <%= request.getParameter("last_name")%>
         </p></li>
      </ul>
   
   </body>
</html>

Vamos colocar o código acima em main.jsp arquivo e use-o na seguinte página HTML -

<html>
   <body>
      
      <form action = "main.jsp" method = "GET">
         First Name: <input type = "text" name = "first_name">
         <br />
         Last Name: <input type = "text" name = "last_name" />
         <input type = "submit" value = "Submit" />
      </form>
      
   </body>
</html>

Mantenha o conteúdo HTML acima em um arquivo hello.jsp e colocar hello.jsp e main.jsp dentro <Tomcat-installation-directory>/webapps/ROOTdiretório. Quando você vai acessarhttp://localhost:8080/hello.jsp, aqui está a saída real do formulário acima.

Tente inserir o nome e o sobrenome e, a seguir, clique no botão enviar. Isso exibirá o nome e o sobrenome na tela e também definirá dois cookiesfirstName e lastName. Esses cookies serão devolvidos ao servidor na próxima vez que você clicar no botão Enviar.

Na próxima seção, explicaremos como você pode acessar esses cookies de volta em seu aplicativo da web.

Lendo Cookies com JSP

Para ler cookies, você precisa criar uma matriz de objetos javax.servlet.http.Cookie chamando ogetCookies( )método de HttpServletRequest . Em seguida, percorra a matriz e usegetName() e getValue() métodos para acessar cada cookie e valor associado.

Exemplo

Vamos agora ler os cookies que foram definidos no exemplo anterior -

<html>
   <head>
      <title>Reading Cookies</title>
   </head>
   
   <body>
      <center>
         <h1>Reading Cookies</h1>
      </center>
      <%
         Cookie cookie = null;
         Cookie[] cookies = null;
         
         // Get an array of Cookies associated with the this domain
         cookies = request.getCookies();
         
         if( cookies != null ) {
            out.println("<h2> Found Cookies Name and Value</h2>");
            
            for (int i = 0; i < cookies.length; i++) {
               cookie = cookies[i];
               out.print("Name : " + cookie.getName( ) + ",  ");
               out.print("Value: " + cookie.getValue( )+" <br/>");
            }
         } else {
            out.println("<h2>No cookies founds</h2>");
         }
      %>
   </body>
   
</html>

Vamos agora colocar o código acima em main.jsparquivo e tente acessá-lo. Se você definir ofirst_name cookie como "John" e o last_name cookie como "Jogador", em seguida, executando http://localhost:8080/main.jsp exibirá o seguinte resultado -

 Found Cookies Name and Value
Name : first_name, Value: John
Name : last_name, Value: Player

Excluir Cookies com JSP

Excluir cookies é muito simples. Se você deseja excluir um cookie, basta seguir estas três etapas -

• Leia um cookie já existente e armazene-o no objeto Cookie.

• Defina a idade do cookie como zero usando o setMaxAge() método para excluir um cookie existente.

• Adicione esse cookie de volta ao cabeçalho da resposta.

Exemplo

O exemplo a seguir mostrará como excluir um cookie existente chamado "first_name" e quando você executar main.jsp JSP da próxima vez, ele retornará um valor nulo para first_name.

<html>
   <head>
      <title>Reading Cookies</title>
   </head>
   
   <body>
      <center>
         <h1>Reading Cookies</h1>
      </center>
      <%
         Cookie cookie = null;
         Cookie[] cookies = null;
         
         // Get an array of Cookies associated with the this domain
         cookies = request.getCookies();
         
         if( cookies != null ) {
            out.println("<h2> Found Cookies Name and Value</h2>");
            
            for (int i = 0; i < cookies.length; i++) {
               cookie = cookies[i];
               
               if((cookie.getName( )).compareTo("first_name") == 0 ) {
                  cookie.setMaxAge(0);
                  response.addCookie(cookie);
                  out.print("Deleted cookie: " + 
                  cookie.getName( ) + "<br/>");
               }
               out.print("Name : " + cookie.getName( ) + ",  ");
               out.print("Value: " + cookie.getValue( )+" <br/>");
            }
         } else {
            out.println(
            "<h2>No cookies founds</h2>");
         }
      %>
   </body>
   
</html>

Vamos agora colocar o código acima no main.jsparquivo e tente acessá-lo. Ele exibirá o seguinte resultado -

Cookies Name and Value
Deleted cookie : first_name
Name : first_name, Value: John
Name : last_name, Value: Player

Agora execute http: // localhost: 8080 / main.jsp mais uma vez e ele deve exibir apenas um cookie da seguinte forma -

 Found Cookies Name and Value
Name : last_name,  Value: Player

Você pode excluir seus cookies no Internet Explorer manualmente. Comece no menu Ferramentas e selecione Opções da Internet. Para excluir todos os cookies, clique no botão Excluir Cookies.

Neste capítulo, discutiremos o rastreamento de sessão em JSP. HTTP é um protocolo "sem estado", o que significa que cada vez que um cliente recupera uma página da Web, o cliente abre uma conexão separada com o servidor da Web e o servidor automaticamente não mantém nenhum registro da solicitação anterior do cliente.

Mantendo Sessão entre Cliente Web e Servidor

Vamos agora discutir algumas opções para manter a sessão entre o Web Client e o Web Server -

Biscoitos

Um servidor da web pode atribuir um ID de sessão exclusivo como um cookie para cada cliente da web e para solicitações subsequentes do cliente, eles podem ser reconhecidos usando o cookie recebido.

Essa pode não ser uma forma eficaz, pois às vezes o navegador não oferece suporte a cookies. Não é recomendado usar este procedimento para manter as sessões.

Campos de formulário ocultos

Um servidor da web pode enviar um campo de formulário HTML oculto junto com um ID de sessão exclusivo da seguinte maneira -

<input type = "hidden" name = "sessionid" value = "12345">

Esta entrada significa que, quando o formulário é enviado, o nome e o valor especificados são incluídos automaticamente no GET ou o POSTdados. Cada vez que o navegador envia a solicitação de volta, osession_id valor pode ser usado para manter o controle de diferentes navegadores da web.

Esta pode ser uma maneira eficaz de controlar a sessão, mas clicar em um link de hipertexto regular (<A HREF...>) não resulta no envio do formulário, portanto, os campos ocultos do formulário também não podem suportar o rastreamento geral da sessão.

Reescrita de URL

Você pode anexar alguns dados extras no final de cada URL. Esses dados identificam a sessão; o servidor pode associar esse identificador de sessão aos dados que armazenou sobre essa sessão.

Por exemplo, com http://tutorialspoint.com/file.htm;sessionid=12345, o identificador da sessão é anexado como sessionid = 12345 que pode ser acessado no servidor web para identificar o cliente.

A regravação de URL é a melhor maneira de manter as sessões e funciona para os navegadores quando eles não suportam cookies. A desvantagem aqui é que você terá que gerar cada URL dinamicamente para atribuir um ID de sessão, embora a página seja uma página HTML estática simples.

O objeto da sessão

Além das opções mencionadas acima, o JSP usa a interface HttpSession fornecida pelo servlet. Essa interface fornece uma maneira de identificar um usuário.

• um pedido de uma página ou
• visita a um site ou
• armazenar informações sobre aquele usuário

Por padrão, os JSPs têm o rastreamento de sessão ativado e um novo objeto HttpSession é instanciado para cada novo cliente automaticamente. A desativação do rastreamento de sessão requer desativá-lo explicitamente, definindo o atributo da sessão da diretiva da página como falso, conforme a seguir -

<%@ page session = "false" %>

O mecanismo JSP expõe o objeto HttpSession para o autor JSP por meio do implícito sessionobjeto. Desde asession objeto já é fornecido ao programador JSP, o programador pode começar imediatamente a armazenar e recuperar dados do objeto sem qualquer inicialização ou getSession().

Aqui está um resumo dos métodos importantes disponíveis por meio do objeto de sessão -

S.No.	Método e Descrição
1	public Object getAttribute(String name) Este método retorna o objeto vinculado ao nome especificado nesta sessão ou nulo se nenhum objeto estiver vinculado ao nome.
2	public Enumeration getAttributeNames() Este método retorna uma Enumeração de objetos String contendo os nomes de todos os objetos vinculados a esta sessão.
3	public long getCreationTime() Este método retorna a hora em que esta sessão foi criada, medida em milissegundos desde a meia-noite de 1º de janeiro de 1970 GMT.
4	public String getId() Este método retorna uma string contendo o identificador exclusivo atribuído a esta sessão.
5	public long getLastAccessedTime() Este método retorna a última vez que o cliente enviou uma solicitação associada a esta sessão, como o número de milissegundos desde a meia-noite de 1º de janeiro de 1970 GMT.
6	public int getMaxInactiveInterval() Este método retorna o intervalo de tempo máximo, em segundos, que o contêiner do servlet manterá esta sessão aberta entre os acessos do cliente.
7	public void invalidate() Este método invalida esta sessão e desassocia todos os objetos ligados a ela.
8	public boolean isNew() Este método retorna verdadeiro se o cliente ainda não sabe sobre a sessão ou se o cliente escolhe não ingressar na sessão.
9	public void removeAttribute(String name) Este método remove o objeto vinculado ao nome especificado desta sessão.
10	public void setAttribute(String name, Object value) Este método liga um objeto a esta sessão, usando o nome especificado.
11	public void setMaxInactiveInterval(int interval) Este método especifica o tempo, em segundos, entre as solicitações do cliente antes que o contêiner do servlet invalide esta sessão.

Exemplo de rastreamento de sessão

Este exemplo descreve como usar o objeto HttpSession para descobrir a hora de criação e a hora do último acesso de uma sessão. Gostaríamos de associar uma nova sessão ao pedido, se ainda não existir.

<%@ page import = "java.io.*,java.util.*" %>
<%
   // Get session creation time.
   Date createTime = new Date(session.getCreationTime());
   
   // Get last access time of this Webpage.
   Date lastAccessTime = new Date(session.getLastAccessedTime());

   String title = "Welcome Back to my website";
   Integer visitCount = new Integer(0);
   String visitCountKey = new String("visitCount");
   String userIDKey = new String("userID");
   String userID = new String("ABCD");

   // Check if this is new comer on your Webpage.
   if (session.isNew() ){
      title = "Welcome to my website";
      session.setAttribute(userIDKey, userID);
      session.setAttribute(visitCountKey,  visitCount);
   } 
   visitCount = (Integer)session.getAttribute(visitCountKey);
   visitCount = visitCount + 1;
   userID = (String)session.getAttribute(userIDKey);
   session.setAttribute(visitCountKey,  visitCount);
%>

<html>
   <head>
      <title>Session Tracking</title>
   </head>
   
   <body>
      <center>
         <h1>Session Tracking</h1>
      </center>
      
      <table border = "1" align = "center"> 
         <tr bgcolor = "#949494">
            <th>Session info</th>
            <th>Value</th>
         </tr> 
         <tr>
            <td>id</td>
            <td><% out.print( session.getId()); %></td>
         </tr> 
         <tr>
            <td>Creation Time</td>
            <td><% out.print(createTime); %></td>
         </tr> 
         <tr>
            <td>Time of Last Access</td>
            <td><% out.print(lastAccessTime); %></td>
         </tr> 
         <tr>
            <td>User ID</td>
            <td><% out.print(userID); %></td>
         </tr> 
         <tr>
            <td>Number of visits</td>
            <td><% out.print(visitCount); %></td>
         </tr> 
      </table> 
   
   </body>
</html>

Agora coloque o código acima em main.jsp e tentar acessar http://localhost:8080/main.jsp. Depois de executar o URL, você receberá o seguinte resultado -

Bem-vindo ao meu site

Session Information

Informação da sessão	valor
Eu iria	0AE3EC93FF44E3C525B4351B77ABB2D5
Tempo de Criação	Terça-feira, 08 de junho 17:26:40 GMT + 04: 00 2010
Hora do último acesso	Terça-feira, 08 de junho 17:26:40 GMT + 04: 00 2010
ID do usuário	ABCD
Número de visitas	0

Agora tente executar o mesmo JSP pela segunda vez, você receberá o seguinte resultado.

Bem-vindo de volta ao meu site

Session Information

tipo de informação	valor
Eu iria	0AE3EC93FF44E3C525B4351B77ABB2D5
Tempo de Criação	Terça-feira, 08 de junho 17:26:40 GMT + 04: 00 2010
Hora do último acesso	Terça-feira, 08 de junho 17:26:40 GMT + 04: 00 2010
ID do usuário	ABCD
Número de visitas	1

Excluindo Dados da Sessão

Ao terminar com os dados de sessão de um usuário, você tem várias opções -

• Remove a particular attribute - Você pode ligar para o public void removeAttribute(String name) método para excluir o valor associado a uma chave específica.

• Delete the whole session - Você pode ligar para o public void invalidate() método para descartar uma sessão inteira.

• Setting Session timeout - Você pode ligar para o public void setMaxInactiveInterval(int interval) método para definir o tempo limite para uma sessão individualmente.

• Log the user out - Os servidores que suportam servlets 2.4, você pode chamar logout para desconectar o cliente do servidor Web e invalidar todas as sessões pertencentes a todos os usuários.

• web.xml Configuration - Se você estiver usando o Tomcat, além dos métodos mencionados acima, você pode configurar o tempo limite da sessão no arquivo web.xml da seguinte maneira.

<session-config>
   <session-timeout>15</session-timeout>
</session-config>

O tempo limite é expresso em minutos e substitui o tempo limite padrão, que é de 30 minutos no Tomcat.

o getMaxInactiveInterval( )método em um servlet retorna o período de tempo limite para aquela sessão em segundos. Portanto, se sua sessão for configurada em web.xml por 15 minutos,getMaxInactiveInterval( ) retorna 900.

Neste capítulo, discutiremos o upload de arquivos em JSP. Um JSP pode ser usado com uma tag de formulário HTML para permitir que os usuários carreguem arquivos no servidor. Um arquivo carregado pode ser um arquivo de texto ou binário ou um arquivo de imagem ou apenas qualquer documento.

Criação de um formulário de upload de arquivo

Vamos agora entender como criar um formulário de upload de arquivo. O código HTML a seguir cria um formulário de upload. A seguir estão os pontos importantes a serem anotados -

• A forma method atributo deve ser definido como POST método e método GET não podem ser usados.

• A forma enctype atributo deve ser definido como multipart/form-data.

• A forma actionatributo deve ser definido como um arquivo JSP que manipularia o upload de arquivos no servidor backend. O exemplo a seguir está usandouploadFile.jsp arquivo de programa para carregar o arquivo.

• Para fazer upload de um único arquivo, você deve usar um único <input .../> tag com atributo type = "file". Para permitir o upload de vários arquivos, inclua mais de uma tag de entrada com valores diferentes para o atributo name. O navegador associa um botão Procurar a cada um deles.

<html>
   <head>
      <title>File Uploading Form</title>
   </head>
   
   <body>
      <h3>File Upload:</h3>
      Select a file to upload: <br />
      <form action = "UploadServlet" method = "post"
         enctype = "multipart/form-data">
         <input type = "file" name = "file" size = "50" />
         <br />
         <input type = "submit" value = "Upload File" />
      </form>
   </body>
   
</html>

Isso exibirá o seguinte resultado. Agora você pode selecionar um arquivo do PC local e quando o usuário clicar em "Carregar Arquivo", o formulário será enviado junto com o arquivo selecionado -

File Upload − 
Select a file to upload −
 
 

 
 

NOTE - O formulário acima é apenas um formulário fictício e não funcionaria, você deve tentar o código acima em sua máquina para fazê-lo funcionar.

Escrevendo Script Backend JSP

Vamos agora definir um local onde os arquivos carregados serão armazenados. Você pode codificar isso em seu programa ou este nome de diretório também pode ser adicionado usando uma configuração externa, como umcontext-param elemento em web.xml da seguinte forma -

<web-app>
....
<context-param> 
   <description>Location to store uploaded file</description> 
   <param-name>file-upload</param-name> 
   <param-value>
      c:\apache-tomcat-5.5.29\webapps\data\
   </param-value> 
</context-param>
....
</web-app>

A seguir está o código-fonte para UploadFile.jsp. Isso pode lidar com o upload de vários arquivos de uma vez. Vamos agora considerar o seguinte antes de prosseguir com o upload de arquivos.

• O exemplo a seguir depende de FileUpload; certifique-se de ter a versão mais recente docommons-fileupload.x.x.jararquivo em seu classpath. Você pode baixá-lo dehttps://commons.apache.org/fileupload/.

• FileUpload depende do Commons IO; certifique-se de ter a versão mais recente docommons-io-x.x.jararquivo em seu classpath. Você pode baixá-lo dehttps://commons.apache.org/io/.

• Ao testar o exemplo a seguir, você deve fazer upload de um arquivo que seja menor que maxFileSize, caso contrário, o arquivo não será carregado.

• Certifique-se de ter criado diretórios c:\temp e c:\apache-tomcat5.5.29\webapps\data com bastante antecedência.

<%@ page import = "java.io.*,java.util.*, javax.servlet.*" %>
<%@ page import = "javax.servlet.http.*" %>
<%@ page import = "org.apache.commons.fileupload.*" %>
<%@ page import = "org.apache.commons.fileupload.disk.*" %>
<%@ page import = "org.apache.commons.fileupload.servlet.*" %>
<%@ page import = "org.apache.commons.io.output.*" %>

<%
   File file ;
   int maxFileSize = 5000 * 1024;
   int maxMemSize = 5000 * 1024;
   ServletContext context = pageContext.getServletContext();
   String filePath = context.getInitParameter("file-upload");

   // Verify the content type
   String contentType = request.getContentType();
   
   if ((contentType.indexOf("multipart/form-data") >= 0)) {
      DiskFileItemFactory factory = new DiskFileItemFactory();
      // maximum size that will be stored in memory
      factory.setSizeThreshold(maxMemSize);
      
      // Location to save data that is larger than maxMemSize.
      factory.setRepository(new File("c:\\temp"));

      // Create a new file upload handler
      ServletFileUpload upload = new ServletFileUpload(factory);
      
      // maximum file size to be uploaded.
      upload.setSizeMax( maxFileSize );
      
      try { 
         // Parse the request to get file items.
         List fileItems = upload.parseRequest(request);

         // Process the uploaded file items
         Iterator i = fileItems.iterator();

         out.println("<html>");
         out.println("<head>");
         out.println("<title>JSP File upload</title>");  
         out.println("</head>");
         out.println("<body>");
         
         while ( i.hasNext () ) {
            FileItem fi = (FileItem)i.next();
            if ( !fi.isFormField () ) {
               // Get the uploaded file parameters
               String fieldName = fi.getFieldName();
               String fileName = fi.getName();
               boolean isInMemory = fi.isInMemory();
               long sizeInBytes = fi.getSize();
            
               // Write the file
               if( fileName.lastIndexOf("\\") >= 0 ) {
                  file = new File( filePath + 
                  fileName.substring( fileName.lastIndexOf("\\"))) ;
               } else {
                  file = new File( filePath + 
                  fileName.substring(fileName.lastIndexOf("\\")+1)) ;
               }
               fi.write( file ) ;
               out.println("Uploaded Filename: " + filePath + 
               fileName + "<br>");
            }
         }
         out.println("</body>");
         out.println("</html>");
      } catch(Exception ex) {
         System.out.println(ex);
      }
   } else {
      out.println("<html>");
      out.println("<head>");
      out.println("<title>Servlet upload</title>");  
      out.println("</head>");
      out.println("<body>");
      out.println("<p>No file uploaded</p>"); 
      out.println("</body>");
      out.println("</html>");
   }
%>

Agora tente fazer upload de arquivos usando o formulário HTML que você criou acima. Quando você tentahttp://localhost:8080/UploadFile.htm, ele exibirá o seguinte resultado. Isso ajudará você a fazer upload de qualquer arquivo de sua máquina local.

File Upload − 
Select a file to upload −
 
 

 

Se o seu script JSP funcionar bem, seu arquivo deve ser carregado em c:\apache-tomcat5.5.29\webapps\data\ diretório.

Neste capítulo, discutiremos como lidar com dados em JSP. Uma das vantagens mais importantes de usar JSP é que você pode usar todos os métodos disponíveis no núcleo do Java. Vamos levá-lo através doDate classe que está disponível no java.utilpacote; esta classe encapsula a data e hora atuais.

A classe Date oferece suporte a dois construtores. O primeiro construtor inicializa o objeto com a data e hora atuais.

Date( )

O construtor a seguir aceita um argumento que é igual ao número de milissegundos decorridos desde a meia-noite de 1º de janeiro de 1970.

Date(long millisec)

Depois de ter um objeto Date disponível, você pode chamar qualquer um dos seguintes métodos de suporte para brincar com datas -

S.No.	Métodos e Descrição
1	boolean after(Date date) Retorna verdadeiro se o objeto de chamada Date contiver uma data posterior à especificada por data; caso contrário, retorna falso.
2	boolean before(Date date) Retorna verdadeiro se o objeto Date de chamada contiver uma data anterior à especificada por data; caso contrário, retorna falso.
3	Object clone( ) Duplica o objeto Date de chamada.
4	int compareTo(Date date) Compara o valor do objeto de chamada com o de data. Retorna 0 se os valores forem iguais. Retorna um valor negativo se o objeto de chamada for anterior à data. Retorna um valor positivo se o objeto de chamada for posterior à data.
5	int compareTo(Object obj) Opera de forma idêntica a compareTo (Date) se obj for da classe Date. Caso contrário, ele lança uma ClassCastException.
6	boolean equals(Object date) Retorna verdadeiro se o objeto de invocação Date contém a mesma hora e data que aquele especificado por data; caso contrário, retorna falso.
7	long getTime( ) Retorna o número de milissegundos decorridos desde 1º de janeiro de 1970.
8	int hashCode( ) Retorna um código hash para o objeto de chamada.
9	void setTime(long time) Define a hora e a data conforme especificado por time, que representa um tempo decorrido em milissegundos a partir da meia-noite de 1º de janeiro de 1970
10	String toString( ) Converte o objeto de chamada Date em uma string e retorna o resultado.

Obtendo data e hora atuais

Com o programa JSP, é muito fácil obter a data e a hora atuais. Você pode usar um objeto Date simples com otoString() método para imprimir a data atual e a hora da seguinte forma -

<%@ page import = "java.io.*,java.util.*, javax.servlet.*" %>

<html>
   <head>
      <title>Display Current Date & Time</title>
   </head>
   
   <body>
      <center>
         <h1>Display Current Date & Time</h1>
      </center>
      <%
         Date date = new Date();
         out.print( "<h2 align = \"center\">" +date.toString()+"</h2>");
      %>
   </body>
</html>

Vamos agora manter o código em CurrentDate.jsp e, em seguida, chame este JSP usando o URL http://localhost:8080/CurrentDate.jsp. Você receberá o seguinte resultado -

Display Current Date & Time
Mon Jun 21 21:46:49 GMT+04:00 2010

Atualize a página com o URL http://localhost:8080/CurrentDate.jsp. Você encontrará a diferença em segundos toda vez que atualizar.

Comparação de datas

Conforme discutido nas seções anteriores, você pode usar todos os métodos Java disponíveis em seus scripts JSP. Caso você precise comparar duas datas, considere os seguintes métodos -

• Você pode usar getTime( ) método para obter o número de milissegundos decorridos desde a meia-noite de 1º de janeiro de 1970 para ambos os objetos e, em seguida, comparar esses dois valores.

• Você pode usar os métodos before( ), after( ), e equals( )porque o dia 12 do mês vem antes do dia 18; por exemplo,new Date(99, 2, 12).before(new Date (99, 2, 18)) retorna verdadeiro.

• Você pode usar o compareTo( )método; este método é definido peloComparable interface e implementado até Date.

Formatação de data usando SimpleDateFormat

SimpleDateFormat é uma classe concreta para formatar e analisar datas de uma maneira que diferencia a localidade. SimpleDateFormat permite que você comece escolhendo quaisquer padrões definidos pelo usuário para a formatação de data e hora.

Vamos modificar o exemplo acima da seguinte maneira -

<%@ page import = "java.io.*,java.util.*" %>
<%@ page import = "javax.servlet.*,java.text.*" %>

<html>
   <head>
      <title>Display Current Date & Time</title>
   </head>
   
   <body>
      <center>
         <h1>Display Current Date & Time</h1>
      </center>
      <%
         Date dNow = new Date( );
         SimpleDateFormat ft = 
         new SimpleDateFormat ("E yyyy.MM.dd 'at' hh:mm:ss a zzz");
         out.print( "<h2 align=\"center\">" + ft.format(dNow) + "</h2>");
      %>
   </body>
</html>

Compile o servlet acima mais uma vez e, em seguida, chame este servlet usando o URL http://localhost:8080/CurrentDate. Você receberá o seguinte resultado -

Display Current Date & Time
Mon 2010.06.21 at 10:06:44 PM GMT+04:00

Códigos de formato simples de DateFormat

Para especificar o formato da hora, use uma string de padrão de hora. Neste padrão, todas as letras ASCII são reservadas como letras padrão, que são definidas da seguinte forma -

Personagem	Descrição	Exemplo
G	Designador era	DE ANÚNCIOS
y	Ano em quatro dígitos	2001
M	Mês no ano	Julho ou 07
d	Dia no mês	0
h	Hora em AM / PM (1 ~ 12)	2
H	Hora do dia (0 ~ 23)	22
m	Minuto em hora	30
s	Segundo em minuto	55
S	Milissegundo	234
E	Dia da semana	terça
D	Dia no ano	360
F	Dia da semana no mês	2 (segunda quarta-feira em julho)
W	Semana no ano	40
W	Semana no mês
uma	Marcador AM / PM	PM
k	Hora do dia (1 ~ 24)	24
K	Hora em AM / PM (0 ~ 11)	0
z	Fuso horário	Hora Padrão do Leste
'	Escape para texto	Delimitador
"	Citação única	`

Para obter uma lista completa de métodos constantes disponíveis para manipular data, você pode consultar a documentação Java padrão.

Neste capítulo, discutiremos o redirecionamento de página com JSP. O redirecionamento de página geralmente é usado quando um documento é movido para um novo local e precisamos enviar o cliente para esse novo local. Isso pode ser devido ao balanceamento de carga ou para randomização simples.

A maneira mais simples de redirecionar uma solicitação para outra página é usando sendRedirect()método do objeto de resposta. A seguir está a assinatura deste método -

public void response.sendRedirect(String location)
throws IOException

Este método envia de volta a resposta ao navegador junto com o código de status e o novo local da página. Você também pode usar osetStatus() e a setHeader() métodos juntos para obter o mesmo exemplo de redirecionamento -

....
String site = "http://www.newpage.com" ;
response.setStatus(response.SC_MOVED_TEMPORARILY);
response.setHeader("Location", site); 
....

Exemplo

Este exemplo mostra como um JSP executa o redirecionamento de página para outro local -

<%@ page import = "java.io.*,java.util.*" %>

<html>
   <head>
      <title>Page Redirection</title>
   </head>
   
   <body>
      <center>
         <h1>Page Redirection</h1>
      </center>
      <%
         // New location to be redirected
         String site = new String("http://www.photofuntoos.com");
         response.setStatus(response.SC_MOVED_TEMPORARILY);
         response.setHeader("Location", site); 
      %>
   </body>
</html>

Vamos agora colocar o código acima em PageRedirect.jsp e chamar este JSP usando o URL http://localhost:8080/PageRedirect.jsp. Isso levaria você ao URL fornecidohttp://www.photofuntoos.com.

Neste capítulo, discutiremos o contador de acessos em JSP. Um contador de visitas informa sobre o número de visitas em uma página específica do seu site. Normalmente, você anexa um contador de visitas à sua página index.jsp, supondo que as pessoas acessem primeiro sua página inicial.

Para implementar um contador de visitas, você pode usar o objeto Application Implicit e métodos associados getAttribute() e setAttribute().

Este objeto é uma representação da página JSP em todo o seu ciclo de vida. Este objeto é criado quando a página JSP é inicializada e será removido quando a página JSP for removida pelojspDestroy() método.

A seguir está a sintaxe para definir uma variável no nível do aplicativo -

application.setAttribute(String Key, Object Value);

Você pode usar o método acima para definir uma variável de contador de visitas e para redefinir a mesma variável. A seguir está o método para ler a variável definida pelo método anterior -

application.getAttribute(String Key);

Cada vez que um usuário acessa sua página, você pode ler o valor atual do contador de visitas e aumentá-lo em um e configurá-lo novamente para uso futuro.

Exemplo

Este exemplo mostra como você pode usar JSP para contar o número total de acessos em uma página específica. Se você quiser contar o número total de acessos de seu site, terá que incluir o mesmo código em todas as páginas JSP.

<%@ page import = "java.io.*,java.util.*" %>

<html>
   <head>
      <title>Application object in JSP</title>
   </head>
   
   <body>
      <%
         Integer hitsCount = (Integer)application.getAttribute("hitCounter");
         if( hitsCount ==null || hitsCount == 0 ) {
            /* First visit */
            out.println("Welcome to my website!");
            hitsCount = 1;
         } else {
            /* return visit */
            out.println("Welcome back to my website!");
            hitsCount += 1;
         }
         application.setAttribute("hitCounter", hitsCount);
      %>
      <center>
         <p>Total number of visits: <%= hitsCount%></p>
      </center>
   
   </body>
</html>

Vamos agora colocar o código acima em main.jsp e chame este JSP usando o URL http://localhost:8080/main.jsp. Isso exibirá o valor do contador de visitas, que aumenta à medida que você atualiza a página. Você pode tentar acessar a página usando diferentes navegadores e você verá que o contador de visitas continuará aumentando a cada acesso e você receberá o resultado da seguinte forma -

 
       
Welcome back to my website!
 
       
Total number of visits: 12
 
      

Reinicializações do contador de visitas

O que acontece quando você reinicia o seu aplicativo, ou seja, o servidor da web, isso irá redefinir a variável do aplicativo e o contador será zerado. Para evitar essa perda, considere os seguintes pontos -

• Defina uma tabela de banco de dados com uma única contagem, digamos hitcount. Atribua um valor zero a ele.

• A cada hit, leia a tabela para obter o valor de hitcount.

• Aumente o valor de hitcount em um e atualize a tabela com o novo valor.

• Exibe o novo valor de hitcount como contagens de visitas totais da página.

• Se você deseja contar acessos para todas as páginas, implemente a lógica acima para todas as páginas.

Neste capítulo, discutiremos a atualização automática em JSP. Considere uma página da Web que exibe o placar do jogo ao vivo, o status do mercado de ações ou a taxa de câmbio. Para todos esses tipos de páginas, você precisa atualizar sua página da Web regularmente usando o botão Atualizar ou recarregar do navegador.

O JSP facilita esse trabalho, fornecendo a você um mecanismo onde você pode criar uma página da Web de forma que ela seja atualizada automaticamente após um determinado intervalo.

A maneira mais simples de atualizar uma página da Web é usando o setIntHeader()método do objeto de resposta. A seguir está a assinatura deste método -

public void setIntHeader(String header, int headerValue)

Este método envia de volta o cabeçalho "Atualizar" para o navegador junto com um valor inteiro que indica o intervalo de tempo em segundos.

Exemplo de atualização automática de página

No exemplo a seguir, usaremos o setIntHeader() método para definir Refreshcabeçalho. Isso ajudará a simular um relógio digital -

<%@ page import = "java.io.*,java.util.*" %>

<html>
   <head>
      <title>Auto Refresh Header Example</title>
   </head>
   
   <body>
      <center>
         <h2>Auto Refresh Header Example</h2>
         <%
            // Set refresh, autoload time as 5 seconds
            response.setIntHeader("Refresh", 5);
            
            // Get current time
            Calendar calendar = new GregorianCalendar();
            String am_pm;
            
            int hour = calendar.get(Calendar.HOUR);
            int minute = calendar.get(Calendar.MINUTE);
            int second = calendar.get(Calendar.SECOND);
            
            if(calendar.get(Calendar.AM_PM) == 0)
               am_pm = "AM";
            else
               am_pm = "PM";
            String CT = hour+":"+ minute +":"+ second +" "+ am_pm;
            out.println("Crrent Time: " + CT + "\n");
         %>
      </center>
   
   </body>
</html>

Agora coloque o código acima em main.jspe tente acessá-lo. Isso exibirá a hora atual do sistema a cada 5 segundos, conforme a seguir. Basta executar o JSP e esperar para ver o resultado -

Auto Refresh Header Example
Current Time is: 9:44:50 PM

Neste capítulo, discutiremos como enviar e-mails usando JSP. Para enviar um e-mail usando JSP, você deve ter oJavaMail API e a Java Activation Framework (JAF) instalado em sua máquina.

• Você pode baixar a versão mais recente do JavaMail (versão 1.2) do site padrão do Java.

• Você pode baixar a versão mais recente do JavaBeans Activation Framework JAF (Versão 1.0.2) do site padrão do Java.

Baixe e descompacte esses arquivos, nos diretórios de nível superior recém-criados. Você encontrará vários arquivos jar para ambos os aplicativos. Você precisa adicionar omail.jar e a activation.jar arquivos em seu CLASSPATH.

Envie um e-mail simples

Aqui está um exemplo para enviar um e-mail simples de sua máquina. Presume-se que seulocalhostestá conectado à Internet e é capaz de enviar um e-mail. Certifique-se de que todos os arquivos jar do pacote Java Email API e do pacote JAF estejam disponíveis em CLASSPATH.

<%@ page import = "java.io.*,java.util.*,javax.mail.*"%>
<%@ page import = "javax.mail.internet.*,javax.activation.*"%>
<%@ page import = "javax.servlet.http.*,javax.servlet.*" %>

<%
   String result;
   
   // Recipient's email ID needs to be mentioned.
   String to = "[email protected]";

   // Sender's email ID needs to be mentioned
   String from = "[email protected]";

   // Assuming you are sending email from localhost
   String host = "localhost";

   // Get system properties object
   Properties properties = System.getProperties();

   // Setup mail server
   properties.setProperty("mail.smtp.host", host);

   // Get the default Session object.
   Session mailSession = Session.getDefaultInstance(properties);

   try {
      // Create a default MimeMessage object.
      MimeMessage message = new MimeMessage(mailSession);
      
      // Set From: header field of the header.
      message.setFrom(new InternetAddress(from));
      
      // Set To: header field of the header.
      message.addRecipient(Message.RecipientType.TO,
                               new InternetAddress(to));
      // Set Subject: header field
      message.setSubject("This is the Subject Line!");
      
      // Now set the actual message
      message.setText("This is actual message");
      
      // Send message
      Transport.send(message);
      result = "Sent message successfully....";
   } catch (MessagingException mex) {
      mex.printStackTrace();
      result = "Error: unable to send message....";
   }
%>

<html>
   <head>
      <title>Send Email using JSP</title>
   </head>
   
   <body>
      <center>
         <h1>Send Email using JSP</h1>
      </center>
      
      <p align = "center">
         <% 
            out.println("Result: " + result + "\n");
         %>
      </p>
   </body>
</html>

Vamos agora colocar o código acima em SendEmail.jsp arquivo e chame este JSP usando o URL http://localhost:8080/SendEmail.jsp. Isso ajudará a enviar um e-mail para o ID de e-mail fornecido[email protected]. Você receberá a seguinte resposta -

Send Email using JSP
Result: Sent message successfully....

Se você deseja enviar um e-mail para vários destinatários, use os seguintes métodos para especificar vários IDs de e-mail -

void addRecipients(Message.RecipientType type, Address[] addresses)
throws MessagingException

Aqui está a descrição dos parâmetros -

• type- Isso seria definido como TO, CC ou BCC. Aqui, CC representa Carbon Copy e BCC representa Black Carbon Copy. Exemplo Message.RecipientType.TO

• addresses- Esta é a matriz de ID de email. Você precisaria usar o método InternetAddress () ao especificar IDs de e-mail

Envie um email HTML

Aqui está um exemplo para enviar um e-mail HTML de sua máquina. Presume-se que seulocalhostestá conectado à Internet e é capaz de enviar um e-mail. Certifique-se de que todos os arquivos jar doJava Email API package e a JAF package estão disponíveis em CLASSPATH.

Este exemplo é muito semelhante ao anterior, exceto que aqui estamos usando o setContent() método para definir o conteúdo cujo segundo argumento é "text/html" para especificar que o conteúdo HTML está incluído na mensagem.

Usando este exemplo, você pode enviar um conteúdo HTML tão grande quanto necessário.

<%@ page import = "java.io.*,java.util.*,javax.mail.*"%>
<%@ page import = "javax.mail.internet.*,javax.activation.*"%>
<%@ page import = "javax.servlet.http.*,javax.servlet.*" %>

<%
   String result;
   
   // Recipient's email ID needs to be mentioned.
   String to = "[email protected]";

   // Sender's email ID needs to be mentioned
   String from = "[email protected]";

   // Assuming you are sending email from localhost
   String host = "localhost";

   // Get system properties object
   Properties properties = System.getProperties();

   // Setup mail server
   properties.setProperty("mail.smtp.host", host);

   // Get the default Session object.
   Session mailSession = Session.getDefaultInstance(properties);

   try {
      // Create a default MimeMessage object.
      MimeMessage message = new MimeMessage(mailSession);
      
      // Set From: header field of the header.
      message.setFrom(new InternetAddress(from));
      
      // Set To: header field of the header.
      message.addRecipient(Message.RecipientType.TO, new InternetAddress(to));
      
      // Set Subject: header field
      message.setSubject("This is the Subject Line!");
     
      // Send the actual HTML message, as big as you like
      message.setContent("<h1>This is actual message</h1>", "text/html" );
      
      // Send message
      Transport.send(message);
      result = "Sent message successfully....";
   } catch (MessagingException mex) {
      mex.printStackTrace();
      result = "Error: unable to send message....";
   }
%>

<html>
   <head>
      <title>Send HTML Email using JSP</title>
   </head>

   <body>
      <center>
         <h1>Send Email using JSP</h1>
      </center>
      
      <p align = "center">
         <% 
            out.println("Result: " + result + "\n");
         %>
      </p>
   </body>
</html>

Vamos agora usar o JSP acima para enviar mensagem HTML em um determinado ID de email.

Enviar anexo por e-mail

A seguir está um exemplo para enviar um e-mail com anexo de sua máquina -

<%@ page import = "java.io.*,java.util.*,javax.mail.*"%>
<%@ page import = "javax.mail.internet.*,javax.activation.*"%>
<%@ page import = "javax.servlet.http.*,javax.servlet.*" %>

<%
   String result;
   
   // Recipient's email ID needs to be mentioned.
   String to = "[email protected]";

   // Sender's email ID needs to be mentioned
   String from = "[email protected]";

   // Assuming you are sending email from localhost
   String host = "localhost";

   // Get system properties object
   Properties properties = System.getProperties();

   // Setup mail server
   properties.setProperty("mail.smtp.host", host);

   // Get the default Session object.
   Session mailSession = Session.getDefaultInstance(properties);

   try {
      // Create a default MimeMessage object.
      MimeMessage message = new MimeMessage(mailSession);

      // Set From: header field of the header.
      message.setFrom(new InternetAddress(from));

      // Set To: header field of the header.
      message.addRecipient(Message.RecipientType.TO, new InternetAddress(to));

      // Set Subject: header field
      message.setSubject("This is the Subject Line!");

      // Create the message part 
      BodyPart messageBodyPart = new MimeBodyPart();

      // Fill the message
      messageBodyPart.setText("This is message body");
      
      // Create a multipart message
      Multipart multipart = new MimeMultipart();

      // Set text message part
      multipart.addBodyPart(messageBodyPart);

      // Part two is attachment
      messageBodyPart = new MimeBodyPart();
      
      String filename = "file.txt";
      DataSource source = new FileDataSource(filename);
      messageBodyPart.setDataHandler(new DataHandler(source));
      messageBodyPart.setFileName(filename);
      multipart.addBodyPart(messageBodyPart);

      // Send the complete message parts
      message.setContent(multipart );

      // Send message
      Transport.send(message);
      String title = "Send Email";
      result = "Sent message successfully....";
   } catch (MessagingException mex) {
      mex.printStackTrace();
      result = "Error: unable to send message....";
   }
%>

<html>
   <head>
      <title>Send Attachment Email using JSP</title>
   </head>
   
   <body>
      <center>
         <h1>Send Attachment Email using JSP</h1>
      </center>
      
      <p align = "center">
         <%out.println("Result: " + result + "\n");%>
      </p>
   </body>
</html>

Vamos agora executar o JSP acima para enviar um arquivo como anexo junto com uma mensagem em um determinado ID de email.

Parte de autenticação do usuário

Se for necessário fornecer ID de usuário e senha ao servidor de e-mail para fins de autenticação, você pode definir essas propriedades da seguinte maneira -

props.setProperty("mail.user", "myuser");
props.setProperty("mail.password", "mypwd");

O resto do mecanismo de envio de email permanecerá conforme explicado acima.

Usando formulários para enviar e-mail

Você pode usar o formulário HTML para aceitar parâmetros de e-mail e, em seguida, pode usar o request objeto para obter todas as informações da seguinte forma -

String to = request.getParameter("to");
String from = request.getParameter("from");
String subject = request.getParameter("subject");
String messageText = request.getParameter("body");

Depois de ter todas as informações, você pode usar os programas mencionados acima para enviar e-mail.

Neste capítulo, vamos entender as diferentes tags em JSP. A JavaServer Pages Standard Tag Library (JSTL) é uma coleção de tags JSP úteis que encapsula a funcionalidade central comum a muitos aplicativos JSP.

JSTL tem suporte para tarefas estruturais comuns, como iteração e condicionais, tags para manipular documentos XML, tags de internacionalização e tags SQL. Ele também fornece uma estrutura para integrar as tags personalizadas existentes com as tags JSTL.

Instalar biblioteca JSTL

Para começar a trabalhar com tages JSP, você precisa primeiro instalar a biblioteca JSTL. Se você estiver usando o contêiner Apache Tomcat, siga estas duas etapas -

Step 1- Baixe a distribuição binária do Apache Standard Taglib e descompacte o arquivo compactado.

Step 2 - Para usar o Taglib padrão de seu Jakarta Taglibs distribution, simplesmente copie os arquivos JAR no diretório 'lib' da distribuição para o diretório de seu aplicativo webapps\ROOT\WEB-INF\lib diretório.

Para usar qualquer uma das bibliotecas, você deve incluir uma diretiva <taglib> no topo de cada JSP que usa a biblioteca.

Classificação das tags JSTL

As tags JSTL podem ser classificadas, de acordo com suas funções, nos seguintes grupos de bibliotecas de tags JSTL que podem ser usados ​​ao criar uma página JSP -

• Core Tags

• Formatting tags

• SQL tags

• XML tags

• JSTL Functions

Tags principais

O grupo principal de tags são as tags JSTL mais comumente usadas. A seguir está a sintaxe para incluir a biblioteca JSTL Core em seu JSP -

<%@ taglib prefix = "c" uri = "http://java.sun.com/jsp/jstl/core" %>

A tabela a seguir lista as principais tags JSTL -

S.No.	Tag e descrição
1	Como <% = ...>, mas para expressões.
2	Define o resultado de uma avaliação de expressão em um 'scope'
3	Remove um scoped variable (de um escopo particular, se especificado).
4	Pega qualquer Throwable que ocorre em seu corpo e, opcionalmente, o expõe.
5	Tag condicional simples que avalia seu corpo se a condição fornecida for verdadeira.
6	Tag condicional simples que estabelece um contexto para operações condicionais mutuamente exclusivas, marcada por <when> e <otherwise>.
7	Subtag de <choose> que inclui seu corpo se sua condição for avaliada para 'true'.
8	Subtag de <choose> que segue o <when> marca e executa somente se todas as condições anteriores avaliadas para 'false'.
9	Recupera um URL absoluto ou relativo e expõe seu conteúdo para a página, uma String em 'var', ou um leitor em 'varReader'.
10	A tag de iteração básica, que aceita muitos tipos de coleção diferentes e oferece suporte a subconjuntos e outras funcionalidades.
11	Itera sobre tokens, separados pelos delimitadores fornecidos.
12	Adiciona um parâmetro a um 'import' URL da tag.
13	Redireciona para um novo URL.
14	Cria um URL com parâmetros de consulta opcionais

Tags de formatação

As tags de formatação JSTL são usadas para formatar e exibir texto, a data, a hora e os números de sites internacionalizados. A seguir está a sintaxe para incluir a biblioteca de formatação em seu JSP -

<%@ taglib prefix = "fmt" uri = "http://java.sun.com/jsp/jstl/fmt" %>

A tabela a seguir lista as tags de formatação JSTL -

S.No.	Tag e descrição
1	Para renderizar valor numérico com precisão ou formato específico.
2	Analisa a representação de string de um número, moeda ou porcentagem.
3	Formata uma data e / ou hora usando os estilos e padrões fornecidos.
4	Analisa a representação de string de uma data e / ou hora
5	Carrega um pacote de recursos a ser usado por seu corpo de tag.
6	Armazena a localidade fornecida na variável de configuração local.
7	Carrega um pacote de recursos e o armazena na variável com escopo nomeado ou na variável de configuração do pacote.
8	Especifica o fuso horário para qualquer formatação de hora ou ações de análise aninhadas em seu corpo.
9	Armazena o fuso horário fornecido na variável de configuração do fuso horário
10	Exibe uma mensagem internacionalizada.
11	Define a codificação de caracteres do pedido

Tags SQL

A biblioteca de tags JSTL SQL fornece tags para interagir com bancos de dados relacionais (RDBMSs), como Oracle, mySQL, ou Microsoft SQL Server.

A seguir está a sintaxe para incluir a biblioteca JSTL SQL em seu JSP -

<%@ taglib prefix = "sql" uri = "http://java.sun.com/jsp/jstl/sql" %>

A tabela a seguir lista as tags SQL JSTL -

S.No.	Tag e descrição
1	Cria um DataSource simples adequado apenas para prototipagem
2	Executa a consulta SQL definida em seu corpo ou por meio do atributo sql.
3	Executa a atualização SQL definida em seu corpo ou por meio do atributo sql.
4	Define um parâmetro em uma instrução SQL para o valor especificado.
5	Define um parâmetro em uma instrução SQL para o valor java.util.Date especificado.
6	Fornece elementos de ação de banco de dados aninhados com uma conexão compartilhada, configurada para executar todas as instruções como uma transação.

Tags XML

As tags JSTL XML fornecem uma maneira centrada em JSP de criar e manipular os documentos XML. A seguir está a sintaxe para incluir a biblioteca JSTL XML em seu JSP.

A biblioteca de tags JSTL XML possui tags personalizadas para interagir com os dados XML. Isso inclui a análise do XML, a transformação dos dados XML e o controle de fluxo com base nas expressões XPath.

<%@ taglib prefix = "x" 
   uri = "http://java.sun.com/jsp/jstl/xml" %>

Antes de prosseguir com os exemplos, você precisará copiar as seguintes duas bibliotecas relacionadas a XML e XPath em seu <Tomcat Installation Directory>\lib -

• XercesImpl.jar - Baixe-o de https://www.apache.org/dist/xerces/j/

• xalan.jar - Baixe-o de https://xml.apache.org/xalan-j/index.html

A seguir está a lista de tags XML JSTL -

S.No.	Tag e descrição
1	Como <% = ...>, mas para expressões XPath.
2	Usado para analisar os dados XML especificados por meio de um atributo ou no corpo da tag.
3	Define uma variável com o valor de uma expressão XPath.
4	Avalia uma expressão XPath de teste e, se for verdadeira, processa seu corpo. Se a condição de teste for falsa, o corpo será ignorado.
5	Para fazer um loop sobre nós em um documento XML.
6	Tag condicional simples que estabelece um contexto para operações condicionais mutuamente exclusivas, marcada por <when> e <otherwise> Tag.
7	Subtag de <choose> isso inclui seu corpo se sua expressão for avaliada como 'verdadeira'.
8	Subtag de <choose> que segue o <when> marca e é executado apenas se todas as condições anteriores forem avaliadas como 'falsas'.
9	Aplica uma transformação XSL em um documento XML
10	Usado junto com o transform tag para definir um parâmetro na folha de estilo XSLT

Funções JSTL

JSTL inclui várias funções padrão, a maioria das quais são funções comuns de manipulação de strings. A seguir está a sintaxe para incluir a biblioteca de funções JSTL em seu JSP -

<%@ taglib prefix = "fn" 
   uri = "http://java.sun.com/jsp/jstl/functions" %>

A tabela a seguir lista as várias funções JSTL -

S.No.	Descrição da função
1	fn: contém () Testa se uma string de entrada contém a substring especificada.
2	fn: containsIgnoreCase () Testa se uma string de entrada contém a substring especificada de uma forma que não diferencia maiúsculas de minúsculas.
3	fn: endsWith () Testa se uma string de entrada termina com o sufixo especificado.
4	fn: escapeXml () Caracteres de escape que podem ser interpretados como marcação XML.
5	fn: indexOf () Retorna o índice dentro de uma string da primeira ocorrência de uma substring especificada.
6	fn: join () Une todos os elementos de uma matriz em uma string.
7	fn: comprimento () Retorna o número de itens em uma coleção ou o número de caracteres em uma string.
8	fn: substituir () Retorna uma string resultante da substituição em uma string de entrada de todas as ocorrências com uma determinada string.
9	fn: split () Divide uma string em uma matriz de substrings.
10	fn: startsWith () Testa se uma string de entrada começa com o prefixo especificado.
11	fn: substring () Retorna um subconjunto de uma string.
12	fn: substringAfter () Retorna um subconjunto de uma string seguindo uma substring específica.
13	fn: substringBefore () Retorna um subconjunto de uma string antes de uma substring específica.
14	fn: toLowerCase () Converte todos os caracteres de uma string em minúsculas.
15	fn: toUpperCase () Converte todos os caracteres de uma string em maiúsculas.
16	fn: trim () Remove os espaços em branco de ambas as extremidades de uma string.

Neste capítulo, discutiremos como acessar o banco de dados com JSP. Presumimos que você tenha um bom conhecimento sobre como o aplicativo JDBC funciona. Antes de iniciar o acesso ao banco de dados por meio de um JSP, certifique-se de ter configurado o ambiente JDBC adequado junto com um banco de dados.

Para obter mais detalhes sobre como acessar o banco de dados usando JDBC e sua configuração de ambiente, você pode consultar nosso Tutorial JDBC .

Para começar com o conceito básico, vamos criar uma tabela e criar alguns registros nessa tabela da seguinte forma -

Criar a tabela

Para criar o Employees tabela no banco de dados EMP, use as seguintes etapas -

Passo 1

Abra um Command Prompt e mude para o diretório de instalação da seguinte forma -

C:\>
C:\>cd Program Files\MySQL\bin
C:\Program Files\MySQL\bin>

Passo 2

Faça login no banco de dados da seguinte forma -

C:\Program Files\MySQL\bin>mysql -u root -p
Enter password: ********
mysql>

etapa 3

Crie o Employee mesa no TEST banco de dados da seguinte forma - -

mysql> use TEST;
mysql> create table Employees
   (
      id int not null,
      age int not null,
      first varchar (255),
      last varchar (255)
   );
Query OK, 0 rows affected (0.08 sec)
mysql>

Criar registros de dados

Vamos agora criar alguns registros no Employee tabela da seguinte forma - -

mysql> INSERT INTO Employees VALUES (100, 18, 'Zara', 'Ali');
Query OK, 1 row affected (0.05 sec)
 
mysql> INSERT INTO Employees VALUES (101, 25, 'Mahnaz', 'Fatma');
Query OK, 1 row affected (0.00 sec)
 
mysql> INSERT INTO Employees VALUES (102, 30, 'Zaid', 'Khan');
Query OK, 1 row affected (0.00 sec)
 
mysql> INSERT INTO Employees VALUES (103, 28, 'Sumit', 'Mittal');
Query OK, 1 row affected (0.00 sec)
 
mysql>

SELECT Operação

O exemplo a seguir mostra como podemos executar o SQL SELECT declaração usando JTSL na programação JSP -

<%@ page import = "java.io.*,java.util.*,java.sql.*"%>
<%@ page import = "javax.servlet.http.*,javax.servlet.*" %>
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix = "c"%>
<%@ taglib uri="http://java.sun.com/jsp/jstl/sql" prefix = "sql"%>
 
<html>
   <head>
      <title>SELECT Operation</title>
   </head>

   <body>
      <sql:setDataSource var = "snapshot" driver = "com.mysql.jdbc.Driver"
         url = "jdbc:mysql://localhost/TEST"
         user = "root"  password = "pass123"/>
 
      <sql:query dataSource = "${snapshot}" var = "result">
         SELECT * from Employees;
      </sql:query>
 
      <table border = "1" width = "100%">
         <tr>
            <th>Emp ID</th>
            <th>First Name</th>
            <th>Last Name</th>
            <th>Age</th>
         </tr>
         
         <c:forEach var = "row" items = "${result.rows}"> <tr> <td><c:out value = "${row.id}"/></td>
               <td><c:out value = "${row.first}"/></td> <td><c:out value = "${row.last}"/></td>
               <td><c:out value = "${row.age}"/></td>
            </tr>
         </c:forEach>
      </table>
 
   </body>
</html>

Acesse o JSP acima, o seguinte resultado será exibido -

 
       

        
 
         
Emp ID
 
         
First Name
 
         
Last Name
 
         
Age
 
        
 
        
 
         
100
 
         
Zara
 
         
Ali
 
         
18
 
        
 
        
 
         
101
 
         
Mahnaz
 
         
Fatma
 
         
25
 
        
 
        
 
         
102
 
         
Zaid
 
         
Khan
 
         
30
 
        
 
        
 
         
103
 
         
Sumit
 
         
Mittal
 
         
28
 
        
 
       
      

Operação INSERT

O exemplo a seguir mostra como podemos executar a instrução SQL INSERT usando JTSL na programação JSP -

<%@ page import = "java.io.*,java.util.*,java.sql.*"%>
<%@ page import = "javax.servlet.http.*,javax.servlet.*" %>
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix = "c"%>
<%@ taglib uri="http://java.sun.com/jsp/jstl/sql" prefix = "sql"%>
 
<html>
   <head>
      <title>JINSERT Operation</title>
   </head>
   
   <body>
      <sql:setDataSource var = "snapshot" driver = "com.mysql.jdbc.Driver"
         url = "jdbc:mysql://localhost/TEST"
         user = "root"  password = "pass123"/>
         <sql:update dataSource = "${snapshot}" var = "result">
         INSERT INTO Employees VALUES (104, 2, 'Nuha', 'Ali');
      </sql:update>
 
      <sql:query dataSource = "${snapshot}" var = "result"> SELECT * from Employees; </sql:query> <table border = "1" width = "100%"> <tr> <th>Emp ID</th> <th>First Name</th> <th>Last Name</th> <th>Age</th> </tr> <c:forEach var = "row" items = "${result.rows}">
            <tr>
               <td><c:out value = "${row.id}"/></td> <td><c:out value = "${row.first}"/></td>
               <td><c:out value = "${row.last}"/></td> <td><c:out value = "${row.age}"/></td>
            </tr>
         </c:forEach>
      </table>
 
   </body>
</html>

Acesse o JSP acima, o seguinte resultado será exibido -

 
       

        
 
         
Emp ID
 
         
First Name
 
         
Last Name
 
         
Age
 
        
 
        
 
         
100
 
         
Zara
 
         
Ali
 
         
18
 
        
 
        
 
         
101
 
         
Mahnaz
 
         
Fatma
 
         
25
 
        
 
        
 
         
102
 
         
Zaid
 
         
Khan
 
         
30
 
        
 
        
 
         
103
 
         
Sumit
 
         
Mittal
 
         
28
 
        
 
        
 
         
104
 
         
Nuha
 
         
Ali
 
         
2
 
        
 
       
      

Operação DELETE

O exemplo a seguir mostra como podemos executar o SQL DELETE declaração usando JTSL na programação JSP -

<%@ page import = "java.io.*,java.util.*,java.sql.*"%>
<%@ page import = "javax.servlet.http.*,javax.servlet.*" %>
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix = "c"%>
<%@ taglib uri="http://java.sun.com/jsp/jstl/sql" prefix = "sql"%>
 
<html>
   <head>
      <title>DELETE Operation</title>
   </head>
   
   <body>
      <sql:setDataSource var = "snapshot" driver = "com.mysql.jdbc.Driver"
         url = "jdbc:mysql://localhost/TEST"
         user = "root" password = "pass123"/>
 
      <c:set var = "empId" value = "103"/>
 
      <sql:update dataSource = "${snapshot}" var = "count"> DELETE FROM Employees WHERE Id = ? <sql:param value = "${empId}" />
      </sql:update>
 
      <sql:query dataSource = "${snapshot}" var = "result"> SELECT * from Employees; </sql:query> <table border = "1" width = "100%"> <tr> <th>Emp ID</th> <th>First Name</th> <th>Last Name</th> <th>Age</th> </tr> <c:forEach var = "row" items = "${result.rows}">
            <tr>
               <td><c:out value = "${row.id}"/></td> <td><c:out value = "${row.first}"/></td>
               <td><c:out value = "${row.last}"/></td> <td><c:out value = "${row.age}"/></td>
            </tr>
         </c:forEach>
      </table>
 
   </body>
</html>

Acesse o JSP acima, o seguinte resultado será exibido -

 
       

        
 
         
Emp ID
 
         
First Name
 
         
Last Name
 
         
Age
 
        
 
        
 
         
100
 
         
Zara
 
         
Ali
 
         
18
 
        
 
        
 
         
101
 
         
Mahnaz
 
         
Fatma
 
         
25
 
        
 
        
 
         
102
 
         
Zaid
 
         
Khan
 
         
30
 
        
 
       
      

Operação ATUALIZAR

O exemplo a seguir mostra como podemos executar o SQL UPDATE declaração usando JTSL na programação JSP -

<%@ page import = "java.io.*,java.util.*,java.sql.*"%>
<%@ page import = "javax.servlet.http.*,javax.servlet.*" %>
<%@ taglib uri = "http://java.sun.com/jsp/jstl/core" prefix = "c"%>
<%@ taglib uri = "http://java.sun.com/jsp/jstl/sql" prefix = "sql"%>
 
<html>
   <head>
      <title>DELETE Operation</title>
   </head>
   
   <body>
      <sql:setDataSource var = "snapshot" driver = "com.mysql.jdbc.Driver"
         url = "jdbc:mysql://localhost/TEST"
         user = "root" password = "pass123"/>
 
      <c:set var = "empId" value = "102"/>
 
      <sql:update dataSource = "${snapshot}" var = "count"> UPDATE Employees SET WHERE last = 'Ali' <sql:param value = "${empId}" />
      </sql:update>
 
      <sql:query dataSource = "${snapshot}" var = "result"> SELECT * from Employees; </sql:query> <table border = "1" width = "100%"> <tr> <th>Emp ID</th> <th>First Name</th> <th>Last Name</th> <th>Age</th> </tr> <c:forEach var = "row" items = "${result.rows}">
            <tr>
               <td><c:out value = "${row.id}"/></td> <td><c:out value = "${row.first}"/></td>
               <td><c:out value = "${row.last}"/></td> <td><c:out value = "${row.age}"/></td>
            </tr>
         </c:forEach>
      </table>
 
   </body>
</html>

Acesse o JSP acima, o seguinte resultado será exibido -

 
       

        
 
         
Emp ID
 
         
First Name
 
         
Last Name
 
         
Age
 
        
 
        
 
         
100
 
         
Zara
 
         
Ali
 
         
18
 
        
 
        
 
         
101
 
         
Mahnaz
 
         
Fatma
 
         
25
 
        
 
        
 
         
102
 
         
Zaid
 
         
Ali
 
         
30
 
        
 
       
      

Quando você envia os dados XML via HTTP, faz sentido usar JSP para lidar com documentos XML de entrada e saída; por exemplo, documentos RSS. Como um documento XML é apenas um monte de texto, criar um por meio de um JSP é muito mais fácil do que criar um documento HTML.

Enviando XML de um JSP

Você pode enviar o conteúdo XML usando JSPs da mesma maneira que envia HTML. A única diferença é que você deve definir o tipo de conteúdo de sua página como text / xml. Para definir o tipo de conteúdo, use o<%@page%> tag, assim -

<%@ page contentType = "text/xml" %>

O exemplo a seguir mostrará como enviar conteúdo XML para o navegador -

<%@ page contentType = "text/xml" %>

<books>
   <book>
      <name>Padam History</name>
      <author>ZARA</author>
      <price>100</price>
   </book>
</books>

Acesse o XML acima usando navegadores diferentes para ver a apresentação da árvore de documentos do XML acima.

Processando XML em JSP

Antes de prosseguir com o processamento de XML usando JSP, você precisará copiar as duas seguintes bibliotecas relacionadas a XML e XPath em seu <Tomcat Installation Directory>\lib -

• XercesImpl.jar - Baixe-o de https://www.apache.org/dist/xerces/j/

• xalan.jar - Baixe-o de https://xml.apache.org/xalan-j/index.html

Vamos colocar o seguinte conteúdo no arquivo books.xml -

<books>
   <book>
      <name>Padam History</name>
      <author>ZARA</author>
      <price>100</price>
   </book>
   
   <book>
      <name>Great Mistry</name>
      <author>NUHA</author>
      <price>2000</price>
   </book>
</books>

Tente o seguinte main.jsp, mantendo no mesmo diretório -

<%@ taglib prefix = "c" uri="http://java.sun.com/jsp/jstl/core" %>
<%@ taglib prefix = "x" uri="http://java.sun.com/jsp/jstl/xml" %>
 
<html>
   <head>
      <title>JSTL x:parse Tags</title>
   </head>

   <body>
      <h3>Books Info:</h3>
      <c:import var = "bookInfo" url="http://localhost:8080/books.xml"/>
 
      <x:parse xml = "${bookInfo}" var = "output"/> <b>The title of the first book is</b>: <x:out select = "$output/books/book[1]/name" />
      <br>
      
      <b>The price of the second book</b>: 
      <x:out select = "$output/books/book[2]/price" />
   </body>
</html>

Acesse o JSP acima usando http://localhost:8080/main.jsp, o seguinte resultado será exibido -

Books Info:
The title of the first book is:Padam History

The price of the second book: 2000

Formatando XML com JSP

Considere a seguinte folha de estilo XSLT style.xsl -

<?xml version = "1.0"?>
<xsl:stylesheet xmlns:xsl = "http://www.w3.org/1999/XSL/Transform" 
   version = "1.0">
 
   <xsl:output method = "html" indent = "yes"/>
   <xsl:template match = "/">
      <html>
         <body>
            <xsl:apply-templates/>
         </body>
      </html>
   </xsl:template>
    
   <xsl:template match = "books">
      <table border = "1" width = "100%">
         <xsl:for-each select = "book">
            <tr>
               <td>
                  <i><xsl:value-of select = "name"/></i>
               </td>
               
               <td>
                  <xsl:value-of select = "author"/>
               </td>
               
               <td>
                  <xsl:value-of select = "price"/>
               </td>
            </tr>
         </xsl:for-each>
      </table>
   
   </xsl:template>
</xsl:stylesheet>

Agora considere o seguinte arquivo JSP -

<%@ taglib prefix = "c" uri = "http://java.sun.com/jsp/jstl/core" %>
<%@ taglib prefix = "x" uri = "http://java.sun.com/jsp/jstl/xml" %>
 
<html>
   <head>
      <title>JSTL x:transform Tags</title>
   </head>
   
   <body>
      <h3>Books Info:</h3>
      <c:set var = "xmltext">
         <books>
            <book>
               <name>Padam History</name>
               <author>ZARA</author>
               <price>100</price>
            </book>
            
            <book>
               <name>Great Mistry</name>
               <author>NUHA</author>
               <price>2000</price>
            </book>
         </books>
      </c:set>
 
      <c:import url = "http://localhost:8080/style.xsl" var = "xslt"/>
      <x:transform xml = "${xmltext}" xslt = "${xslt}"/>
   </body>
</html>

O seguinte resultado será exibido -

Books Info:

      
 
       

        
 
         
Padam History
 
         
ZARA
 
         
100
 
        
 
        
 
         
Great Mistry
 
         
NUHA
 
         
2000
 
        
 
       
      

Para saber mais sobre o processamento de XML usando JSTL, você pode verificar JSP Standard Tag Library .

Um JavaBean é uma classe Java especialmente construída, escrita em Java e codificada de acordo com as especificações da API JavaBeans.

A seguir estão as características exclusivas que distinguem um JavaBean de outras classes Java -

• Ele fornece um construtor padrão, sem argumento.

• Deve ser serializável e o que pode implementar o Serializable interface.

• Pode ter várias propriedades que podem ser lidas ou gravadas.

• Pode ter um número de "getter"e"setter"métodos para as propriedades.

Propriedades JavaBeans

Uma propriedade JavaBean é um atributo nomeado que pode ser acessado pelo usuário do objeto. O atributo pode ser de qualquer tipo de dados Java, incluindo as classes que você define.

Uma propriedade JavaBean pode ser read, write, read only, ou write only. As propriedades JavaBean são acessadas por meio de dois métodos na classe de implementação JavaBean -

S.No.	Método e Descrição
1	peguePropertyName() Por exemplo, se o nome da propriedade for firstName , o nome do seu método serágetFirstName()para ler essa propriedade. Este método é denominado acessador.
2	conjuntoPropertyName() Por exemplo, se o nome da propriedade for firstName , o nome do seu método serásetFirstName()escrever essa propriedade. Esse método é chamado de mutador.

Um atributo somente leitura terá apenas um getPropertyName() método, e um atributo somente gravação terá apenas um setPropertyName() método.

Exemplo de JavaBeans

Considere uma classe de aluno com poucas propriedades -

package com.tutorialspoint;

public class StudentsBean implements java.io.Serializable {
   private String firstName = null;
   private String lastName = null;
   private int age = 0;

   public StudentsBean() {
   }
   public String getFirstName(){
      return firstName;
   }
   public String getLastName(){
      return lastName;
   }
   public int getAge(){
      return age;
   }
   public void setFirstName(String firstName){
      this.firstName = firstName;
   }
   public void setLastName(String lastName){
      this.lastName = lastName;
   }
   public void setAge(Integer age){
      this.age = age;
   }
}

Acessando JavaBeans

o useBeanaction declara um JavaBean para uso em um JSP. Uma vez declarado, o bean se torna uma variável de script que pode ser acessada por elementos de script e outras tags personalizadas usadas no JSP. A sintaxe completa para a tag useBean é a seguinte -

<jsp:useBean id = "bean's name" scope = "bean's scope" typeSpec/>

Aqui, os valores para o atributo de escopo podem ser um page, request, session ou application basedem sua exigência. O valor doid atributo pode ser qualquer valor, desde que seja um nome único entre outros useBean declarations no mesmo JSP.

O exemplo a seguir mostra como usar a ação useBean -

<html>
   <head>
      <title>useBean Example</title>
   </head>
   
   <body>
      <jsp:useBean id = "date" class = "java.util.Date" /> 
      <p>The date/time is <%= date %>
   </body>
</html>

Você receberá o seguinte resultado - -

The date/time is Thu Sep 30 11:18:11 GST 2010

Acessando Propriedades JavaBeans

Junto com <jsp:useBean...> ação, você pode usar o <jsp:getProperty/> ação para acessar os métodos get e o <jsp:setProperty/>ação para acessar os métodos definidos. Aqui está a sintaxe completa -

<jsp:useBean id = "id" class = "bean's class" scope = "bean's scope">
   <jsp:setProperty name = "bean's id" property = "property name"  
      value = "value"/>
   <jsp:getProperty name = "bean's id" property = "property name"/>
   ...........
</jsp:useBean>

O atributo name faz referência ao id de um JavaBean previamente introduzido no JSP pela ação useBean. O atributo de propriedade é o nome doget ou o set métodos que devem ser chamados.

O exemplo a seguir mostra como acessar os dados usando a sintaxe acima -

<html>
   <head>
      <title>get and set properties Example</title>
   </head>
   
   <body>
      <jsp:useBean id = "students" class = "com.tutorialspoint.StudentsBean"> 
         <jsp:setProperty name = "students" property = "firstName" value = "Zara"/>
         <jsp:setProperty name = "students" property = "lastName" value = "Ali"/>
         <jsp:setProperty name = "students" property = "age" value = "10"/>
      </jsp:useBean>

      <p>Student First Name: 
         <jsp:getProperty name = "students" property = "firstName"/>
      </p>
      
      <p>Student Last Name: 
         <jsp:getProperty name = "students" property = "lastName"/>
      </p>
      
      <p>Student Age: 
         <jsp:getProperty name = "students" property = "age"/>
      </p>

   </body>
</html>

Vamos fazer o StudentsBean.classdisponível em CLASSPATH. Acesse o JSP acima. o seguinte resultado será exibido -

Student First Name: Zara 

Student Last Name: Ali 

Student Age: 10

Neste capítulo, discutiremos as tags personalizadas em JSP. Uma tag customizada é um elemento de linguagem JSP definido pelo usuário. Quando uma página JSP contendo uma tag customizada é convertida em um servlet, a tag é convertida em operações em um objeto chamado manipulador de tag. O contêiner da Web então chama essas operações quando o servlet da página JSP é executado.

As extensões de tag JSP permitem criar novas tags que podem ser inseridas diretamente em uma página JavaServer. A especificação JSP 2.0 introduziu os Manipuladores de Tag Simples para escrever essas tags personalizadas.

Para escrever uma tag personalizada, você pode simplesmente estender SimpleTagSupport classe e substituir o doTag() método, onde você pode colocar seu código para gerar conteúdo para a tag.

Criar tag "Hello"

Considere que você deseja definir uma tag personalizada chamada <ex: Hello> e deseja usá-la da seguinte maneira sem um corpo -

<ex:Hello />

Para criar uma tag JSP customizada, você deve primeiro criar uma classe Java que atue como um manipulador de tag. Vamos agora criar oHelloTag classe como segue -

package com.tutorialspoint;

import javax.servlet.jsp.tagext.*;
import javax.servlet.jsp.*;
import java.io.*;

public class HelloTag extends SimpleTagSupport {
   public void doTag() throws JspException, IOException {
      JspWriter out = getJspContext().getOut();
      out.println("Hello Custom Tag!");
   }
}

O código acima tem uma codificação simples onde o doTag() método pega o objeto JspContext atual usando o getJspContext() método e usa-o para enviar "Hello Custom Tag!" para o atual JspWriter objeto

Vamos compilar a classe acima e copiá-la em um diretório disponível na variável de ambiente CLASSPATH. Por fim, crie o seguinte arquivo de biblioteca de tags:<Tomcat-Installation-Directory>webapps\ROOT\WEB-INF\custom.tld.

<taglib>
   <tlib-version>1.0</tlib-version>
   <jsp-version>2.0</jsp-version>
   <short-name>Example TLD</short-name>
   
   <tag>
      <name>Hello</name>
      <tag-class>com.tutorialspoint.HelloTag</tag-class>
      <body-content>empty</body-content>
   </tag>
</taglib>

Vamos agora usar a tag personalizada definida acima Hello em nosso programa JSP da seguinte forma -

<%@ taglib prefix = "ex" uri = "WEB-INF/custom.tld"%>

<html>
   <head>
      <title>A sample custom tag</title>
   </head>
   
   <body>
      <ex:Hello/>
   </body>
</html>

Chame o JSP acima e isso deve produzir o seguinte resultado -

Hello Custom Tag!

Acessando o corpo da tag

Você pode incluir uma mensagem no corpo da tag, como viu com as tags padrão. Considere que você deseja definir uma tag personalizada chamada<ex:Hello> e você deseja usá-lo da seguinte maneira com um corpo -

<ex:Hello>
   This is message body
</ex:Hello>

Vamos fazer as seguintes alterações no código da tag acima para processar o corpo da tag -

package com.tutorialspoint;

import javax.servlet.jsp.tagext.*;
import javax.servlet.jsp.*;
import java.io.*;

public class HelloTag extends SimpleTagSupport {
   StringWriter sw = new StringWriter();
   public void doTag()
   
   throws JspException, IOException {
      getJspBody().invoke(sw);
      getJspContext().getOut().println(sw.toString());
   }
}

Aqui, a saída resultante da invocação é primeiro capturada em um StringWriterantes de ser gravado no JspWriter associado à tag. Precisamos alterar o arquivo TLD da seguinte forma -

<taglib>
   <tlib-version>1.0</tlib-version>
   <jsp-version>2.0</jsp-version>
   <short-name>Example TLD with Body</short-name>
   
   <tag>
      <name>Hello</name>
      <tag-class>com.tutorialspoint.HelloTag</tag-class>
      <body-content>scriptless</body-content>
   </tag>
</taglib>

Vamos agora chamar a tag acima com o corpo adequado da seguinte maneira -

<%@ taglib prefix = "ex" uri = "WEB-INF/custom.tld"%>

<html>
   <head>
      <title>A sample custom tag</title>
   </head>
   
   <body>
      <ex:Hello>
         This is message body
      </ex:Hello>
   </body>
</html>

Você receberá o seguinte resultado -

This is message body

Atributos de tag personalizada

Você pode usar vários atributos junto com suas tags personalizadas. Para aceitar um valor de atributo, uma classe de tag personalizada precisa implementar osetter métodos, idênticos aos métodos setter JavaBean, conforme mostrado abaixo -

package com.tutorialspoint;

import javax.servlet.jsp.tagext.*;
import javax.servlet.jsp.*;
import java.io.*;

public class HelloTag extends SimpleTagSupport {
   private String message;

   public void setMessage(String msg) {
      this.message = msg;
   }
   StringWriter sw = new StringWriter();
   public void doTag()
   
   throws JspException, IOException {
      if (message != null) {
         /* Use message from attribute */
         JspWriter out = getJspContext().getOut();
         out.println( message );
      } else {
         /* use message from the body */
         getJspBody().invoke(sw);
         getJspContext().getOut().println(sw.toString());
      }
   }
}

O nome do atributo é "message", então o método setter é setMessage(). Vamos agora adicionar este atributo no arquivo TLD usando o<attribute> elemento da seguinte forma -

<taglib>
   <tlib-version>1.0</tlib-version>
   <jsp-version>2.0</jsp-version>
   <short-name>Example TLD with Body</short-name>
   
   <tag>
      <name>Hello</name>
      <tag-class>com.tutorialspoint.HelloTag</tag-class>
      <body-content>scriptless</body-content>
      
      <attribute>
         <name>message</name>
      </attribute>
   
   </tag>
</taglib>

Vamos seguir JSP com o atributo de mensagem da seguinte forma -

<%@ taglib prefix = "ex" uri = "WEB-INF/custom.tld"%>

<html>
   <head>
      <title>A sample custom tag</title>
   </head>
   
   <body>
      <ex:Hello message = "This is custom tag" />
   </body>
</html>

Isso produzirá o seguinte resultado -

This is custom tag

Considere incluir as seguintes propriedades para um atributo -

S.No.	Propriedade e finalidade
1	name O elemento name define o nome de um atributo. Cada nome de atributo deve ser exclusivo para uma tag específica.
2	required Isso especifica se este atributo é obrigatório ou opcional. Seria falso para opcional.
3	rtexprvalue Declara se um valor de expressão de tempo de execução para um atributo de tag é válido
4	type Define o tipo de classe Java deste atributo. Por padrão, é assumido comoString
5	description A descrição informativa pode ser fornecida.
6	fragment Declara se este valor de atributo deve ser tratado como um JspFragment.

A seguir está o exemplo para especificar propriedades relacionadas a um atributo -

.....
   <attribute>
      <name>attribute_name</name>
      <required>false</required>
      <type>java.util.Date</type>
      <fragment>false</fragment>
   </attribute>
.....

Se estiver usando dois atributos, você pode modificar seu TLD da seguinte maneira -

.....
   <attribute>
      <name>attribute_name1</name>
      <required>false</required>
      <type>java.util.Boolean</type>
      <fragment>false</fragment>
   </attribute>
   
   <attribute>
      <name>attribute_name2</name>
      <required>true</required>
      <type>java.util.Date</type>
   </attribute>
.....

JSP Expression Language (EL) torna possível acessar facilmente dados de aplicativos armazenados em componentes JavaBeans. JSP EL permite que você crie expressões tanto(a) aritmética e (b)lógico. Em uma expressão JSP EL, você pode usarintegers, floating point numbers, strings, the built-in constants true and false para valores booleanos e nulo.

Sintaxe Simples

Normalmente, ao especificar um valor de atributo em uma tag JSP, você simplesmente usa uma sequência. Por exemplo -

<jsp:setProperty name = "box" property = "perimeter" value = "100"/>

JSP EL permite que você especifique uma expressão para qualquer um desses valores de atributo. Uma sintaxe simples para JSP EL é a seguinte -

${expr}

Aqui exprespecifica a própria expressão. Os operadores mais comuns em JSP EL são. e []. Esses dois operadores permitem que você acesse vários atributos de Java Beans e objetos JSP integrados.

Por exemplo, a sintaxe acima <jsp:setProperty> tag pode ser escrita com uma expressão como -

<jsp:setProperty name = "box" property = "perimeter" 
   value = "${2*box.width+2*box.height}"/>

Quando o compilador JSP vê o ${} forma em um atributo, ele gera código para avaliar a expressão e substitui o valor de expresson.

Você também pode usar as expressões JSP EL no texto do modelo para uma tag. Por exemplo, o<jsp:text>tag simplesmente insere seu conteúdo no corpo de um JSP. Os seguintes<jsp:text> inserções de declaração <h1>Hello JSP!</h1> na saída JSP -

<jsp:text>
   <h1>Hello JSP!</h1>
</jsp:text>

Agora você pode incluir uma expressão JSP EL no corpo de um <jsp:text> tag (ou qualquer outra tag) com o mesmo ${}sintaxe que você usa para atributos. Por exemplo -

<jsp:text>
   Box Perimeter is: ${2*box.width + 2*box.height}
</jsp:text>

As expressões EL podem usar parênteses para agrupar subexpressões. Por exemplo,${(1 + 2) * 3} equals 9, but ${1 + (2 * 3)} equals 7.

Para desativar a avaliação de expressões EL, especificamos o isELIgnored atributo da diretiva de página conforme abaixo -

<%@ page isELIgnored = "true|false" %>

Os valores válidos deste atributo são verdadeiros e falsos. Se for verdade, as expressões EL são ignoradas quando aparecem em texto estático ou atributos de tag. Se for falso, as expressões EL são avaliadas pelo contêiner.

Operadores básicos em EL

JSP Expression Language (EL) suporta a maioria dos operadores aritméticos e lógicos suportados pelo Java. A tabela a seguir lista os operadores usados ​​com mais frequência -

S.No.	Operador e descrição
1	. Acesse uma propriedade de bean ou entrada de mapa
2	[] Acesse uma matriz ou elemento de lista
3	( ) Agrupe uma subexpressão para alterar a ordem de avaliação
4	+ Adição
5	- Subtração ou negação de um valor
6	* Multiplicação
7	/ or div Divisão
8	% or mod Módulo (resto)
9	== or eq Teste de igualdade
10	!= or ne Teste de desigualdade
11	< or lt Teste por menos de
12	> or gt Teste para maior que
13	<= or le Teste para menor ou igual
14	>= or ge Teste para maior ou igual
15	&& or and Teste para AND lógico
16	|| or or Teste para OR lógico
17	! or not Complemento booleano unário
18	empty Teste para valores de variáveis ​​vazios

Funções em JSP EL

JSP EL permite que você use funções em expressões também. Essas funções devem ser definidas nas bibliotecas de tags personalizadas. O uso de uma função tem a seguinte sintaxe -

${ns:func(param1, param2, ...)}

Onde ns é o namespace da função, func é o nome da função e param1é o primeiro valor do parâmetro. Por exemplo, a funçãofn:length, que faz parte da biblioteca JSTL. Esta função pode ser usada da seguinte maneira para obter o comprimento de uma string.

${fn:length("Get my length")}

Para usar uma função de qualquer biblioteca de tag (padrão ou personalizada), você deve instalar essa biblioteca em seu servidor e deve incluir a biblioteca em seu JSP usando o <taglib> conforme explicado no capítulo JSTL.

Objetos JSP EL implícitos

A linguagem de expressão JSP suporta os seguintes objetos implícitos -

S.No	Objeto implícito e descrição
1	pageScope Variáveis ​​com escopo do escopo da página
2	requestScope Variáveis ​​com escopo do escopo da solicitação
3	sessionScope Variáveis ​​com escopo do escopo da sessão
4	applicationScope Variáveis ​​com escopo do aplicativo
5	param Solicitar parâmetros como strings
6	paramValues Solicite parâmetros como coleções de strings
7	header Cabeçalhos de solicitação HTTP como strings
8	headerValues Cabeçalhos de solicitação HTTP como coleções de strings
9	initParam Parâmetros de inicialização de contexto
10	cookie Valores de cookies
11	pageContext O objeto JSP PageContext para a página atual

Você pode usar esses objetos em uma expressão como se fossem variáveis. Os exemplos a seguir o ajudarão a entender os conceitos -

O objeto pageContext

O objeto pageContext fornece acesso ao objeto JSP pageContext. Por meio do objeto pageContext, você pode acessar o objeto de solicitação. Por exemplo, para acessar a string de consulta de entrada para uma solicitação, você pode usar a seguinte expressão -

${pageContext.request.queryString}

Os Objetos do Escopo

o pageScope, requestScope, sessionScope, e applicationScope variáveis ​​fornecem acesso a variáveis ​​armazenadas em cada nível de escopo.

Por exemplo, se você precisa acessar explicitamente a variável box no escopo do aplicativo, você pode acessá-la por meio da variável applicationScope como applicationScope.box.

Os objetos param e paramValues

Os objetos param e paramValues ​​fornecem acesso aos valores dos parâmetros normalmente disponíveis através do request.getParameter e request.getParameterValues métodos.

Por exemplo, para acessar um parâmetro denominado pedido, use a expressão ${param.order} ou ${param["order"]}.

A seguir está o exemplo para acessar um parâmetro de solicitação chamado nome de usuário -

<%@ page import = "java.io.*,java.util.*" %>
<%String title = "Accessing Request Param";%>

<html>
   <head>
      <title><% out.print(title); %></title>
   </head>
   
   <body>
      <center>
         <h1><% out.print(title); %></h1>
      </center>
      
      <div align = "center">
         <p>${param["username"]}</p>
      </div>
   </body>
</html>

O objeto param retorna valores de string simples, enquanto o objeto paramValues ​​retorna arrays de string.

Objetos header e headerValues

Os objetos header e headerValues ​​fornecem acesso aos valores do cabeçalho normalmente disponíveis por meio do request.getHeader e a request.getHeaders métodos.

Por exemplo, para acessar um cabeçalho denominado user-agent, use a expressão ${header.user-agent} ou ${header["user-agent"]}.

A seguir está o exemplo para acessar um parâmetro de cabeçalho denominado user-agent -

<%@ page import = "java.io.*,java.util.*" %>
<%String title = "User Agent Example";%>

<html>
   <head>
      <title><% out.print(title); %></title>
   </head>
   
   <body>
      <center>
         <h1><% out.print(title); %></h1>
      </center>
      
      <div align = "center">
         <p>${header["user-agent"]}</p>
      </div>
   </body>
</html>

O resultado será mais ou menos como o seguinte -

User Agent Example

      
 
       
Mozilla/4.0 (compatible; MSIE 8.0; Windows NT 6.1; WOW64; Trident/4.0; SLCC2; .NET CLR 2.0.50727; .NET CLR 3.5.30729; .NET CLR 3.0.30729; Media Center PC 6.0; HPNTDF; .NET4.0C; InfoPath.2)
 
      

O objeto de cabeçalho retorna valores de string simples, enquanto o objeto headerValues ​​retorna arrays de string.

Neste capítulo. discutiremos como lidar com exceções em JSP. Ao escrever um código JSP, você pode cometer erros de codificação que podem ocorrer em qualquer parte do código. Podem ocorrer os seguintes tipos de erros em seu código JSP -

Exceções verificadas

Uma exceção verificada é uma exceção que normalmente é um erro do usuário ou um problema que não pode ser previsto pelo programador. Por exemplo, se um arquivo deve ser aberto, mas o arquivo não pode ser encontrado, ocorre uma exceção. Essas exceções não podem ser simplesmente ignoradas no momento da compilação.

Exceções de tempo de execução

Uma exceção de tempo de execução é uma exceção que provavelmente poderia ter sido evitada pelo programador. Ao contrário das exceções verificadas, as exceções de tempo de execução são ignoradas no momento da conclusão.

Erros

Não são exceções, mas problemas que surgem além do controle do usuário ou do programador. Os erros são geralmente ignorados em seu código porque você raramente pode fazer algo sobre um erro. Por exemplo, se ocorrer um estouro de pilha, ocorrerá um erro. Eles também são ignorados no momento da compilação.

Discutiremos mais adiante maneiras de lidar com exceção / erro de tempo de execução que ocorre em seu código JSP.

Usando objeto de exceção

O objeto de exceção é uma instância de uma subclasse de Throwable (por exemplo, java.lang. NullPointerException) e está disponível apenas nas páginas de erro. A tabela a seguir lista os métodos importantes disponíveis na classe Throwable.

S.No.	Métodos e Descrição
1	public String getMessage() Retorna uma mensagem detalhada sobre a exceção que ocorreu. Esta mensagem é inicializada no construtor Throwable.
2	public Throwable getCause() Retorna a causa da exceção conforme representado por um objeto Throwable.
3	public String toString() Retorna o nome da classe concatenada com o resultado de getMessage().
4	public void printStackTrace() Imprime o resultado de toString() junto com o rastreamento de pilha para System.err, o fluxo de saída de erro.
5	public StackTraceElement [] getStackTrace() Retorna uma matriz contendo cada elemento no rastreamento da pilha. O elemento no índice 0 representa o topo da pilha de chamadas e o último elemento na matriz representa o método na parte inferior da pilha.
6	public Throwable fillInStackTrace() Preenche o rastreamento de pilha deste objeto Throwable com o rastreamento de pilha atual, adicionando a qualquer informação anterior no rastreamento de pilha.

JSP oferece uma opção para especificar Error Pagepara cada JSP. Sempre que a página lança uma exceção, o contêiner JSP invoca automaticamente a página de erro.

A seguir está um exemplo para especificar uma página de erro para um main.jsp. Para configurar uma página de erro, use o<%@ page errorPage = "xxx" %> diretiva.

<%@ page errorPage = "ShowError.jsp" %>

<html>
   <head>
      <title>Error Handling Example</title>
   </head>
   
   <body>
      <%
         // Throw an exception to invoke the error page
         int x = 1;
         
         if (x == 1) {
            throw new RuntimeException("Error condition!!!");
         }
      %>
   </body>
</html>

Agora escreveremos um Error Handling JSP ShowError.jsp, que é fornecido a seguir. Observe que a página de tratamento de erros inclui a diretiva<%@ page isErrorPage = "true" %>. Esta diretiva faz com que o compilador JSP gere a variável de instância de exceção.

<%@ page isErrorPage = "true" %>

<html>
   <head>
      <title>Show Error Page</title>
   </head>
   
   <body>
      <h1>Opps...</h1>
      <p>Sorry, an error occurred.</p>
      <p>Here is the exception stack trace: </p>
      <pre><% exception.printStackTrace(response.getWriter()); %></pre>
   </body>
</html>

Acesse o main.jsp, você receberá uma saída parecida com a seguinte -

java.lang.RuntimeException: Error condition!!!
......

Opps...
Sorry, an error occurred.

Here is the exception stack trace:

Usando tags JSTL para página de erro

Você pode usar tags JSTL para escrever uma página de erro ShowError.jsp. Esta página tem quase a mesma lógica do exemplo acima, com melhor estrutura e mais informações -

<%@ taglib prefix = "c" uri = "http://java.sun.com/jsp/jstl/core" %>
<%@page isErrorPage = "true" %>

<html>
   <head>
      <title>Show Error Page</title>
   </head>
   
   <body>
      <h1>Opps...</h1>
      <table width = "100%" border = "1">
         <tr valign = "top">
            <td width = "40%"><b>Error:</b></td>
            <td>${pageContext.exception}</td>
         </tr>
            
         <tr valign = "top">
            <td><b>URI:</b></td>
            <td>${pageContext.errorData.requestURI}</td> </tr> <tr valign = "top"> <td><b>Status code:</b></td> <td>${pageContext.errorData.statusCode}</td>
         </tr>
            
         <tr valign = "top">
            <td><b>Stack trace:</b></td>
            <td>
               <c:forEach var = "trace" 
                  items = "${pageContext.exception.stackTrace}"> <p>${trace}</p>
               </c:forEach>
            </td>
         </tr>
      </table>

   </body>
</html>

Acesse o main.jsp, o seguinte será gerado -

Opps...

      
 
       

        
 
         
Error:
 
         
java.lang.RuntimeException: Error condition!!!
 
        
 
        
 
         
URI:
 
         
/main.jsp
 
        
 
        
 
         
Status code:
 
         
500
 
        
 
        
 
         
Stack trace:
 
         
 
org.apache.jsp.main_jsp._jspService(main_jsp.java:65)
 
org.apache.jasper.runtime.HttpJspBase.service(HttpJspBase.java:68)
 
javax.servlet.http.HttpServlet.service(HttpServlet.java:722)
 
org.apache.jasper.servlet.JspServlet.service(JspServlet.java:265)
 
javax.servlet.http.HttpServlet.service(HttpServlet.java:722)
 
 
        
 
       
      

Usando Try ... Catch Block

Se você deseja lidar com erros na mesma página e deseja realizar alguma ação em vez de disparar uma página de erro, você pode usar o try....catch quadra.

A seguir está um exemplo simples que mostra como usar o bloco try ... catch. Vamos colocar o seguinte código em main.jsp -

<html>
   <head>
      <title>Try...Catch Example</title>
   </head>
   
   <body>
      <%
         try {
            int i = 1;
            i = i / 0;
            out.println("The answer is " + i);
         }
         catch (Exception e) {
            out.println("An exception occurred: " + e.getMessage());
         }
      %>
   </body>
</html>

Acesse o main.jsp, ele deve gerar uma saída parecida com a seguinte -

An exception occurred: / by zero

Neste capítulo, discutiremos a depuração de um JSP. É sempre difícil testar / depurar um JSP e servlets. JSP e Servlets tendem a envolver uma grande quantidade de interação cliente / servidor, tornando os erros prováveis, mas difíceis de reproduzir.

A seguir estão algumas dicas e sugestões que podem ajudá-lo em sua depuração.

Usando System.out.println ()

System.out.println()é fácil de usar como um marcador para testar se um determinado trecho de código está sendo executado ou não. Podemos imprimir os valores das variáveis ​​também. Considere os seguintes pontos adicionais -

• Como o objeto System faz parte dos objetos Java principais, ele pode ser usado em qualquer lugar sem a necessidade de instalar nenhuma classe extra. Isso incluiServlets, JSP, RMI, EJB's, ordinary Beans e classes, e standalone applications.

• Comparado a parar em pontos de interrupção, escrever para System.out não interfere muito no fluxo normal de execução do aplicativo, o que o torna muito valioso quando o iming é crucial.

A seguir está a sintaxe a ser usada System.out.println() -

System.out.println("Debugging message");

O exemplo a seguir mostra como usar System.out.print() -

<%@taglib prefix = "c" uri = "http://java.sun.com/jsp/jstl/core" %>

<html>
   <head><title>System.out.println</title></head>
   <body>
      <c:forEach var = "counter" begin = "1" end = "10" step = "1" >
      
         <c:out value = "${counter-5}"/></br>
         <% System.out.println( "counter = " + pageContext.findAttribute("counter") ); %>
      </c:forEach>
      
   </body>
</html>

Acesse o JSP acima, o navegador mostrará o seguinte resultado -

-4
-3
-2
-1
0
1
2
3
4
5

Se você estiver usando o Tomcat, também encontrará essas linhas anexadas ao final do stdout.log no diretório de logs.

counter = 1
counter = 2
counter = 3
counter = 4
counter = 5
counter = 6
counter = 7
counter = 8
counter = 9
counter = 10

Dessa forma, você pode trazer variáveis ​​e outras informações para o log do sistema, que podem ser analisadas para descobrir a causa raiz do problema ou por vários outros motivos.

Usando o JDB Logger

o J2SEa estrutura de registro é projetada para fornecer serviços de registro para qualquer classe em execução na JVM. Podemos fazer uso desta estrutura para registrar qualquer informação.

Vamos reescrever o exemplo acima usando a API JDK logger -

<%@taglib prefix = "c" uri = "http://java.sun.com/jsp/jstl/core" %>
<%@page import = "java.util.logging.Logger" %>

<html>
   <head><title>Logger.info</title></head>
   
   <body>
      <% Logger logger = Logger.getLogger(this.getClass().getName());%>

      <c:forEach var = "counter" begin = "1" end = "10" step = "1" >
      <c:set var = "myCount" value = "${counter-5}" />
      <c:out value = "${myCount}"/></br>
         <% String message = "counter = "
            + pageContext.findAttribute("counter") + "myCount = "
            + pageContext.findAttribute("myCount");
            logger.info( message );
         %>
      </c:forEach>
      
   </body>
</html>

O código acima irá gerar resultados semelhantes no navegador e em stdout.log, mas você terá informações adicionais em stdout.log. Vamos usar oinfométodo do logger porque e registrar a mensagem apenas para fins informativos. A seguir está um instantâneo do arquivo stdout.log -

24-Sep-2010 23:31:31 org.apache.jsp.main_jsp _jspService
INFO: counter = 1 myCount = -4
24-Sep-2010 23:31:31 org.apache.jsp.main_jsp _jspService
INFO: counter = 2 myCount = -3
24-Sep-2010 23:31:31 org.apache.jsp.main_jsp _jspService
INFO: counter = 3 myCount = -2
24-Sep-2010 23:31:31 org.apache.jsp.main_jsp _jspService
INFO: counter = 4 myCount = -1
24-Sep-2010 23:31:31 org.apache.jsp.main_jsp _jspService
INFO: counter = 5 myCount = 0
24-Sep-2010 23:31:31 org.apache.jsp.main_jsp _jspService
INFO: counter = 6 myCount = 1
24-Sep-2010 23:31:31 org.apache.jsp.main_jsp _jspService
INFO: counter = 7 myCount = 2
24-Sep-2010 23:31:31 org.apache.jsp.main_jsp _jspService
INFO: counter = 8 myCount = 3
24-Sep-2010 23:31:31 org.apache.jsp.main_jsp _jspService
INFO: counter = 9 myCount = 4
24-Sep-2010 23:31:31 org.apache.jsp.main_jsp _jspService
INFO: counter = 10 myCount = 5

As mensagens podem ser enviadas em vários níveis usando as funções de conveniência severe(), warning(), info(), config(), fine(), finer(), e finest(). Aqui, o método finest () pode ser usado para registrar as melhores informações e o método serious () pode ser usado para registrar as informações graves.

Você pode usar o Log4J Framework para registrar mensagens em arquivos diferentes com base em seus níveis de gravidade e importância.

Ferramentas de depuração

O NetBeans é um Java Integrated Development Environment gratuito e de código aberto que oferece suporte ao desenvolvimento de aplicativos Java autônomos e aplicativos da Web que oferecem suporte às especificações JSP e servlet e também inclui um depurador JSP.

O NetBeans suporta as seguintes funcionalidades básicas de depuração -

• Breakpoints
• Percorrendo o código
• Watchpoints

Você pode se referir a NetBeans documentation para entender as funcionalidades de depuração acima.

Usando JDB Debugger

Você pode depurar JSP e servlets com o mesmo jdb comandos que você usa para depurar um miniaplicativo ou um aplicativo.

Para depurar um JSP ou servlet, você pode depurar sun.servlet.http.HttpServer, então observe como o HttpServer executa o JSP / servlets em resposta às solicitações HTTP que fazemos de um navegador. Isso é muito semelhante a como os miniaplicativos são depurados. A diferença é que com os miniaplicativos, o programa real sendo depurado ésun.applet.AppletViewer.

A maioria dos depuradores esconde esse detalhe sabendo automaticamente como depurar miniaplicativos. Até que eles façam o mesmo para JSP, você deve ajudar seu depurador considerando o seguinte -

• Defina o classpath do seu depurador. Isso ajuda você a encontrarsun.servlet.http.Http-Server e as classes associadas.

• Defina o classpath do seu depurador. Isso ajuda a encontrar seu JSP e classes de suporte, normalmenteROOT\WEB-INF\classes.

Depois de definir o caminho de classe adequado, comece a depurar sun.servlet.http.HttpServer. Você pode definir pontos de interrupção em qualquer JSP que estiver interessado em depurar e, em seguida, usar um navegador da web para fazer uma solicitação ao HttpServer para o JSP fornecido(http://localhost:8080/JSPToDebug). A execução aqui para em pontos de interrupção.

Usando comentários

Comentários em seu código podem ajudar o processo de depuração de várias maneiras. Os comentários podem ser usados ​​de muitas outras maneiras no processo de depuração.

O JSP usa comentários Java e single line (// ...) e multiple line (/* ... */)os comentários podem ser usados ​​para remover temporariamente partes do seu código Java. Se o bug desaparecer, dê uma olhada no código que você acabou de comentar e descubra o problema.

Cabeçalhos de cliente e servidor

Às vezes, quando um JSP não se comporta conforme o esperado, é útil examinar a solicitação e a resposta HTTP brutas. Se você estiver familiarizado com a estrutura do HTTP, poderá ler a solicitação e a resposta e ver o que exatamente está acontecendo com esses cabeçalhos.

Dicas importantes de depuração

Aqui está uma lista de mais algumas dicas de depuração na depuração JSP -

• Peça a um navegador para mostrar o conteúdo bruto da página que está exibindo. Isso pode ajudar a identificar problemas de formatação. Geralmente é uma opção do menu Exibir.

• Certifique-se de que o navegador não esteja armazenando em cache a saída de uma solicitação anterior, forçando uma recarga completa da página. ComNetscape Navigator, usar Shift-Reload; comInternet Explorer usar Shift-Refresh.

JavaServer Pages e servlets disponibilizam vários mecanismos aos desenvolvedores da Web para proteger os aplicativos. Os recursos são protegidos declarativamente, identificando-os no descritor de implantação do aplicativo e atribuindo uma função a eles.

Vários níveis de autenticação estão disponíveis, desde autenticação básica usando identificadores e senhas até autenticação sofisticada usando certificados.

Autenticação baseada em função

O mecanismo de autenticação na especificação do servlet usa uma técnica chamada role-based security. A ideia é que, em vez de restringir recursos no nível do usuário, você cria funções e restringe os recursos por função.

Você pode definir diferentes funções no arquivo tomcat-users.xml, que está localizado fora do diretório inicial do Tomcat em conf. Um exemplo deste arquivo é mostrado abaixo -

<?xml version = '1.0' encoding = 'utf-8'?>
<tomcat-users>
   <role rolename = "tomcat"/>
   <role rolename = "role1"/>
   <role rolename = "manager"/>
   <role rolename = "admin"/>
   <user username = "tomcat" password = "tomcat" roles = "tomcat"/>
   <user username = "role1" password = "tomcat" roles = "role1"/>
   <user username = "both" password = "tomcat" roles = "tomcat,role1"/>
   <user username = "admin" password = "secret" roles = "admin,manager"/>
</tomcat-users>

Este arquivo define um mapeamento simples entre username, password, e role. Observe que um determinado usuário pode ter várias funções; por exemplo,username = "both" está na função "tomcat" e na função "role1".

Depois de identificar e definir diferentes funções, as restrições de segurança baseadas em funções podem ser colocadas em diferentes recursos de aplicativos da Web usando o <security-constraint> elemento em web.xml arquivo disponível no diretório WEB-INF.

A seguir está um exemplo de entrada em web.xml -

<web-app>
   ...
   <security-constraint>
      <web-resource-collection>
         <web-resource-name>SecuredBookSite</web-resource-name>
         <url-pattern>/secured/*</url-pattern>
         <http-method>GET</http-method>
         <http-method>POST</http-method>
      </web-resource-collection>
      
      <auth-constraint>
         <description>
            Let only managers use this app
         </description>
         <role-name>manager</role-name>
      </auth-constraint>
   </security-constraint>
   
   <security-role>
      <role-name>manager</role-name>
   </security-role>
   
   <login-config>
      <auth-method>BASIC</auth-method>
   </login-config>
   ...
</web-app>

As entradas acima significariam -

• Qualquer solicitação HTTP GET ou POST para uma URL correspondida por / secure / * estaria sujeita à restrição de segurança.

• Uma pessoa com a função de gerente recebe acesso aos recursos protegidos.

• o login-config elemento é usado para descrever o BASIC forma de autenticação.

Se você tentar navegar em qualquer URL, incluindo o /securitydiretório, a seguinte caixa de diálogo será exibida solicitando nome de usuário e senha. Se você fornecer um usuário"admin" e senha "secret", então você terá acesso ao URL correspondido por /secured/* como definimos o usuário admin com função de gerente que tem permissão para acessar este recurso.

Autenticação baseada em formulário

Ao usar o método de autenticação FORM, você deve fornecer um formulário de login para solicitar ao usuário um nome de usuário e uma senha. A seguir está um código simples delogin.jsp. Isso ajuda a criar um formulário com o mesmo propósito -

<html>
   <body bgcolor = "#ffffff">
      
      <form method = "POST" action ="j_security_check">
         <table border = "0">
            <tr>
               <td>Login</td>
               <td><input type = "text" name="j_username"></td>
            </tr>
            <tr>
               <td>Password</td>
               <td><input type = "password" name="j_password"></td>
            </tr>
         </table>
         <input type = "submit" value = "Login!">
      </form>
      
   </body>
</html>

Aqui você deve se certificar de que o formulário de login deve conter os elementos do formulário chamados j_username e j_password. A ação no<form> tag deve ser j_security_check. POSTdeve ser usado como o método de formulário. Ao mesmo tempo, você terá que modificar o<login-config> tag para especificar o método de autenticação como FORM -

<web-app>
   ...
   <security-constraint>
      <web-resource-collection>
         <web-resource-name>SecuredBookSite</web-resource-name>
         <url-pattern>/secured/*</url-pattern>
            <http-method>GET</http-method>
            <http-method>POST</http-method>
      </web-resource-collection>
      
      <auth-constraint>
         <description>Let only managers use this app</description>
         <role-name>manager</role-name>
      </auth-constraint>
   </security-constraint>
   
   <security-role>
      <role-name>manager</role-name>
   </security-role>
   
   <login-config>
      <auth-method>FORM</auth-method>
      <form-login-config>
         <form-login-page>/login.jsp</form-login-page>
         <form-error-page>/error.jsp</form-error-page>
      </form-login-config>
   </login-config>
   ...
</web-app>

Agora, quando você tenta acessar qualquer recurso com URL /secured/*, ele exibirá o formulário acima solicitando o ID do usuário e a senha. Quando o contêiner vê o "j_security_check", ele usa algum mecanismo interno para autenticar o chamador.

Se o login for bem-sucedido e o chamador estiver autorizado a acessar o recurso seguro, o contêiner usará uma ID de sessão para identificar uma sessão de login para o chamador daquele ponto em diante. O contêiner mantém a sessão de login com um cookie contendo o id da sessão. O servidor envia o cookie de volta ao cliente e, desde que o chamador apresente esse cookie com solicitações subsequentes, o contêiner saberá quem é o chamador.

Se o login falhar, o servidor enviará de volta a página identificada pela configuração da página de erro do formulário

Aqui, j_security_checké a ação que os aplicativos que usam o login baseado em formulário devem especificar para o formulário de login. No mesmo formulário, você também deve ter um controle de entrada de texto chamadoj_username e um password input control chamado j_password. Ao ver isso, significa que as informações contidas no formulário serão enviadas ao servidor, que verificará o nome e a senha. A forma como isso é feito é específica do servidor.

Verifique as implementações de domínio padrão para entender comoj_security_check funciona para contêiner Tomcat ..

Segurança Programática em um Servlet / JSP

o HttpServletRequest objeto fornece os seguintes métodos, que podem ser usados ​​para extrair informações de segurança em tempo de execução -

S.No.	Método e Descrição
1	String getAuthType() o getAuthType() método retorna um objeto String que representa o nome do esquema de autenticação usado para proteger o Servlet.
2	boolean isUserInRole(java.lang.String role) o isUserInRole() O método retorna um valor booleano: verdadeiro se o usuário estiver na função fornecida ou falso se não estiver.
3	String getProtocol() o getProtocol()método retorna um objeto String que representa o protocolo que foi usado para enviar a solicitação. Este valor pode ser verificado para determinar se um protocolo seguro foi usado.
4	boolean isSecure() o isSecure()método retorna um valor booleano que representa se a solicitação foi feita usando HTTPS. Um valor true significa que sim e que a conexão é segura. Um valor false significa que a solicitação não foi.
5	Principle getUserPrinciple() o getUserPrinciple() método retorna um objeto java.security.Principle que contém o nome do usuário autenticado atual.

Por exemplo, para uma página JavaServer vinculada a páginas para gerentes, você pode ter o seguinte código -

<% if (request.isUserInRole("manager")) { %>
   <a href = "managers/mgrreport.jsp">Manager Report</a>
   <a href = "managers/personnel.jsp">Personnel Records</a>
<% } %>

Ao verificar a função do usuário em um JSP ou servlet, você pode personalizar a página da Web para mostrar ao usuário apenas os itens que ele pode acessar. Se você precisar do nome do usuário conforme inserido no formulário de autenticação, pode ligar para ogetRemoteUser método no objeto de solicitação.

Neste capítulo, discutiremos o conceito de Internacionalização em JSP. Antes de prosseguirmos, vamos entender os três termos importantes a seguir -

• Internationalization (i18n) - Isso significa permitir que um site forneça diferentes versões de conteúdo traduzido para o idioma ou nacionalidade do visitante.

• Localization (l10n) - Isso significa adicionar recursos a um site para adaptá-lo a uma determinada região geográfica ou cultural, por exemplo, tradução de hindi para um site.

• locale- Esta é uma determinada região cultural ou geográfica. Normalmente é referido como um símbolo de idioma seguido por um símbolo de país que são separados por um sublinhado. Por exemplo, "en_US"representa a localidade em inglês dos EUA.

Há uma série de itens que devem ser cuidados durante a construção de um site global. Este tutorial não fornecerá detalhes completos sobre isso, mas dará um bom exemplo de como você pode oferecer sua página da Web em diferentes idiomas para a comunidade da Internet, diferenciando sua localização, ou seja, local.

Um JSP pode obter a versão apropriada do site com base na localidade do solicitante e fornecer a versão apropriada do site de acordo com o idioma, cultura e requisitos locais. A seguir está o método do objeto de solicitação que retorna o objeto Locale.

java.util.Locale request.getLocale()

Detectando localidade

A seguir estão os métodos de localidade importantes que você pode usar para detectar requester's location, language e claro locale. Todos os métodos a seguir exibem o nome do país e o nome do idioma definidos no navegador do solicitante.

S.No.	Método e Descrição
1	String getCountry() Este método retorna o código do país / região em maiúsculas para este local no formato ISO 3166 de 2 letras.
2	String getDisplayCountry() Este método retorna um nome para o país do local apropriado para exibição ao usuário.
3	String getLanguage() Este método retorna o código do idioma em minúsculas para este local no formato ISO 639.
4	String getDisplayLanguage() Este método retorna um nome para o idioma do local apropriado para exibição ao usuário.
5	String getISO3Country() Este método retorna uma abreviação de três letras para o país desta localidade.
6	String getISO3Language() Este método retorna uma abreviação de três letras para o idioma deste local.

Exemplo

O exemplo a seguir mostra como exibir um idioma e país associado para uma solicitação em um JSP -

<%@ page import = "java.io.*,java.util.Locale" %>
<%@ page import = "javax.servlet.*,javax.servlet.http.* "%>
<%
   //Get the client's Locale
   Locale locale = request.getLocale();
   String language = locale.getLanguage();
   String country = locale.getCountry();
%>

<html>
   <head>
      <title>Detecting Locale</title>
   </head>

   <body>
      <center>
         <h1>Detecting Locale</h1>
      </center>
      
      <p align = "center">
         <% 
            out.println("Language : " + language  + "<br />");
            out.println("Country  : " + country   + "<br />");
         %>
      </p>
   </body>
</html>

Configuração de idiomas

Um JSP pode produzir uma página escrita em um idioma da Europa Ocidental, como inglês, espanhol, alemão, francês, italiano, holandês, etc. Aqui é importante definir o cabeçalho Content-Language para exibir todos os caracteres corretamente.

Outro ponto importante é exibir todos os caracteres especiais usando entidades HTML; por exemplo,"&#241;" representa "ñ", e "&#161;" representa "¡" como segue -

<%@ page import = "java.io.*,java.util.Locale" %>
<%@ page import = "javax.servlet.*,javax.servlet.http.* "%>

<%
   // Set response content type
   response.setContentType("text/html");
   
   // Set spanish language code.
   response.setHeader("Content-Language", "es");
   String title = "En Español";
%>

<html>
   <head>
      <title><%  out.print(title); %></title>
   </head>
   
   <body>
      <center>
         <h1><%  out.print(title); %></h1>
      </center>
      
      <div align = "center">
         <p>En Español</p>
         <p>¡Hola Mundo!</p>
      </div>
   </body>
</html>

Datas específicas da localidade

Você pode usar o java.text.DateFormat classe e sua estática getDateTimeInstance( )método para formatar data e hora específicas para local. A seguir está o exemplo que mostra como formatar datas específicas para um determinado local -

<%@ page import = "java.io.*,java.util.Locale" %>
<%@ page import = "javax.servlet.*,javax.servlet.http.* "%>
<%@ page import = "java.text.DateFormat,java.util.Date" %>

<%
   String title = "Locale Specific Dates";
   
   //Get the client's Locale
   Locale locale = request.getLocale( );
   
   String date = DateFormat.getDateTimeInstance(
      DateFormat.FULL, 
      DateFormat.SHORT, 
      locale).format(new Date( ));
%>

<html>
   
   <head>
      <title><% out.print(title); %></title>
   </head>
   
   <body>
      <center>
         <h1><% out.print(title); %></h1>
      </center>
      
      <div align = "center">
         <p>Local Date: <%  out.print(date); %></p>
      </div>
   </body>
</html>

Moeda específica da localidade

Você pode usar o java.txt.NumberFormat classe e sua estática getCurrencyInstance( )método para formatar um número, como um tipo longo ou duplo, em uma moeda específica do local. A seguir está o exemplo que mostra como formatar uma moeda específica para um determinado local -

<%@ page import = "java.io.*,java.util.Locale" %>
<%@ page import = "javax.servlet.*,javax.servlet.http.* "%>
<%@ page import = "java.text.NumberFormat,java.util.Date" %>

<%
   String title = "Locale Specific Currency";
   
   //Get the client's Locale
   Locale locale = request.getLocale( );
   
   NumberFormat nft = NumberFormat.getCurrencyInstance(locale);
   String formattedCurr = nft.format(1000000);
%>

<html>
   
   <head>
      <title><% out.print(title); %></title>
   </head>
   
   <body>
      <center>
         <h1><% out.print(title); %></h1>
      </center>
      
      <div align = "center">
         <p>Formatted Currency: <%  out.print(formattedCurr); %></p>
      </div>
   </body>
</html>

Porcentagem específica da localidade

Você pode usar o java.txt.NumberFormat classe e sua estática getPercentInstance( )método para obter a porcentagem específica do local. O exemplo a seguir mostra como formatar a porcentagem específica para um determinado local -

<%@ page import = "java.io.*,java.util.Locale" %>
<%@ page import = "javax.servlet.*,javax.servlet.http.* "%>
<%@ page import = "java.text.NumberFormat,java.util.Date" %>

<%
   String title = "Locale Specific Percentage";
   
   //Get the client's Locale
   Locale locale = request.getLocale( );
   
   NumberFormat nft = NumberFormat.getPercentInstance(locale);
   String formattedPerc = nft.format(0.51);
%>

<html>
   
   <head>
      <title><% out.print(title); %></title>
   </head>
   
   <body>
      <center>
         <h1><% out.print(title); %></h1>
      </center>
      
      <div align = "center">
         <p>Formatted Percentage: <%  out.print(formattedPerc); %></p>
      </div>
   </body>
</html>