Tutorial 2

IMPLEMENTAÇÃO DE SOFTWARE PARA WEB UTILIZANDO O
FRAMEWORK STRUTS
BARCELAR, RICARDO RODRIGUES
FARIAS, WENDELL PEREIRA
UNIVAG Centro Universitário
Avenida Frei Orlando S/N, Cristo Rei, Várzea Grande – MT – Brasil
[email protected]
[email protected]
Várzea Grande MT
Outubro/2005
SUMÁRIO
RESUMO...................................................................................................................................3
1. INTRODUÇÃO.....................................................................................................................3
2. ARQUITETURA EM CAMADAS ......................................................................................3
3. MODELO, VISUALIZAÇÃO E CONTROLE (MVC)......................................................5
4. STRUTS................................................................................................................................6
5. ESTUDO DE CASO............................................................................................................7
5.1. ESQUEMA DO BANDO DE DADOS ...................................................................................7
5.2. ARQUITETURA DA APLICAÇÃO .......................................................................................8
5.3. IMPLEMENTAÇÃO DO SISTEMA .......................................................................................8
5.3.1. Conexão com o Banco.........................................................................................8
5.3.2. Workspace .............................................................................................................9
5.3.3. Implementação da Camada de Modelo através dos Business Components
......................................................................................................................................... 10
5.3.4. Implementação da Camada de Controle usando o Framework Struts ..... 12
5.3.5. Implementação da Camada de Visão usando a tecnologia UIX ................ 13
5.3.5. Criando as páginas de navegação, edição e pesquisa de dados ............. 15
5.3.5.1. Página de navegação de dados............................................................... 15
5.3.5.2. Página de edição de dados ...................................................................... 16
5.3.5.3. Página de pesquisa de dados .................................................................. 20
5.3.5.4. Página Inicial ............................................................................................... 21
5. CONCLUSÃO ................................................................................................................... 22
6. BIBLIOGRAFIA ................................................................................................................ 23
2
RESUMO
Neste Tutorial Prático serão abordados aspectos referentes à implementação
de um software para web utilizando o Framework Struts, viabilizando assim, a
navegação entre as páginas de um sistema, neste caso uma agenda telefônica.
Sendo o Struts um Framework, o desenvolvedor deverá se preocupar apenas com
as regras de negócio, uma vez que o trabalho complexo será realizado pelas classes
do framework. Para a consecução dos objetivos, a adoção do Framework ADF
(Application Development Framework), da Oracle será uma ferramenta que agilizará
o trabalho de criação das regras de negócio, visto que, baseado em assistentes, o
desenvolvedor criará as três camadas do sistema, sendo elas, modelo, visualização
e controle.
1. INTRODUÇÃO
A explosão da internet na década de 90 forçou a migração de grande parte
dos sistemas que antes trabalhavam em arquiteturas de uma ou duas camadas para
uma arquitetura que possibilitasse a plena utilização dos recursos da internet com
desempenho e segurança. Assim, sugiram os sistemas em três camadas, que se
aperfeiçoaram com o padrão de projeto MVC (Modelo, Visualização e Controlador).
O Framework Struts, objetivo deste tutorial, surgiu decorrente da necessidade
de se utilizar os recursos da web integrando tecnologias já consagradas como JSP,
Servlets, JavaBeans, dentre outros de uma maneira menos complexa e com tempo
de desenvolvimento reduzido.
Tecnologias como o Framework ADF da Oracle, trouxeram ainda mais
agilidade e facilidade no desenvolvimento de sistemas para web utilizando o
Framework Struts. Através da ferramenta de programação JDeveloper da Oracle é
possível desenvo lver pequenos sistemas, como uma agenda telefônica, em poucas
horas de trabalho.
O objetivo principal deste tutorial é ao fim de oito horas o instruendo identificar
as potencialidades do Framework Struts e ser capaz de, utilizando a ferramenta de
desenvolvimento JDeveloper, linguagem de programação Java e bando de dados
PostgreSQL, desenvolver pequenos sistemas para web.
2. ARQUITETURA EM CAMADAS
No inicio, quando os primeiros sistemas foram desenvolvidos os sistemas
eram construídos para serem utilizados em uma só máquina. Esses aplicativos eram
constituídos de um único módulo responsável por desempenhar todas as funções.
Não havia separação, seja física ou lógica. Estes eram chamados sistemas
atômicos ou monolíticos.
3
Figura 1
Foi à necessidade de se compartilhar a base de dados e de se obter acessos
simultâneos que a antiga estrutura centralizada de processamento baseado em
Mainframes foi sucedida por uma arquitetura organizada em duas camadas, sendo
uma camada responsável por cuidar dos dados e outra pela parte da lógica da
aplicação. Esta arquitetura recebeu o nome de Arquitetura em Duas Camadas ou
Arquitetura Cliente-Servidor.
Figura 2
Com o advento da internet, surgiu a Arquitetura em Três Camadas. Os
sistemas em duas camadas deram lugar a uma metodologia de desenvolvimento em
três camadas distintas, que separa as regras de negócio, a interface com o usuário e
o acesso ao banco de dados, que passou a ser realizado através de regras contidas
em um servidor.
Figura 3
4
3. MODELO, VISUALIZAÇÃO E CONTROLE (MVC)
Johnson (2002), afirma que uma aplicação interativa quase sempre deve
fazer uso da arquitetura MVC, pois dessa forma são dividas as funcionalidades entre
os objetos envolvidos. Com o modelo MVC as responsabilidades que estavam
centradas em uma mesma camada, geralmente na interface com o usuário, agora se
vêem separadas em três camadas distintas possibilitando a gerência de múltiplos
visualizadores, a simplicidade em incluir novos clientes e a escalabilidade da
aplicação.
Figura 4
Com o intuito de tornar as páginas mais dinâmicas e fáceis de escrever foram
introduzidas as JSP, no entanto seu desempenho estava relacionado a quantidades
de páginas entrelaçadas, sendo necessário o uso de scriplets complexos para
transmitir o código entre as páginas. Esta arquitetura foi denominada Modelo 1 .
Figura 5
Logo foi percebido que utilizar pequenas aplicações de servidores,
denominadas servlets, para fazer a interação com os clientes, se responsabilizando
pelo fluxo da apresentação e o mapeamento das ações proporcionava o
encapsulamento dos dados e a melhoria na segurança da aplicação. Dessa forma
foi concebida a arquitetura Modelo 2.
Figura 6
5
4. STRUTS
A fim de minimizar a problemática do desenvolvimento de aplicações surgiram
os frameworks e dentre eles o Struts. Um framework é um conjunto de classes e
interfaces que cooperam para resolver um tipo de problema de software visto como
um padrão de arquitetura, cuja modelagem reflete uma infra-estrutura reutilizável e
adaptável a um determinado contexto representando uma solução incompleta.
[FIORINI, 2001].
O Struts foi criado por Craig R. McClanahan, a fim de facilitar o
desenvolvimento de software para web. Hoje é um projeto da fundação Apache
constituindo uma implementação do código aberto do modelo 2 possuindo um
controlador central. Seus principais componentes:
4.1. ActionServlet:
Uma classe que estende a classe javax.servlet.HttpServlet. O ActionServlet lê
o arquivo de configuração do Struts (struts-config.xml) e cria os objetos de
configuração apropriados (estrutura de dados) na memória. Como é um servlet,
intercepta a requisição HTTP baseado no padrão URL e os opera.
4.2. ActionForm:
O ActionForm pode desempenhar o papel de coleta do campo, buffer de
dados, transformador de tipos e objeto de transferência. São responsáveis, ainda,
por validar se os atributos da requisição estão sintaticamente corretos e
eventualmente disparar exceções avisando o usuário final.
4.3. ActionForward:
A classe ActionFoward é responsável pelo mapeamento lógico das páginas
do sistema, evitando assim, o uso do nome físico (URI) dentro do código. O uso
eficiente da ActionFoward facilita a manutenção do sistema.
4.4. ActionMapping:
O ActionMapping (org.apache.struts.action.AcionMapping) descreve como o
framework trabalha as operações de negócio. Cada ActionMapping é associado a
um URI por meio de um path na qual será realizado o roteamento das solicitações à
aplicação para um Servlet, direcionando quais operações ou comandos deverão ser
executados.
4.5. Action:
É uma classe Java simples e leve à qual o ActionServlet delega o tratamento
da solicitação e de sua resposta. Ela é conectada a ActionServlet e pode chamar
qualquer propriedade pública, mas sem o overhead de instanciar outro servlet.
6
4.6. Arquivo de Configuração – struts-config.xml:
O Struts usa um arquivo de configuração para definir e carregar vários
componentes críticos do framework, inclusive os nomes lógicos para as
hiperligações. É um documento XML que é lido na inicialização e usado para criar
um banco de dados de objetos. Vários componentes Struts consultam esse arquivo
de dados para fornecer os serviços do framework.
4.7. Tags:
O Struts possui um conjunto poderoso de tags JSP escritas previamente que
fazem parte do framework. As tags podem ser usadas para preencher perfeitamente
os campos de texto ou selecionar listas e para gerenciar os arrays de quadros de
seleção e radiobutton.
4.8. web.xml:
Apesar de não fazer parte do Struts, é vastamente utilizado e de suma
importância para o framework. Segundo Husted (2004), o arquivo web.xml é usado
para informar ao contêiner do servlet sobre como configurar os servlets e outros
objetos de alto nível que a aplicação necessita.
5. ESTUDO DE CASO
O objetivo deste capítulo é desenvolver uma pequena aplicação em forma de
estudo de caso, cuja finalidade é demonstrar a implementação do framework Struts
em uma aplicação para web, neste caso um sistema de informações pessoais
(Agenda).
Para o desenvolvimento deste estudo de caso será utilizando o Sistema
Gerenciador de Bando de Dados (SGDB) PostGreSQL. Com a base de dados
previamente criada, será possível demonstrar a implementação do Framework Struts
utilizando a tecnologia ADF através da ferramenta de programação JDeveloper, da
Oracle.
5.1. Esquema do Bando de Dados
7
Figura 6
5.2. Arquitetura da Aplicação
O framework ADF fornece uma implementação genérica de uma aplicação
com a arquitetura MVC especificando os limites entre as unidades lógicas. O
diagrama abaixo mostra uma visão simples dos passos realizados no
desenvolvimento da aplicação:
Figura 7
5.3. Implementação do Sistema
Uma vez entendido como o sistema está estruturado podemos iniciar a
implementação do sistema.
5.3.1. Conexão com o Banco
Realizaremos a conexão com o banco de dados seguindo os seguintes
passos:
1) Com o JDeveloper já aberto clicar em Connections-Navigator (Aba Connections)
e criar uma nova conexão (New Database Connection).
2) Escolher o tipo de conexão “Third Party JDBC Driver”.
3) Preencher username e password conforme definidos no SGDB.
4) Criar um novo Driver Class que deverá conter o path do driver:
org.postgresql.Driver.
8
- Em Library preencher os campos Class, Source e Doc Path com o caminho
onde
está
localizado
o
jar:
C:\Arquivos
de
programas\PostgreSQL\8.0\jdbc\posgresql-8.0-311.jdbc3.jar
- Na URL: jdbc:postgresql://localhost/nomedoseubanco.
5) Realizar o Test, que deverá retornar Success.
6) Entrar no menu Tools>Embedded OC4J Server Preferences. No TreeView Global
>
Libraries
>
Add...
Localizar
C:\Arquivos
de
programas
\PostgreSQL\8.0\jdbc\posgresql-8.0-311.jdbc3.jar.
5.3.2. Workspace
Em Aplications – Navigator clicar com o botão direito sobre Applications >
New Application Workspace...
Preencher conforme abaixo:
Figura 8
O Template escolhido, dentre várias opções que o JDeveloper oferece, gera
um conjunto de pacotes estruturados para uma aplicação web, divididos
principalmente em dois grupos: Model e ViewController.
Figura 9
9
5.3.3. Implementação
Components
da
Camada
de
Modelo
através
dos
Business
As regras de negócio do sistema serão criadas a partir do nó Model do
workspace. Dentro desta categoria criam-se, então, os componentes de negócio. Os
componentes de negócio, denominados Business Components, implementam uma
aplicação baseada no Design Pattern MVC/Model 2.
Segundo Muench (2005), os business components reforçam a separação
lógica do cliente funcionalmente acessível e a implementação da camada de
negócio.
São cinco os principais componentes que constituem o Business components:
- Entity Objects
- Associations
- View Objects
- View Links
- Application Module
Cabe ressaltar que estes não são os únicos componentes existentes no
framework, no entanto foram os utilizados na camada de modelo desta aplicação.
Clicar com o botão direito sobre o nó model e em seguida New... . Ao abrir a
janela New Gallery selecionar Business Components em Categories e em Items
Business Componentes from Tables
Figura 10
Dessa forma será aberto um assistente que nos auxiliará na criação dos
componentes de negócios.
Passo 1: Criar as Entity Objects e Associations. Para isso basta selecionar as
tabelas necessárias.
10
Figura 11
Passo 2 e 3: Criar as View Objects e View Links selecionando as mesmas tabelas.
Figura 12
Passo 4: E por fim, criar o Application Module.
Figura 13
11
Dessa forma concluímos a criação dos componentes de negócio. Cabe
ressaltar que tal procedimento pode ser mais polido com a edição de alguns
atributos em Entity Objects.
Figura 14
5.3.4. Implementação da Camada de Controle usando o Framework Struts
Para a implementação da camada de controle de nossa aplicação, usaremos
o Framework Struts. A implementação é facilitada utilizando o ambiente gráfico
oferecido pelo JDeveloper, denominado Struts Page Flow Diagram. Para obter
acesso, clicar com o botão direito sobre o nó ViewController e em seguida sobre
Open Struts Page Flow Diagram...
Figura 15
Cabe ressaltar que todos os componente criados, bem como a ligação entre
os componentes realizados no diagrama, refletirão no arquivo de configuração
struts-config.xml.
12
5.3.5. Implementação da Camada de Visão usando a tecnologia UIX
Antes de prosseguirmos na tarefa de criar a camada de controle é importante
desde já criarmos o template da camada de visão. Para isso, clicar com o botão
direito sobre o nó View Controller e em seguida New... Selecionar em Categories
ADF UIX e em Items UIX XML Page with Header, Footer, and Navigation.
Figura 16
Nos passos seguintes basta seguir o assistente :
Passo 1: Dar um nome ao arquivo a ser criado.
Figura 17
Passo 2: Definir um título que aparecerá no topo da página de exibição.
13
Figura 18
Passo 3: Escolher uma imagem que represente o projeto
Figura 19
Passo 4: Criar as barras de guias com as abas Navegar, Editar e Pesquisar.
Figura 20
14
Passo 5: Colocar informações de rodapé.
Figura 21
Passo 6: Finalizar.
Uma vez criado o template, é possível reaproveitar o modelo em
diversas visualizações.
5.3.5. Criando as páginas de navegação, edição e pesquisa de dados
Retornaremos ao Struts Page Flow Diagram para prosseguirmos na criação
da camada de controle. Cabe ressaltar que nesta etapa, estaremos sempre
alternando em tarefas na camada de controle e na camada de visão.
5.3.5.1. Página de navegação de dados
Arrastar componentes Data Page e Data Action da Component Palette para
a área de trabalho do Page Flow Diagram e renomeá-los para /pessoa-navega e
/action_pessoa-navega, respectivamente. Em seguida ligá-los por meio de um
Forward.
Figura 22
Clicar duas vezes sobre o Data Page /pessoa-navega e edita-lo de modo que
possamos criar nossa primeira página de navegação. Dessa forma abrir-se-á,
automaticamente, uma página de edição, denominada pessoa-navega.uix. Nesta
página selecionaremos a aba Data-Controls. Em Drag and Drop As escolher ReadOnly-Table. E arrastar o Data Control PessoaView para a área de edição em
pessoa-navega.uix.
15
Figura 23
É importante criar na página de navegação quatro botões que nos permitirão
editar os dados apresentados: Editar, Apagar, Gravar e Cancelar. A exceção do
botão Editar que criaremos posteriormente, em Data Control Palette maximizar a
árvore em PessoaView1 e em Operations arrastar o item Delete. Para os botões
Gravar e Cancelar ir em Operation de AppModuleDataControl e arrastar os itens
Commit e Rolback para pessoa-navega.uix.
Figura 24
5.3.5.2. Página de edição de dados
Arrastar os componentes Data Page e Data Action da Component Palette
para a área de trabalho do Page Flow Diagram e renomeá-los para /pessoa-edita e
/action pessoa-edita, respectivamente. Em seguida ligá-los por meio de um Forward.
16
Figura 25
Clicar duas vezes sobre o Data Page /pessoa-edita e editá-lo de modo que
possamos criar nossa primeira página de edição de dados. Dessa forma abrir-se-á,
automaticamente, uma página de edição denominada pessoa-edita.uix. Nesta
página selecionaremos a aba Data-Controls. Em Drag and Drop As escolher Input
Form (With Navigation). E arrastar o Data Control PessoaView para a área de
edição em pessoa-edita.uix.
Figura 26
Para que possamos inserir, editar e excluir dados é necessário criar os botões
que mudam o estado dos campos permitindo executar a operação desejada.
Em Data Controls Palette maximizar a árvore do DataControl PessoaView1 e
dentro de Operations arrastar para a área de edição de pessoa-edita.uix os items
Create e Delete.
17
Figura 27
É necessário criar um botão na página de navegação que redirecione a
aplicação para a página de edição de modos que possamos editar os dados
desejados.
Mas antes, ir para Page Flow Diagram e criar uma ligação Forward entre o
Data Page pessoa-navega e o Data Action action_pessoa-edita. Renomear o
Forward para fwPessoaEdita.
Figura 28
Criar um botão editar na página pessoa-navega.uix clicando na Component
Palette em Submit Button. Clicar duas vezes sobre o botão editar os campos: Text:
Editar e Event: goPessoa-edita.
Com o botão Editar selecionado ir para Structure, no fim da árvore clicar com
o botão direito do mouse sobre Handlers e criar um Event nomeando-o com
goPessoa-edita.
18
Figura 29
De modo semelhante clicar com o botão direito em handlers. Novamente
clicar com o botão direito sobre event – goPessoa-edita, recém criado, e atribuir uma
ação ao evento, neste caso ele vai chamar o Forward que criamos no Page Flow
Diagram .
Figura 30
Selecionar fwPessoa-edita.
Figura 31
19
5.3.5.3. Página de pesquisa de dados
Arrastar os componentes Data Page e Data Action da Component Palette
para a área de trabalho do Page Flow Diagram e renomeá-los para /pessoapesquisa e /action_pessoa-pesquisa, respectivamente. Em seguida ligá-los por meio
de um Forward.
Figura 32
Clicar duas vezes sobre o Data Page /pessoa-pesquisa e dita-lo de modo
que possamos criar nossa primeira página de pesquisa. Dessa forma abrir-se-á,
automaticamente, uma página de pesquisa denominada pessoa-pesquisa.uix. Nesta
página selecionaremos a aba Data-Controls. Em Drag and Drop As escolher Search
Form. E arrastar o Data Control PessoaView para a área de edição em pessoapesquisa.uix.
Figura 33
De modo semelhando deve-se proceder para criar as demais páginas.
20
5.3.5.4. Página Inicial
É importante que exista uma página inicial para que o usuário possa acessar
os módulos da aplicação.
De modo semelhante à criação dos templates, criar uma página UIX XML with
pageLayout. Nesta página inserir um componente TabBar e em seguida adicionar
os links necessários clicando com o botão direito do mouse sobre TabBar em
Structure.
Figura 34
Criar os links para os módulos selecionando as abas e em seguida
selecionando o destino em Destinations em Property Inspector.
Figura 35
Muito bem, já temos uma aplicação de agenda implementada para web. Todo
esse trabalho realizado pode ser polido pelo desenvolvedor, seja editando o nome
21
dos botões, campos, etc que são criados por default, seja agregando mais
funcionalidades.
Cabe destacar o arquivo de configuração struts-config.xml, construído
graficamente pela ferramenta, que é o coração do framework.
Figura 36
5. CONCLUSÃO
Notamos que nossa aplicação seguiu fielmente o padrão de projeto MVC,
mais especificamente o Modelo 2. O sistema foi dividido em três módulos, com um
servlet controlando o fluxo da aplicação pela leitura do arquivo struts-config.xml,
implementado através do Struts Page Flow Diagram da ferramenta de
desenvolvimento JDeveloper da Oracle.
Percebemos ainda que o desenvolvedor preocupou-se apenas com a
implementação das regras de negócio, não despendendo tempo em códigos
pesados que certamente consumiriam boa parte de seu expediente. Essa é a
finalidade dos Frameworks, e não poderia ser diferente com o Struts.
O Framework Struts proporciona uma maneira clara, fácil e robusta de criar
sistemas utilizando modernas tecnologias proporcionando rapidez e padronização
na implementação de sistemas.
22
6. BIBLIOGRAFIA
HUSTED, Ted, et al. Struts em ação. Tradução: Eveline Vieira Machado. Rio de
Janeiro RJ: Editora Ciência Moderna Ltda., 2004.
KURNIAWAN, Budi. Java para Web com Servlet, JSP e EJB. 1ª Edição. Rio de
Janeiro RJ: Editora Ciência Moderna Ltda., 2002.
HIGHTOWER, Richard. Jakarta Struts Live. Highlands Ranch,
SourceBeat, 2004.
TEMPLE, Andre, et al. Jsp, Servlets e J2EE. Stanford, Califórnia, 2004.
Colorado:
CAVANESS, Chuck. Jakarta Struts. O’Reilly, 2002.
CAVANESS, Chuck. Programming Jakarta Struts. 2. ed. O’Reilly, 2004.
SHENOY, Srikanth. Struts Survival Guide, Basic to Best Practices. Austin TX:
ObjectSource LLC, 2004.
SINGH, Inderjeet. Designing Enterprise Applications, with the J2EETM Platform.
2. ed. Upper Saddle River NJ: Addison-Wesley, 2002.
FALKNER, Jayson; JONES, Kevin. Servlets and JavaServer Pages, The J2EE
Technology Web Tier. Boston MA: Addison-Wesley, 2004.
DAVIS, Malcolm. Struts, an open-source MVC implementation, 2001. Disponível
em: <http://www-106.ibm.com/developerworks/library/j-struts/>. Acesso em 20 de
abril de 2005.
MUENCH, Steve. ADF Business Components J2EE Design Pattern Catalog,
2005. Disponível em: <http://www.oracle.com/technology/products/jdev/tips/
muench/designpatterns/index.html>. Acesso em 23 de maio de 2005.
MUENCH, Steve. Oracle ADF Data Binding Primer and ADF/Struts Overview,
2005. Disponível em: <http://www.oracle.com/technology/products/jdev/collateral/
papers/10g/ADFBindingPrimer/index.html>. Acesso em 20 de maio de 2005.
MILLS, Duncan. Using Struts 1.2.1 with JDeveloper 10g, 2004. Disponível em
<http://www.oracle.com/technology/products/jdev/tips/mills/struts1_2_1.html>.
Acesso em 12 de maio de 2005.
GARNIER, Jean Michel. Struts 1.1 Controller UML diagrams. Disponível em
<http://rollerjm.free.fr/pro/Struts11.html>. Acesso em 29 de abril de 2005.
JELLEMA, Lucas. Struts best practices - white paper on JavaWorld. Disponível
em <http://technology.amis.nl/blog/index.php?p=400>. Acesso em 30 de abril de
2005.
Improving Designs with the MVC Design Pattern. Disponível em:
<http://java.sun.com/developer/EJTechTips/2004/tt0324.html>. Acesso em 01 de
maio de 2005
23
Oracle ADF UIX Developer's Guide Table of Contents. Disponível em
<http://helponline.oracle.com/jdeveloper/help?topic=uixdg_toc_html>. Acesso em 20
de maio de 2005.
Apache Struts Framework (Version 1.2.7). Disponível em http://struts.apache.
org/api/index.html>. Acesso em 05 de abril de 2005.
Struts. Disponível em <http://struts.apache.org/>. Acesso em 05 de abril de 2005
24