JEEBrasil

Abaixo estão os links para a API que define essas interfaces:
ServletRequest
HttpServletRequest

O exemplo a seguir ilustra a utilização do objeto implícito request:

.....    
Seu IP é :<%= request.getRemoteAddr() %><br>
Seu Host é :<%= request.getRemoteHost() %><br>
.....

Objeto response

O objeto response representa a resposta que será enviada de volta para o usuário como resultado do processamento da página JSP. Este objeto implementa a interface javax.servlet.http.HttpServletResponse que é uma subinterface de javax.servlet.ServletResponse.

Podemos dividir os métodos desse objeto em quatro funcionalidades:

Abaixo estão os links para a API que define essas interfaces:
ServletResponse
HttpServletResponse

O exemplo abaixo ilustra uma das utilidades desse objeto. Vários cabeçalhos são definidos para evitar que a página seja armazenada em cache por um navegador.

<%
response.setHeader("Expires", 0);
response.setHeader("Pragme, "no-cache");
if(request.getProtocol().equals("HTTP/1.1")){
    response.setHeader("Cache-Control", "no-cache"); 
}
%>

Este script primeiro define o cabeçalho Expires para uma data no passado. Isto significa que o conteúdo da página já expirou, como uma dica que seu conteúdo não deve ser armazenado em cache.

Objeto out

Este objeto implícito representa o fluxo de saída para a página, cujo conteúdo será enviado para o navegador com o corpo de sua resposta. O objeto out é uma intância da classe javax.servlet.jsp.JspWriter.

Esse objeto implementa todos os métodos print() e println() definidos por java.io.Writer.

Por exemplo, o objeto out pode ser usado dentro de um script para adicionar conteúdo à página gerada. Veja o exemplo abaixo:

<%
int i = (int)(Math.random()*10);
if(i%2==0){
    out.print("O Número escolhido "+ i +" é par!");
}
else {
    out.print("O Número escolhido "+ i +" é impar!");
}
%>

Esse objeto é muito utilizado para para gerar conteúdo dentro do corpo de um script, sem ter que fechá-lo temporariamente para inserir conteúdo de página estático. Contudo, deve-se evitar usar os métodos print() ou println() para inserir cadeias de caracteres muito grandes. No próximo caso, é mais aconselhável fechar o script e inserir o conteúdo estático. Veja o exemplo abaixo:

Não Aconselhável:
<%
if(i == 1){
out.print("<h6>"+
"<font face='verdana'>"+
"Guga viaja nesta sexta"+
"para a Suíça para"+
"jogar"+
"</font>"+
"</h6>");
}
%>

Aconselhável:
<% if(i == 1) {%>
<h6>
<font face='verdana'>
Guga viaja nesta sexta
para a Suíça para
jogar
</font>
</h6>
<% } %>

O links abaixo refere-se a API que define a interfaces que o objeto out implementa:
JspWriter

Objetos Contextuais

Os objetos implícitos dessa categoria fornece à página JSP acesso ao contexto dentro do qual ela está respondendo. Os quatro objetos implícitos contextuais são:

• request;
• session;
• application;
• pageContext.

Todos eles têm a capacidade de armazenar e recuperar valores de atributos arbitrários. Os atributos de página, armazenados no objeto pageContext, duram apenas enquanto o processamento de uma única página ocorre. Os atributos de solicitação, armazenados no objeto request, também tem pouca duração, mas podem ser transferidos entre páginas quando for transferido o controle. Os atributos de sessão, armazenados no objeto session, duram enquanto o usuário continuar a interagir com o servidor da web. Os atributos de aplicação, armazenados no objeto application, são mantidos enquanto o container JSP mantiver uma ou mais páginas de uma aplicação carregada na memória - enquanto o container JSP estiver rodando. A tabela a seguir traz os métodos comuns aos quatro objetos e que são usados para armazenar e recuperar valores de atributos:

Objeto session

Este objeto representa a sessão atual de um usuário individual. Todas as solicitações feitas por um usuário são consideradas parte de uma sessão. Desde que novas solicitações por aqueles usuários continuem a ser recebidas pelo servidor, a sessão persiste. Se, no entanto, um certo período de tempo passar sem que qualquer nova solicitação do usuário seja recebida, a sessão expira.

O objeto session armazena informações a respeito da sessão. Um dos principais usos para o objeto session é armazenar e recuperar valores de atributos, a fim de transmitir as informações específicas de usuários entre as páginas. Abaixo segue um exemplo que armazena dados na sessão, na forma de um objeto que é instância de uma classe hipotética "Usuario":

<%
Usuario u = new Usuario(nome, senha);
session.setAttribute("usuario", u);
%>

Uma vez que um objeto tenha sido armazenado através do método setAttibute(), ele pode ser recuperado - na mesma página ou em outra acessada pelo usuário. O código abaixo ilustra a recuperação do objeto armazenado no código anterior:

<%
Usuario u = (Usuario)session.getAttribute("usuario");
.....
%>

Perceba que o método getAttribute() retorna um objeto da classe Object, portanto, é necessário fazermos um cast para converter o objeto retornado em uma instância da classe desejada.

O objeto session implementa a interface javax.servlet.http.HttpSession. A tabela abaixo traz os principais métodos utilizados por esse objeto, além daqueles descritos anteriormente na tabela 1:

O link abaixo exibe a API completa da interface que implementa o objeto session:
HttpSession

Objeto application

Este objeto representa a aplicação à qual a página JSP pertence. Ele é uma instância da interface javax.servlet.ServletContext. Os containers JSP tipicamente tratam do primeiro nome de diretório em um URL como uma aplicação. Exemplo:

• http://server/jspbrasil/index.jsp
  
• http://server/jspbrasil/principal.jsp
  
• http://server/jspbrasil/forum/forum.jsp
  
• http://server/jspbrasil/tutorial/tutorial.jsp
  

São todos considerados parte da mesma aplicação jspbrasil.

Além dos métodos descritos na tabela 1, os métodos do objeto application podem ser divididos em quatro funcionalidades:

O link abaixo exibe a API completa da interface que implementa o objeto application:
ServletContext

Objeto pageContext

O objeto pageContext fornece várias facilidades como gerenciamento de sessões, atributos, páginas de erro, inclusões e encaminhamento de requisições de fluxo de resposta.

O objeto pageContext é uma instância da classe javax.servlet.jsp.PageContext. Além dos métodos descritos na tabela 1, os principais métodos desse objeto podem ser divididos em três categorias:

Os últimos dois métodos listados na tabela anterior permitem a procura, através de todos os escopos definidos, por um atributo associado com uma String passada como parâmetro. Nos dois casos, o objeto pageContext irá realizar uma busca através dos escopos na seguinte ordem: pageContext, request, session e application.

A tabela anterior traz métodos que recebe parâmetros para especificar o escopo. A classe javax.servlet.jsp.PageContext fornece variáveis estáticas para representar estes quatro escopos diferentes. A tabela a seguir resume estas variáveis:

O exemplo abaixo ilustra o uso do método "getAttribute" e das variáveis estáticas descritas na tabela anterior:

<%
User uPag=(User)pageContext.getAttibute("user",pageContext.PAGE_SCOPE)
//Recupera o object "usuario" do escopo pageContext

User uReq=(User)pageContext.getAttibute("user",pageContext.REQUEST_SCOPE)
//Recupera o object "usuario" do escopo request

User uSes=(User)pageContext.getAttibute("user",pageContext.SESSION_SCOPE)
//Recupera o object "usuario" do escopo session

User uApp=(User)pageContext.getAttibute("user",pageContext.APPLICATION_SCOPE)
//Recupera o object "usuario" do escopo application
%>

O link abaixo exibe a API completa da interface que implementa o objeto pageContext:
PageContext

Tratamento de Erros

Esta última categoria dos objetos implícitos tem apenas um membro, o objeto exception. Este objeto implícito é fornecido com o propósito de tratamento de erros dentro de uma página JSP.

Objeto Exception

O objeto exception não está automaticamente disponível em todas as páginas JSP. Este objeto está disponível apenas nas páginas que tenham sido designadas como páginas de erro, usando o atributo isErrorPage configurado com true na diretiva page. O objeto exception é uma instância da classe java.lang.Throwable correspondente ao erro não capturado que fez com que o controle fosse transferido para a página de erro. Os principais métodos da classe java.lang.Throwable que são utilizados dentro das páginas JSP são listados na tabela abaixo:

O trecho abaixo ilustra o uso do objeto exception em uma página de erro JSP:

<@ page isErrorPage=true %>
<h1>Erro Encontrado</h1>
O seguinte erro foi eoncontrado:<br>
<b><%= exception %></b><br>
<% exception.printStackTrace(out); %>

Criando funções que manipulam Objetos Implícitos

Como foi visto em módulos anteriores, é possível definir funções na própria página JSP através das tags <%! e %>. Veja o exemplo abaixo:

<%!
String jogueMoeda(){
  String retorno = "";
  int i = (int)(Math.random()*10); //um número entre 0 e 10
  i = i%2;                         //resto da divisao de i por 2
  if(i==0){
     retorno = "cara";
  } else {
     retorno = "coroa";
  }
  return retorno;
}
%>

<html>
<body>

<h1>O resultado foi <%= jogueMoeda() %>!</h1>

</body>
</html>

Nesse trecho de código, uma função é definida dentro de uma página JSP. Essa função é bastante simples: simula o lançamento de uma moeda para cima e escolhe, aleatoriamente, entre cara ou coroa.

Imagine agora que queremos que a função simule o lançamento da moeda várias vezes seguidas. Podemos alterar o código anterior e chamarmos a função várias vezes:

....
<html>
<body>

<h1>O(s) resultado(s) foi(ram) <%= jogueMoeda() %>, 
<%= jogueMoeda() %> ... 
<%= jogueMoeda() %>!</h1>

</body>
</html>

Essa, solução, apesar de funcionar, não é a mais adequada. Podemos reescrever a função para receber como parâmetros a quantidades de jogadas que deverão ser efetuadas e fornecer um meio para que a função possa escrever o conteúdo na página JSP:

<%!
void jogueMoeda(int numeroJogadas, javax.servlet.jsp.JspWriter o){
  try{
    for(int k=1; k <= numeroJogadas; k++){
      int i = (int)(Math.random()*10); //número entre 0 e 10
      i = i%2; 
      if(i==0){
         o.print("cara");
      } else {
         o.print("coroa");
      }
      if(k==numeroJogadas){
         o.print("!");
      } else {
         o.print(", ");
      }
    }
  } catch(Exception e){}
}
%>

<html>
<body>

<h1>Deu <% jogueMoeda(10,out); %></h1>

</body>
</html>

Essa segunda versão, apesar de ter uma funcionalidade bem parecida com a anterior traz algumas novidades:

• Passamos como parâmetro um objeto da interface javax.servlet.jsp.JspWriter. É através desse objeto que iremos enviar para a página JSP o resultado da "jogada".
• Na chamada da função passamos, além do número de jogadas desejadas, uma referência ao objeto implícito out. É através dessa referência que a função irá imprimir na saída da página JSP o resultado de sua jogada.

É importante aprender que não podemos chamar o objeto out (ou qualquer outro objeto implícito) diretamente em uma função declarada dentro de uma página JSP. Portanto, o seguinte código está errado e apresentará um erro em tempo de compilação:

<%!
void jogueMoeda(int numeroJogadas){
  for(int k=1; k <= numerovezes; k++){
    int i = Math.random();
    i = i*10;
    i = i%2; 
    if(i==0){
       out.print("cara");
    } else {
       out.print("coroa");
    }
	if(k==numeroJogadas){
	   out.print("!");
	} else {
	   out.print(", ");
	}
  }
}
%>
<html>
<body>

<h1>Deu <% jogueMoeda(50) %></h1>

</body>
</html>

A tabela a seguir exibe como criar e chamar funções que usam os nove objetos implícitos:

void f(javax.servlet.jsp.HttpJspPage p){
  ...
  p.algumaFuncaoDoObjetoPage();
  ...
}

<%
f(page);
%>

void f(javax.servlet.Config c){
  ...
  c.algumaFuncaoDoObjetoConfig();
  ...
}

<%
f(config);
%>

void f(javax.servet.http.HttpServletRequest rq){
  ...
  rq.algumaFuncaoDoObjetoRequest();
  ...
}

<%
f(request);
%>

void f(javax.servet.http.HttpServletResponse rp){
  ...
  rp.algumaFuncaoDoObjetoResponse();
  ...
}

<%
f(response);
%>

void f(javax.servet.jsp.JspWriter o){
  ...
  o.algumaFuncaoDoObjetoOut();
  ...
}

<%
f(out);
%>

void f(javax.servet.http.HttpSesseion s){
  ...
  s.algumaFuncaoDoObjetoSession();
  ...
}

<%
f(session);
%>

void f(javax.servet.ServletContext a){
  ...
  a.algumaFuncaoDoObjetoApplication();
  ...
}

<%
f(application);
%>

void f(javax.servet.jsp.PageContext pc){
  ...
  pc.algumaFuncaoDoObjetoPageContext();
  ...
}

<%
f(pageContext);
%>

void f(java.lang.Throwable e){
  ...
  e.algumaFuncaoDoObjetoException();
  ...
}

<%
f(exception);
%>

Conclusão

Sem dúvida esse foi um dos maiores módulos do tutorial de JSP. O tema mereceu (e merece) atenção para aqueles que estão estudando JSP. As vantagens desses objetos são mais perceptíveis para aqueles que já programam com Servlet (onde todos os objetos devem ser declarados explicitamente). No momento em que o JSP é traduzido para Servlet (tipicamente durante o primeiro acesso ao JSP), algumas variáveis - os objetos implícitos - são criados pelo tradutor. O Servlet gerado automaticamente contém todas as variáveis implícitas dentro do JSP.

É aconselhável para aqueles que pretendem trabalhar com JSP conhecer um pouco da API dos objetos implícitos (os links estão distribuídos pelo texto). Esse módulo não tratou com exautão todos os métodos disponíveis nas classes que regem esses objetos.