Desenvolvimento de aplicativos Web com JSP e XML Parte I: Rápido JSP

Se você já teve a oportunidade de construir aplicações web, usando tecnologias como CGI (Common Gateway Interface) e servlets, você está acostumado à idéia de escrever um programa para gerar a página toda (o estático e o dinâmico parte), utilizando o mesmo programa. Se você está procurando uma solução na qual possa separar as duas partes, não procure mais. As páginas JavaServer (JSP) estão aqui.

as páginas JSP permitem separar a apresentação front-end da lógica de negócios (níveis médio e back-end). É uma ótima abordagem de desenvolvimento rápido de aplicativos (RAD) para aplicativos da Web. Esta série de artigos fornece um tutorial prático explicando como desenvolver aplicativos da Web modernos para o mercado de hoje e de amanhã. Esta série começa com este artigo, que explica os conceitos e benefícios da tecnologia JSP e, em seguida, mostra como utilizar essa tecnologia empolgante e como criar componentes reutilizáveis para o manuseio de formulários.

the Dynamic Web

a Web evoluiu de um sistema de informação distribuída hypermedia baseado em rede que oferece informações estáticas para um mercado de venda e compra de bens e serviços. Os aplicativos cada vez mais sofisticados para permitir esse mercado exigem uma tecnologia para apresentar informações dinâmicas.

as soluções de primeira geração incluíam o CGI, que é um mecanismo para executar programas externos por meio de um servidor web. O problema com scripts CGI é escalabilidade; um novo processo é criado para cada solicitação.

as soluções de segunda geração incluíam fornecedores de Servidores web que forneciam plug-ins e APIs para seus servidores. O problema é que suas soluções eram específicas para seus produtos de servidor. Por exemplo, a Microsoft forneceu páginas do Active Server (ASP) que facilitaram a criação de conteúdo dinâmico. No entanto, sua solução funcionou apenas com o Microsoft IIS ou Personal Web Server. Portanto, se você quisesse usar o ASP, teria que se comprometer com os produtos da Microsoft e não estaria aproveitando a liberdade de selecionar seu servidor web e sistema operacional favoritos!

outra tecnologia de segunda geração que é bastante popular na computação corporativa são os servlets. Servlets facilitam a gravação de aplicativos do lado do servidor usando a tecnologia Java. O problema com CGI ou servlets, no entanto, é que você deve seguir o ciclo de vida write, compile e deploy.As páginas JSP são uma solução de terceira geração que pode ser combinada facilmente com algumas soluções de segunda geração, criando conteúdo dinâmico e tornando mais fácil e rápido criar aplicativos baseados na web que funcionam com uma variedade de outras tecnologias: servidores web, navegadores web, Servidores de aplicativos e outras ferramentas de desenvolvimento.

JavaServer Pages (JSP)

a tecnologia JSP é uma especificação aberta e disponível gratuitamente desenvolvida pela Sun Microsystems como uma alternativa à tecnologia Active Server Pages (ASP) da Microsoft e um componente-chave da especificação Java 2 Enterprise Edition (J2EE). Muitos dos servidores de aplicativos disponíveis comercialmente (como BEA WebLogic, IBM WebSphere, Live JRun, Orion e assim por diante) já suportam a tecnologia JSP.

JSP versus ASP

JSP e ASP oferecem funcionalidade semelhante. Ambos usam tags para permitir código incorporado em uma página HTML, rastreamento de sessão e conexão de banco de dados. Algumas das diferenças triviais são:

• as páginas ASP são escritas em VBScript e as páginas JSP são escritas na linguagem de programação Java. Portanto, as páginas JSP são independentes da plataforma e as páginas ASP não.
• as páginas JSP usam a tecnologia JavaBeans como a arquitetura de componentes e as páginas ASP usam componentes ActiveX.

além dessas diferenças triviais, há uma série de diferenças importantes que podem ajudá-lo a escolher uma tecnologia para sua organização:Velocidade e escalabilidade: embora as páginas ASP sejam armazenadas em cache, elas são sempre interpretadas. Por outro lado, as páginas JSP são compiladas em servlets Java e carregadas na memória na primeira vez que são chamadas e executadas para todas as chamadas subsequentes. Isso dá às páginas JSP vantagem de aspeed e escalabilidade sobre as páginas ASP.

para uma comparação mais detalhada entre páginas JSP e páginas ASP, consulte comparando JSP e ASP.

ambiente de Software

para executar páginas JSP, você precisa de um servidor web com um contêiner da web que esteja em conformidade com as especificações JSP e servlet. O contêiner da web é executado no servidor da web e gerencia a execução de todas as páginas e servlets JSP em execução nesse servidor da web. Tomcat 3.2.1 é uma implementação de referência completa para as especificações Java Servlet 2.2 e JSP 1.1. Baixe e instale versões binárias do Tomcat.

para configurar o Tomcat:

• defina a variável de ambiente JAVA_HOME para apontar para o diretório raiz da instalação do Java 2 Standard Edition (J2SE).
• defina a variável de ambiente TOMCAT_HOME para apontar para o diretório raiz da instalação do Tomcat.
• Para iniciar o Tomcat, use TOMCAT_HOME/bin/startup.bat para windows ou startup.sh para UNIX.
  por padrão, ele começará a ouvir na porta 8080.
• Salve seus arquivos .jsp em TOMCAT_HOME/webapps/examples/jspe suas classes JavaBeans em TOMCAT_HOME/webapps/examples/web-inf/classes.

Nota: Se você trabalha no Windows, pode obter um erro de ambiente fora do espaço ao tentar iniciar o Tomcat. Existem duas maneiras de corrigir isso: altere a configuração de memória inicial da janela do DOS para um valor maior que 3200 ou edite a configuração.arquivo sys e adicione a seguinte linha: SHELL=c:\PATHTO\command.com /E:4096 /P.

como as páginas JSP funcionam

uma página JSP é basicamente uma página da web com HTML tradicional e bits de código Java. A extensão do arquivo de uma página JSP é”.jsp “em vez de”.html” ou “.htm”, e que diz ao servidor que esta página requer tratamento especial que será realizado por uma extensão do servidor ou um plug-in. Aqui está um exemplo simples:

amostra 1: Data.jsp

 <HTML><HEAD><TITLE>JSP Example</TITLE></HEAD><BODY BGCOLOR="ffffcc"><CENTER><H2>Date and Time</H2><% java.util.Date today = new java.util.Date();out.println("Today's date is: "+today);%></CENTER> </BODY> </HTML> 

este exemplo contém HTML tradicional e algum código Java. A tag <% identifica o início de um scriptlet e a tag %> identifica o fim de um scriptlet. Quando date.jsp é solicitado a partir de um navegador da web, você vê algo semelhante à Figura 1.

Figura 1: Data de solicitação.jsp

nos bastidores

quando esta página (date.jsp) é chamada, ela será compilada (pelo mecanismo JSP) em um servlet java. Neste ponto, o servlet é tratado pelo motor servlet como qualquer outro servlet. O motor servlet, em seguida, carrega a classe servlet (usando um carregador de classe) e executa-lo para criar HTML dinâmico para ser enviado para o navegador, como mostrado na Figura 2. Para este exemplo, o servlet cria um objeto Date e o grava como uma string para o objeto out, que é um fluxo de saída para o navegador.

Figura 2: Solicitação/Resposta de Fluxo ao Chamar um JSP

na próxima vez que a página é solicitada, a JSP engine executa o já-servlet carregado, a menos que a página JSP foi alterado, caso em que é recompilados automaticamente em um servlet e executado.

elementos de script

no exemplo date.jsp o nome completo da classe Date é usado, incluindo o nome do pacote, que pode se tornar tedioso. Se você deseja criar uma instância de Date simplesmente usando: Date today = new Date(); sem ter que especificar o caminho da classe completa, use a diretiva page da seguinte maneira:

amostra 2 :date2.jsp

 <%@page import="java.util.*" %><HTML> <HEAD> <TITLE>JSP Example</TITLE> </HEAD> <BODY BGCOLOR="ffffcc"><CENTER> <H2>Date and Time</H2> <% java.util.Date today = new java.util.Date();out.println("Today's date is: "+today);%></CENTER></BODY> </HTML>

no entanto, outra maneira de fazer a mesma coisa usando a tag <%= é escrevendo:

amostra 3:date3.jsp

 <%@page import="java.util.*" %> <HTML> <HEAD> <TITLE>JSP Example</TITLE> </HEAD> <BODY BGCOLOR="#ffffcc"> <CENTER> <H2>Date and Time</H2> Today's date is: <%= new Date() %> </CENTER> </BODY> </HTML> 

como você pode ver, a mesma coisa pode ser realizada usando diferentes tags e técnicas. Existem vários elementos de script JSP. Aqui estão algumas regras convencionais que ajudarão você a usar elementos de script JSP de forma eficaz:

• Use <% ... %> para lidar com declarações, expressões ou qualquer outro tipo de trecho de código válido. A amostra 1 acima é um exemplo.
• Use a diretiva page como em <%@page ... %> para definir a linguagem de script. Além disso, ele pode ser usado para especificar instruções import. Aqui está um exemplo:
  <%@page language="java" import="java.util.*" %>.
• Use <%! .... %> para declarar variáveis ou métodos. Por exemplo:
  <%! int x = 10; double y = 2.0; %>.
• Use <%= ... %> para definir uma expressão e lançar o resultado como um String. Por exemplo:
  <%= a+b %> ou <%= new java.util.Date() %>.
• Use a diretiva include como em <%@ include ... %> para inserir o conteúdo de outro arquivo no arquivo JSP principal. Por exemplo:
  <%@include file="copyright.html" %>.

manipulando formulários

uma das partes mais comuns dos aplicativos de comércio eletrônico é um formulário HTML onde o usuário insere algumas informações, como nome e endereço. Usando o JSP, os dados do formulário (as informações que o usuário insere no formulário) são armazenados no objeto request que é enviado do navegador para o contêiner JSP. A solicitação é processada e o resultado é enviado através do objeto response de volta ao navegador. Esses dois objetos estão implicitamente disponíveis para você.

para demonstrar como lidar com formulários HTML usando JSP, aqui está um formulário de exemplo com dois campos: um para nome e outro para E-mail. Como você pode ver, o formulário HTML é definido em um arquivo de origem JSP. O método request.getParameter está sendo usado para recuperar dados do formulário em variáveis criadas usando tags JSP.

a página process.jsp imprime um formulário ou as informações fornecidas pelo Usuário, dependendo dos valores dos campos do formulário. Se os valores do formulário forem null, o formulário será exibido, caso contrário, as informações fornecidas pelo usuário serão exibidas. Observe que o formulário é criado e tratado por código no mesmo arquivo JSP.

Amostra 4: processo.jsp

 <HTML> <HEAD> <TITLE>Form Example</TITLE> </HEAD> <BODY BGCOLOR="#ffffcc"> <% if (request.getParameter("name")==null && request.getParameter("email") == null) { %> <CENTER> <H2>User Info Request Form</H2> <FORM METHOD="GET" ACTION="/developer/technicalArticles/xml/WebAppDev/process.jsp"> <P> Your name: <input type="text" name="name" size=26> <P> Your email: <input type="text" name="email" size=26> <P> <input type="submit" value="Process"> </FORM> </CENTER> <% } else { %> <%! String name, email; %> <% name = request.getParameter("name"); email = request.getParameter("email"); %> <P> <B>You have provided the following info</B>: <P> <B>Name</B>: <%= name %><P> <B>Email</B>: <%= email %> <% } %> </BODY> </HTML> 

se process.jsp for solicitado a um servidor web, você verá algo semelhante à Figura 3.

Figura 3: processo.JSP carregado

digite seu nome e E-mail e clique em processo para enviar o formulário para processamento, e você vê algo semelhante à figura 4.

Figura 4: O formulário é processado

componentes reutilizáveis

o formulário de exemplo acima é simples no sentido de que não há muito código envolvido. Quando Mais código está envolvido, é importante não misturar lógica de negócios com apresentação front-end no mesmo arquivo. Separar a lógica de negócios da apresentação permite alterações em ambos os lados sem afetar o outro. No entanto, o código JSP de produção deve ser limitado à apresentação front-end. Então, como você implementa a parte lógica de negócios?

é aí que os JavaBeans entram para jogar. Essa tecnologia é um modelo de componente portátil e independente de plataforma que permite aos desenvolvedores escrever componentes e reutilizá-los em todos os lugares. No contexto do JSP, o JavaBeans contém lógica de negócios que retorna dados para um script em uma página JSP, que por sua vez Formata os dados retornados do componente JavaBean para exibição pelo navegador. Uma página JSP usa um componente JavaBean definindo e obtendo as propriedades que ele fornece.

quais são os benefícios

existem vários benefícios em usar JavaBeans para aumentar as páginas JSP:

• componentes reutilizáveis: diferentes aplicativos poderão reutilizar os componentes.
• separação da lógica de negócios e da lógica de apresentação: você pode alterar a maneira como os dados são exibidos sem afetar a lógica de negócios.
• protegendo sua propriedade intelectual mantendo o código-fonte seguro.

Exemplo: Usando JavaBeans com JSP

Agora, vamos ver como modificar o process.jsp exemplo acima para usar JavaBeans. Na forma acima, estes são dois campos: name e email. Em JavaBeans, estes são chamados de propriedades. Então, primeiro você escreve Um componente JavaBean com setX e getX métodos, onde X é o nome da propriedade. Por exemplo, se você tiver métodos get e set: setName e getName, então você tem uma propriedade conhecida como name. A amostra 5 mostra um componente FormBean.

bons componentes devem ser capazes de interoperar com outros componentes de diferentes fornecedores. Portanto, para alcançar a reutilização de componentes, existem duas regras importantes (que são impostas pela arquitetura JavaBeans) a seguir:

1. O feijão classe deve fornecer um construtor sem argumentos para que ele pode ser criado usando Beans.instantiate.
2. sua classe bean deve suportar persistência implementando a interface Serializable ou Externalizable.

Amostra 5: FormBean.java

 package userinfo; import java.io.*; public class FormBean implements Serializable { private String name; private String email; public FormBean() { name = null; email = null; } public void setName(String name) { this.name = name; } public String getName() { return name; } public void setEmail(String email) { this.email = email; } public String getEmail() { return email; } } 

para usar o componente FormBean no arquivo JSP, você precisa instanciar o componente bean. Isso é feito usando a tag <jsp:useBean>. A próxima linha <jsp:setProperty> é executada quando o bean é instanciado e usado para inicializar as propriedades do bean. Nesse caso, ambas as propriedades ( name e email) são definidas usando uma única instrução. Alternativamente, é possível definir as propriedades uma de cada vez, mas primeiro você precisa recuperar a data do formulário. Aqui está um exemplo de como você definiria a propriedade name :

 <%! String yourname, youremail; %> <% yourname = request.getParameter("name"); %> <jsp:setProperty name="formbean" property="name" value="<%=yourname%>"/> 

uma vez inicializadas as propriedades com os dados recuperados do formulário, os valores das propriedades são recuperados para apresentação usando <jsp:getProperty> na parte else, conforme mostrado na amostra 6.

Amostra 6: processo2.jsp

 <jsp:useBean class="userinfo.FormBean"/><jsp:setProperty name="formbean" property="*"/> <HTML> <HEAD><TITLE>Form Example</TITLE></HEAD><BODY BGCOLOR="#ffffcc"><% if (request.getParameter("name")==null && request.getParameter("email") == null) { %><CENTER><H2>User Info Request Form </H2><form method="GET" action="/developer/technicalArticles/xml/WebAppDev/process2.jsp"><P>Your name: <input type="text" name="name" size=27><p> Your email: <input type="text" name="email" size=27> <P> <input type="submit" value="Process"></FORM></CENTER><% } else { %><P><B>You have provided the following info</B>: <P> <B>Name</B>: <jsp:getProperty name="formbean"property="name"/> <P> <B>Email</B>: <jsp:getPropertyname="formbean" property="email"/> <% } %> </BODY> </HTML> 

conclusão

os desenvolvedores interessados em desenvolver aplicativos web de produção de qualidade devem se familiarizar com tecnologias que são aplicáveis não apenas ao mercado de hoje, mas também ao de amanhã, a saber, JSP e XML. O próximo artigo discutirá os recursos que a tecnologia JSP oferece que são ideais para trabalhar com XML; e mostrar como usar efetivamente o JSP com XML. JSP e XML são uma excelente combinação para aplicativos da web que compartilham informações, porque as páginas JSP têm suporte XML embutido na forma de bibliotecas de tags personalizadas JSP. Fique ligado para mais informações sobre isso no próximo artigo desta série.