Introdução ao Desenvolvimento Internet usando a J2EE

Introdução ao Desenvolvimento Internet usando a J2EE 1.4
Nascimento e evolução da Arquitetura Internet:
Com a evolução dos mercados e da forma de relacionamento empresa-cliente e empresa-empresa, o
advento da Internet impulsionou o desenvolvimento e evolução de tecnologias para facilitar a implementação
e implantação de aplicações corporativas e de relacionamento eletrônico.
Na figura abaixo vemos a evolução das tecnologias, com as necessidades de mercado, comparada
com o valor do negócio.
Como o objetivo é falar de desenvolvimento para a internet, devemos entender primeiro como
funciona o modelo CGI (Common Gateway Interface) criado em meados da década de 1990 e que prometia
uma revolução nas tecnologias e serve de modelo até os dias de hoje para todas as tecnologias existentes.
No fim da década de 1990, nasciam outras tecnologias, mas ainda seguindo os conceitos do CGI, e
visando facilitar o desenvolvimento permitindo um aumento de mão-de-obra, por serem mais simples, e
também melhorando a performance e escalabilidade dos sistemas.
Em uma década, as mudanças foram enormes e acabaram forçando tanto empresas como
desenvolvedores a se atualizarem constantemente.
Oziel Moreira Neto
www.oziel.com.br
[email protected]
1
Introdução ao Desenvolvimento Internet usando a J2EE 1.4
Veja no quadro como funciona o modelo CGI:
Modelo CGI (Common Gateway Interface ):
O modelo do CGI é baseado em Requisição – Resposta (Request – Response), ou seja, um cliente
conectado a uma rede TCP submete uma requisição á um servidor, que por sua vez executará algumas tarefas
básicas:
• entendimento da requisição;
• processamento das informações;
• geração de conteúdo dinâmica, baseada em repositórios de dados;
• devolução da resposta;
O modelo CGI ainda é muito utilizado atualmente, entretanto ele enfrenta alguns problemas de
escalabilidade e portabilidade, pois são dependentes da plataforma.
Vantagens:
• várias linguagens;
• facilidade de
desenvolvimento;
Desvantagens:
• execução nativa;
• não escalável;
• regra de negócio mesclada
com apresentação;
• dependentes de plataforma
operacional;
Dentro do modelo CGI e das tecnologias internet, existem conceitos muito importantes:
•
sessão do usuário: área de memória dentro do servidor web usada para armazenar informações de
um usuário durante seu contato com a aplicação;
•
•
•
•
Oziel Moreira Neto
contexto: área de memória dentro do servidor web usada para armazenar informações que podem
ser compartilhadas por todos os usuários;
requisição: uma ação do usuário, que foi convertida num comando, entendida pelo servidor web
que executará um determinado processo, formatando e devolvendo uma resposta;
cabeçalho (header): são conteúdos de dados padronizados para facilitar o entendimento das
requisições pelo servidor e do conteúdo devolvido para o cliente;
cookies: são pequenos conteúdos de dados, trocados entre o cliente e o servidor, para garantir a
sessão do usuário e prover um mecanismo de armazenamento de informações do lado do cliente e
que pode ser seguramente acessado pela aplicação;
www.oziel.com.br
[email protected]
2
Introdução ao Desenvolvimento Internet usando a J2EE 1.4
Para facilitar o mapeamento das ações do usuário na interface cliente dentro das aplicações internet,
foi criado um conjunto de protocolos de comunicação cliente-servidor baseados em TCP/IP (veja no quadro
alguns protocolos internet e sua utilização).
Principais Protocolos Internet:
•
•
•
•
•
TCP ( Transport Communication Protocol ): representa a camada de transporte de dados e
comunicação entre máquina cliente e servidor;
HTTP ( Hiper Text Transfer Protocol ): fornece os comandos necessários para a navegação e
execução de aplicativos baseados em ações do usuários;
FTP ( File Transfer Protocol ): fornece os comandos necessários para a troca de arquivos via
internet;
SMTP ( Simple Message Transfer Protocol ): fornece os comandos necessários para o envio de
mensagens para um servidor de e-mail;
POP ( Post Office Protocol ): fornece os comandos necessários para retirada e leitura das
mensagens baseadas em e-mail;
O desenvolvimento de aplicações internet requer um mínimo de conhecimento do protocolo HTTP,
que possui uma série de comandos que são usados para refletir as ações do usuários dentro da aplicação, os
principais comandos são: o GET e POST (veja no quadro a lista completa de comandos do HTTP).
Comandos do HTTP:
•
•
•
•
•
•
•
GET: permite ao cliente requisitar ao servidor web um documento completo ( cabeçalho + corpo );
POST: permite ao cliente enviar um grande conjunto de dados ao servidor web, após o envio o servidor
web devolve um documento completo;
PUT: permite ao cliente enviar um arquivo para o servidor web;
HEAD: permite ao cliente requisitar ao servidor web somente o cabeçalho de um documento;
DELETE: permite ao cliente excluir um documento dentro do servidor web;
TRACE: usado para debug das requisições devolvendo somente o cabeçalho de um documento;
OPTIONS: permite ao cliente consultar quais comandos estão disponíveis a aquele usuário;
Exemplos de requisição e resposta:
Geralmente, as aplicações internet utilizam HTML, DHTML e JavaScript.
O HTML e DHTML são linguagens baseadas em TAGs, somente interpretadas e padronizadas pelo
consórcio W3, utilizadas para a exibição de conteúdo formatado e diagramado permitindo a criação de
layouts simples e complexos, usando textos e imagens.
O JavaScript, é uma linguagem script, somente interpretada e padronizada pela Netscape, muito
utilizada para implementar pequenas regras de validação de campos até a construção de menus complexos.
Todas essas tecnologias são dependentes de versões e gerações de navegadores, e trazem uma
complexidade extra ao desenvolvimento web devido á não conformidade de comportamento dentro dos
navegadores existentes no mercado.
O objetivo deste material não é tratar de tais tecnologias, por isso sugiro uma pesquisa e estudo extra
desses assuntos, pois serão abordados superficialmente.
Oziel Moreira Neto
www.oziel.com.br
[email protected]
3
Introdução ao Desenvolvimento Internet usando a J2EE 1.4
Entendendo a J2EE 1.4:
A Java2 Enterprise Edition esta baseada em alguns pontos importantes:
• uma plataforma robusta e altamente escalável;
• independente de plataforma operacional;
• dividida em Containers (ambiente de execução e publicação de componentes);
• padronizada industrialmente;
• APIs completas (componentes reutilizáveis) para a construção de aplicações;
• orientada á objetos;
• grande conjunto de serviços disponíveis para as aplicações;
• conjunto de Blueprints (boas práticas) para o desenvolvimento e arquitetura;
Mais informações sobre a J2EE 1.4 no quadro:
A J2EE possui dois “Containers” divididos por
responsabilidade:
•
WebContainer: responsável por
suportar os componentes Web
(Servlets, JSPs, TagLibs e JavaBeans);
•
EJBContainer: responsável por
suportar os componentes EJB
(SessionBeans, EntityBeans e
MessageDrivenBeans);
O Servidor J2EE ainda é responsável por
fornecer o serviços de:
•
transações, gerência de recursos e
memória, persistência, segurança e
conectividade;
Os principais serviços da J2EE são representados por um grande conjunto de APIs:
Saiba mais sobre a J2EE: http://java.sun.com/j2ee e
http://java.sun.com/j2ee/1.4/docs/tutorial/doc/index.html
Oziel Moreira Neto
www.oziel.com.br
[email protected]
4
Introdução ao Desenvolvimento Internet usando a J2EE 1.4
Entendendo o WebContainer J2EE 1.4:
Desenvolvido com o intuito de fornecer o controle das requisições, ambiente de execução de
componentes web, controle de memória e threads, o WebContainer J2EE depende de uma JRE (Java
Runtime Enviromnent) e da infra-estrutura de serviços da J2EE (vide quadro J2EE).
No WebContainer J2EE podemos fazer o deploy ( publicação ) de componentes baseados em:
• JavaServlets;
• JavaServer Pages;
• TagLibaries;
• JavaBeans;
Cada um desses tipos de componentes tem uma forma de construção, publicação e execuções
distintas, uma aplicação Java para a Web, provavelmente conterá todos esses elementos para garantir sua
modularidade, escalabilidade, segurança, evolução e robustez (veja o quadro Padrão MVC ).
Como as aplicações baseadas na J2EE serão escritas em Java, é imprescindível o domínio de:
• conceitos de Orientação á Objetos:
Conjunto de tutoriais que
o Objetos, Classes, Atributos, Métodos, Herança,
facilitarão o entendimento dos
Polimorfismo, Sobrecarga e Sobrescrita de métodos,
pré-requisitos
para
o
Interfaces e Classes Abstratas;
desenvolvimento profissional
• as APIs Core da J2SE:
para Web com Java/J2EE:
o java.lang, lava.util, java.io, java.sql;
• as APIs Web da J2EE:
http://java.sun.com/tutorial
o javax.servlet; javax.servlet.http; javax.servlet.jsp;
http://go.to/ricarte
Padrão MVC para aplicações J2EE:
Depois de anos de evolução das tecnologias
Web e dos processos fabris de construção de
aplicações orientadas a objetos, o padrão MVC
(Model-View-Controller) garante a separação
da interface, do controle de fluxo e da regra de
negócio, onde cada tipo de componente executa
um determinado tipo de tarefa.
O Struts, famoso framework para facilitar o
controle das ações dos usuários, é baseado no
modelo MVC.
No modelo MVC cada componente tem um tipo de responsabilidade:
Servlets: atuam como “controllers” que vão atender e entender as requisições dos usuários;
JavaBeans: atuam como “model”, representam e devem executar a regra de negócio;
JSP: atuam como “views” , vão disponibilizar as diversas formas de visualização do modelo de dados;
Mais informações sobre padrões de solução para a J2EE consulte:
http://java.sun.com/blueprints/guidelines/designing_enterprise_applications_2e/index.html
O WebContainer J2EE fornece ainda o controle de sessão e requisição, autenticação e autorização,
controle de logs, gerencia das requisições e das threads, e controle de memória.
Cada WebContainer J2EE possui configurações proprietárias em relação a essas características, e o
conteúdo deste material abrangerá algumas configurações do Apache Tomcat 5.0.X, que é utilizado como
referência de comportamento para as aplicações Web J2EE 1.4. (veja no quadro como fazer download,
instalação e configuração básica do Tomcat 5.0.X).
Oziel Moreira Neto
www.oziel.com.br
[email protected]
5
Introdução ao Desenvolvimento Internet usando a J2EE 1.4
Download, instalação e configuração básica do Apache Tomcat 5.0.X em Windows:
• Pré-requisito: ter instalada um J2SDK 1.4.0 ou superior;
http://java.sun.com/j2se/1.4.2/download.html
• Faça o download da última versão estável em formato .ZIP:
http://jakarta.apache.org/tomcat/index.html ;
• Descompacte na raiz do disco C:\, estrutura descompactada:
A linha em vermelho representa o valor: TOMCAT_HOME;
o diretório TOMCAT_HOME\bin: possui os binário para inicialização (startup.bat) e
encerramento (shutdown.bat) do Tomcat 5.0;
o diretório TOMCAT_HOME\conf: armazena os arquivos XML de configuração;
o diretório TOMCAT_HOME\webapps: armazena as aplicações publicadas;
o diretório TOMCAT_HOME\work: armazena arquivos temporários gerados pelo
servidor;
Ao executar o startup.bat, tem-se uma saída de tela assim:
Oziel Moreira Neto
www.oziel.com.br
[email protected]
6
Introdução ao Desenvolvimento Internet usando a J2EE 1.4
Teste do Tomcat 5.0:
• abra o navegador de sua preferência:
• aponte para a url: http://127.0.0.1:8080/
• exemplo de saída de tela;
•
•
pronto, o Tomcat 5.0 está instalado e funcionando;
para encerrar o Tomcat 5.0; vá até o diretório TOMCAT_HOME\bin, e execute o shutdown.bat;
Oziel Moreira Neto
www.oziel.com.br
[email protected]
7
Introdução ao Desenvolvimento Internet usando a J2EE 1.4
Desenvolvendo JavaServlets:
Os Servlets surgiram como uma alternativa aos programas e scripts baseados na tecnologia CGI.
A Sun em parceria com a Apache, iniciaram o processo de desenvolvimento da tecnologia.
Atualmente, dentro da J2EE 1.4, temos a JavaServlet API 2.4.
Processo de construção de um Servlet:
• Escolha do Tipo;
o Codificação;
o Empacotamento e Publicação;
o Teste;
Podemos construir dois tipos de Servlets, um para qualquer tipo de requisição TCP, chamado
GenericServlet e outro para as requisições HTTP, chamado HttpServlet.
Exemplo de um TCP Servlet:
import javax.servlet.*;
import java.io.*;
public class HelloServlet extends GenericServlet
{
public void service(ServletRequest request,
ServletResponse response)
throws IOException {
PrintWriter out = response.getWriter();
// Gerando a resposta
out.println(“Bem vindo aos JavaServlets!”);
out.close();
}
}
Como o objetivo do material é o desenvolvimento para Internet, não vamos nos aprofundar nos TCP
Servlets. Essas informações são suficientes para o inicio de um estudo mais detalhado sobre as capacidades
dos TCP Servlets.
Oziel Moreira Neto
www.oziel.com.br
[email protected]
8
Introdução ao Desenvolvimento Internet usando a J2EE 1.4
Desenvolvendo para a Web com JavaServlets e JSP:
O HttpServlet, é uma especialização de um componente dentro da JavaServlet API, o
javax.servlet.http.HttpServlet. Ele trás em sua interface pública um conjunto de métodos que podem ser
reescritos de acordo com o tipo de ação do HTTP que desejamos tratar, trás também um conjunto de métodos
para facilitar sua configuração através de parâmetros e para o gerenciamento do ciclo de vida.
Para isso, o WebContainer se responsabiliza em carregar o Servlet e suas dependências, garantindo
assim o controle do número de instâncias. Ou seja, somente o WebContainer pode instanciar um Servlet, e
após isso ele controlará as requisições e o ciclo de vida.
Ciclo de vida:
Após a carga do Servlet, o
WebContainer executa o método
init().
A cada requisição será executado
o método service() dentro de uma
Thread.
E quando o servidor web for
encerrado, para cada um dos
Servlets em memória, será
executado o método destroy().
Não devemos interferir programaticamente nos métodos do clico de vida. Ou seja, dentro do nosso
código, não devemos chamar os métodos init(), service() ou destroy();
O ciclo de vida dos Servlets é muito interessante, e foi criado visando garantir a escalabilidade das
aplicações, usando o conceito de Multi-Threading os Servlets são capazes de atender múltiplas requisições ao
mesmo tempo.
Veja o processo pelo qual o container cria uma Thread contendo a requisição e a resposta:
Este desenho mostra a execução de uma ação do HTTP do tipo GET, onde foram criados os objeto
de Request e Response e executado o método service(), e doGet() do Servlet.
Oziel Moreira Neto
www.oziel.com.br
[email protected]
9
Introdução ao Desenvolvimento Internet usando a J2EE 1.4
Veja no quadro a construção, publicação e teste de um HttpServlet:
// Código fonte
package web;
import javax.servlet.*;
import javax.servlet.http.*;
import java.io.*;
public class HelloServlet extends HttpServlet {
private String greetingText;
public void init() {
greetingText = getInitParameter(“textoSaudacao”);
}
public void service(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
PrintWriter out = response.getWriter();
// Generate the HTML response
out.println("<HTML>");
out.println("<HEAD>");
out.println("<TITLE>Hello Servlet</TITLE>");
out.println("</HEAD>");
out.println("<BODY BGCOLOR=\"white\">");
out.println("<B>" + greetingText + "</B>");
out.println("</BODY>");
out.println("</HTML>");
}
public void destroy() {
greetingText = null;
}
Oziel Moreira Neto
www.oziel.com.br
[email protected]
10
Introdução ao Desenvolvimento Internet usando a J2EE 1.4
Publicando uma aplicação Web com Servlets:
O processo de publicação (deploy) de um ou mais Servlets de uma aplicação Web é simples e
padronizado para todos os WebContainers existentes no mercado, entretanto devemos nos atentar aos
detalhes.
Devemos criar uma estrutura de diretórios que deve ser seguida á risca, cada um dos diretórios da
estrutura tem uma finalidade.
A linha em vermelho representa a estrutura obrigatória;
o diretório webmodule\WEB-INF: possui um arquivo obrigatório para o deploy, o
web.xml;
o diretório webmodule\classes: armazena as classes dos Servlets (.class)
o diretório webmodule \lib: armazena bibliotecas de classes java (.jar) ;
A linha em azul representa uma estrutura opcional para facilitar a separação de componentes;
o diretório webmodule\css: armazenará as páginas de estilos (.css);
o diretório webmodule\images: armazenará as imagens da aplicação web (.jpg);
o diretório webmodule\js: armazenará bibliotecas JavaScripts (.js) ;
O web.xml, é um arquivo padronizado para a configuração da aplicação web, incluído os Servlets.
Formato básico:
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE web-app PUBLIC '-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN'
'http://java.sun.com/dtd/web-app_2_3.dtd'>
<web-app>
<display-name> Web Module </display-name>
<servlet>
<servlet-name>HelloServlet</servlet-name>
<servlet-class>web.HelloServlet</servlet-class>
<init-param>
<param-name>textoSaudacao</param-name>
<param-value>Bem vindo aos JavaServlets</param-value>
</init-param>
</servlet>
<servlet-mapping>
<servlet-name>HelloServlet </servlet-name>
<url-pattern>/hello</url-pattern>
</servlet-mapping>
<session-config>
<session-timeout>10</session-timeout>
</session-config>
</web-app>
Oziel Moreira Neto
www.oziel.com.br
[email protected]
11
Introdução ao Desenvolvimento Internet usando a J2EE 1.4
Após a construção da estrutura, compilação das classes, criação do web.xml, devemos fazer o
empacotamento. Escolhemos um nome para a aplicação web. Se quisermos que nossa aplicação chame intro,
devemos criar um arquivo compactado da estrutura do webmodule chamado intro.war, e para isso fazemos:
Podemos ver que foi criado o arquivo intro.war. Agora é só fazer a publicação dentro do Tomcat 5.0.
Usamos o mesmo processo para empacotar aplicações web usando JSP.
Oziel Moreira Neto
www.oziel.com.br
[email protected]
12
Introdução ao Desenvolvimento Internet usando a J2EE 1.4
Basta copiar o arquivo intro.war dentro da pasta TOMCAT_HOME\webapps do Tomcat 5.0, iniciar o
Tomcat, e testar a publicação: http://127.0.0.1:8080/intro/
Para testar o Servlet: http://127.0.0.1:8080/intro/hello
O nome hello, não é uma adivinhação, podemos procurar no web.xml uma TAG <servlet-mapping>,
lá veremos que o HelloServlet, tem um nome físico (web.HelloServlet), um nome lógico (HelloServlet) e
uma URL ( hello ).
O maior uso do JavaServlets esta dentro de grandes aplicações, principalmente aquelas baseadas me
portais, ou que utilizem o Jakarta Struts (poderoso framework para facilitar a construção de aplicações
internet).
A tecnologia dos Servlets foi precursora da tecnologia dos JavaServer Pages.
O ideal é eliminar o código HTML de dentro dos Servlets, colocando-o dentro dos JSPs, e assim
melhorar a flexibilidade de manutenção das aplicações web baseadas em J2EE.
Oziel Moreira Neto
www.oziel.com.br
[email protected]
13
Introdução ao Desenvolvimento Internet usando a J2EE 1.4
A Tecnologia JavaServer Pages da J2EE 1.4.
Um JSP, é um arquivo texto (um script), que segue uma forma padronizada podendo conter TAGs
da especificação JSP 2.0. Esse arquivo de TAGs é pré-compilado numa classe Java baseada na Tecnologia
JSP. Depois de compilado numa classe Java, o compilador javac gerará o bytecode necessário para sua
execução dentro do WebContainer.
Processo de compilação do .jsp em um Servlet:
Depois de compilado, o JSPServlet proveniente do .jsp, fica disponível para atender as
requisições da mesma forma que os Servlets.
Formato do arquivo .jsp:
Existem 5 tipos de estruturas que um .jsp pode conter:
o
o
o
o
o
comentários: <%-- este é um comentário --%>
diretiva de compilação: <%@ page info=”info” %>
declaração de métodos e/ou atributos: <%! String texto = “”; %>
scriptlet (trecho de código): <% if ( texto.equals(“”) ) { texto += “texto”; } %>
expressão: <%= texto.toString() %>
Estruturas de TAGs do JavaServer Pages:
Saída HTML:
<%@ page info="teste" buffer="2kb" %>
<%-- Esta página teste --%>
<%! private int counter; %>
<HTML>
<HEAD><TITLE> Teste do JSP </TITLE></HEAD>
<BODY>
<% counter++; %>
Acessos: <%= counter %>
</BODY>
</HTML>
<HTML>
<HEAD><TITLE> Teste do JSP </TITLE></HEAD>
<BODY>
Acessos: 1
</BODY>
</HTML>
Este JSP, será pré-compilado pelo Jasper (http://jakarta.apache.org/tomcat/tomcat-5.0doc/jasper/docs/api/index.html ) numa classe java quando acontecer a primeira requisição.
Oziel Moreira Neto
www.oziel.com.br
[email protected]
14
Introdução ao Desenvolvimento Internet usando a J2EE 1.4
Código java gerado pelo compilador JSP:
package org.apache.jsp;
import javax.servlet.*;
import javax.servlet.http.*;
import javax.servlet.jsp.*;
public final class teste_jsp extends org.apache.jasper.runtime.HttpJspBase
implements org.apache.jasper.runtime.JspSourceDependent {
public String getServletInfo() {
return "teste";
}
private int counter;
private static java.util.Vector _jspx_dependants;
public java.util.List getDependants() {
return _jspx_dependants;
}
public void _jspService(HttpServletRequest request, HttpServletResponse response)
throws java.io.IOException, ServletException {
JspFactory _jspxFactory = null;
PageContext pageContext = null;
HttpSession session = null;
ServletContext application = null;
ServletConfig config = null;
JspWriter out = null;
Object page = this;
JspWriter _jspx_out = null;
try {
_jspxFactory = JspFactory.getDefaultFactory();
response.setContentType("text/html");
pageContext = _jspxFactory.getPageContext(this, request, response,
null, true, 2048, true);
application = pageContext.getServletContext();
config = pageContext.getServletConfig();
session = pageContext.getSession();
out = pageContext.getOut();
_jspx_out = out;
out.write("\r\n\r\n");
out.write("\r\n<HTML>\r\n<HEAD><TITLE> Teste do JSP
</TITLE></HEAD>\r\n<BODY>\r\n");
counter++;
out.write("\r\nAcessos: ");
out.print( counter );
out.write("\r\n</BODY>\r\n</HTML>\r\n");
} catch (Throwable t) {
if (!(t instanceof SkipPageException)){
out = _jspx_out;
if (out != null && out.getBufferSize() != 0)
out.clearBuffer();
if (pageContext != null) pageContext.handlePageException(t);
}
} finally {
if (_jspxFactory != null) _jspxFactory.releasePageContext(pageContext);
}
}
}
Podemos ver que o código HTML é colocado como saída de texto, e os trechos compreendidos
pelos demarcadores <% %> são convertidos em código java.
A cada requisição que acontecer ao JSP, o WebContainer criará os objetos de Request e Response, e
invocará o método _jspService(HttpServletRequest request, HttpServletResponse response).
Oziel Moreira Neto
www.oziel.com.br
[email protected]
15
Introdução ao Desenvolvimento Internet usando a J2EE 1.4
Objetos Intrínsecos:
Para facilitar o desenvolvimento de aplicações web, a tecnologia JSP disponibiliza um conjunto de
objetos que podem ser usados dentro de um JSP sem a necessidade de declaração:
session: define um objeto javax.servlet.http.HttpSession que representa a sessão do
usuário, onde programaticamente podemos armazenar conteúdos de dados somente visíveis para um
usuário;
request: define um objeto javax.servlet.http.HttpServletRequest que representa a
requisição do usuário, de onde programaticamente podemos recuperar dados enviados pelo usuário;
response: define um objeto javax.servlet.http.HttpServletResponse que representa a
resposta ao usuário, onde programaticamente podemos inserir conteúdo de texto como resultado de
processamento;
application: define um objeto javax.servlet.ServletContext que representa o contexto da
aplicação, onde programaticamente podemos armazenar conteúdos de dados que serão compartilhados e
visíveis á todas sessões da aplicação;
exception: define um objeto java.lang.Throwable que representa uma exceção e estará
presente em páginas de erros da aplicação;
\ out: define um objeto javax.servlet.jsp.JspWriter que representa a saída de conteúdo de
texto do objeto de reposta (response);
config: define um objeto javax.servlet.ServletConfig que representa objeto de
configuração do servlet gerado para o JSP, e pode ser configurado pelo descritor de publicação (deploy)
web.xml;
pageContext: define um objeto
existentes durante uma única requisição;
javax.servlet.jsp.PageContext
que encapsula os objetos
Como o uso do JSP vai muito além de somente exibir conteúdo, a sua especificação permite
implementar todos conceitos de componentização, e para isso a tecnologia disponibiliza ao desenvolvedor
duas tecnologias muito interessantes e que nos permite retirar todo o código java de dentro do JSP e
encapsulá-lo em classes java, podendo ser reaproveitados em várias aplicações. Esses componentes são os
JavaBeans e as CustomTags.
Para entendermos a necessidade de se usar JavaBeans e CustomTags, devemos entender que mesclar
HTML com código Java e JavaScript trás alguns infortúnios como:
• pouca modularidade;
• códigos complexos;
• dificuldade de separar as tarefas de desenvolvimento das tarefas de design;
• dificuldade de manutenção;
Dentro da especificação JSP 2.0, foram incluídas duas novas importantes tecnologias:
•
um processador de expressões regulares chamado JSP EL;
http://java.sun.com/developer/technicalArticles/javaserverpages/JSP20/
•
um conjunto de TagLibs padronizadas para facilitar a construção de estruturas de repetição,
condição, acesso a bancos de dados e processamento de XML;
http://java.sun.com/developer/technicalArticles/javaserverpages/faster/
Essas duas novas tecnologias, vêem melhorar o desenvolvimento de código JSP, diminuindo os
custos de desenvolvimento de conteúdo WEB.
Oziel Moreira Neto
www.oziel.com.br
[email protected]
16
Introdução ao Desenvolvimento Internet usando a J2EE 1.4
Veja um código JSP de uma pequena ferramenta de cálculo (conversor.jsp):
<%@ page info="converter" buffer="2kb" errorPage="error.jsp" %>
<%-- Esta página não usa um JavaBean --%>
<HTML>
<HEAD><TITLE> Conversor de Moedas usando Scriptlet</TITLE></HEAD>
<BODY>
<%
double calculo = 0;
if ( request.getParameter("calcular") != null ) {
String valor = request.getParameter("valor");
String taxa = request.getParameter("taxa");
if ( valor != null && taxa != null ) {
out.println("Valor: "+valor);
out.println("<BR>Taxa: "+taxa);
double val = Double.parseDouble( valor );
double tax = Double.parseDouble( taxa );
calculo = val * tax;
out.println("<BR>Valor Convertido: "+ calculo );
}
}
%>
<FORM NAME="CALCULADORA" ACTION="conversor.jsp" METHOD="POST">
Valor: <INPUT TYPE="TEXT" NAME="valor"><br>
Taxa: <INPUT TYPE="TEXT" NAME="taxa"><br>
<INPUT TYPE="SUBMIT" NAME="calcular" VALUE="Calcular">
</FORM>
</BODY>
</HTML>
Saída de tela:
Podemos converter uma boa parte do código Java para um componente JavaBean. Um JavaBean é
uma classe java, que deve ter o construtor padrão, métodos set e get para cada um dos atributos privados, e
métodos de negócio quando necessário.
Para a ferramenta de cálculo,o JavaBean deve armazenar o valor base, a taxa de conversão e prover
um método de cálculo, ficando assim:
package beans;
public class ConversorBean implements
java.io.Serializable {
private double value;
private double tax;
public double getValue() {
return value;
}
public double getTax() {
return tax;
}
public void setValue(double value) {
this.value = value;
}
public void setTax(double tax) {
this.tax = tax;
}
public double convert() {
return value * tax;
}
}
Oziel Moreira Neto
www.oziel.com.br
[email protected]
17
Introdução ao Desenvolvimento Internet usando a J2EE 1.4
Veja o código do JSP alterado e usando o JavaBean de Cálculo ( conversorBean.jsp ):
<%@ page info="converter" buffer="2kb" import="beans.ConversorBean" errorPage="error.jsp" %>
<%-- Esta página usa um JavaBean --%>
<%-- JavaBean Conversor, que tem escopo Request --%>
<jsp:useBean id="conversor" class="beans.ConversorBean" scope="request" />
<jsp:setProperty name="conversor" property="*"/>
<HTML>
<HEAD><TITLE> Conversor de Moedas usando JavaBeans </TITLE></HEAD>
<BODY>
<%
if ( request.getParameter("calcular") != null ) {
%>
<br>Valor: <%= conversor.getValue() %>
<br>Taxa: <%= conversor.getTax() %>
<br>Valor Convertido: <%= conversor.convert() %>
<%
}
%>
<FORM NAME="CALCULADORA" ACTION="conversorBean.jsp" METHOD="POST">
Valor: <INPUT TYPE="TEXT" NAME="value"><br>
Taxa: <INPUT TYPE="TEXT" NAME="tax"><br>
<INPUT TYPE="SUBMIT" NAME="calcular" VALUE="Calcular">
</FORM>
</BODY>
Saída de tela:
Se acontecer algum erro de execução da requisição, como as páginas indicam na diretiva de
compilação erroPage: <%@ page info="converter" buffer="2kb" import="beans.ConversorBean"
errorPage="error.jsp" %> a requisição será redirecionada para uma página de erro.
<%@ page info="error" buffer="2kb" isErrorPage="true" %>
<%-- Esta página é um exemplo de uso do JSP (teste.jsp) --%>
<HTML>
<HEAD><TITLE> Página de Erro </TITLE></HEAD>
<BODY>
Erro:
<%= ( exception != null ? exception.toString() : "Erro Desconhecido" ) %>
</BODY>
</HTML>
A página de erro, obrigatoriamente deve especificar na diretiva o valor isErrorPage:
<%@ page info="error" buffer="2kb" isErrorPage="true" %>
Oziel Moreira Neto
www.oziel.com.br
[email protected]
18
Introdução ao Desenvolvimento Internet usando a J2EE 1.4
Arquitetura MVC 1: JSP e JavaBeans
Usamos somente JSP, tanto como “controller” como “view”, e os JavaBeans como “model”;
Arquitetura MVC 2: Servlets, JSP e JavaBeans
Usamos Servlets como “controller”, JSP como “view”, e os JavaBeans como “model”;
Oziel Moreira Neto
www.oziel.com.br
[email protected]
19
Introdução ao Desenvolvimento Internet usando a J2EE 1.4
Acessando Bancos de Dados com Java:
O acesso á banco de dados usando java é feito através da API JDBC, disponível na J2SE e
complementado pela J2EE. A J2SE fornece os componentes básicos para a execução de rotinas SQL para
qualquer banco de dados relacional que suporte o SQL-ANSI 92.
Para entender como o JDBC funciona, sugiro o estudo do tutorial da Sun:
http://java.sun.com/docs/books/tutorial/jdbc/index.html
Acessando Bancos de Dados na Internet usando J2EE:
Como na internet, não se pode prever a quantidade de usuários concorrentes e nem o número de
requisições, devemos usar um modelo escalável de uso de conexões com o banco de dados, que forneça um
pool de conexões e um DataSource baseado na especificação J2EE 1.4.
O modelo de DataSource da J2EE é suportado pelo Servidor de Aplicações J2EE, no nosso caso é o
Tomcat 5.0 que suporta a especificação e fornece o Objeto javax.sql.DataSource
(http://jakarta.apache.org/tomcat/tomcat-5.0-doc/jndi-datasource-examples-howto.html)
O modelo de acesso a banco de dados com java e orientado á objetos, deve trazer um conjunto de
classes chamados DataAccessObjects. Essa camada, chamada persistência, fornecerá uma abstração melhor
em relação aos repositórios de dados, permitindo uma maior flexibilidade da aplicação.
Veja aqui uma literatura mais detalhada sobre o DAO
(http://java.sun.com/blueprints/corej2eepatterns/Patterns/DataAccessObject.html ).
Faça download dos códigos completos deste artigo (www.oziel.com.br/fontes.html) :
• jCard – controle de cartões de visitas usando MySQL, JSP e JavaBeans;
Oziel Moreira Neto
www.oziel.com.br
[email protected]
20