Web Framework Jakarta Struts Aplicado No E-Commerce

UNIVERSIDADE DA AMAZÔNIA - UNAMA
CENTRO DE CIÊNCIAS EXATAS E TECNOLOGIA - CCET
CURSO DE BACHARELADO EM CIÊNCIA DA COMPUTAÇÃO
Ernani dos Santos Jacob Junior
João Matheus Aracaty Botelho
Marcelo dos Santos Gambôa
WEB FRAMEWORK JAKARTA STRUTS

APLICADO NO E–COMMERCE
Belém/PA
2004

Trabalho de Conclusão de Curso apresentado ao

Centro de Ciências Exatas e Tecnologia da
UNAMA – Universidade da Amazônia, como
exigência parcial para obtenção do título de
Bacharel em Ciência da Computação. Elaborado
sob orientação do Prof. M.Sc. Antonio Benedito
Coimbra Sampaio Junior.
Belém/Pa
2004

Professores Avaliadores
__________________________________
Antonio Benedito Coimbra Sampaio Jr.
__________________________________
Cláudio Alex Jorge da Rocha
__________________________________
Cláudio Roberto Martins
Aprovado em: ____/_____/____
Nota: _____________________
A minha família, pelo apoio em todos os
momentos e incentivo para vencer mais
essa etapa de minha vida.
Ernani dos Santos Jacob Jr.
Dedico este trabalho a Jeová Deus por

conceder-me vida e estar presente em
todos os momentos desta caminhada, e
também a minha família e amigos leais que
estiveram sempre presentes nos momentos
bons e ruins, me ajudando a chegar a este
momento feliz.
Aos meus amados pais, os maiores

motivadores e incentivadores dos meus
estudos e a minha namorada que sempre
me incentivou a concluir este curso.
iv
AGRADECIMENTOS
Agradeço ao Senhor Jesus Cristo, por me conceder esta benção de concluir o

curso de Bacharelado em Ciência da Computação.
À minha família, pelo apoio em todos os momentos.
Agradeço a minha namorada Anice Lena, pelo amor e compreensão.
Aos meus amigos e em especial, Marcelo e João, pela paciência e dedicação
para a finalizar este trabalho.
Aos meus professores pelos conhecimentos passados.
Ao orientador e amigo, Antônio B. C. Sampaio Jr, pela inspiração e dedicação
para a elaboração deste TCC.
Ernani dos Santos Jacob Jr.
Agradeço principalmente a Jeová Deus, por dar-me forças para vencer e concluir
o curso de Ciência da Computação.
Aos meus pais, Fernando e Iolanda, por acreditarem sempre no meu potencial e
pelo seu amor incondicional estando ao meu lado em todos os momentos. Obrigado por
serem meus pais!
A minha família, especialmente aos meus irmãos e minha cunhada, pelo amor,
paciência e incentivo ao longo desta caminhada.
Aos meus segundos pais, Neuza e Francisco (in memorian), pelo amor e
incentivo que sempre me deram.
Aos meus grandes amigos, Marcelo e Ernani, que fizeram deste trabalho um
vinculo de amizade eterna.
Á todos os meus amigos leias que estiveram sempre ao meu lado nas horas que
eu mais precisei.
Ao orientador e amigo, Antônio Sampaio, pela amizade e paciência durante a
elaboração deste TCC.
v
Agradeço a Deus e a Jesus, pela minha vitória de concluir o curso de Ciência da
Computação.
À minha família, pelo apoio e sustento que sempre me deram e pelo seu amor
incondicional.
Agradeço a minha namorada, Alice, pelo amor, amizade, paciência e
compreensão atitudes que sempre me fortalecem. Te amo Lilica!!!
Aos meus amigos e companheiros de TCC, João e Ernani, que ao meu lado
sempre trabalharam para a concretização deste trabalho.
Aos meus professores pelos conhecimentos passados.
Ao professor Cláudio Martins pela ajuda oferecida em momentos difíceis da
elaboração deste TCC. Obrigado professor.
Ao orientador e amigo, Antônio B. C. Sampaio Jr., pela amizade e paciência
durante a elaboração deste TCC.
vi
“Feliz o homem que achou sabedoria e o
homem que obtém discernimento, porque
tê-la por ganho é melhor de que ter por
ganho a prata, e tê-la como produto é
melhor do que o próprio ouro”.
Provérbios – 3:13, 14
vii
RESUMO
O comércio eletrônico (e-commerce) tornou-se popular com o surgimento da
Internet. A Internet com os seus serviços básicos, como correio eletrônico e a WWW,
têm criado um novo espaço para realização de negócios. Este novo ambiente tem
fornecido para os agentes econômicos, tanto para as empresas quanto indivíduos,
canais alternativos para realizar transações comerciais e, ainda, trocar informações e
transferir diferentes tipos de produtos e serviços. Assim, as empresas estão
encontrando no mundo virtual outra alternativa de oferecer seus serviços, tornando-se
mais competitivas e com um custo reduzido.
Outro fenômeno que tem ocorrido é o maior uso do web framework Jakarta
Struts. Este reúne várias tecnologias afins para que os desenvolvedores web possam
criar aplicações baseadas em padrões que sejam mais fáceis de construir, estender e
manter.
Este trabalho tem como objetivo elaborar um projeto de e-commerce utilizando o
Struts. Para tanto, é feito um estudo sobre os tipos de e-commerce, sobre a plataforma
J2EE e o web framework Jakarta Struts. Com base nestes estudos é feita a
especificação de um carrinho de compras do site de e-commerce e sua implementação.
Palavras–chaves: e-commerce, J2EE, framework Struts.
viii
ABSTRACT
The electronic commerce (e-commerce) became popular with the sprouting of the
Internet. The Internet with its basic services, as e-mail and the WWW, has created a
new space for accomplishment business-oriented. This new environment has supplied
the economic agents, as much for the companies how much individuals, alternative
canals to still carry through commercial transactions and, to change information and to
transfer to different types of products and services. Thus, the companies are finding in
the virtual world another alternative to offer its services, becoming more competitive and
with a reduced cost.
Another phenomenon that has occurred is the biggest use of web framework
Jakarta Struts. This congregates some technologies similar so that the web creators can
create applications based on standards that are more easy to construct, to extend and
to keep.
This work has as objective to make a project of e-commerce using the Struts. For
in such a way, a study on the types of e-commerce, the platform J2EE and web is made
framework Jakarta Struts. With base in these studies it is made the specification of a
stand of purchases of the site of e-commerce and its implementation.
Keywords: e-commerce, J2EE, framework Struts.
ix
SUMÁRIO
1. INTRODUÇÃO.......................................................................................................... 1
2. TECNOLOGIAS RELACIONADAS.......................................................................... 5
2.1- Comércio Eletrônico (e-commerce)................................................................... 5
2.1.1- Business-to-Business (B2B)..................................................................... 7
2.1.2- Business-to-Consumer (B2C)................................................................... 9
2.2- Aplicações Corporativas.................................................................................... 11
2.2.1- Modelos de Desenvolvimento................................................................... 11
2.2.2- A Plataforma J2EE.................................................................................... 15
2.2.2.1- Clientes J2EE................................................................................... 17
2.2.2.2- Componentes Web.......................................................................... 17
2.2.2.3- Componentes de Negócios.............................................................. 18
2.3- Web Frameworks............................................................................................... 20
2.3.1- Model-View-Controller (MVC)..............................…………………………. 21
2.3.2- Exemplos e Características...................................................................... 24
3. WEB FRAMEWORK JAKARTASTRUTS…….……………………………………….. 27

3.1- Introdução…………………………………………………………………………….. 27
3.2- A Arquitetura do Struts....................................................................................... 28
3.3- Funcionamento do Modelo Struts...................................................................... 30
3.4- Instalação do Struts........................................................................................... 33
3.4.1- Download do Struts 1.1............................................................................. 33
3.4.2- O Jakarta-Struts-1.1.................................................................................. 34
3.4.3- Requisitos do Struts.................................................................................. 34
3.5- Como iniciar a aplicação Struts Blank............................................................... 35
3.6- Exemplo de uma Simples Aplicação.................................................................. 38
3.6.1- A Base de Dados...................................................................................... 40
3.6.2- O ActionForm............................................................................................ 41
3.6.3- O ActionBean............................................................................................ 43
3.6.4- Configuração do Struts-Config.XML......................................................... 44
3.6.5- Configuração do Application.properties.................................................... 46
3.6.6- As páginas JSP......................................................................................... 46
4. ESPECIFICAÇÃO DO PROJETO DE E-COMMERCE............................................ 49

4.1- Visão Geral........................................................................................................ 49
4.2- Diagrama de Classes......................................................................................... 57
4.3- Diagrama de Seqüência..................................................................................... 59
5. ESTUDO DE CASO.................................................................................................. 61
5.1- Cenário do protótipo desenvolvido..................................................................... 61
5.2- Softwares utilizados........................................................................................... 62
5.2.1- Cliente...................................................................................................... 62
5.2.2- Servidor.................................................................................................... 63
x
5.2.3- Banco de Dados....................................................................................... 63
5.3- Cenário de Uso do Protótipo.............................................................................. 64
6. CONSIDERAÇÕES FINAIS E TRABALHOS FUTUROS........................................ 76

6.1- Contribuições.................................................................................................... 76
6.2- Limitações......................................................................................................... 77
6.3- Trabalhos Futuros............................................................................................. 78
REFERÊNCIAS BIBLIOGRÁFICAS............................................................................. 79
xi
LISTA DE FIGURAS
Figura 1. Estrutura de Relacionamento de um portal B2B........................................... 8

Figura 2. Exemplo de um portal B2B de uma empresa atacadista.............................. 8
Figura 3. Exemplo de uma livraria virtual B2C............................................................. 10
Figura 4. Modelo Monolítico......................................................................................... 12
Figura 5. Modelo Cliente-Servidor................................................................................ 13
Figura 6. Arquitetura de N camadas físicas................................................................. 14
Figura 7. Aplicações Multicamada................................................................................ 16
Figura 8. Container J2EE............................................................................................. 19
Figura 9. Esquema do mapeamento das tarefas de entrada, processamento e saída
da arquitetura MVC....................................................................................... 22
Figura 10. Representação do modelo MVC................................................................. 23
Figura 11. Diagrama de Componentes do Struts......................................................... 29
Figura 12. Funcionamento do Modelo Struts............................................................... 30
Figura 13. Tela de download do Struts 1.1.................................................................. 33
Figura 14. Estrutura de Pastas do Struts 1.1............................................................... 34
Figura 15. Página da documentação do Struts............................................................ 35
Figura 16. Estrutura de pastas da aplicação struts-blank............................................ 36
Figura 17. Tela de boas vindas da aplicação struts-blank........................................... 36
Figura 18. Tela principal da aplicação.......................................................................... 38
Figura 19. Telas da Aplicação...................................................................................... 39
Figura 20. Tabela Tbusuario........................................................................................ 41
Figura 21. Diagrama de Casos de Uso carrinho de compras...................................... 50
Figura 22. Tela que representa o Caso de Uso “Acessar Catalogo de Produtos”....... 52
Figura 23. Tela que representa o Caso de Uso “Adicionar Item ao Carrinho de
Compras”.................................................................................................... 53
Figura 24. Tela que representa o Caso de Uso “Acessar Carrinho de Compras”........ 55
Figura 25. Tela que representa o Caso de Uso “Atualizar Carrinho de Compras”....... 56
Figura 26. Diagrama de Classes do carrinho de compras........................................... 57
Figura 27. Diagrama de seqüência carrinho de compras............................................. 60
Figura 28. Cenário utilizado no desenvolvimento do protótipo..................................... 61
Figura 29. Tela de edição do Eclipse........................................................................... 62
Figura 30. Tomcat executando..................................................................................... 63
Figura 31. Gerenciador do SQL Server....................................................................... 64
Figura 32. Representação das Classes Action no modelo MVC.................................. 65
Figura 33. Representação dos arquivos de modelo no MVC....................................... 66
Figura 34. Representação das Páginas JSP’s............................................................. 67
Figura 35. Acesso do cliente ao servlet controller........................................................ 67
Figura 36. Mapeamento do servlet controller............................................................... 68
Figura 37. ActionServlet invocando a classe CatalogoAction...................................... 68
Figura 38. Classe CatalogoAction acessando a camada de negócio.......................... 69
Figura 39. Acesso ao banco de dados........................................................................ 70
Figura 40. Volta do controle do fluxo da aplicação à classe Action............................. 70
Figura 41. Retorno à classe ActionServlet................................................................... 71
xii
Figura 42. Montar página JSP...................................................................................... 72
Figura 43. Exibir tela principal...................................................................................... 72
Figura 44. Tela principal do e-commerce com carrinho de compras vazio.................. 73
Figura 45. Ícone do carrinho de compras..................................................................... 74
Figura 46. Carrinho de compras com item selecionado pelo cliente............................ 75
Figura 47. Grau de dificuldade do Struts X Tempo Aprendizado................................. 77
xiii
LISTA DE TABELAS
Tabela 1. Características principais dos tipos de comércio eletrônico (e-commerce)

B2B e B2C.................................................................................................... 10
Tabela 2. Vantagens e desvantagens do modelo MVC................................................ 24
Tabela 3. Exemplos e características de alguns web frameworks............................... 24
Tabela 4. Os arquivos da aplicação Struts Blank......................................................... 37
Tabela 5. Arquivos de controle do projeto de e-commerce.......................................... 64
Tabela 6. Arquivos de modelo do projeto de e-commerce........................................... 65
Tabela 7. Arquivos de visualização do projeto de e-commerce................................... 66
xiv
LISTA DE LISTAGEM
Listagem 1. CadastroForm.Java.................................................................................. 42
Listagem 2. O ActionBean........................................................................................... 43
Listagem 3. O struts-config.xml.................................................................................... 45
Listagem 4. O arquivo applicatio.properties................................................................. 46
Listagem 5. Formulário que aparece o navegador...................................................... 47
Listagem 6. Página de erro exibida no navegador....................................................... 48
Listagem 7. Página de sucesso exibida no navegador................................................ 48
xv
Capítulo 1 - Introdução 1
CAPÍTULO 1
INTRODUÇÃO
A Internet é uma ferramenta poderosa, com linguagens intuitivas e acessíveis,
que possibilita vantagens imediatas a quem a adota. Conecta-nos a um mundo
virtual de informações, de produtos, de serviços e até de oportunidades para
emprego antes nunca vistas. Entre os serviços oferecidos pela internet destacamos
a World Wide Web, WWW, ou simplesmente Web. Com o serviço web acessamos
textos, sons e imagens publicados em outros computadores conectados, além de
informações de páginas pessoais e de empresas. Sem esquecer alguns serviços
populares, entre eles bate-papo (chat), Home-banking e compras on-line (e-
commerce).
O volume de informação é tão grande que temos a facilidade de encontrar
tudo na hora e no lugar que quisermos por meio da internet. Esta tecnologia
transformou a vida das pessoas, e ganha a cada dia ainda mais usuários, já são
quase 600 milhões no mundo inteiro e só, no Brasil, são mais de 20,5 milhões [10].
O fato é que a internet está tomando conta de quase tudo, está cada vez mais
presente na vida e no ambiente em que se vive. Com isso, o comércio eletrônico ou
e-commerce – toda atividade de compra e venda realizada com auxilio de recursos
eletrônicos [14] – é um mercado bastante promissor e se expande de forma muito
rápida pelo mundo. Assim, muitas empresas do mundo físico estão migrando seus
sistemas e aplicativos ao mundo virtual, para tornarem-se mais competitivas, com
menos custos de manutenção.

Hoje em dia, a busca por uma fatia do mercado estimula empresas a
disponibilizar lojas na internet, devido à massa de dinheiro movimentada on-line, que
dobra a cada ano, triplicou em 2003 chegando a 394 bilhões de reais contra 126
bilhões em 2002 [10]. Portanto o consumidor ganha mais facilidades, mais produtos,
mais opções e mais comodidade.
Diante desta novidade, as empresas precisam se atualizar para usufruírem os
recursos cada vez mais sofisticados, e se sintonizarem com este novo meio de
comunicação. Os objetivos dela devem expandir a margem de negócios e reduzir,
consideravelmente, seus custos. Baseado nisso, pretende-se fazer um estudo mais
aprofundado das formas e tipos de e-commerce para motivar mais empresas a
conhecer e aderir este novo nicho de mercado.
O comércio eletrônico está amadurecendo, nota-se nesse processo a
consolidação e o surgimento de novas tecnologias para sua implementação.
Azevedo [18] divide o comércio eletrônico em duas gerações: na primeira,
enquadram-se todas as transações financeiras e comerciais efetuadas
eletronicamente; na segunda, englobam-se quaisquer transações comercial e
financeira baseadas em ambiente Internet.
Para Nakamura [14], e-commerce é toda atividade de compra e venda
realizada com auxilio de recursos eletrônicos. Turban et al [19] definem o comércio
eletrônico como sendo o processo de comprar e vender eletronicamente produtos e
informação.
Este trabalho tem como fundamentos teóricos os estudos de Albertin [17], o
qual afirma que “o comercio eletrônico (CE) é a realização de toda cadeia de valor
dos procesos de negócios num ambiente eletrônico, por meio da aplicação intensa
das tecnologias de comunicação e de informação, atendendo aos objetivos de
negócio”.
O principal objetivo deste trabalho é elaborar um projeto de e-commerce
utilizando web frameworks - tecnologia que oferece aos desenvolvedores um modelo
para reuso, além de uma forma de capturar a essência de padrões de projeto
(design patterns) [16]. São analisados os dois tipos de e-commerce: B2B (business-
to-business) e B2C (business-to-consumer). É especificado o projeto de e-
commerce, bem como a descrição das etapas para a sua concepção. É feito um
estudo sobre web frameworks. É feito um estudo de caso do carrinho de compras do
site de e-commerce. E por fim será Implementado o projeto de comércio eletrônico
utilizando as tecnologias da plataforma J2EE (Java 2 Enterprise Edition) e o web
framework Jakarta Struts.
Por apresentar um tema atual e pouco explorado, será estudado a web
frameworks Jakarta Struts para a implementação do projeto trazendo uma relevância
teórica dos conceitos e sua estrutura. Este trabalho irá contribuir, também, de forma
prática, com a especificação de um modelo de carrinho de compras e sua
implementação.
Esta monografia esta estruturada da seguinte forma: o segundo capítulo,
intitulado “Tecnologias Relacionadas”, abordará as tecnologias que serão usadas
durante o projeto de e-commerce. É desenvolvida uma análise teórica sobre
comércio eletrônico, suas definições, características, estrutura e evolução. Ainda
neste capitulo, serão abordadas quais as tecnologias importantes para criação de
um e-commerce, explicando-se cada uma delas.
No terceiro capítulo, intitulado de “Web Framework Struts”, é apresentada
uma introdução ao framework Jakarta Struts, abordando suas características, sua

instalação e configuração assim como uma pequena aplicação para exemplificar sua
utilização.
No quarto capítulo, intitulado “Especificação do Projeto de E-Commerce”, é
apresentado um modelo que irá ser utilizado para estruturação de uma solução de e-
commerce em atividades B2C (business-to-consumer) dentro da infra-estrutura
pública da Internet. São analisados os requisitos de um e-commerce, suas unidades
funcionais, suas características e suas etapas para estruturação, utilizando para isso
as notações de UML (Unified Modeling Language).
No quinto capitulo, é mostrado um estudo de caso referente ao carrinho de
compras de uma loja virtual.
No sexto capitulo, são feitas as conclusões e pretensões futuras, e no sétimo
capitulo, a bibliografia utilizada será apresentada.

Capítulo 2 – Tecnologias Relacionadas 5
CAPÍTULO 2
TECNOLOGIAS RELACIONADAS
2.1 Comércio Eletrônico (e-commerce)
O comércio eletrônico busca automatizar tarefas comerciais, incluindo
geração, processamento, coordenação, distribuição e harmonização de transações
comerciais, via Internet e outras mídias eletrônicas. Freqüentemente a terminologia
associada ao comércio eletrônico pode ser confusa. Quer a denominação seja
Internet commerce, e-commerce, ou mesmo ec, trata-se da mesma tecnologia:
comércio eletrônico, e todos os outros termos associados, significam comprar ou
vender bens ou serviços de uma empresa eletronicamente.
Esta nova forma de comércio permite negociar bens e serviços
imediatamente, ultrapassando barreiras de tempo e distância. A qualquer hora do
dia e da noite, os clientes podem acessar on-line e comprar qualquer coisa que
desejarem [22]. O comércio eletrônico é o passo mais recente na evolução das
transações comerciais. Substitui a troca de dinheiro ou bens pela troca de
informação entre computadores [20].
Segundo Andrew Bartel [21], vice-presidente e chefe de pesquisa sobre as
tendências do e-commerce no Giga Information Group [21], o comércio eletrônico
envolve trocas entre clientes, parceiros comerciais e fornecedores, ou seja, é um
sistema comercial com transações que envolvem trocas de bens ou serviços entre
duas ou mais partes de forma automática, utilizando-se da internet. Esta que é um
poderoso meio pelo qual aproxima empresas e clientes por meio da tecnologia. Um
mundo sem barreiras e a infinita possibilidade de aumentar o número de clientes
[21].
Como a Internet, o comércio eletrônico é toda conectividade que provê tanto
os modos como os meios para o acesso à Internet e a presença na Web para um
infinito número de negócios. Tanto as pequenas empresas quanto as grandes
empresas nacionais ou mesmo internacionais reconhecem as oportunidades em
longo prazo por meio de aquisições estratégicas e a capacidade de marketing
agressivo do comércio eletrônico [22].
Esta não é uma tendência, é o início de uma nova revolução no mundo dos
negócios que já esta afetando a maneira como as pessoas vivem, trabalham e se
divertem por toda a vida. Diante disso, este trabalho focaliza sua atenção no e-
commerce sendo a base deste projeto. Todavia, é importante que especifiquemos as
duas principais modalidades de comércio eletrônico: o primeiro chamado de B2B, ou
Business-to-Business, ou o comercio entre empresas. O outro é chamado de B2C,
ou Business-to-Consumer, o tradicional negócio entre um comerciante e um
consumidor final. Ambos utilizam a internet para aumentar sua produtividade e
adquirir mais clientes.
2.1.1 Business-to-Business (B2B)
Este tipo de e-commerce é a estratégia de comércio eletrônico entre
empresas, principalmente na relação produtor/importador e sua relação de
distribuição [14]. Transforma inteiramente o processo corporativo – desde a
concepção e criação de produtos – até produção, distribuição e consumo [1]. B2B

refere-se às relações de compras ou vendas entre empresas, isto é, as relações
entre uma empresa e seus fornecedores ou seu clientes (também empresas) [23].
Muitas empresas utilizam este tipo de e-commerce para se relacionar com seus
fornecedores fazendo pedidos, recebendo e pagando faturas, trocando dados e
adquirindo novas parcerias [23]. A maior parte do comércio é B2B. Há dois modelos
de B2B: (1) Modelo Vertical – o qual provê bens e serviços especializados por
intermédio de várias indústrias; (2) Modelo Horizontal - o qual provê bens e
serviços para uma empresa em particular. A razão do crescimento do mercado B2B
é puramente econômica, quer seja o modelo vertical ou horizontal. B2B provê infra-
estrutura para cadeias de fornecedores e sites comerciais que ajudam corporações
a aperfeiçoarem o modo como negociam com clientes e fornecedores. Com B2B as
empresas estão aptas a consolidar fornecedores e explorar o poder de compra dos
conglomerados [22].
Para a comunicação entre as empresas é necessária a utilização de
tecnologias que utilizem Intercâmbio de Dados Eletrônicos (IED - Interchange of
Electronic Data). Esta tecnologia permite a comunicação direta entre sistemas
computadorizados das empresas sem necessitar de envolvimento humano. Foi
criado para automatizar e acelerar a troca de informações entre empresas que
faziam negócios juntas regularmente. O IED ainda é usado e existem muitos outros
mecanismos para interação comercial, como catálogos eletrônicos e sistemas de
pagamento eletrônico [20]. Nota-se na Figura 1, a estrutura de relacionamento de
um portal B2B.
SISTEMA DE RELACIONAMENTO
DE UM PORTAL B2B
Investimentos
Financeiros
PORTAL B2B
Fornecedor Comprador
Logística
Figura 1 - Estrutura de Relacionamento de um portal B2B.
Observa-se na Figura 2 um exemplo de um portal B2B de uma empresa

atacadista.
Figura 2 - Exemplo de um portal B2B de uma empresa atacadista.

2.1.2 Business-to-Consumer (B2C)
Uma forma popular de e-commerce hoje é aquela na qual uma empresa
vende diretamente para o consumidor. B2C refere-se a um relacionamento varejista,
o qual é realizado via internet. Neste modelo de comércio, empresas disponibilizam
para consumidores ao invés de para outras empresas. As empresas anunciam ou
distribuem seus próprios serviços ou produtos para os clientes por meio de um
armazenamento eletrônico baseado na internet utilizando construções de base de
dados da web sem a intervenção de qualquer usuário [22].
Um determinado consumidor entra no site em busca de um produto. Após
encontrá-lo, procura por informações sobre o produto, manual técnico,
funcionamento, preço, prazo de entrega, etc. Satisfeito com as informações, ele
começa a realizar a compra. Seleciona o produto, a forma de pagamento, preenche
os dados e envia. No prazo estipulado, ele receberá o produto da compra. Este tipo
de comércio permite manter baixos estoques de produtos, que podem ser montados
ou adquiridos na medida em que são escoados. Percebe-se assim uma grande
vantagem em especificar um projeto de e-commerce baseado em B2C, sendo que
as empresas estão cada vez mais dispostas a migrar para esta nova forma de se
obter lucros e reduzir custos. É possível observar, na Figura 3, um exemplo de uma
livraria virtual B2C, onde o cliente pode fazer suas compras com toda a comodidade,
sem sair de casa.

Figura 3 - Exemplo de uma livraria virtual B2C.
O projeto de e-commerce proposto neste trabalho será baseado na
modalidade de comércio eletrônico business-to-consumer (B2C).
Na Tabela 1, são mostradas, as características principais dos dois tipos de
comércio eletrônico.
Tabela 1 - Características principais dos tipos de comércio eletrônico.
B2B B2C
Orientado ao Consumidor.
Negócios entre empresas; Negócios entre empresas e
consumidores;
Empresas negociam com Maior alcance geográfico para
revendedores, fornecedores, empresa;
distribuidores e consumidores;
Ganhou respaldo com Habilidade para atender a
Aplicações IED; clientes 24h por dia;
Envolve empresas de grande Oportunidades para melhores
porte. relacionamentos com o cliente
por meio de marketing.
2.2 Aplicações Corporativas
Os projetos de e-commerce modernos exigem aplicações distribuídas em
multicamadas com o objetivo de separar interface do usuário, lógica de negócio e
dados da aplicação, para que as etapas de desenvolvimento sejam realizadas
paralelamente e também para que as manutenções sejam facilmente
compreendidas.
Este seção tem o objetivo de mostrar as transformações dos modelos de
desenvolvimento e dar um claro entendimento dos conceitos e das terminologias
usados neste ambiente para atender as necessidades dos atuais projetos de e-
commerce.
2.2.1 Modelos de Desenvolvimento
Durante muitos anos, na história da computação, utilizou-se o Modelo de
Desenvolvimento Monolítico onde era comum encontrar um único programa grande,
com as implementações de todas as funcionalidades. O seu processamento era
executado em um computador central (chamado “mainframe”) e acessado a partir de
vários terminais.
Na Figura 4, é mostrada a arquitetura da aplicação no modelo de
desenvolvimento monolítico.
Aplicativo
Lógica de Lógica de Lógicas de

Apresentação Negócios Acesso a Dados
Banco de
Dados
Figura 4 - Modelo Monolítico.
Mais tarde, com o barateamento dos computadores, os altos níveis de
manutenção exigidos para acompanhar as necessidades corporativas e o problema
da recompilação de muitos códigos desnecessários, ocorreu um movimento
chamado downsizing, onde o processamento centralizado foi distribuído para vários
computadores menores e mais baratos, causando a mudança do antigo modelo para
o novo modelo de desenvolvimento cliente-servidor.
O modelo cliente-servidor, já é considerado um sistema distribuído, pois o
software é dividido em dois programas, o programa do cliente (camada cliente) e o
programa do servidor (camada servidor), e podem ser executados em dois ou mais
computadores, utilizando-se então a arquitetura de duas camadas. O aplicativo
cliente consiste nas lógicas de apresentação e de negócio, e o programa do servidor
contém a lógica de acesso a dados, com o objetivo de atender os pedidos realizados
pelo programa cliente. Na Figura 5, é apresentada a mudança para a segunda
camada física, onde os dados são acessados através de uma conexão via protocolo
HTTP com o banco de dados em outra máquina.

Camada Cliente Camada do Servidor
Aplicativo Cliente Aplicativo Servidor

HTTP
Banco de
Dados
Figura 5 - Modelo Cliente-Servidor.
A vantagem de ter a lógica de acesso a dados, dividida em um ambiente
físico separado, significa que não apenas os dados podem ser compartilhados, mas
que todas as alterações na lógica de acesso a dados estão localizadas nessa
segunda camada física [36], o que torna a manutenção da segunda camada física
eficiente, podendo até mesmo substituir o banco de dados por outro que tenha a
mesma interface de acesso.
Observou-se que as partes do sistema estão divididas em camadas lógicas
de acordo com suas funcionalidades, da seguinte maneira:
• Lógica de Apresentação: define como serão apresentadas as informações
para o usuário e como ele vai interagir com o sistema.
• Lógica de Negócio: definem as regras do negócio e todas as
funcionalidades da aplicação. Ela processa as requisições e solicita para a
lógica de acesso a dados todos os dados necessários.
• Lógica de Acesso a Dados: define a conexão com todos os bancos de
dados e através desta fornece os dados para a lógica do negócio.

Porém o modelo cliente-servidor de duas camadas continua a apresentar
problemas de manutenção, pois o aplicativo cliente ainda contém a lógica de
apresentação e do negócio, conhecido como cliente gordo (thick).
Com o advento da Internet, houve um movimento para separar a lógica do
negócio da interface com o usuário [36], criando-se então uma nova camada física
para armazenar a lógica de negócio, o que permite utilizar um único navegador da
web para acessar todas as aplicações disponíveis, tornando-se o cliente “gordo” em
“magro”. Na Figura 6, é ilustrada a atual arquitetura de “n” camadas.
Camada Cliente Camada do Servidor Camada do Servidor
Aplicativo Cliente Aplicativo Se

Servi
vidor Aplicativo Servidor
Banco de
Dados
Figura 6 - Arquitetura de N camadas físicas.
A diferença desta arquitetura de n camadas se dá pela divisão do programa
servidor em mais camadas e o enxugamento da camada cliente, conhecida como
thin client. A sua principal vantagem é que a lógica de apresentação, por exemplo,
pode ser substituída de uma interface com base em HTML para uma interface
gráfica sem interferir nas lógicas de negócio e de acesso a dados. A separação em
camadas lógicas torna os sistemas mais flexíveis, de modo que as partes podem ser
alteradas independentemente [36].

Constantemente desenvolvedores, arquitetos e gerentes de projetos lidam com
novas necessidades dos usuários, novos projetos, novas tecnologias e ainda fazem
manutenções nas aplicações existentes, e tudo isso na maioria das vezes, no menor
tempo possível e com menos recursos do que realmente precisam.
Para isso, a Sun Microsystem apresentou o J2EE (Java 2 Enterprise Edition)
para ajudar os desenvolvedores a construírem aplicativos amigáveis e
freqüentemente usados para distribuir soluções de comércio eletrônico.
2.2.2 A Plataforma J2EE
A Plataforma J2EE define um padrão para o desenvolvimento de aplicações
multicamadas, simplificando o seu desenvolvimento através de uma padronização
baseada em componentes, fornecendo um conjunto completo de serviços para
esses componentes, e da manipulação automática de vários detalhes inerentes ao
ambiente coorporativo, tais como: controle transacional; ajuste de performance;
persistência; segurança; escalabilidade; gerencia de recursos (processos, memória,
conexões com banco de dados e outros) [25].
O padrão define quais serviços devem ser fornecidos pelos servidores que
suportam J2EE. Muitas empresas estão agora distribuindo bens e serviços para os
clientes através da Internet, usando tais servidores com base em J2EE [36].
Uma aplicação J2EE é dividida em quatro camadas: camada do cliente,
camada da Web, camada de negócios e a camada de EIS (Enterprise Information
System); mas geralmente está distribuída em três locais distintos: as máquinas

clientes, a máquina do servidor J2EE e as máquinas de banco de dados. Na Figura
7, são ilustradas as camadas distribuídas nas respectivas máquinas.
Figura 7 - Aplicações Multicamada.
A camada EIS trata do software de EIS e inclui sistemas de infra-estrutura
empresariais (ERP, CRM, etc), sistemas de banco de dados e outros sistemas
legados. Os componentes de aplicação J2EE podem acessar o EIS para obter
conectividade com o banco de dados.
A lógica da aplicação é dividida em componentes de acordo com sua função.
Um componente é uma unidade de software funcional independente composta de
arquivos e classes relacionadas e que se comunica com outros componentes [25].
A especificação J2EE define os seguintes componentes: clientes,
componentes web e componentes de negócios;

2.2.2.1 Clientes J2EE
Um cliente J2EE pode ser um cliente web ou um cliente de aplicação. O
cliente web é dividido em duas partes: um navegador web e as páginas web
dinâmicas por ele recebidas do servidor. Essas páginas podem possuir ter incluído
um applet1 incorporado, em que o cliente necessitará de um Java plugin e um
arquivo de políticas de segurança para que este applet possa ser executado com
sucesso no navegador web.
O cliente da aplicação J2EE é normalmente uma interface gráfica criada a
partir da API swing, que acessa diretamente os enterprise beans que são
executados na camada de negócios, ou então pode abrir uma conexão HTTP para
fazer comunicação com um servlet que está sendo executado na camada web.
2.2.2.2 Componentes Web
Os componentes web podem ser:
• Servlet: são classes da linguagem Java armazenadas no servidor que
executam dinamicamente solicitações e constroem respostas.
• Páginas JSP (JavaServer Pages): são documentos que mesclam
código Java e HTML, permitindo mostrar conteúdos dinâmicos e mais
facilmente conteúdos estáticos.
1
Um applet é uma pequena aplicação cliente escrita em Java que é executada em uma
máquina virtual instalada no navegador Web.
2.2.2.3 Componentes de Negócios
Os componentes de negócios são os que implementam a lógica de negócios
da aplicação, sendo esta responsável por satisfazer o objetivo da aplicação e são
tratados por enterprise Java beans, também conhecidos como EJBs.
Os EJBs são de três tipos:
• Beans de Sessão: representa a execução transitória de algum trabalho
a um cliente.
• Beans de Entidade: representa os dados persistentes armazenados em
registros de tabelas de banco de dados relacionais.
• Beans Orientados a Mensagens: ele combina recursos de um bean de
sessão e mensagens JMS (Java Message Service), permitindo
mensagens assíncronas.
O padrão J2EE especifica que um servidor de aplicativos compatíveis com
J2EE Application Servers deve fornecer um conjunto definido de containers para
abrigar os componentes J2EE. Desse modo, a J2SE (Java 2 Standard Edition) está
disponível em cada container. As APIs (Application Programming Interface –
Interface de Programação de Aplicativos) no J2EE também estão disponíveis, para
fornecer comunicação entre componentes, persistência, etc [25].
Antes que um componente web, cliente da aplicação, ou enterprise bean
possa ser executado, ele deve ser montado em uma aplicação J2EE e implantado
no seu container. O container funciona como uma interface entre o componente e a
funcionalidade específica da plataforma de baixo nível que dá suporte ao
componente [26].
Os containers são implementados pelos fornecedores de servidor de aplicativos
e deve haver um container disponível, como mostra a Figura 8, para cada tipo de
componente. A especificação J2EE definiu os seguintes containers:
• Container Web: gerencia a execução dos componentes da página JSP e
do servlet.
• Container EJB: gerencia a execução de enterprise beans.
Figura 8 - Container J2EE.
As principais tecnologias englobadas nas aplicações J2EE são [25]:
• Banco de Dados: JDBC, JDO;
• Objetos Distribuídos: Java RMI, RMI-IIOP, CORBA, EJB;
• Serviços Distribuídos: JTA, JTS, JAAS, JNDI;
• Eventos Distribuídos: JMS;
• WEB: Servlets, JSP, JSTL;
• XML e WEB SERVICES: JAXP, JAXB, JAXM, JAXR, JAX-RPC;
• E-MAIL: JavaMail;
Para o desenvolvimento de aplicações corporativas (e-commerce), utilizando-se
a plataforma J2EE, pode-se utilizar um web framework para melhoria da
produtividade no desenvolvimento e da qualidade e manutenibilidade da aplicação.
2.3 Web Frameworks
Um Web Framework é uma aplicação reutilizável e semicompleta que pode
ser especializada para produzir aplicações personalizadas [32]. Um web framework
reusa análise, projeto e código. Reusa análise porque descreve os tipos de objetos
importantes e como um problema maior pode ser dividido em problemas menores.
Reusa projeto porque contém algoritmos abstratos que descreve a interface que o
programador deve implementar e as restrições a serem satisfeitas pela
implementação. E Reusa código porque torna mais fácil desenvolver uma biblioteca
de componentes compatíveis e porque a implementação de novos componentes
pode herdar grande parte de seu código das super-classes abstratas [27].
Um Framework é definido por Coad [28] como um esqueleto de classes,
objetos e relacionamentos agrupados para construir aplicações específicas e, por
Johnson [29] como um conjunto de classes abstratas e concretas que provê uma
infra-estrutura genérica de soluções para um conjunto de problemas. Essas classes
podem fazer parte de uma biblioteca de classes ou podem ser específicas da
aplicação. Os Frameworks possibilitam reutilizar não só componentes isolados como
também toda a arquitetura de um domínio específico [30].
Uma característica importante dos web frameworks é que os métodos
definidos pelo usuário são chamados de dentro do próprio web framework, ao invés
de serem chamados do código de aplicação do usuário [27]. O web framework
geralmente faz o papel de programa principal, coordenando e seqüenciando as
atividades da aplicação web.
Diversos web frameworks têm sido desenvolvidos nas duas últimas décadas,
visando o reuso de software e conseqüentemente a melhoria da produtividade,
qualidade e manutenibilidade [30].
Neste tópico, são apresentados os web frameworks, bem como o padrão de
projeto Model-View-Controller (MVC) utilizado pela maioria destes, assim como
exemplos de alguns web frameworks existentes.
2.3.1 Model-View-Controller (MVC)
Padrões de projetos (disign patterns) são soluções para problemas que alguém
um dia teve e resolveu aplicando um modelo que foi documentado e que você pode
adaptar integralmente ou de acordo com a necessidade de sua solução. O MVC
será o padrão de projeto abordo para o desenvolvimento do projeto de e-commerce,
e que tem por objetivo básico separar a lógica de negócio da apresentação [31].
A arquitetura MVC fornece uma maneira de dividir a funcionalidade envolvida
na manutenção e apresentação dos dados de uma aplicação. A arquitetura MVC
não é nova e foi originalmente desenvolvida para mapear as tarefas tradicionais de
entrada, processamento e saída para o modelo de interação com o usuário, como
visto na Figura 9. Usando o padrão MVC fica fácil mapear esses conceitos no
domínio de aplicações web multicamadas [31].

Entrada Processamento Saída
Controlador Modelo Visualização
Figura 9 - Esquema do mapeamento das tarefas de entrada, processamento e saída da

arquitetura MVC.
Na arquitetura MVC, o modelo representa os dados da aplicação e as regras
do negócio que governam o acesso e a modificação dos dados. O modelo mantém o
estado persistente do negócio e fornece ao controlador a capacidade de acessar as
funcionalidades da aplicação encapsuladas pelo próprio modelo [31].
Um componente de visualização renderiza o conteúdo de uma parte
particular do modelo e encaminha para o controlador as ações do usuário; acessa
também os dados do modelo via controlador e define como esses dados devem ser
apresentados [31].
Um controlador define o comportamento da aplicação, é ele que interpreta
as ações do usuário e as mapeia para chamadas do modelo. Em um cliente de
aplicações Web essas ações do usuário poderiam ser cliques de botões ou seleções
de menus. As ações realizadas pelo modelo incluem ativar processos de negócio ou
alterar o estado do modelo. Com base na ação do usuário e no resultado do
processamento do modelo, o controlador seleciona uma visualização a ser exibida
como parte da resposta a solicitação do usuário. Há normalmente um controlador
para cada conjunto de funcionalidades relacionadas [31].
A arquitetura de três (3) camadas que está representada na Figura 10, ilustrada
abaixo, é uma implementação do modelo MVC. O modelo MVC está preocupado em
separar a informação de sua apresentação.

HTTP
Request SET
SGB
Browser
GET
HTTP
Response
Figura 10 – Representação do modelo MVC
A partir da representação mostrada na figura10, são apresentadas as
principais características das camadas do modelo MVC:
Camada Modelo - É o “coração” da aplicação. Define as regras de negócio. Suas
Principais características são:
• Modelar os dados e o comportamento por traz do processo de negócios;
• Gerenciar o armazenamento, a manipulação e geração de dados;
• Encapsular os dados e comportamento independente da apresentação.
Camada Visualização - Não está preocupada onde e como a informação foi obtida,
apenas exibe a informação. Suas Principais características são:
• Incluir os elementos de exibição no cliente: HTML, XML, JSP;
• Representar a camada de interface do usuário;
• Receber a entrada de dados e apresentar o resultado.

Camada Controle - Determina o fluxo da apresentação servindo como uma camada
intermediária entre a camada de apresentação e a lógica. Sua Principal
característica é:
• Controlar e mapear as ações.
Na Tabela 2, são apresentadas algumas vantagens e desvantagens da
arquitetura MVC.
Tabela 2 - Vantagens e desvantagens do modelo MVC.
Vantagens do modelo MVC Desvantagens do modelo MVC

Como o modelo MVC gerencia múltiplos Requer uma quantidade maior de tempo
visualizadores usando o mesmo modelo para analisar e modelar o sistema;
é fácil manter, testar e atualizar sistemas
múltiplos;
Torna a aplicação escalável; Requer pessoal especializado;
Possibilita o desenvolvimento em Não é aconselhável para pequenas
paralelo para o modelo, visão e controle. aplicações.
2.3.2 Exemplos e Características.
Na Tabela 3, encontram-se alguns exemplos de web frameworks com suas
respectivas características.
Web framework Características

É um framework open source do projeto Jakarta que auxilia
a construção de aplicações para a Web. É construído em
Java, e seu “coração” consiste em uma camada de controle
flexível baseada nas tecnologias Java Servlets, JavaBeans,
ResourceBundles e XML.
Struts
O Struts favorece o desenvolvimento de aplicações
seguindo o paradigma MVC. Fornece um componente
Controller e se integra a outras tecnologias para oferecer
suporte aos componentes Model (como JDBC, EJB’s, etc.),
e View (como JSP, XSLT, etc).
É um framework de apresentação. Utiliza a arquitetura

MVC, similar ao Struts. A diferença é que este provê um
mecanismo de notificação de eventos. Diferente da
abordagem JSP clássica, o framework Barracuda foi criado
Barracuda
como um Template Component, que permite uma maior
flexibilidade e extensibilidade. O framework separa o
conteúdo do código pela abordagem XMLC2 de criar
interfaces gráficas.
É um projeto open source fundado em janeiro de 1999. A

meta do Cocoon era ajudar a separar o estilo do conteúdo,
lógica de aplicação e gerenciamento de funções para sites
Cocoon baseado em XML. Cocoon “alavanca” o XML, XSLT
(Entensible Stylesheet Language Transformations), e o SAX
(Simple API for XML) para ajudar a criar, implantar e manter
aplicações em XML.
É um framework para desenvolvimento de aplicações web e

oferece suporte a implementação da lógica de acesso a
Expresso banco de dados. O Expresso pode ser integrado com Struts
e adicionar características de segurança, mapeamento
objeto relacional, background e outros serviços.
É um template open source de HTML usado com Servlets.

Com Freemaker, é possível armazenar o HTML em um
Freemaker template, que eventualmente é compilado em um objeto
template. Esses objetos templates então geram o HTML
dinamicamente, usando os dados fornecidos pelos Servlets.
É outro projeto do Jakarta. É um template similar ao

Freemarker, capaz de criar conteúdo dinâmico para web.
Velocity pode gerar SQL, PostScript e XML a partir de
templates, e pode também ser usado como um utilitário
Velocity
stand alone para gerar código fonte e relatórios. Pode ainda
ser usado como um componente integrado de outros
sistemas. Velocity também provê serviços templates para
“turbinar” frameworks de aplicações web.
É um framework open source que usa uma linguagem de

script que permite separar a apresentação da lógica do
WebMacro negócio. WebMacro pode rodar em modo stand alone ou
com um servlet container.
2
XMLC é um compilador baseado em Java que usa documentos HTML ou XML para criar
classes Java.
É um framework que oferece a habilidade de renderizar

visualizações usando JSP, a linguagem de Script Velocity,
Maverick ou XSLT. Maverick é uma arquitetura do tipo MVC, mas
atualmente provê um mecanismo de visualização de
template.
É um framework open source do projeto Jakarta, baseado

em servlets. O foco de Turbine é ser um provedor de
Turbine coleções de componentes reutilizáveis. Um largo conjunto
de componentes é incluído neste framework, fazendo com
que ele se assemelhe a uma biblioteca de componentes.
A tecnologia Java Server Faces (JSF), implementada sobre

a arquitetura MVC, é uma especificação que define uma
arquitetura e um conjunto de APIs para a criação e
manutenção de aplicações Java no servidor. Um site JSF
possui páginas JSP e JavaBeans. Além disso, é acrescido
Java Server Faces
de alguns recursos que organizam e facilitam a construção
e manutenção do mesmo. Usualmente, uma página JSP é
convertida em um servlet, durante o primeiro acesso da
página. Assim, quando é feita uma requisição HTPP, esta é
tratada pelo servlet correspondente.
Tabela 3 - Exemplos e características de alguns web frameworks
Visando a melhoria da produtividade, da qualidade e manutenibilidade de
aplicações coorporativas para a web, foi utilizado o web framework Struts para o
desenvolvimento do projeto de e-commerce proposto neste trabalho.

Capítulo 3 - Web Framework Struts 27
CAPÍTULO 3
3.1 Introdução
O framework Struts foi desenvolvido por Craig McClanahan e doado, em
maio de 2002, à Apache Foundation [37]. Atualmente há uma comunidade de
desenvolvedores espalhados pelo mundo, trabalhando de forma cooperativa neste
projeto.
Struts é um modelo de código aberto, proposto pela Jakarta, útil para construir
aplicativos Web, usando Servlets e JSP. Struts estimula o uso de uma arquitetura de
aplicação baseada no paradigma de projeto Model-View-Controller (MVC),
conhecida como Modelo 2. Ele provê seu próprio componente de controle e o integra
com outra tecnologias para possibilitar o Modelo e a Visão. Com relação ao Modelo,
Struts pode interagir com qualquer tecnologia padrão de acesso a dados. Quanto à
Visão, o modelo Struts funciona bem com JSP [32].
Abaixo estão listados as principais motivações que levaram o Struts a ser
utilizado como padrão de mercado [32]:
• Possui garantia de que o Apache Group irá manter o framework (correção de
bugs e novos releases);
• Possibilita Integração com a maioria das IDEs de mercado;
• Não “reinventa a roda”, focando os seus esforços em regras de negócio;

• Separa a camada de negócio da camada de apresentação;
• Incorpora diversos padrões de projetos3 (design patterns);
• Cria aplicações padronizadas, facilitando a manutenção;
• Cria aplicações internacionalizadas4;
• Possibilita gerar a saída de acordo com o dispositivo usado (HTML, SHTML,
WML, etc);
• Aumenta a produtividade.
3.2 A Arquitetura do Struts
Todos os componentes básicos dessa arquitetura são encontrados em um
pacote chamado org.apache.struts.action como é mostrada na Figura 11:
<< encaminha >> << instancia >>

ActionServlet ActionForm
JSP
( visão )
<< chama >>
Action
<< usa >>
taglib << usa >>

( visão ) ActionMapping
org.apache.struts.action
Figura 11 - Diagrama de Componentes do Struts.
3
Padrões de Projetos é uma descrição das soluções, estratégias e conseqüências para
serem usadas rapidamente para resolver problema[32].
4
O framework Struts permite que suas aplicações sejam internacionalizadas. Assim é
possível a visualização das páginas web em diversos idiomas, sendo configurado através de
arquivos nomeados seguindo o código ISO do idioma. Ex.:application_em.properties [32].
Os componentes ActionServlet, ActionForm, Action e ActionMapping são
componentes fundamentais da arquitetura Struts, sendo descritos da seguinte forma:
O ActionServlet (org.apache.action.ActionServlet) é o controlador no
framework Struts. Ele é responsável por criar e interagir com os objetos Action e
utilizar o ActionMapping para carregar os mapeamentos.
O ActionForm (org.apache.action.ActionForm) é responsável por tratar os
formulários. Suas instâncias são preenchidas com os dados do formulário e
validados (se necessário) pela invocação do método validade antes de um objeto
Action ser executado.
O Action (org.apache.action.Action) chama a lógica de negócio, que em
geral, se encontra separada fisicamente em outra camada. Com o objetivo de
manter a capacidade de reutilização de quaisquer componentes de negócios.
O ActionMapping (org.apache.action.ActionMapping) contém todos os
mapeamentos utilizados pelo controlador para encaminhar as solicitações para os
respectivos objetos Action. Os objetos ActionMapping são carregados em memória a
partir de um arquivo XML chamado struts-config.xml.
3.3 Funcionamento do Modelo Struts
Na Figura 12, é descrito o funcionamento do Struts, mostrando passo a passo
desde a primeira solicitação do usuário, passando pelo gerenciamento e
processamento do Struts para essa solicitação, até retornar a resposta ao usuário
através de uma nova página html.

Figura 12 – Funcionamento do Modelo Struts
1. O usuário faz uma solicitação através de uma url no browser.
Ex: http://localhost:8080/catalogo.do. Note que no final da url tem um .do que
será usado para invocar (na verdade mapear) o servlet controlador do Struts;
2. Se for a primeira solicitação que o container recebeu para esta aplicação, ele
irá invocar o método init() da ActionServlet e irá carregar as configurações do
arquivo struts-config.xml em estruturas de dados na memória. Vale lembrar
que esta passagem só será executada uma única vez, pois nas solicitações
subseqüentes, o servlet consulta estas estruturas na memória para decidir o
fluxo a ser seguido;
3. Baseado no fluxo definido no arquivo struts-config.xml, e que neste momento
já se encontra carregado em estruturas na memória, o ActionServlet
identificará qual o ActionForm (classe para a validação dos dados) irá invocar.
A classe ActionForm através do método validate irá verificar a integridade dos
dados que foram recebidos na solicitação que vem do browser;
4. O controle da aplicação é retomado pelo ActionServlet, que checa o resultado
da verificação do ActionForm. Caso falte alguma coisa (campo não
preenchido, valor inválido, etc), o usuário recebe um formulário html
(geralmente o mesmo que fez a solicitação), informando o motivo do não
atendimento da solicitação, para que o usuário possa preencher corretamente
os dados para fazer uma nova solicitação. Se não faltou nenhuma
informação, ou seja, todos os dados foram enviados corretamente, o
controlador passa para o próximo passo Action;
5. O ActionServlet, baseado no fluxo da aplicação (estruturas já carregadas em
memória) invoca uma classe Action. A classe Action passará pelo método
execute que irá delegar a requisição para a camada de negócio;
6. A camada de negócio irá executar algum processo (geralmente popular um
bean, ou uma coleção). O resultado da execução deste processo (objetos já
populados) será usado na camada de apresentação para exibir os dados;
7. Quando o controle do fluxo da aplicação voltar ao Action que invocou o
processo da camada de negócio, será analisado o resultado, e definido qual o
mapeamento adotado para o fluxo da aplicação. Neste ponto, os objetos que
foram “populados” na camada de negócio serão inseridos como atributos na
seção do usuário;
8. Baseado no mapeamento feito pelo o Action, o controlador faz um forward
para a JSP para apresentar os dados.

9. Na camada de apresentação (Visão), os objetos que foram inseridos como
atributos da sessão do usuário serão consultados para montar a JSP.
10. Chega a JSP como resposta da requisição feita pelo usuário.
O controlador já vem implementado no Struts, embora, seja possível estendê-
lo a fim de adicionar funcionalidade. O fluxo da aplicação é programado em um
arquivo XML através das ações que serão executadas. As ações são classes base
implementadas pela framework seguindo o padrão MVC. Assim devemos estendê-
las a fim de adicionar a funcionalidade desejada.
A geração da página dinâmica é feita através de tags. A distribuição Struts
inclui um conjunto poderoso de tags JSP, escritas previamente, que integram o
framework nas páginas JSP [32], evitando assim o uso de scriptlets (códigos Java
entre <%> e <%>), deixando o código JSP mais limpo e fácil de manter.
3.4 Instalação do Struts
3.4.1 Download do Struts 1.1
Neste trabalho foi utilizada a versão mais recente do Struts, 1.1, pois
incorpora uma série de melhorias em relação à versão anterior.
O download do arquivo jakarta-struts-1.1.zip, pode ser feito a partir do site
do Struts, em http://jakarta.apache.org/struts, como mostra a Figura 13.

Figura 13 – Tela de download do Struts 1.1
3.4.2 O Jakarta-Struts-1.1
O arquivo jakarta-struts-1.1 apresenta a estrutura de pastas como mostra a
Figura 14.
Figura 14 – Estrutura de Pastas do Struts 1.1

Dentro da pasta chamada webapps, há vários arquivos do tipo WAR contendo
exemplos (struts-example.war), a documentação do Struts (struts-
documentation.war) e uma aplicação modelo (struts-blank.war) utilizada para iniciar
projetos web com Struts.
3.4.3 Requisitos do Struts
Para um ambiente mínimo de desenvolvimento com Struts, usa-se um
container web (Tomcat, Resin, etc) e o pacote JDK da SUN disponíveis em:
• Sun JDK, http://java.sun.com/j2se
• Tomcat 4, http://jakarta.apache.org/tomcat
3.5 Como iniciar a aplicação Struts Blank
A aplicação Struts Blank já fornece uma estrutura de pastas contendo todos
os arquivos básicos da distribuição e as versões de inicialização dos arquivos de
configuração (web.xml, struts-config.xml, build.xml e application.properties), junto
com as configurações do framework para o Tiles 5e o Validator6.
O arquivo struts-blank.war deve ser copiado para a pasta
<tomcathome>\webapps. A Figura 15 mostra a disposição do arquivo struts-
blank.war dentro da pasta do Tomcat.
5
Tiles é um framework contendo uma biblioteca de tags para tornar o uso do layout do template mais
fácil.
6
Validator é um framework que permite validar as entradas de dados em formulários.
Figura 15 – Página da documentação do Struts
Ao iniciar o Tomcat, automaticamente será gerada a estrutura de pastas como
mostra a Figura 16.
Figura 16 – Estrutura de pastas da aplicação struts-blank.
A aplicação struts-blank já está disponível em http://localhost:8080/struts-
blank e se tudo estiver correto será exibido uma tela de boas vindas do Struts como
mostra a Figura 17.
Figura 17 – Tela de boas vindas da aplicação struts-blank

A aplicação blank possui os arquivos e funcionalidades descritas na tabela 4.
Nome do Arquivo Objetivo
É a página inicial que aciona uma ação Struts

/index.jsp
Welcome.
É a página de “boas vindas” chamadas através da

/pages/Welcome.jsp
ação Welcome.
WEB-INF/classes/resources/ É uma cópia de trabalho, a original é mantida com

application. Properties os outros arquivos do código-fonte.
WEB-INF/struts-config.xml É o arquivo principal de configuração Struts padrão.
É o arquivo de principal de configuração Tiles

WEB-INF/tiles-def.xml
padrão.
É o arquivo de principal de configuração Validator

WEB-INF/validator-rules.xml
padrão que configura os validadores básicos.
Um arquivo de configuração Validations de

WEB-INF/ validations.xml inicialização no qual você descreve seus próprios
formulários.
Os arquivos do descritor da biblioteca de tags para

WEB-INF/*.tld
as bibliotecas de tags do Struts.
São arquivos (biblioteca, API) necessários para

WEB-INF/lib/*.jar
executar a aplicação.
É o arquivo utilizado pela ferramenta Ant para

WEB-INF/src/build.xml automatizar as atividades de desenvolvimento,
como compilação e empacotamento de classes.
Uma pasta de inicialização para seus arquivos-

WEN-INF/src/java/
fontes Java.
WEN-INF/src/resources/ É o arquivo original que permite a

application.properties internacionalização de sua aplicação.
Tabela 4 – Os arquivos da aplicação Struts Blank.
3.6 Exemplo de uma Simples Aplicação
A maneira mais fácil de construir uma primeira aplicação Struts é reutilizar
como modelo inicial à aplicação struts-blank.war.
Para melhor compreender a construção de uma aplicação struts, foi
construída um exemplo de cadastro de usuários. A aplicação exibira uma tela de
registro com cinco campos – Nome, E-mail, Login, Senha de Acesso e Confirmação
de Senha, como mostra Figura 18.
Figura 18 – Tela principal da aplicação
Após o preenchimento do formulário, o usuário finaliza o cadastro através do
botão cadastrar, ocorrendo as seguintes possibilidades:
Se estiver faltando preencher algum campo, a aplicação não efetuara o
cadastro e mostrara mensagens para os campos incompletos, como mostra a Figura
19 (a).
Se as duas senhas não coincidirem, a aplicação não efetuará o cadastro e
enviará um aviso informando que as senhas são diferentes, como mostra a Figura
19 (b).
Se a aplicação encontrar problemas ao conectar-se ao banco de dados, será
exibida uma nova página informando o erro de banco de dados, como mostra a
Figura 19 (c).
Se o cadastro estiver correto, o controle irá para uma página de resposta
confirmando sucesso na realização do cadastro do usuário, como mostra a Figura 19
(d).
(a) (b)
(c) (d)
Figura 19 (a, b, c, d) – Exemplo de cadastro de usuários.
O objetivo desta aplicação é mostrar como criar páginas JSP com formulários
HTML capturando sua entrada de dados, como criar um ActionForm para cada
formulário, como criar uma ação Action, como configurar o ActionServlet através do
arquivo struts-config.xml, e ainda como processar a entrada de dados através da
lógica de negócios e mudar o fluxo de controle com base na entrada dinâmica.
As etapas para o desenvolvimento da aplicação são:
• Criar a base de dados;
• Criar o ActionForm;
• Criar o ActionBean;
• Configurar o Struts-config.xml;
• Configurar o Application.properties;
• Criar as Páginas JSP.
3.6.1 A Base de Dados
Por questão de facilidade utilizou-se o Microsoft Access como base dados
para criar a tabela chamada TBusuario, como mostra a Figura 21.

Figura 20 - Tabela Tbusuario.
3.6.2 O ActionForm
Um ActionForm é um JavaBean que estende a classe
org.apache.struts.ActionForm com o objetivo de capturar os campos de entrada
enviados através da solicitação [32]. O ActionForm tem uma propriedade
correspondente para campo do formulário HTML, assim o ActionServlet coincide os
parâmetros da solicitação com as propriedades do ActionForm transmitindo-lhe os
valores do formulario através do método setter. O ActionForm implementa o método
validate para verificar se todos os campos requeridos foram preenchidos.
As classes ActionForm geralmente são denominadas xxxForm.java onde xxx
é o nome da Action. Nesta aplicação, portanto, o nome do ActionForm é

CadastreForm.java mostrado na Listagem 1.1. Esse arquivo se encontra na pasta do
projeto, <tomcathome>\webapps\cadastro\WEB-INF\src\cad\form.
Package cad.form;
import org.apache.struts.action.*;
import javax.servlet.http.HttpServletRequest;
Public class CadastreForm extends Actionform {

// declarar como private as variáveis nome, email, login, senha1 e senha2.
Private String nome;
...
// Declarar os métodos getter e setter para as variáveis.
Public String getNome() { return this.nome; };
Public void setNome(String nome) { this.nome = nome; };
...
public void reset ( ActionMapping map, HttpServletRequest req) {
nome = “”;
...
// Testar se as variáveis sao vazias.
Public ActionErros validate (ActionMapping map, HttpServlet req) {
if ((nome == null) || (nome == “”)){
erros.add(“nome”, new ActionErros(“error.nome.required”));}
...
if (!senha1.equals(senha2)){
erros.add("alerta", new ActionError("errors.alerta"));}
}
Listagem 1 - CadastroForm.java
O trabalho de validação e geração de mensagens de erros, são
implementados no ActionForm através mo método validate.
Quando terminada a execução do método validate, se ocorrer algum erro,
será adicionado em um Collection de erros. Se este collection tiver algum erro, o
ActioForm devolve para a JSP que entrou com os dados, com os campos
preenchidos, e com as mensagens de erros ocorridos. Se não ocorreu nenhum erro,
o fluxo segue para um ActionBean para invocar a camada de negócio para gravar os
dados no banco de dados.

3.6.3 O ActionBean
Um ActionBean é uma classe Java que estende o org.apache.strtuts.Action. O
ActionServlet preenche o ActionForm e então transmite-o para Action que é
responsável por validar a entrada, acessar a lógica de negócios e determinar qual
ActionForward retornar para o servlet [32].
As classes ActionBean geralmente são denominadas xxxAction.java onde xxx
é o nome da Action. Neste exemplo, portanto, o nome do ActionBean será chamado
CadastreAction.java mostrado no código fonte na Listagem 1.2.
package cadastro;
Import org.apache.struts.action.*;
Import javax.servlet.http.*;
Import java.io.*;
Public class CadastrarAction extends Action {

public ActionForward execute( ActionMapping mapping,
ActionForm form,
HttpServletRequest req,
HttpServletResponse res )
Throws Exception {
// 1. Faça a comparação do formulário para o CadastrarForm

CadastreForm cform = (CadastreForm) form;
String nome = cf.getNome();
String email = cf.getEmail();
String login = cf.getLogin();
String senha1 = cf.getSenha1();
String senha2 = cf.getSenha2();
// 2. Aplique a lógica de negócio

AcessaBD acesso = AcessaBD.getInstance();
acesso.insereUsuario(cform.getNome(), cform.getEmail(),
cform.getLogin(), cform.getSenha1());
// 3. Retorne ActionForward no caso de sucesso

return mapping.findForward("sucesso");
} catch (SQLException e) {
ActionErrors erros = new ActionErrors();
erros.add(ActionErrors.GLOBAL_ERROR, new
ActionError("errors.sqlerror"));
saveErrors(req, erros);
return mapping.findForward("excecoes");
}
...
Listagem 2 – O ActionBean
Esse ActionBean possui, de um modo geral, todas as tarefas que os Actions
fazem.
Em 1, o ActionForm de entrada tem semelhança com o CadastrarForm, sendo
passado os valores para os atributos nome, email, login, senha1 e senha2 e em
seguida sendo executado o método validate do ActionForm.
Em 2, é cadastrado um novo usuário através do AcessaBD em 3 e é
retornado um ActionForward associado ao sucesso.
O AcessaBD é uma classe auxiliar que registrará as informações do usuário
no banco de dados. Caso as senhas não coincidam, o ActionForward é associado
ao erro. Os objetos ActionForward de sucesso e erro serão especificados no arquivo
de configuração struts-config.xml.
3.6.4 Configuração do Struts-Config.XML
O arquivo de configuração struts-config.xml é usado para carregar vários
componentes críticos do framework. Juntos, esses objetos compõem a configuração
Struts. A configuração Struts e o Struts actionservlet trabalham juntos para criar a
camada de controle de sua aplicação [32].
O arquivo de configuração Struts (struts-config.xml) é para o Struts o que o
descritor de desenvolvimento (web.xm) é para o seu container. A listagem 1.3
mostra o arquivo struts-config.xml.

...
<struts-config>


<form-beans>
<form-bean name="cadastreForm"
type="cad.form.CadastreForm">
</form-bean>
</form-beans>


<global-exceptions>
</global-exceptions>


<global-forwards>
<forward name="welcome"
path="/Welcome.do">
</forward>
<forward name="excecoes"
path="/jsp/error.jsp">
</forward>
</global-forwards>


<action-mappings>
<action path="/Welcome"
type="org.apache.struts.actions.ForwardAction"
</action>
<action type="cad.action.ListarAction"
path="/listar">
<forward name="sucesso"
path="/jsp/lista.jsp">
</forward>
</action>
<action type="cad.action.CadastreAction"
path="/cadastre"
name="cadastreForm"
Scope="request"
validate="true"
Input="/jsp/cadastro.jsp">
<forward name="sucesso"
path="/jsp/sucesso.jsp">
</forward>
</action>
</action-mappings>
...
Listagem 3 – O struts-config.xml
3.6.5 Configuração do Application.properties
O framework Struts fornece um sistema de mensagem capaz e flexível. O
texto para as mensagens é armazenado em um arquivo Java Properties
(Java.util.Properties), que é um arquivo texto simples com par de chaves-valor em
cada linha [32]. O Struts foi internacionalizado completamente para que o processo
de construir uma aplicação possa ser adaptada às várias línguas e regiões.
A listagem 1.4 mostra parte do arquivo application.properties utilizado na
aplicação.
//...
# -- Customizadas --
index.title= Aplicação Simples de Struts.
application.name=Cadastro de Usuário.
errors.sqlerror=<li>Um erro genérico de SQL ocorreu.
errors.title=Os Seguintes Erros Foram Encontrados.
errors.nome=O Nome é requerido.
errors.email=O Email é requerido.
errors.login=O Login é requerido.
Errors.senha1=A Senha de Acesso é requerida.
Errors.senha2=Confirme Sua Senha.
errors.alerta=<script language="javascript">alert('Senha de Acesso
Diferente da Confirmação!');</script>
//...
Listagem 4 - O arquivo applicatio.properties
3.6.6 As páginas JSP
Os formulários HTML são construídos utilizando bibliotecas de tags
específicas do Struts. A Listagem 1.5 mostra o formulário que aparece o navegador
como na Figura 19(a).

<%@ taglib uri="/WEB-INF/struts-bean.tld" prefix="bean" %>

<%@ taglib uri="/WEB-INF/struts-html.tld" prefix="html" %>
//...
<body bgcolor="white">
<html:form action="/cadastre">
<h2><bean:message key="application.name"/></h2>
<p>Nome:<html:text property="nome"/>
<html:errors property="nome"/>
<p>Email:<html:text property="email"/>
<html:errors property="email"/>
<p>Login de Acesso:<html:text property="login"/>
<html:errors property="login"/>
<p>Senha de Acesso:<html:password property="senha1"/>
<html:errors property="senha1"/>
<p>Confirme a Senha:<html:password property="senha2"/>
<html:errors property="senha2"/>
<html:errors property="alerta"/>
<p><html:submit value="Cadastrar"/><html:reset value="Limpar"/>
</html:form>
...
Listagem 5 - Formulário que aparece o navegador
A distribuição do Struts inclui quatro bibliotecas de tags principais descritas
abaixo:
• As tags bean são úteis para acessar os JavaBean e suas propriedades, assim
como definir novos componentes.
• As tags html são usadas para criar formulários de entrrada HTML que podem
interagir com o framework Struts e as tags HTML afins.
• As tags logic são para gerenciar a geração condicional de saída, fazer um
loop nas coleções de objetos para exibi-lás e o gerenciamento do fluxo da
aplicação.
• As tags nesting fornencem capacidades de aninhamento melhoradas para as
outras tags Struts.
A Listagem 1.6 mostra a página de erro que exibida no navegador como na
Figura 19(c).
<%@ taglib uri="/WEB-INF/struts-bean.tld" prefix="bean" %>

...
<body bgcolor="white">
<br>
<bean:message key="errors.title"/>:
<br>
<html:errors/>
<br>
<html:link page="/index.jsp">Retornar para o Formulário.</html:link>
</body>
…
Listagem 6 – Página de erro exibida no navegador
A Listagem 1.6 mostra a página de sucesso que exibida no navegador como
na Figura 19(d).
<%@ taglib uri="/WEB-INF/struts-html.tld" prefix="html" %>
...
<body bgcolor="#FFFFFF">
<HR><h2>Cadastro Realizado com Sucesso!!!</h2>
<%
request.getSession().getAttribute("usuario");
%>
<HR>
<html:link page="/index.jsp">Retornar para o Formulário.</html:link>
</body>
</html>
Listagem 7 – Página de sucesso exibida no navegador

Capítulo 4 – Especificação do Projeto de e-commerce 49
CAPÍTULO 4
ESPECIFICAÇÃO DO PROJETO DE E-COMMERCE
4.1 Visão Geral
Este projeto tem por objetivo construir a especificação de um carrinho de
compras para o site de e-commerce de uma livraria, possibilitando aos clientes
negociar bens e serviços a qualquer hora, ultrapassando as barreiras do tempo e da
distância. Utilizando uma infra-estrutura de comunicações adequada, um usuário
através de um browser fará solicitações que serão repassadas e processadas por
um servidor J2EE e em seguida, serão retornadas adequadamente para o cliente.
Utilizando a notação UML (Unified Modeling Language) [33] para representar
os componentes de serviços especificados neste projeto, é apresentado na Figura
21, o diagrama de casos de uso do carrinho de compras. Este diagrama descreve
uma seqüência de passos e interação entre o usuário e o sistema, sendo uma
ferramenta essencial na captura de requisitos e no planejamento e controle de um
projeto [33]. Como este diagrama representa apenas uma visão externa do sistema,
é de fácil entendimento tanto por um especialista quanto pelo usuário, servindo
também como meio de comunicação entre eles.
Devido às limitações de tempo, este projeto de comércio eletrônico,
concentrou-se somente na funcionalidade de carrinho de compras.

Figura 21 – Diagrama de Casos de Uso carrinho de compras.
Os seguintes passos serão necessários para que o cliente utilize o carrinho
de compras do site de e-commerce.
1) Através da URL (http://localhost:8080/catalogo) o cliente acessa o
catalogo de produtos;
2) Após acessar o catálogo, o cliente poderá acessar o carrinho de compras,
que estará vazio, ou adicionar um item a este;
3) Ao acessar ou adicionar itens ao carrinho de compras, o cliente poderá
atualizá-lo através das ações: limpar o carrinho, remover itens ou através
do botão “atualizar”.
O diagrama, apresentado na Figura 21, descreve as funções essenciais
desempenhadas pelo carrinho de compras. No entanto, cada caso de uso realiza
uma função específica e bem definida, os quais serão detalhadas abaixo:

Casos de Uso do Carrinho de Compras:
Acessar Catalogo de Produtos
Breve Descrição:
O cliente, através de um browser, acessa o catálogo de produtos.
Ator Principal:
Cliente
Pré-condições:
Nenhuma pré-condição especial é requerida.
Fluxo Principal:
1. O cliente acessa o catálogo de produtos através da URL
http://localhost:8080/catalogo/index.jsp.
2. O sistema reconhece a solicitação de acesso ao catálogo de produtos e
retorna uma página jsp (catalogo.jsp) para a exibição do catálogo.
Fluxo Alternativo e Exceções:
Não é aplicável.
Pós-condições:
1. O sistema retorna ao cliente o catálogo de produtos.
Requisitos Funcionais (RF):
RF1 – Carregar os produtos do banco de dados de dados para exibir a página
catalogo.jsp.
Requisitos Não – Funcionais (RNF):
RNF1 – O sistema não reconhecerá a solicitação de acesso ao catálogo de
produtos caso o cliente digite a URL erroneamente, acarretando em uma mensagem
de página não encontrada.
RNF2 – A interface de exibição será o browser de navegação na Internet.
Regras de Negócio:
RN1 – Catálogo de Produtos
Figura 22 – Tela que representa o Caso de Uso “Acessar Catalogo de Produtos”
Adicionar Item ao Carrinho de Compras
Breve Descrição:
O cliente ao acessar o catálogo de produtos poderá adicionar itens ao
carrinho de compras.
Ator Principal:
Cliente
Pré-condições:
O cliente deve estar com acesso ao catalogo de produtos, ou seja, deve ter
acessado a página catalogo.jsp.
Fluxo Principal:
2. O cliente poderá adicionar itens ao carrinho de compras clicando no botão
“comprar”.
3. O sistema ira adicionar o item e exibir o carrinho de compras listando todos os
itens adicionados.
Não aplicável.
Pós-condições:
1. O sistema retorna ao cliente a exibição do carrinho de compras com todos os
itens adicionados.
RF1 – Carregar os produtos do banco de dados de dados para exibir a página
catalogo.jsp.
Regras de Negócio:
RN2 – Botão “Comprar”.
Figura 23 – Tela que representa o Caso de Uso “Adicionar Item ao Carrinho de Compras”
Acessar Carrinho de Compras
Breve Descrição:
O cliente poderá acessar o carrinho de compras e verificar o seu conteúdo.
Ator Principal:
Cliente
Pré-condições:
Nenhuma pré-condição especial é requerida.
Fluxo Principal:
2. O cliente poderá acessar o carrinho de compras clicando no botão “acessar
carrinho”.
3. O sistema reconhece a solicitação de acesso ao carrinho de compras e
retorna uma página jsp (carrinho.jsp) para exibição do carrinho.
2.1. O cliente poderá acessar o carrinho de compras quando este estivar vazio.
2.2. O cliente poderá acessar o carrinho de compras adicionando um item a este.
Pós-condições:
2. O sistema retorna ao cliente o carrinho de compras.
RF1 – Direcionar a ação do botão “acessar carrinho” para invocar a página
carrinho.jsp.
Regras de Negócio:
RN2 – Botão “Acessar Carrinho”.
RN3 – Botão “Comprar”.
Figura 24 – Tela que representa o Caso de Uso “Acessar Carrinho de Compras”
Atualizar Carrinho de Compras
Breve Descrição:
O cliente poderá atualizar o conteúdo do seu carrinho de compras, alterando

a quantidade de itens adicionados, removendo um item ou limpando o carrinho.
Ator Principal:
Cliente
Pré-condições:
1. Para atualizar o carrinho de compras o cliente terá que adicionar itens a este.
2. O cliente terá que alterar a quantidade de itens adicionados, remover itens ou
limpar o carrinho de compras, para que este seja atualizado.
Fluxo Principal:
1. O cliente requisita acesso ao carrinho de compras clicando no botão
“acessar carrinho” ou adicionando itens a este.
2. O cliente poderá atualizar o carrinho de compras clicando no botão
“atualizar”.
3. O sistema reconhece a solicitação de atualização e retorna uma página jsp
(carrinho.jsp) com quantidade, itens e valor total atualizados.

Não aplicável.
Pós-condições:
1. O sistema retorna ao cliente o carrinho de compras atualizado.
RF1 – Direcionar a ação do botão “atualizar” para invocar a página
carrinho.jsp que será exibida com as devidas atualização.
Regras de Negócio:
RN1 – Botão “acessar carrinho”.
RN2 – Botão “comprar”.
RN3 – Botão “atualizar”.
Figura 25 – Tela que representa o Caso de Uso “Atualizar Carrinho de Compras”

4.2 Diagrama de Classes
Para construir o carrinho de compras foi necessária a utilização de um pacote
já definido e criado pelo projeto Jakarta Struts: org.apache.struts. Este pacote
possui todas as classes do framework struts. A Figura 26 ilustra o diagrama de
classes do carrinho de compras.
CONTROLLER
MODEL
VIEW
Figura 26 – Diagrama de Classes do carrinho de compras

A superclasse Action recebe do controlador as ações que serão
responsáveis por executar a tarefa solicitada pelo usuário. Foram definidas duas
ações: CatalogoAction e CarrinhoComprasAction.
A ação CatalogoAction é invocada para a exibição dos produtos. Seu
método execute() recupera os produtos do banco de dados, representado pela
classe CatalogoDAO, e os insere em uma listagem para criar o catálogo de
produtos. A página index.jsp é invocada pelo usuário e redireciona a solicitação
para a página catalago.jsp, exibindo a listagem de produtos e permitindo a inserção
de itens no carrinho. Nela recuperamos os produtos cadastrados listando-os com
seus respectivos atributos.
A ação CarrinhoComprasAction é invocada todas as vezes que se insere
um item ao carrinho de compras ou acessa-o com o status de vazio. Na inserção de
um item ao carrinho a pagina carrinho.jsp será exibida com um novo produto. Na
página carrinho.jsp é possível remover itens alterar quantidades e limpar o
carrinho.
Dicionário de Dados:
CarrinhoCompras
Esta classe representa o carrinho de compras para armazenar os produtos
adicionados pelo cliente.
Métodos: CarrinhoCompra(), adicionaItem(item), atualizaQuantidade(),
removeItem(), limparCarrinho(), getTamanho(), getItensCarrinho(),
getPrecoTotal() e recalcularPrecoTotal().
Atributos: precoTotal, ItensCarrinho: ArrayList.

ItemCarrinho
Esta classe representa os produtos que foram inseridos no carrinho.
Métodos: ItemCarrinho(), getItemId(), getProdutoId(), getNome(), getPreco(),
getQuantidade(), setQuantidade(), getImagem(), setImagem() e
getPrecoItemTotal().
Atributos: imagem, itemId, nome, preço, produtoId, quantidade.
Produto
Esta classe representa os produtos que serão visualizados no catalogo.
Métodos: Produto(), getProdutoId(), setProdutoId(), getNome(), setNome(),
getDescrição(), setDescrição(), getPreco(), setPreco(), getImagem() e
setImagem().
Atributos: produtoId, nome, descrição, imagem e preco.
4.3 Diagrama de Seqüência
O diagrama de seqüência expõe o aspecto do modelo que enfatiza o
comportamento dos objetos em um sistema, incluindo suas operações, iterações,
colaborações e histórias de estado em seqüência temporal de mensagem e
representação explícita de ativação de operações [33]. Os objetos são desenhados
como linhas verticais, as mensagens como linhas horizontais e a seqüência de
mensagens é lida de cima para baixo na página.
Para acessar o catálogo de produtos, o cliente deverá interagir com o sistema
através de um browser onde inicialmente fará uma solicitação http através de uma
URL (http://localhost:8080/catalogo.do) de acesso ao catalogo. O catalogo.do no
final da URL, será usado para invocar o ActionServlet que receberá a solicitação
HTTP e chamará a classe CatalogoAction, que através do método execute()
instanciará o método de negócio. A classe Action irá definir qual página JSP será
exibida. Baseado na definição da classe Action, o ActionServlet receberá um
forward (redirecionamento) sobre qual página JSP apresentará os dados. O
ActionServlet encaminhará a página JSP a ser exibida (catalogo.jsp), montando
assim o carrinho de compras que será visualizado pelo cliente. A Figura 27 ilustra o
referido diagrama do carrinho de compras do sistema de e-commerce.
Figura 27 – Diagrama de seqüência carrinho de compras

Capítulo 5 – Estudo de Caso 61
CAPÍTULO 5
ESTUDO DE CASO
5.1 Cenário inicial do protótipo desenvolvido
Para o desenvolvimento do protótipo carrinho de compras para o site de e-
commerce de uma livraria, foi utilizada uma máquina cliente web para acessar por meio
da Internet uma outra máquina servidora, que possui como infra-estrutura o framework
Struts utilizando os componentes J2EE, um container web responsável por gerenciar a
execução destes componentes e um gerenciador de banco de dados, contendo as
informações dos produtos oferecidos pelo site. A Figura 28 ilustra o cenário de uso
acima descrito.
Rede BD
Servidor Banco de
Cliente
Dados
Figura 28 – Cenário utilizado no desenvolvimento do protótipo.

5.2 Softwares Utilizados
5.2.1 Cliente
Na máquina cliente, foi utilizada a ferramenta Eclipse [35] para a edição e
construção das classes e arquivos referentes à aplicação de e-commerce. É um
software gratuito disponível em home page especifica [35]. A Figura 29 ilustra a tela de
edição de código do Eclipse.
Figura 29 – Tela de edição do Eclipse

5.2.2 Servidor
Na máquina servidora cada componente J2EE é implantado no seu devido
container. Para os componentes web foi utilizado o Tomcat do projeto Jakarta Apache
[34]. O Tomcat simplifica a criação de classes Java recompilando-o e carregando-o
automaticamente quando o arquivo de origem é alterado. Desta forma, isto agiliza o
trabalho do desenvolvedor que se limita apenas a editar o código da página JSP, o
JavaBean e atualizar o browser. É um software gratuito e disponível no site da Apache
[34]. A Figura 30 ilustra este container web executando.
Figura 30 - Tomcat executando
5.2.2 Banco de Dados
As informações dos produtos oferecidos pelo site foram armazenadas no
software de banco de dados SQL Server da Microsoft (poderia ser utilizado qualquer
outro banco de dados), instalado na máquina servidora. A Figura 31 ilustra o
gerenciador do SQL Server.
Figura 31 - Gerenciador do SQL Server
5.3 Cenário de Uso do Protótipo
O protótipo carrinho de compras está dividido de acordo com o padrão MVC da
seguinte maneira:
Controller
Em uma aplicação em camadas, todas as solicitações para as páginas ou dados
passam pela camada de controle. A Tabela 5 descreve as exigências do controlador
para o projeto de e-commerce.
Classes Actions Especificação

CarrinhoComprasAction.java Ação responsável por gerenciar o carrinho de
compras.
CatalogoAction.Java Ação responsável por gerar o catálogo de produto.
Tabela 5 – Arquivos de controle do projeto de e-commerce.
A Figura 32 ilustra as classes Action da camada controller do modelo MVC.
Struts-config.xml
Figura 32 – Representação das Classes Action no modelo MVC.
Model
A Tabela 6 descreve as exigências para camada de acesso a dados do modelo
MVC para a aplicação de e-commerce.
Objetos de Modelo (JavaBeans) Especificação

CarrinhoCompras.java JavaBean do carrinho de compras
CatalogoDAO.java Modelo de Acesso ao banco de dados.
ItemCarrinho.Java JavaBean do item do carrinho de compras.
Produto.java JavaBean do produto.
Tabela 6 – Arquivos de modelo do projeto de e-commerce.
A Figura 33 ilustra as classes de acesso a dados da camada modelo.

BD
Figura 33 – Representação dos arquivos de modelo no MVC.
View
A camada de visão do modelo MVC é representada pelas páginas JSP’s que
definem as partes visíveis da aplicação. A Tabela 7 descreve as exigências para a
camada de visão (apresentação) dos dados da aplicação de e-commerce.
JavaServer Pages Especificação
Carrinho.jsp Retorna o carrinho de compras com os devidos itens

adicionados ou vazio.
Catalogo.jsp Retorna a listagem de produtos e permite a inserção
de itens no carrinho.
Index.jsp Direciona a solicitação do usuário ao
ServletController
Tabela 7 – Arquivos de visualização do projeto de e-commerce.
A Figura 34 ilustra as páginas JSP’s que representam a camada de visão do
modelo MVC para a aplicação de e-commerce.

Figura 34 – Representação das páginas JSP’s
Passos realizados
Para o melhor entendimento considera-se a cada passo realizado, a ação
descrita em “vermelho”.
Passo 1: Iniciar a aplicação
O cliente utilizando o browser instalado na sua máquina acessa o endereço
http://localhost:8080/catalogo/index.jsp. A Figura 35 ilustra o acesso do cliente,
através do browser, ao servlet controller (ActionServlet).
”index.jsp”
Figura 35 – Acesso do cliente ao servlet controller
Passo 2: Mapear o servlet controller do Struts
Após a solicitação do cliente, o servlet controller do Struts é mapeado para
carregar as configurações do arquivo struts-config.xml. A Figura 36 ilustra o
mapeamento do servlet controller.

carrega
”index.jsp”
Figura 36 - Mapeamento do servlet controller
Passo 3: Acessar a classe Action
Baseado no fluxo definido no arquivo struts-config.xml, e que neste momento já
se encontra carregado em memória, o ActionServlet invoca a classe CatalogoAction.
A Figura 37 ilustra o ActionServlet invocando a classe CatalogoAction da aplicação.
Carrega
”index.jsp” Invoca
Figura 37 – ActionServlet invocando a classe CatalogoAction

Passo 4: Acessar a camada de negócio
A classe CatalogoAction passará pelo método execute que irá delegar a
requisição para a camada de negócio (Model) A Figura 38 ilustra a classe
CatalogoAction acessando a camada de negócio.
Carrega
Chama os
”index.jsp” Invoca Javabeans
Figura 38 – Classe CatalogoAction acessando a camada de negócio
Passo 5: Acessar banco de dados
A classe CatalogoDAO representa a camada de negócio. Ela popula os
Javabeans com as informações dos produtos armazenados no banco de dados. O
resultado da execução deste processo (objetos já populados) é usado na camada de
apresentação para exibir os dados. A Figura 39 ilustra o acesso ao banco de dados.

BD
Carrega Acessa
Chama os
”index.jsp” Invoca Javabeans
Figura 39 – Acesso ao banco de dados
Passo 6: Retornar à classe Action
Quando o controle do fluxo da aplicação voltar à classe CatalogoAction que
invocou o processo da camada de negócio, será analisado o resultado, e definido qual
o mapa adotado para o fluxo da aplicação. Neste ponto, os objetos que foram
populados na camada de negócio serão "atachados" como atributos na seção do
usuário. A Figura 40 ilustra a volta do controle do fluxo da aplicação à classe Action.
BD
Acessa
Carrega
Chama os
Javabeans
”index.jsp” Invoca
Volta para
Action
Figura 40- Volta do controle do fluxo da aplicação à classe Action

Passo 7: Retornar ao controller (ActionServlet)
Baseado no mapeamento feito pela classe CatalogoAction, o Controller
(ActionServlet) faz um forward para o catalogo.jsp. A Figura 41 ilustra o retorno ao
ActionServlet,
BD
Acessa
Carrega
Chama os
Invoca Javabeans
”index.jsp”
Volta ao Volta para

ActionServlet Action
Figura 41 – Retorno à classe ActionServlet
Passo 8: Montar JSP
Na camada de apresentação (View), os objetos que foram "estabelecidos" como
atributos da sessão do usuário serão consultados para montar a página catalogo.jsp
para o browser como mostra a Figura 42.

BD
Acessa
Carrega
Chama os
Invoca Javabeans
”index.jsp”
Volta ao Volta para

ActionServlet Action
Monta
Usa objetos
Figura 42 – Montar página JSP
Passo 9: Exibir a página JSP
A tela principal do e-commerce é exibida como resposta requisitada pelo usuário.
Como ilustra a figura 43.
BD
Acessa
Carrega
Chama os
Invoca Javabeans
“index.jsp”
Volta ao
Volta para
ActionServlet
Action
Monta
Exibi “catalogo.jsp” Usa objetos
Figura 43 – Exibir tela principal

A tela principal exibe um catálogo dos produtos disponíveis e inclui informações
como preços, descrições e imagens.
Neste estudo de caso, utilizamos um conjunto de livros, obtidos diretamente de
uma base de dados criada. As operações que podem ser executadas no catálogo são:
a inserção de um livro no carrinho de compras e acessar o carrinho para visualizar os
produtos já escolhidos. A Figura 44 ilustra a tela principal apresentando o catálogo de
livros.
Figura 44 – Tela principal do e-commerce com carrinho de compras vazio
Assim, o cliente poderá navegar pelo site e escolher os livros desejados.

Passos para o Carrinho Compras
Passo 1: Inserindo livros no carrinho de compras
Na tela principal encontramos, abaixo de cada livro, um botão “Comprar” para
adicioná-lo ao carrinho. Ao clicar no botão, o carrinho de compras será exibido com o
novo item de livro incluído o se o livro já estiver no carrinho, sa quantidade será
incrementada.
Passo 2: Acessando o carrinho de compras
Podemos acessar o carrinho de compras a partir da tela principal clicando sobre
o link “Carrinho” no menu, clicando sobre o ícone do carrinho o como citado no passo
três (1), quando inserimos livros no carrinho de compras. Na Figura 45 notamos o ícone
do carrinho de compras da tela principal.
Figura 45 – Ícone do carrinho de compras
No carrinho de compras encontra-se a identificação dos livros, sua quantidade e
imagem. As possíveis operações que podem ser feitas no carrinho são: voltar ao
catálogo de livros, remover um livro, atualizar ma quantidade e limpar o carrinho. No
carrinho é exibido o total da compra, mas omitimos dados como valores de frete e de
descontos, por simplicidade. A figura 46 ilustra o carrinho de compras com itens
inseridos pelo cliente.
Figura 2
Figura 46 – Carrinho de compras com item selecionado pelo cliente

Capítulo 6 – Considerações Finais & Trabalhos Futuros 76
CAPÍTULO 6
CONCLUSÕES E TRABALHOS FUTUROS
6.1 Contribuições
O objetivo deste trabalho foi desenvolver um protótipo de um carrinho de
compra de um site de e-commerce utilizando o web framework Jakarta Struts, que
adota as tecnologias J2EE como base para o desenvolvimento de aplicações web.
Para a elaboração deste projeto, foi feito um estudo sobre os tipos de e-
commerce (B2B e B2C), a plataforma J2EE e o web framework Struts.
As pesquisas realizadas sobre as ferramentas, frameworks, tecnologias e
arquiteturas envolvidas nesse assunto, são as principais contribuições deste
trabalho. Contribui de forma direta para os alunos, como material de estudo e para
empresas que desejam também disponibilizar seus serviços para a internet, obtendo
maiores lucros, tornando-se mais competitivas e reduzindo consideravelmente os
seus custos, devido a melhoria da produtividade, da qualidade e manutenibilidade
que o Struts traz para aplicações coorporativas.
Para o desenvolvedor iniciante, este trabalho facilitará muito seu aprendizado
do framework Struts e irá colocá-lo rapidamente em atividades em seus próprios
projetos. Mas, mesmo o desenvolvedor mais experiente certamente aprenderá algo
novo lendo este trabalho.

6.2 Limitações
A principal limitação deste trabalho foi a grande dificuldade inicial de entender
o funcionamento do framework Struts. A Figura 47 ilustra o grau de dificuldade em
relação ao tempo, encontrado em entender o framework Struts e implementá-lo
neste projeto.
Grau de
Dificuldade
100%
80%
60%
40%
20%
0%
1°Trim. 2°Trim. 3°Trim. 4°Trim. Ano 2004
Figura 47 – Grau de dificuldade do Struts X Tempo Aprendizado
Nesse projeto de e-commerce, foi implementado e detalhado apenas a
funcionalidade carrinho de compras faltando ainda funcionalidades como: cadastro
de clientes, formas de pagamento, busca de produtos, entre outras.
A funcionalidade carrinho de compras utiliza apenas consultas ao banco de
dados, com isso a camada de negócios foi apresentada de forma bastante
simplificada.
O estudo apresentado no trabalho concentrou-se bastante na implementação
do projeto utilizando as tecnologias J2EE integradas ao framework Struts sem que
fosse dada ênfase a outras tecnologias tais como: EJB e webservices.

6.3 Trabalhos Futuros
Como trabalhos futuros relacionados ao tema exposto, podem ser
destacados:
1. Finalizar o projeto de e-commerce adicionando outras funcionalidades, como:
cadastro de clientes, formas de pagamento, busca de produtos, entre
outras;
2. Implementar o projeto de e-commerce utilizando outras web frameworks;
3. Utilizar na camada de modelo a tecnologia EJB;
4. Integração do projeto de e-commerce com a tecnologia webservices;

REFERÊNCIAS BIBLIOGRÁFICAS 79
REFERÊNCIAS BIBLIOGRÁFICAS
[1] SAMPAIO, A. B. C.; “Oportunidades e Modelos de Negócios na Web”.
Disponível em: http://www.unama.br/PRINCIPAL/creditos/abc/disciplinasgrad/
disciplinas_gradTecWeb.html.
[2] SOUZA, Welington B.; “Manual Básico de Struts”. Disponível em:
http://www.jspbrasil.com.br/jsp/artigos/artigo.jsp?idArtigo=0007.
[3] LIMA, Gleydson; “Frameworks para Desenvolvimento Web”. Disponível em:
http://www.jspbrasil.com.br/jsp/artigos/artigo.jsp?idArtigo= 0002
[4] COSTA, Marcelo Ribeiro; “Struts - Tutorial introdutório”. Disponível
em:http://www.portaljava.com.br/home/modules.php?name=Content&pa=
showpage&pid=6&page=1.
[5] YURI, Flavia; “O e-commerce caiu no chat”. Disponível em: http://www.e-
commerce.org.br/Artigos_Sua_Empresa/O_e-commerce_caiu _no_chat.htm.
[6] WIDEBIZZ, Luiz Edmundo; “ABAIXO O BUSINESS PLAN!!”. Disponível em:
http://www.e-commerce.org.br/Artigos_Sua_Empresa /Abaixo_o_ business _plan
htm.
[7] SCHAFER, Maria; “O comandante das pontocom”. Disponível em: http://
www.e-commerce.org.br/Artigos_Sua_Empresa /Abaixo_o_business_plan .htm.
[8] ”Mais da metade dos internautas nos EUA compra on-line”; Disponível em:
http://www.ecommerce.org.br/Artigos_Mercado/Mais_da_ metade_dos_internautas
_americanos_compra_on-line.htm. Fonte:IDG now.
[9] “E-COMMERCE? E-BUSINESS? E-O QUÊ?”; Disponível em: http:// www.e-
commerce.org.br/Artigos_Geral/ecommerce_ebusiness.htm. Fonte: IDG now

[10] REGGIANI, Lucia; “Todo Poder ao E-Commerce”, INFO EXAME. São
Paulo: Editora Abril, ano 19, nº 218, Maio 2004.
[11] NEVES, Fernando Charles Benigno. “O Comércio Eletrônico e os seus
Benefícios em Empresas na Cidade de Belém”. 2002. 12-14p (Dissertação de
Mestrado em Administração). Universidade da Amazônia.
[12] SILVA, Flavio Cezar Massoud Salame. “O Comércio Eletrônico entre
Empresas”. 2000. 15-17p (Monografia para Especialização em Engenharia de
Produção). Universidade da Amazônia.
[14] NAKAMURA, Rodolfo Reijiro; “E-Commerce na Internet – Fácil de
Entender”, 8ª edição, 2001.
[15] CÂMARA, M. A. R.; VALENTIM, N.G.; COSTA, T.V.V.; ”Construção de
Aplicações Wirelless para a WEB”. 2003. (Trabalho de Conclusão do Curso de
Bacharelado em Ciência da Computação). Universidade da Amazônia.
[16]CORTÉS, M. I., REZENDE, L. J.;”Uso de Frameworks em Processos e
Regras de Negócios: Estratégia para Reuso e Aprimoramento”; Disponível
em: http://www.cce.puc-rio.br/informatica/frameworks.htm
[17] ALBERTIN, Alberto. Luiz. Comércio Eletrônico: Modelo, Aspectos e
Contribuições de sua Aplicação. 2. ed. São Paulo: Editora Atlas, 2000a.
[18] AZEVEDO, Jovane Medina. Metodologia para um Modelo Flexível de
Cadeia de Abastecimento Utilizando o Comércio Eletrônico como Vantagem
competitiva. 2002. 87 fls. Anteprojeto de Tese (Doutorado em Engenharia de
Produção) – Programa de Pós-Graduação em Engenharia de Produção,
Universidade Federal de Santa Catarina, Florianópolis.

[19] TURBAN, Efrain, et al. ELetronic Commerce: a Managerial Perspective. New
Jersey: PHI, 1999.
[20] BIRMAN, Fernando; “E-Commerce – Tutorial”; Disponínel em:
http://www.sit.com.br/SeparataECO0007.htm
[21] DEITEL, H. M, et al. E-business e e-commerce para administradores. São
Paulo: Editora Pearson Education do Brasil, 2004.
[22] NELSON, Anne, et al. Building Eletronic Commerce With Web Database
Constructions. New York: Editora Addison – Wesley, 2002.
[23] “Internet Comercial”; Disponível em: http://www.mct.gov.br/Temas/info/
Pesquisas/Conceitos.pdf
[24] ROCHA, Helder da; "Introdução a J2EE e servidores de aplicação EJB";
Disponível em: http://www.argonavis.com.br
[25] BODOFF, Stephanie, et al. Tutorial do J2EE. SãoPaulo: Editora CAMPUS,
2002
[26] “Design Patterns Fundamentais do J2EE”; Disponível em:
http://www.fundaopro.br
[27] Johnson, Ralph E.; Russo, Vincent. Reusing Object-Oriented Designs.
Relatório Técnico da Universidade de Illinois, UIUCDCS 91-1696, 1991.
[28] Coad, Peter. Object-Oriented Patterns. Communications of the ACM, V.
35, nº9, p. 152-159, setembro 1992.
[29] Johnson, Ralph E.; Foote B. Designing Reusable Classes. Journal of
Object Oriented Programming JOOP, 1(2):22-35, Junho/Julho 1988.

[30] MALDONADO, José Carlos et al; Padrões e Frameworks de software. Local:
São Paulo: Universidade de São Paulo, Disponível em: http://www.icmc.sc.usp.br/
~rtvb/apostila.pdf . Data de acesso: 25/08/2004.
[31] Macoratti, José Carlos; Padrões de Projeto : O modelo MVC - Model View
Controller, Disponível em: http://www.macoratti.net/vbn_mvc.htm
[32] HUSTED, Ted et al; Struts em ação. Local: Rio de Janeiro: Editora Ciência
Moderna Ltda, 2004
[33] Furlan, Jose Davi; Modelagem De Objetos Atraves Da UML-The Unified
Modeling Language. Editora Makron Books, 1998.
[34] Disponível para download em:http://jakarta.apache.org/tomcat/index.html
[35] Disponível para download em: http://www.eclipse.org
[36] Bond, Martin et al; Aprenda J2EE em 21 dias: com EJB, JSP, SERVLETS,
JNDI, JDBC E XML. Editora: MAKRON BOOKS, 2003.
[37] Todd, Nick et al; JAVASERVER PAGES: Guia do Desenvolvedor. Editora:
CAMPUS, 2003.

Web Framework Jakarta Struts Aplicado No E-Commerce

Загружено:

Сведения о документе

Оригинальное название

Авторское право

Доступные форматы

Поделиться этим документом

Поделиться или встроить документ

Параметры публикации

Этот документ был вам полезен?

Это неприемлемый материал?

Авторское право:

Доступные форматы

Web Framework Jakarta Struts Aplicado No E-Commerce

Загружено:

Авторское право:

Доступные форматы

UNIVERSIDADE DA AMAZÔNIA - UNAMA

CENTRO DE CIÊNCIAS EXATAS E TECNOLOGIA - CCET

CURSO DE BACHARELADO EM CIÊNCIA DA COMPUTAÇÃO

Ernani dos Santos Jacob Junior

João Matheus Aracaty Botelho

Marcelo dos Santos Gambôa