Introdução - Projetos

1
UNIVERSIDADE FEDERAL DE SANTA CATARINA - UFSC
Desenvolvimento da Camada de Persistência
do Projeto SIAP-F
Trabalho de Conclusão de Curso
apresentado ao Curso de Bacharelado
em Sistemas de Informação da
Universidade Federal de Santa Catarina
como requisito parcial para obtenção do
grau de bacharel em Sistemas de Informação
Orientador: Prof. Leandro J. Komosinski, Dr.
Florianópolis
2005
HENRIQUE SCHAEFER
VITOR FERREIRA ISAIA
2
Framework para um Sistema de
Acompanhamento de Pedidos - SIAP-F
Florianópolis, 31 de Maio de 2005.
BANCA EXAMINADORA
______________________________
Prof. Leandro J. Komosinski
Universidade Federal de Santa Catarina
Orientador
_______________________________
______________________________
Prof. Frank Augusto Siqueira
Prof. Aline de França Abreu
Universidade Federal de Santa Catarina
Universidade Federal de Santa Catarina
SUMÁRIO
1. Introdução ............................................................................................................ 6
1.1. Objetivos do Trabalho ...................................................................................... 6
1.1.1. Objetivo Geral ................................................................................................ 7
1.1.2. Objetivos Específicos..................................................................................... 7
3
1.3. Justificativa do Trabalho ................................................................................... 7
1.4. SIAP-F Visão geral ........................................................................................... 8
1.4.1 O Padrão MVC ............................................................................................... 8
1.4.2 A Estrutura ...................................................................................................... 9
2. Estado da Arte ................................................................................................... 12
2.1. Soluções existentes no mercado .................................................................... 12
3. Solução Proposta............................................................................................... 20
3.1. Pizzaria........................................................................................................... 20
3.2. Análise Orientada a Objetos........................................................................... 21
5. A Estrutura da camada de persistência ............................................................. 22
5.1 Abordagem Entidade Relacionamento ............................................................ 22
5.2 Definição das Classes da camada de Persistência ......................................... 22
5.3 A Tecnologia Hibernate ................................................................................... 24
6. Tecnologias Auxiliares ....................................................................................... 26
6.1 Log4j ............................................................................................................... 26
6.2 Ant ................................................................................................................... 26
6.3 CVS ................................................................................................................. 27
6.4 Jakarta Tomcat ................................................................................................ 27
7. Conclusão .......................................................................................................... 29
7. Bibliografia ......................................................................................................... 30
Lista de Siglas.
XML: eXtensible Markup Language
J2EE: Java 2 Platform, Enterprise Edition
J2SE: Java 2 Platform, Standard Edition
SGBD: Sistema gerenciador de Banco de Dados
HTTP: HyperText Markup Language
MVC: Model, View e Controller
JVM: Java Virtual Machine
HQL: Hibernate query language
4
Resumo
No presente trabalho apresenta-se uma solução de camada de persistência objetorelacional em Java, para o framework de acompanhamento de pedidos SIAP-F. O
framework foi projetado para atender desde pequenos negócios até grandes linhas de
montagens, fornecendo informações de cada etapa do pedido, para acompanhamento
via web. Foi utilizada a arquitetura de 3 camadas (apresentação, lógica e persistência),
para que a identificação dos papéis dentro do framework ficasse totalmente clara.
PALAVRAS-CHAVE: PERSISTÊNCIA DE DADOS, JAVA, HIBERNATE,
ACOMPANHAMENTO DE PEDIDOS.1. INTRODUÇÃO
Em várias organizações a relação entre cliente e empresa o processo de compra de um
produto ou serviço passa pelo ciclo escolher o produto ou serviço a ser comprado,
fazer o pedido, aguardar o pedido ou serviço ficar pronto e, finalmente, receber o
produto ou serviço.
Para o cliente, uma vez feito o pedido, é importante saber como está andando o seu
pedido, ou seja, em que etapa da produção está e, principalmente, quando ele será
entregue. Para a empresa é importante ter acesso a todas as informações relacionadas
ao processo produtivo, em todas as suas etapas. Pode-se, com isso, produzir diversas
estatísticas sobre a cadeia produtiva. Por exemplo, podem-se identificar gargalos de
produção.
5
De posse de todas as informações é possível melhorar a qualidade no atendimento ao
cliente, fornecendo-lhe informações confiáveis sobre quando o produto ou serviço será
entregue.
1.1. Objetivos do Trabalho
1.1.1. Objetivo Geral
O objetivo deste trabalho é o desenvolvimento da Camada de Persistência do Projeto
SIAP-F, um framework que servirá para agilizar o desenvolvimento de sistemas de
informação que permitam o acompanhamento de pedidos. A intenção é capturar e
implementar os requisitos comuns a grande maioria dos sistema de acompanhamento
de pedidos no que diz respeito a pesistência dos dados, fazendo com que o
desenvolvimento de novos sistemas com esse fim sejam agilizados.
1.1.2. Objetivos Específicos
- Estudar o Pattern MVC;
- Estudar Hibernate;
- Desenvolver duas aplicações como modelo para o framework;
- Desenvolver um framework para sistemas de acompanhamento de pedidos;
6
1.3. Justificativa do Trabalho
No período pré-Internet, o cliente fazia o acompanhamento dos seus pedidos via
inspeção in loco quando possível ou, o mais comum, via telefone. Com a disseminação
da Internet este acompanhamento pode ser feito a partir de qualquer dispositivo
(computador, telefone celular, PDA, etc.) que tenha acesso à Internet.
O desenvolvimento de um sistema próprio ou a compra e personalização de um sistema
existente apresentam problemas. O desenvolvimento de sistemas próprios são inviáveis
pois seu tempo de construção e, consequentemente, custo são grandes. Por outro
lado, os sistemas existentes no mercado são destinados à grandes empresas.
Consequentemente seu custo de personalização e implantação muitas vezes os torna
inviáveis para pequenas e médias empresas.
Uma solução para os problemas levantados é a construção de sistemas de
acompanhamento de pedidos a partir de um framework concebido para este tipo de
problema.
1.4. SIAP-F Visão geral
1.4.1 O Padrão MVC
O padrão MVC foi originado do SmallTalk, e consiste em três elementos: o Modelo, a
Visão e o Controlador, conforme descrito abaixo (CAVANESS, 2002):
7
manipulado e apresentado ao usuário.
o
dos objetos de dados.
o
Controlador: Define a maneira que a interface com o usuário reage às entradas
de um usuário. É o objeto que manipula o Modelo.
Os benefícios trazidos pela utilização do MVC são os seguintes (CAVANESS, 2002):
o Confiabilidade: As camadas de apresentação e de transação têm uma clara
delimitação, o que permite mudar a aparência da aplicação sem recompilar o
código do modelo ou do controlador. Isto permite que alterações na aparência
não afetem a estabilidade do código responsável pela execução de transações.
o Reutilização elevada e adaptabilidade: O MVC permite o uso de múltiplos tipos de
visão, todas acessando o mesmo código no servidor.
o Baixo custo de desenvolvimento e ciclo de vida minimizado: O MVC torna possível
possuir programadores de lógica da aplicação e designers responsáveis por
manter as interfaces com o usuário, aumentando assim a produtividade e a
qualidade do produto final promovida pela especialização das atividades.
o Desenvolvimento rápido: o tempo de desenvolvimento pode ser reduzido
substancialmente porque os programadores do controlador podem focar apenas
em transações, e os designers podem manter seu foco apenas na apresentação.
8
1.4.2 A Estrutura
O projeto SIAP-F é composto por três equipes, assim cada equipe implementa uma
camada segundo o padrão MVC.
A visão ou apresentação é implementada pelo colega Renê Fischer e inicialmente será
desenvolvida para a WEB sendo acessada pelo navegador, observa-se, no entanto que
poderá ser desenvolvida a camada de apresentação tanto para desktop, palm, celulares
e outros, assim que for criada a demanda sem interferir em nada no funcionamento das
demais camadas que não sofrerão nenhuma alteração.
A camada lógica é implementada pelos colegas IIsac Ramos Luz e David Gerson
Ramos de Andrade e é nela que é feito todo o controle do fluxo de dados, a
comunicação entre a camada de apresentação e a da persistência.
Ela é desenvolvida de modo que toda e qualquer modificação nas demais camadas não
afetem o seu funcionamento.
A camada de persistência é implementada pelo nosso grupo e representa o domínio do
problema. O modelo serve para duas principais finalidades: (WALNES):
–
Expor os dados encapsulados pela aplicação, assim como uma lista de produtos
do inventario.
9
–
Permitir que a lógica do negócio seja executada no modelo, assim como a compra
de um produto.
Compreende todos os objetos de negócio onde se implementa a lógica de negócio (o
"how it's done") e onde se deve suportar todos os requisitos e funcionalidades do
sistema. Define o banco de dados a ser utilizado para persistir as informações do
sistema, que até o momento o escolhido foi o MySQL.
Para utilização da camada de persistência estamos utilizando o hibernate que até o
momento é a forma mais apropriada para a implementação, dadas a suas vantagens e
também ao nosso escopo.
1.6. Metodologia
Como metodologia foi definida o desenvolvimento e duas aplicações, bem distintas,
principalmente na quantidade de etapas do pedido, para que pudéssemos observar o
que de comum existe entre essas diferentes aplicações que possam fazer parte do
framework.
A primeira aplicação implementa um sistema mais simples de acompanhamento de
pedidos, com poucas etapas. Foi desenvolvido um sistema para uma pizzaria, que é
composto por 3 etapas para os clientes (pedido efetuado, montando pizza e em
entrega) e em 6 etapas para a própria pizzaria.
1
0 o
A segunda aplicação será realiza posteriormente, quanto também será montado
framework após a análise e constatação das similaridades das duas aplicações.
O framework será desenvolvido conforme os fatos comuns que serão observados nas
duas aplicações e será utilizado XML para a configuração do framework.
1.5 Arquitetura
A arquitetura do projeto SIAP-F é mostrada na figura abaixo, sendo que neste
trabalho trabalharesmos a Camada Persistência.
1
1
1
2
2. ESTADO DA ARTE
Paralelamente ao desenvolvimento, foram realizadas uma série de buscas de
bibliografias e tecnologias com o intuito de auxiliar o desenvolvimento da camada lógica
– denomidada também como Servidor. Com o resultado de tais pesquisas concluiu-se
que é necessário um denso estudo nas principais tecnologias de software de 3
camadas. Entre tais tecnologias são citadas: o Framework Spring, a IDE de
desenvolvimento Eclipse com os plugins para auxílio de implementação, JavaBeans,
alguns Design Patterns como: DTO (Data Transfer Object); Session Façade; a
metalinguagem de marcação XML e a tecnologia JSP baseada em Servlets (o servidor
deve estar preparado para atender requisições a partir do browser).
Estaremos detalhando estas tecnologias a seguir, descrevendo as funcionalidades
utilizadas no desenvolvimento deste projeto.
2.1. Soluções existentes no mercado
Foi realizada extensa pesquisa na internet em busca de soluções existentes no
mercado, gratuita ou não, que se assemelhasse em contexto, problema e proposta de
solução, ao modelo SIAP-F. Esta pesquisa, até o presente momento, não retornou
resultados que pudessem indicar a existência de tais itens.
Em contrapartida algumas soluções comuns foram encontradas relacionadas à área de
acompanhamento de pedidos. Entre as quais podemos citar:
1
1-
3
O acompanhamento tradicional de um site bem conhecido: Submarino.
O acompanhamento é diferenciado de acordo com o tipo de produto
adquirido. Mostramos nas figuras a seguir o acompanhamento mais
completo, que seria de Livros, CDs e DVDs.
(https://www.submarino.com.br/orderstatus.asp).
Figura 1 – Tela de Consulta de Pedidos do Submarino
1
4
Figura 2 – Destaque dos Pedidos selecionados
Nos dois campos circulador na figura 2 podemos ter maiores informações. Através do
STATUS é possível ter um breve relato da última ação tomada. Já através do
ACOMPANHE A ENTREGA pode-se ter detalhadamente o caminho percorrido pelo
produto desde sua origem até o seu destino final.
1
5
Figura 3 – STATUS - Detalhe do Pedido solicitado
1
6
Figura 4 – ACOMPANHE A ENTREGA: Parceria com os Correios
2-
Um kit de loja virtual para quem deseja disponibilizar seus produtos,
oferecido
pela
empresa
Internet
oficial.com.br/222/e-commerce.htm).
Oficial
(http://www.internet-
1
7
Figura 1 – Modelo do kit oferecido pela Internet Oficial
3-
Kit de loja virtual configurável oferecido pela empresa Haven Hosting
(http://www.haven.com.br/loja.html).
1
8
Figura 2- Modelo do kit oferecido pela empresa Haven Hosting
4-
Empresa DigiPix (www.digipix.com.br/duvidas.html) que oferece a
possibilidade de fazer acompanhamento de pedidos fotográficos feitos
através de seu site. E a possbilidade do cliente inserir em sua própria
página um link para pedidos terceirizados de soluções fotográficas.
1
9
Figura 3 – Página de logon para pedido e acompanhamento de pedidos
fotográficos.
3. SOLUÇÃO PROPOSTA
Para facilitar o desenvolvimento do framework foi modelada e desenvolvida uma
pequena aplicação de exemplo: Sistema de acompanhamento de pedidos para uma
pizzaria. Desta forma foi possível identificar entidades que possivelmente farão parte do
framework final.
3.1. Pizzaria
O sistema de acompanhamento de pedidos para a pizzaria trata o típico caso de um
pedido de uma pizza, que é:
2
O cliente telefona para a pizzaria identificando-se com seu número de telefone. 0Com
esta informação o atendente verifica no sistema se o cliente já está cadastrado. Se o
mesmo não estiver, então é realizado o seu cadastramento no sistema, que inclui nome
e telefone.
Após a identificação do cliente o atendente registra o pedido no sistema incluindo qual
pizza o cliente deseja, sendo que o pedido poderá somente conter um produto(pizza)
por vez. Registrado o pedido, o número do mesmo é passado ao cliente para futuro
acompanhamento, onde poderá ser observada a etapa atual do pedido. Nesta consulta
também será possível verificar o tempo restante estimado para a entrega.
Para que o sistema possa ser operado, previamente é necessária a inclusão dos
produtos (pizzas) no banco de dados através do sistema, assim como as etapas que
os compõem. O produto(pizza) possui três etapas na sua produção, as quais são
cadastradas juntamente com o produto. Estas etapas possuem nome e duração, os
quais são informados no seu cadastramento.
3.2. Análise Orientada a Objetos
Com base no texto acima identificamos como grandes candidatas para uso no
framework as entidades Cliente, Pedido, Produto e Etapa que estão melhor
apresentadas abaixo:
2
1
ATÉ O PRESENTE MOMENTO, ESTA É FOI A ANÁLISE OO REALIZADA
PARA O FRAMEWORK. NO PRÓXIMO TRABALHO, EM PROJETOS II,
SERÁ FEITA UMA ANÁLISE MAIS COMPLETA, ALÉM DO PROJETO E
DESENVOLVIMENTO.5. A ESTRUTURA DA CAMADA DE
PERSISTÊNCIA
5.1 Abordagem Entidade Relacionamento
2
2
O armazenamento dos dados da camada de persistência é feito em um banco de dados
relacional. Com isso, a técnica de modelagem dos dados que foi utilizada é a
abordagem entidade-relacionamento. Uma entidade representa um conjunto de objetos
da realidade modelada. Tais entidades possuem relacionamentos entre si, que segundo
o mesmo autor significam a associação entre objetos (entidades) de um banco de
dados.
5.2 Padrões de Projetos Utilizados
Foram utilizados neste trabalho os seguintes padrões de projeto:
o DAO: Data Access Object. De acordo com a Sun (responsável pela tecnologia
JAVA), o padrão DAO adapta uma API específica de acesso a banco de dados a
uma interface genérica de acesso para o cliente. O padrão DAO permite a
mudança do mecanismo de acesso ao banco de dados sem implicar em
alterações no código que usa os dados. No projeto SIAP-F, as classes que
seguem o padrão DAO são aquelas que fazem uso das bibliotecas do Hibernate,
a ser detalhado adiante.
o POJO: Plain Old Java Object. Trata-se de objetos Java comum, sem nenhuma
lógica dentro de seu código. Possuem apenas atributos e seus respectivos
médotos de acesso (getters e setters). No projeto SIAP-F, as classes POJO são
aquelas que estão associadas à tabelas, para a utilização do Hibernate. A
estrutura de cada classe corresponde à estrutura da tabela em que a classe está
associada.
2
3
o Facade: Fachada. É a “porta de entrada” da camada de persistência. Possui todos
os métodos relevantes à camada lógica. Cada método está associado ao objeto
responsável pelo verdadeiro processamento a ser feito, devolvendo ou não um
resultado. É importante ressaltar que não há nenhuma outra implementação da
fachada que não seja a chamada de métodos de outros objetos. No projeto
SIAP-F existe um único facade, chamado de PersistenceFacade, que
implementa a interface IPersistenceFacade.
o Static Factory: Classe com um ou mais métodos que devolvem instâncias de um
objeto. O retorno destes métodos é um objeto instanciado que implementa
determinada interface, a ser utilizada pelo cliente que utiliza a factory. No projeto
SIAP-F existe uma única factory, chamada de PersistenceFactory, que devolve
objetos que implementem a interface IpersistenceFacade.
5.3 Classes Definidas
Os próximos tópicos colocam as classes que foram criadas no desenvolvimento
da persistência.
5.3.1 PersistenceFactory
Sua função é de instanciar a classe que será usada pela lógica no acesso aos serviços
oferecidos pela persistência. Retorna uma instância da classe PersistenceFacade.
Utiliza o padrão Static Factory.
2
5.3.2 IPersistenceFacade
4
Interface que define os serviços oferecidos pela camada persistência. Utiliza o padrão
Facade.
5.3.3 PersistenceFacade
Classe que implementa a interface IpersistenceFacade
5.3.4 BasePOJO
Sua única função é servir de filtro no BaseDAO, para que os métodos insert, delete e
uptade só aceitem como parâmetros objetos que estendam esta classe.
5.3.5 CustomerPOJO
Estende a classe BasePOJO e representa a persistência de um Cliente. Utiliza o
padrão POJO. Seus atributos são: id (identificador), name (nome do Cliente) e
phoneNumber (número do telefone do Cliente).
5.3.6 OrderPOJO
Estende a classe BasePOJO e representa a persistência de um Pedido. Utiliza o
padrão POJO. Seus atributos são id (identificador), customerPOJO (Cliente que fez
este pedido), productPOJO (produto escolhido para este pedido) e stagePOJO (etapa
atual em que o pedido se encontra).
5.3.7 ProductPOJO
Estende a classe BasePOJO e representa a persistência de um Produto. Utiliza o
padrão POJO. Seus atributos são id (identificador), name (nome do produto) e
description (descrição do produto).
2
5
5.3.8 StagePOJO
Estende a classe BasePOJO e representa a persistência de uma Etapa. Utiliza o
padrão POJO. Seus atributos são id (identificador), name (seu nome), durationTime
(duração em minutos da etapa), sequence (a ordem desta etapa) e relatedProduct
(indica de qual produto esta etapa está associada).
5.3.9 IBaseDAO
Interface que define os métodos para operações com o banco de dados, como
inserção, remoção e consulta, entre outros. Utiliza o padrão DAO.
5.3.10 BaseDAO
Classe que implementa a interface IBaseDAO.
5.3.11 IPersistenceController
Interface que define os serviços de processamento existentes na camada de
persistência, como conversão de DTOs para POJOs, formatação de dados, entre
outros.
5.3.12 PersistenceController
Classe que implementa a interface IPersistenceController
5.4 A Tecnologia Hibernate
2
6
Hibernate é um framework que implementa persistência objeto / relacional para Java.
Permite desenvolver classes persistentes em Java, utilizando-se de heranças,
associações, entre outros. Além disso, Hibernate também possui a HQL - Hibernate
Query Language - que não é nada mais que uma extensão a linguagem SQL normal,
adicionando extensões orientadas a objeto.
Hibernate está sobre a licença LGPL, o que significa que ele é um software livre que
pode ser utilizado juntamente com softwares comerciais.
Hibernate lê mapeamentos de arquivos xml. Assim, cada tabela de um sistema possui
um arquivo xml que mapeia seus campos para um JavaBean. Para iniciar o uso do
Hibernate, é necessário criar uma sessão hibernate, que é gerada através da classe
SessionFactory. Essa classe lê os mapeamentos xml e gera a sessão. A partir dessa
sessão, é possível gerenciar os dados dos bancos de dados.
5.4.1 Vantagens
Uma grande vantagem trazida ao mapear bancos de dados relacionais para classes
Java, é a de que o programador não precisa ficar alternando da visão orientada a objeto
para a relacional toda vez que ele vai acessar o banco de dados, pois toda a maneira
de pensar sobre o banco de dados torna-se orientada a objeto.
Hibernate também possui grandes facilidades para realizar queries e buscas - um de
seus métodos simples busca um objeto inteiro da base de dados. Por esses e outros
motivos, ele reduz de uma maneira significativa o tempo de desenvolvimento.
2
7
Para alterar-se a base de dados, somente é necessário alterar qual o tipo do banco
utilizado no arquivo de configuração do hibernate, e automaticamente todas as queries
passarão a ser realizadas para o banco de dados escolhido.
6. TECNOLOGIAS AUXILIARES
6.1 Log4j
O Log4j faz parte do Projeto Jakarta, e é uma ferramenta muito útil para depuração e
tratamento de exceções e/ou erros. Essa tecnologia fornece um mecanismo para
controlar declarativamente as mensagens de log, de forma que os códigos de produção
e de testes sejam os mesmos, e a sobrecarga de processamento seja mínima quando o
log estiver em sua configuração mínima de detalhamento. Ele é responsável por cuidar
de qualquer tipo de mensagem, desde alertas a mensagens de erro. (SHENOY e
MALLYA, 2004).
Vantagens sobre o gerenciamento de erros pelo contêiner:
- Os erros do contêiner são gravados no console, entretanto procurar no console
por uma exceção não é adequado em um sistema que estiver em produção.
- Mesmo se o log do console for redirecionado para um arquivo de saída, ainda
assim o arquivo pode ser sobrescrito quando o servidor for reiniciado.
- É mais vantajoso utilizar a ferramenta Log4j do que usar os comandos para
escrever mensagens destinadas a depuração durante a fase de testes. Esta
2
8 do
outra opção implica que seja necessário apagar as mensagens antes
programa ser utilizado em um ambiente de produção, o que não garante que o
código seja o mesmo código de testes.
6.2 Ant
O Ant é uma ferramenta para automação de construção de aplicações independente de
plataforma. O Ant é um projeto de código aberto, que faz parte do projeto jakarta . O
ANT pode, por exemplo, atualizar localização das classes, compilar o código separando
os binários do código fonte em pastas distintas, gerar arquivos de distribuição, gerar
documentação do projeto, efetuar testes de unidade no código, configurar e executar a
aplicação.
A automação de tarefas não é novidade, entretanto o que faz o Ant ser poderoso é o
fato de ser independente de sistema operacional. Além disso, é independente de
ambiente de desenvolvimento sendo que a maior parte destes ambientes já trabalha
com o Ant. Uma de suas principais vantagens é que seu arquivo de configuração em
XML torna-o fácil de aprender. (CAVANESS, 2002)
6.3 CVS
'Concurrent Versioning System', provê a habilidade para realizar mudanças
incrementais sobre arquivos, e pode ser usado por vários desenvolvedores ao mesmo
tempo. Assim, após realizar uma alteração em um arquivo, o desenvolvedor o envia
2
para o CVS (através da IDE de desenvolvimento) e o CVS trata de fazer um merge9 das
alterações realizadas com o arquivo atual no servidor, criando um log das alterações.
Assim, caso haja algum problema, ou alguém tenha sobrescrito a alteração de outra
pessoa, esses dados são facilmente recuperados.
6.4 Jakarta Tomcat
Servidor WEB da Apache Software Foundation que implementa containers para
Java Servlets e Java Server Pages (JSP's). Na sua última versão estável (5.5.9),
implementa as especificações de servlet 2.4 e JSP 2.0. Essas especificações são
desenvolvidas pela Sun através do Java Community Process.
O SERVIDOR TOMCAT ESTÁ SENDO UTILIZADO COMO PADRÃO
PARA O DESENVOLVIMENTO DAS PÁGINAS PARA APLICAÇÕES
JAVA QUE NÃO UTILIZAM EJB. TAMBÉM É DISTRIBUÍDO SOPRE A
LICENÇA APACHE.7. CONCLUSÃO
Observamos que não existe, até o presente momento, nenhum framework de
acompanhamento de pedidos que seja semelhante ao SIAP-F. Para o desenvolvimento,
foram eleitas as tecnologias como Java, Hibernate, IDE Eclipse, entre outras.
Com base na aplicação exemplo Sistema de Acompanhamento de Pedidos para
uma Pizzaria foi realizada uma primeira análise orientada à objetos, para identificação
das possíveis entidades que irão compor o framework SIAP-F.
3
0
7. BIBLIOGRAFIA
[1] LARMAN, Craig – Utilizando UML e Padrões – Uma introdução à análise e ao
projeto orientado à objetos. Bookman, 2000.
[2] ALUR, Deepak; MALK, Dans; CRUPI, Johns – Core J2EE Patterns – Best
Practices and Design Strategies. Patience Hall PTR, 2nd Edition, 2003.
[3] JBOSS GROUP – The Hibernate Tutorial
http://www.hibernate.org (acesso: maio de 2005).
[4] MARTIN, Robert C. - Principles, Patterns, and Practices: The Factory Pattern
http://today.java.net/pub/a/today/2005/03/09/factory.html (acesso: maio de 2005).
[5] SUN MICROSYSTEMS - Design Patterns: Data Access Object
http://java.sun.com/blueprints/patterns/DAO.html (acesso: maio de 2005).