Pipeline :: Java Server Pages (JSP)
Make your own free website on Tripod.com

   Linguagens de Programação - JSP

Java Server Pages

Introdução

Antes de falarmos de JSP, é interessante que primeiro falemos das servlets Java. Imagine um cliente solicitando que alguma ação seja realizada e, então, um servidor realiza a ação solicitada e responde a este cliente. Este modelo de comunicação solicitação-resposta é o fundamento para o mais alto nível de redes em Java: as servlets. Um servlet estende, então, a funcionalidade de um servidor.

Dessa forma, servlets são a resposta de Java ao Common Gateway Interface (CGI). As servlets são programas que rodam em um servidor Web, agindo como uma camada intermediária entre uma solicitação vinda de um cliente HTTP e aplicações existentes em um servidor Web. Entre suas funcionalidades estão:
  • Ler dados enviados pelos usuários. Esses dados normalmente são enviados via um formulário em uma página Web, podendo vir também via applets Java ou outro programa do lado do cliente.
  • Gerar resultados. Esse processo pode solicitar informações de banco de dados, execuções de RMI (Remote Method Invocation), entre outros.
  • Formatar os resultados dentro de um documento. Na maioria das vezes, esse processo envolve agrupar os resultados dentro de uma página HTML.
  • Configurar os parâmetros apropriados para a resposta HTTP. Isso significa dizer ao browser que tipo de documento está sendo retornado (por exemplo, um documento HTML), configurar cookies, dentre outros.
  • Enviar o documento de volta para o cliente. Esse documento pode voltar em formato de arquivo texto, binário, comprimido ou outro formato.
As servlets podem, também, ser utilizadas para a geração dinâmica de páginas, ou seja, páginas que são criadas conforme dados enviados pelos usuários (por exemplo, páginas de respostas a pesquisas, como no GoogleTM ou Yahoo!TM), ou que são criadas a partir de dados que mudam freqüentemente (como por exemplo, informações de clima ou de bolsa de valores).

Agora que já sabemos um pouco sobre servlets Java, podemos iniciar a nossa discussão sobre JSP.

Java Server Pages - Aplicabilidade e Uso

A tecnologia JSP é parte da família de tecnologias Java. Páginas JSP são compiladas em servlets e podem chamar componentes JavaBeans (beans) ou componentes Enterprise JavaBeans (enterprise beans) para a realização do processamento no servidor. A tecnologia JSP é, então, um componente chave na arquitetura de alto escala para aplicações baseadas na Web, provendo um modo simplificado e dinâmico de gerar páginas web que contêm um código dinamicamente gerado.

Mas, então, você pode estar se perguntando: se essa é a função do JSP, então para que eu preciso de JSP se eu já tenho as servlets? Realmente, como veremos adiante, as páginas JSP são compiladas em servlets, então, teoricamente, você pode escrever servlets para suportar as suas aplicações Web. Entretanto, a tecnologia JSP foi projetada para simplificar o projeto de criação de páginas, separando a interface Web de seu conteúdo. Em muitas aplicações, a resposta que é enviada ao usuário está na forma de conteúdo padrão juntamente com conteúdo gerado dinamicamente. Nestas situações, é mais fácil trabalhar com JSP do que fazer tudo com servlets.

A tecnologia JSP permite, então, que mixemos o conteúdo estático HTML com o conteúdo dinamicamente gerado das servlets. Dessa forma, você simplesmente escreve o HTML regular normalmente, usando qualquer editor para esse propósito. Você, então, delimita as partes dinâmicas com tags especiais, a maioria das quais começando com <% e terminando com %>.

Separar o HTML estático do conteúdo dinâmico traz um grande benefício sobre o uso das servlets, e a filosofia usada pelo JSP oferece várias vantagens sobre outras tecnologias como ASP, PHP e ColdFusion. Basicamente pode-se citar dois fatos: primeiro, JSP é amplamente suportado e, portanto, não prende você a nenhum sistema operacional em particular ou a um servidor Web; segundo, JSP nos dá acesso completo às servlets e à tecnologia Java para a parte dinâmica, em vez de solicitar que você use uma outra linguagem somente para esse propósito.

Como funciona o JSP

Uma página JSP é uma página construída por um desenvolvedor Web que inclui a tecnologia JSP e tags específicas, combinadas com outras tags estáticas (HTML ou XML). Uma página JSP tem a extensão .jps ou .jspx; isso sinaliza a um servidor Web para que um engine processe e codifique os elementos presentes nessa página.

Páginas JSP usam tags XML e scriptlets escritos na linguagem Java para encapsular a lógica que gera o conteúdo para a página. Isso envia qualquer tag de formatação (HTML ou XML) de volta à página de resposta. Desta forma, páginas JSP separam a lógica da página de seu design e de sua exibição.
  1. Como uma página JSP é compilada É importante sabermos como uma página JSP é compilada quando o usuário a carrega em Web browser. O processo de compilação é ilustrado na figura a seguir.

    Processo de compilação de uma página JSP

    A seguir apresentamos uma descrição da figura.
    1. Antes de tudo, uma aplicação JSP é, normalmente, uma coleção de arquivos JSP, arquivos HTML, gráficos e outras fontes.
    2. Quando o usuário carreaga a página pela primeira vez, os arquivos que constituem a aplicação são todos traduzidos ,em conjunto, sem qualquer dado dinâmico, para um único arquivo fonte Java (.java), com o nome definido pela a sua aplicação JSP.
    3. Em seguida, o arquivo .java é compilado em um arquivo .class. Normalmente, o arquivo .java é uma servlet Java, a qual está de acordo com a API Java Servlet. Estes três passos são conhecidos como "tempo de tradução" (translation time).
    4. Quando um usuário realiza uma soliciatação (request) à aplicação JSP (por exemplo, colocando algo em um campo de formulário e clicando em um botão Submit) um ou mais de um dos componentes da aplicação (bean, enterprise bean ou servlet) manipula os dados que o usuário submeteu ou recupera os dados dinamicamente de um repositório de dados e retorna os dados para um arquivo .java, o qual é recompilado em um arquivo .class. O arquivo .class, sendo uma servlet Java, retorna os dados para o Web browser do cliente através do seu método service.
    5. Quando o usuário faz uma nova solicitação, o componente obtém ou manipula os dados novamente e os retorna para o arquivo .java, o qual é novamente compilado em um arquivo .class. Essa etapa é conhecida como "tempo de solicitação" (request time).
  2. O que acontece acontece com os dados enviados pelo usuário As informações que um usuário envia, por exemplo, através de um formulário HTML são armazenadas em um objeto request, que as envia do cliente para um container JSP. A figura abaixo mostra o que acontece em seguida. Como os dados são passados entre o cliente e o servidor A seguir apresentamos uma descrição da figura.
    1. O container JSP envia o objeto request para o componente (beans, enterprise bean ou servlet) especificado pelo arquivo JSP.
    2. O componente manipula o request, possivelmente recuperando dados de um banco de dados ou de outro tipo de repositório, e, então, envia um objeto response de volta para o container JSP.
    3. O container JSP passa o objeto response para a página JSP, onde os dados do objeto response são formatados de acordo com o design da página HTML.
    4. O container JSP e o servidor Web enviam, então, a página JSP, já formatada, de volta para o cliente, onde o usuário pode ver os resultados em seu browser Web. O protocolo de comunicação usado entre cliente e servidor pode ser HTTP, ou algum outro.

Os elementos básicos de uma página JSP

Os principais elementos de uma página JSP são: declarações, expressões, scriptlets e diretivas. Os três primeiros têm sintaxes e usos similares, mas têm diferenças importantes. Vamos explicar, com alguns exemplos, as semelhanças e diferenças entre eles.

As Declarações

As declarações situam-se entre os delimitadores <%! e %>. São usadas para definir variáveis e métodos específicos para uma página JSP. Os métodos e variáveis declaradas podem então ser referenciados por outros elementos de criação de scriptlets na mesma página. A cada declaração deve ser finalizada ou separada por "ponto-e-vírgula". Vejamos alguns exemplos:



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


Você deve declarar uma variável ou um método antes de usá-lo. O escopo de uma declaração é geralmente o arquivo JSP, mas se for incluído outros arquivos com a diretiva include, o escopo se expande para o cover do arquivo incluído.

Expressões

As expressões situam-se entre os delimitadores <%= e %>. Podem conter alguma expressão válida da linguagem de script usada nessa página (o padrão é que a Linguagem seja Java), MAS SEM PONTO-E-VíRGULA!!

Veja alguns exemplos:

<%= Math.sqrt(2) %>
<%= items[i] %>
<%= a + b + c %>
<%= new java.util.Date() %>

A expressão Java é avaliada (da esquerda para a direita), convertida em String e depois inserida na página. Essa avaliação é feita em tempo de execução (quando a página é solicitada) permitindo fácil e rápido acesso a informação que foi requisitada. Por exemplo, uma exibição de data e hora em que a página é acessada.

Para construir uma expressão em JSP você pode colocar entre as tags qualquer expressão definida na Especificação da Linguagem Java. Ao contrário dos scriptlets (que veremos a seguir), uma expressão não aceita ponto e vírgula e define somente uma expressão da Linguagem.

Scriptlets

Os scriplets situam-se entre os delimitadores <% e %>. Permitem você escrever trechos de código da Linguagem usada na página. Veja o exemplo abaixo:

<html>
<body>
.
.
.
<%
    resposta = request.getParameter("opcao"); 
    
    if (resposta.equals("sim")){
       respostas[0]++;
    }else{
       respostas[1]++;
    }

    numSim = respostas[0];
    numNao = respostas[1];

   try{
     output = new ObjectOutputStream( new FileOutputStream(f));
     output.writeObject(respostas);
     output.flush();
     output.close();
   }
   catch(IOException io){
     io.printStackTrace();
   }
%>
.
.
.
</html>
</body>

Lembre-se que em um script você deve finalizar as expressões através do uso de ponto-e-vírgula. Quando você escreve um script, você pode usar algum dos objetos implícitos do JSP ou das classes importadas através da diretiva page, variáveis ou métodos (declarados entre as tags <%! e %> ou objetos nomeados através da tag <jsp:useBean>.

Diretivas

As diretivas são usadas para fornecer informações especiais ao container JSP sobre a página JSP quando esta é compilada para servlet. As diretivas JSP afetam a estrutura global da classe servlet. Existem dois tipos principais de diretivas:
  • page: permite situações como importação de classes, customização de super classes servlet entre outras;
  • include: permite que seja inserido o conteúdo de um arquivo no servlet no momento em que o arquivo JSP é traduzido para servlet.
Diretiva page: A diretiva page tem a seguinte sintaxe:

<%@ page attribute1=valor1 attribute2=valor2 attribute3=... %>

Alguns dos atributos de page são import, que especifica qual o pacote a ser importado e session (com os valores true/false), que indica se a variável predefinida session (do tipo HttpSession) deve estar ligada a sessão existente.

Diretiva include:A diretiva include permite que sejam incluídos arquivos na hora em que a página JSP é traduzida no servlet. Uma directive include é algo como:

<%@ include file="relative url" %>

Esta diretiva pode, então, ser usada para incluir arquivos que sejam usadas em diversas páginas como, por exemplo, um arquivo que represente um menu de navegação que está presente em todas as páginas do site; assim, o menu é editado apenas uma vez e incluído em todas as páginas por meio da diretiva include. Isso facilita a manutenção do site.

Um exemplo simples

O exemplo a seguir é um exemplo de uma página JSP simples. Para executá-lo, você deve ter um servidor Web, como o Tomcat, instalado em sua máquina, além do JDK. Mais detalhes podem ser conferidos no tutorial Como Instalar e Configurar o Tomcat.

1.<HTML>
2.<HEAD>
3.<TITLE>Um Simples Exemplo</TITLE>
4.</HEAD>
5.<BODY>
6.<%! private String mensagem; %>
7.
8.  <%
9.   mensagem = new String("mensagem gerada via JSP!");
10.%>
11.
12. <H1>Esta é uma <%= mensagem %>  </H1>
13.
14.</BODY>
15.</HTML>

Esse código é uma versão do famoso Hello World. Podemos ver que JSP mistura o código da linguagem Java com a linguagem HTML. Na linha 6, vemos que há uma declaração de variável do tipo String. Nas linhas de 8 a 10 há um scriptlet que inicializa a variável String; e na linha 12, temos uma expressão; observe que, conforme dissemos anteriormente, as expressões não são finalizadas com ponto-e-vírgula.

Essa é uma demontração simples, com intuito didático, do uso de JSP. Aplicações muito mais elaboradas, com acesso a arquivos, banco de dados e outros, podem ser construídas por meio da utilização de Java Server Pages.

Voltar para o início da página.
 
   Menu JSP