Escolar Documentos
Profissional Documentos
Cultura Documentos
S
A
SISTEMA PARA GESTÃO DE CONDOMÍNIO
IN
IM
N
U
Uberlândia
2009
1
Marco Aurélio Silva Rodrigues
Maria Margaret de Vasconcelos Lemos
Orlando Alves de Oliveira
S
A
SISTEMA PARA GESTÃO DE CONDOMÍNIO
IN
Trabalho de Final de curso submetido à
IM
Uberlândia
2009
2
Marcos Aurélio Silva Rodrigues
Maria Margaret de Vasconcelos Lemos
Orlando Alves de Oliveira
S
Banca Examinadora:
Uberlândia, 9 de julho de 2009.
A
IN
________________________________________________________________
IM
________________________________________________________________
N
_________________________________________________________________
Uberlândia
2009
3
S
A
IN
IM
N
U
Isaac Newton
AGRADECIMENTOS
S
na elaboração deste trabalho.
Dividir com vocês essa autoria foi um privilégio que poucos de nós
tiveram!
A
IN
IM
N
U
RESUMO
S
customizados, sendo essa a escolha do Condomínio do Edifício Porto Seguro,
localizado em Uberlândia, MG. Assim, desenvolveu-se um sistema de fácil operação,
A
para apoiar a sua administração, possibilitando o registro de moradores e
proprietários, mantendo o histórico dessas informações. Foi feita a análise, definidos
IN
os casos de uso e elaborados os diagramas de sequência documentados com o
emprego da UML. O modelo escolhido foi o MVC, implementado com o uso do
Eclipse e dos frameworks Struts e Hibernate. O mapeamento objeto relacional foi
realizado pelo JDBC juntamente com a utilização do framewok Hibernate. Para o
IM
S
A
IN
IM
N
U
ABSTRACT
The Industrial Revolution, one of the landmarks of the Modern Age actually triggered
the process of urbanization, which in itself has brought issues to be resolved. As a
result, housing became a problem to be solved. The solution that presented itself
was the verticalisation, bringing answers to the need for space. With the spread of
this form of association, have created laws governing its administration, which
currently tends to professionalism, so that there is more market information systems
focused on management of condominiums, but some customers prefer customized
software, and this is the choice the condominium building of Porto Seguro, located in
S
Uberlândia, MG. Therefore, has developed a system to support its a system to
support its administration, easy operation, allowing the registration of residents and
A
owners, while maintaining the historical information. Was the analysis, the set of use
cases and developed the sequence of diagrams that have been documented with the
use of UML. The model chosen was the MVC, implemented using the Eclipse and
IN
the frameworks Hibernate and Struts. The object relational mapping was performed
by JDBC with the use of Hibernate framewok. To access the database was used the
design pattern DAO, configured to connect to MySQL, the DBMS chosen for the
IM
persistence of data. The web server selected was the Tomcat, which implements the
servlet and JSP specifications. The user interface was developed with JSP pages
with color blue as the most peaceful of all, suggesting space and depth. The tools
used for coding the system allowed the simplification of the code. Reverse
N
has been the persistence of data in a simple way, the MySQL, choosing database,
had good performance, proving that it was appropriated for the application. Although
whole use cases have not been implemented, the system can be completed because
the number of condominiums is growing and the relationship between management
and owners have changed. In addition, the system features and documentation to
support the expansion of the project is available, these will help the realization of this
task.
Keywords: condominium management, information system, implementation of
software.
S
A
IN
IM
N
U
LISTA DE ABREVIATURAS
S
HTML Hipertext Modelling Language
HTTP Hipertext Transfer Protocol
FK Foreign key
IBGE
IDE
IP A
Instituto Brasileiro de Geografia e Estatística
Integrated Development Environment
Internet Protocol
IN
J2EE Java Enterprise Edition
JDBC Java Database Conectivity
JDK Java Development Kit
JEE
IM
Página
Lista de Quadros
Página
S
Quadro 1 – Regras de Negócio............................................................................................................ 31
Quadro 3 – Especificação do caso de uso: Fazer Login. .................................................................... 37
Quadro 4 – Especificação do caso de uso: Cadastrar Dados. ............................................................ 39
A
Quadro 5 – Especificação do caso de uso: Listar Pessoas. ................................................................ 42
Quadro 6 – Especificação do caso de uso: Consultar Pessoa. ........................................................... 44
Quadro 7 – Especificação do caso de uso: Consultar Unidade........................................................... 46
IN
Quadro 8 – Especificação do caso de uso: Atualizar Histórico. .......................................................... 49
Quadro 9 – Especificação do caso de uso: Pesquisar Histórico. ........................................................ 51
Quadro 10 – Especificação do caso de uso: Registrar Conta a Pagar. .............................................. 53
Quadro 11 – Especificação do caso de uso: Registrar Pagamento de Contas................................... 55
IM
Lista de Figuras
U
Página
S
Figura 22 – Classes do pacote action.................................................................................................. 75
Figura 23 – Diagrama de sequência com as classes de projeto do caso de uso: Fazer
A
Login. ................................................................................................................................ 77
Figura 24 – Diagrama de sequência com as classes de projeto do caso de uso:
Cadastrar Dados............................................................................................................... 79
IN
Figura 25 – Diagrama de sequência com as classes de projeto do caso de uso: Listar
Pessoas. ........................................................................................................................... 81
Figura 26 – Diagrama de sequência com as classes de projeto do caso de uso:
Consultar Pessoa.............................................................................................................. 83
Figura 27 – Diagrama de sequência com as classes de projeto do caso de uso:
IM
S
Figura 52 – Comando geração do objeto pessoaDAO declarado no construtor da classe
PessoaBO....................................................................................................................... 107
A
Figura 53 – Chamada do método insert() através do método insertPessoa()
implementado na classe PessoaBO............................................................................... 108
Figura 54 – Código do método insert() implementado pela classe PessoaHibernateDAO. .............. 108
IN
Figura 55 – Comandos do método gravaPropAquisicao() implementado pela classe
CadastrarPessoaAction. ................................................................................................. 109
Figura 56 – Comandos de criação do objeto UnidadeHibernateDAO declarado no
construtor da classe UnidadeBO. ................................................................................... 109
Figura 57 – Comandos do método updateUnidade() implementado pela classe
IM
S
Figura 76 – Tela com mensagem de erro, CPF cadastrado como morador em outra
unidade. .......................................................................................................................... 124
A
Figura 77 – Tela com mensagem de sucesso ao cadastrar os dados. ............................................. 125
Figura 78 – Tela que apresenta a lista das pessoas cadastradas..................................................... 125
Figura 79 – Tela para solicitar a pesquisa dos dados de uma pessoa.............................................. 126
IN
Figura 80 – Tela que apresenta os dados da pessoa pesquisada. ................................................... 126
Figura 81 – Tela para solicitar a pesquisa dos dados de uma unidade. ........................................... 127
Figura 82 – Tela que apresenta os dados da unidade pesquisada. .................................................. 127
Figura 83 – Sistema simplificado de Banco de Dados. ..................................................................... 131
Figura 84 – Arquitetura de Modelo de Banco de Dados. ................................................................... 134
IM
1. INTRODUÇÃO 17
1.1. UM BREVE HISTÓRICO............................................................................................ 17
1.2. CENÁRIO ATUAL ..................................................................................................... 20
1.3. IDENTIFICAÇÃO DO PROBLEMA ................................................................................ 22
1.4. OBJETIVOS ............................................................................................................ 23
1.4.1. Geral....................................................................................................... 23
1.4.2. Específicos ............................................................................................. 23
1.5. JUSTIFICATIVA........................................................................................................ 23
S
1.6. ORGANIZAÇÃO DO TRABALHO ................................................................................. 24
2. ESPECIFICAÇÃO DO PROBLEMA 26
3. ANÁLISE E PROJETO 28
3.1.
3.2.
3.3. A
UNIFIED MODELLING LANGUAGE – UML .................................................................. 28
ETAPAS DA ANÁLISE DE SISTEMA ............................................................................ 29
REQUISITOS........................................................................................................... 30
IN
3.4. REGRAS DE NEGÓCIO............................................................................................. 31
3.5. CLASSES ............................................................................................................... 33
3.6. CASOS DE USO ...................................................................................................... 36
IM
S
4.6. TOMCAT ................................................................................................................ 97
4.7. IMPLEMENTAÇÃO .................................................................................................... 98
4.7.1.
4.7.2.
4.7.3. A
Struts ...................................................................................................... 98
Diagrama de Pacotes ........................................................................... 100
Implementação do Caso de Uso Cadastrar Dados ............................... 103
IN
5. INTERFACE 116
5.1. DIAGRAMA DE NAVEGABILIDADE ............................................................................ 119
6. PERSISTÊNCIA DE DADOS 128
6.1. CONCEITOS DE BANCO DE DADOS......................................................................... 129
IM
1. INTRODUÇÃO
S
pudessem conviver de forma próxima e participativa. Com isso, estabeleceu-se,
então, um conflito entre a necessidade de proteção e a repressão dos instintos
A
(FREUD, 2002). Nasceu, assim, a civilização.
Na Grécia antiga, pequenas comunidades se agrupavam em um centro,
na tentativa de se protegerem de ataques externos. Denomina-se tal fenômeno de
IN
sinecismo, que significa coabitação. Assim, originaram-se as “Polis” gregas, que
deram origem às cidades ocidentais (WIKIPEDIA, 2009).
Ainda dentro do processo histórico, na Idade Média, embora
IM
S
De acordo com o Instituto Brasileiro de Geografia e Estatística – IBGE
até a década de 1960, a maioria da população residia nas áreas rurais. A partir de
A
1970 houve a inversão, com o predomínio da população urbana (55,92%), como
mostra a tabela 1 (BRASIL, 2009b).
IN
Tabela 1 – População brasileira, segundo os censos demográficos de 1940, 1950,
1960, 1970, 1980, 1991 e contagem de 1996.
ÁREA URBANA ÁREA RURAL TOTAL
ANOS
IM
cento, sendo que a região Sudeste apresenta taxa acima de 75 por cento na maioria
dos municípios, como mostra a figura 1.
S
A
IN
Figura 1 – Grau de Urbanização, Brasil, 2000.
Fonte: IBGE (BRASIL, 2001).
IM
região Sudeste, sua taxa de urbanização é alta, da ordem de 97,56 por cento, ao
considerar-se o censo de 2000.
U
S
com custo mais acessível.
A
Ao se considerar o município de Uberlândia, o número de condomínios
IN
tem crescido, embora não se conheça estatística oficial sobre o assunto. Se
inicialmente, na década de 1960 os condomínios eram constituídos na área central
da cidade em edificações de vários andares, no final da década de 1980 até meados
da década de 1990, iniciou-se a construção de pequenas edificações, não mais na
IM
região central da cidade. Um dos locais, que nesse período apresentou um grande
crescimento desse tipo de condomínio, foi o bairro Santa Maria. Nesse bairro,
localiza-se o condomínio do Edifício Porto Seguro, prédio estritamente residencial,
composto por três andares, sendo que cada andar abriga duas unidades
N
edílicos está no Código Civil Brasileiro, notadamente no Livro III, em seus artigos
1.331 a 1.358.
De acordo com a legislação, o síndico seria a pessoa responsável pela
administração do condomínio. Embora o papel do síndico se mantenha o mesmo,
esse não precisa necessariamente ser um morador, sendo cada vez mais comum a
figura de um administrador profissional ou até mesmo uma empresa que assuma as
funções administrativas. Também, é comum a existência de empresas de
administração que apóiam as atividades do síndico.
A profissionalização dessas administrações é uma tendência, pois há
condomínios com grande número de unidades, que requerem uma abordagem mais
direcionada com embasamento legal. Também, pequenos condomínios estão
S
fazendo uso desses serviços, de modo que os direitos e deveres passam a ser
respeitados e exigidos de forma mais conveniente. Há, no mercado várias empresas
A
de administração de condomínio, inclusive sindicatos e associações de empresas,
apóiam a gestão de condomínios.
IN
Se a revolução industrial imprimiu mudanças profundas na sociedade,
respondendo inclusive pela urbanização, a era da informação, também, tem
provocado alterações significativas na sociedade. A valorização do capital material
tem-se deslocado para a valorização do capital intelectual. A competitividade está
IM
- cadastros gerais;
- mapas demonstrativos;
- taxas a receber;
- contas a pagar;
S
- tesouraria e fluxo de caixa;
-
balancetes;
relatórios diversos. A
IN
Fazer uso de sistemas padronizados ou buscar softwares
customizados é uma decisão importante. As duas possibilidades apresentam
vantagens e desvantagens. Sistemas já desenvolvidos podem ter menor custo e
IM
1.4. OBJETIVOS
1.4.1. Geral
1.4.2. Específicos
S
- documentar os casos de uso;
- A
elaborar os diagramas de seqüência de análise
1.5. JUSTIFICATIVA
S
condomínios traz o desafio de associar a tecnologia a uma gestão personalizada de
pequenos espaços residenciais, quando o mercado parece ofertar propostas mais
complexas.
A
Esse diferencial por si só justifica o desenvolvimento de uma nova
ferramenta, para atender a essa clientela.
IN
1.6. ORGANIZAÇÃO DO TRABALHO
S
Apresenta o processo de armazenagem e recuperação dos dados.
Resgata os conceitos e tecnologias que foram empregados durante o
desenvolvimento do sistema.
Capítulo 7: Conclusões
A
IN
Nesta parte são apresentadas as conclusões observadas pelo grupo
considerando-se os objetivos que nortearam a realização deste trabalho.
IM
N
U
26
2. ESPECIFICAÇÃO DO PROBLEMA
S
realizado pelos proprietários no momento do estabelecimento do condomínio.
A
IN
IM
N
U
S
que apóie a administração do condomínio, que seja de fácil operação. Esse sistema
deverá registrar os moradores e proprietários das unidades, mantendo, inclusive o
A
histórico dessas informações, permitindo resgatá-las quando necessário. O software
deverá, ainda, registrar todas as contas a serem pagas para, então, gerar a taxa de
IN
condomínio, que é dada pelo rateio das despesas mensais. O recebimento da taxa
de condomínio será realizado até o 10º dia do mês subseqüente. Após essa data
incidiram juros e multa.
Será importante que o sistema registre todos os recebimentos da taxa
IM
3. ANÁLISE E PROJETO
Maria Margaret de Vasconcellos Lemos
S
O principal objetivo da análise de sistemas é realizar um mapeamento
prévio do comportamento requerido para os elementos de modelagem que serão
implementados posteriormente na fase de construção (SILVA, 2009).
A
Assim, modelagem é a concepção de sistemas de informações, antes
que sejam codificados. É, ainda, parte essencial do desenvolvimento de grandes
IN
projetos, sendo, também, importante para aqueles de médio e pequeno porte. Trata-
se de uma forma de visualizar o projeto e verificar se os requisitos estão sendo
atendidos antes da implementação (OBJECT MANEGEMMENT GROUP, 2009).
Dada a importância da elaboração de projetos de softwares, foi definida uma
IM
S
que a classe deve implementar.
Os diagramas são representações gráficas que oferecem vários
A
ângulos de visualização de um sistema. São nove os diagramas definidos pela UML,
sendo que cada um tem função bem definida. O diagrama de classes exibe o
IN
conjunto de classes, interfaces, colaborações e os relacionamentos, enquanto que o
diagrama de objeto apresenta os objetos e seus relacionamentos. Já, o diagrama de
casos de uso representa o conjunto de caos de uso e atores, sendo importante para
organização e modelagem de comportamento do sistema. Para registrar a interação
IM
S
3.3. REQUISITOS
A
Os requisitos descrevem de modo claro, sem ambigüidades, conciso e
IN
consistente todos os aspectos significativos do sistema proposto. Eles devem
permitir que os desenvolvedores construam um sistema que satisfaça os clientes.
Um requisito é considerado como funcional quando descreve um
serviço ou função a ser realizada. Já requisitos não funcionais coincidem com
IM
Requisitos funcionais
1. Cadastrar proprietários;
2. cadastrar moradores;
3. registrar contas a pagar;
4. calcular o valor da taxa de condomínio;
5. registrar recebimento mensal da taxa de condomínio;
6. registrar pagamentos;
7. emitir recibos;
8. gerar prestação de contas.
S
Requisitos não-funcionais
variadas. Há aquelas que são definidas por dispositivos legais, como o percentual a
ser pago a título de imposto ou o valor permitido para o cálculo de juros ou multas.
Outras definem as pessoas responsáveis por determinadas operações no sistema.
Existem, ainda, regras para cálculos internos, a obrigatoriedade de validação de
dados, como por exemplo, no sistema proposto, o CPF a ser cadastrado deverá ser
uma sequência numérica válida.
Para o sistema de condomínio, foram identificadas e documentadas
dez regras de negócio como apresenta o quadro 2 a seguir.
32
Nome Permissão RN - 01
S
Nome Cadastro de proprietário RN - 04
Descrição
A
Para cadastrar o proprietário de uma unidade é preciso ter registrado
a venda realizada pelo proprietário anterior. Assim, somente será
cadastrado o proprietário de uma unidade, quando não houver
proprietário já cadastrado.
IN
Nome Lançamento de contas a pagar RN - 05
S
3.5. CLASSES
A
organização das classes do sistema, permitindo além da visualização das classes e
de seus atributos e métodos, a representação de seus relacionamentos, como estas
IN
se complementam e a transmissão da informação dentro do sistema (SILVA, 2007).
Durante o processo de análise, ao se delinear o sumário executivo,
como regra básica para nortear o analista, considera-se que os substantivos
encontrados sugerem as classes de negócios necessárias para o desenvolvimento
IM
Classe Pessoa
É responsável pelo registro de todas as pessoas que se relacionam
com o imóvel, sejam moradores ou proprietários. Os atributos dessa classe são:
nome, CPF e telefone.
Classe Unidade
Registra todas as unidades habitacionais existentes, ou seja, os
apartamentos. Mantém o registro do atual morador e atual proprietário. Seus
atributos são: número, morador e proprietário.
Classe Histórico
Essa classe é responsável por manter o registro de todos os
moradores e proprietários de cada uma das unidades, registrando inclusive a data
S
inicial e a data do término da relação de cada pessoa com a unidade. Por isso tem
como atributos: unidade, proprietário, proDtAquisicao, pro_DtVenda, morador,
mor_DtEntrada e mor_DtSaida.
Classe ContasAPagar
A
IN
Essa classe é responsável pelo registro de todas as contas que o
condomínio deverá pagar em função de bens adquiridos ou serviços recebidos. Os
atributos dessa classe são: dataVencimento, descricaoConta, valorConta e mesRef.
Classe TaxaCondomínio
IM
Os atributos dessa classe são: data, tipo, descrição, juros, multa e valorFinal.
Na etapa de análise foi usado o Enterprise Architect ferramenta
desenvolvida para a análise, modelagem e manutenção de softwares, que emprega
a UML e gera a documentação do sistema. Como um dos resultados do emprego
dessa ferramenta foi o diagrama de classes obtido pela interação das classes
descritas anteriormente (Figura 3).
35
U
N
IM
IN
A
Figura 3 – Diagrama de classes de negócio.
S
36
S
A
IN
IM
N
U
S
Pré-condição: O usuário estar cadastrado.
Pós-condição: O login foi realizado.
Fluxo Alternativo:
Não há.
Fluxo de Exceção [3]: Dados incorretos
N
RN01
Quadro 3 – Especificação do caso de uso: Fazer Login.
38
S
A
IN
Figura 5 – Diagrama de sequência do caso de uso: Fazer Login.
papéis são:
e a classe Usuários.
Neste caso de uso, o síndico fará o cadastro de uma pessoa que terá
relação com o condomínio de moradia ou de propriedade. O sistema não permitirá o
cadastro de morador ou proprietário de uma unidade se outra pessoa já estiver
cadastrada nessa situação. Para isso é necessário registrar, anteriormente a saída
ou a venda da unidade (Quadro 4) .
S
Sumário cadastro dos dados pessoais de proprietários ou moradores e a
unidade com a qual manterão relação.
Ator primário: Síndico.
Ator(es) secundário(s): Não há.
A
Pré-condição: Não haver registro de pessoa na unidade, na condição a ser
registrada.
IN
Pós-condição: O cadastro foi realizado.
Fluxo Principal
1. O síndico solicita o cadastro de dados pessoais.
IM
Fluxo Alternativo:
Não há.
U
S
A
IN
IM
papéis são:
a) Menu Inicial: representa a interface de acesso às funcionalidades dos sistema.
No caso, o síndico solicita o cadastro de uma pessoa.
U
d) Pessoa: representa uma das classes de entidade deste caso de uso. Sua
função é armazenar os atributos das pessoas cadastradas, nome; CPF e
telefone.
e) Unidade: representa outra classe de entidade deste caso de uso. Sua função é
armazenar os atributos das unidades, o número da unidade, a pessoa que é
moradora, assim como a pessoa que é proprietária da unidade em questão.
S
de entrada e a data de saída do morador; a pessoa que é proprietária; a data
de aquisição e a data de venda relativa a esse proprietário.
A
IN
IM
N
U
42
S
Ator(es) secundário(s): Não há.
Pré-condição: Ter pessoas cadastradas no sistema.
A
Pós-condição: A lista com os dados das pessoas cadastradas é apresentada.
Fluxo Principal
1. O síndico solicita listar todas as pessoas cadastradas.
IN
2. O sistema apresenta o cadastro de pessoas com CPF, nome e o telefone
de cada pessoa.
3. O caso de uso é encerrado.
IM
Fluxo Alternativo:
Não há.
S
A
Figura 7 – Diagrama de sequência do caso de uso: Listar Pessoas.
S
Pré-condição: A pessoa estar cadastrada no sistema.
Pós-condição: Os dados da pessoa foram recuperados.
A
Fluxo Principal
1. O síndico solicita consultar o cadastro de uma pessoa.
IN
2. O sistema solicita o CPF da pessoa.
3. O síndico informa o CPF.
4. O sistema apresenta o nome e o telefone da pessoa.
5. O caso de uso é encerrado.
IM
S
A
IN
Figura 8 – Diagrama de sequência do caso de uso: Consultar Pessoa.
d) Pessoa: representa uma das classes de entidade deste caso de uso. Sua
função é armazenar os atributos das pessoas cadastradas, nome; CPF e
telefone.
46
S
Pré-condição: A unidade estar cadastrada no sistema.
Pós-condição: Os dados da unidade foram recuperados.
A
Fluxo Principal
1. O síndico solicita a consulta de dados de uma unidade.
2. O sistema solicita o número da unidade.
IN
3. O síndico informa o número.
4. O sistema apresenta o morador e o proprietário da unidade.
5. O caso de uso é encerrado.
IM
Fluxo Alternativo:
Não há.
Fluxo de Exceção:
N
Não há.
S
A
IN
Figura 9 – Diagrama de sequência do caso de uso: Consultar Unidade.
IM
d) Unidade: representa uma das classes de entidade deste caso de uso. Sua
função é armazenar os atributos das unidades, o número da unidade, a pessoa
48
e) Pessoa: representa outra classe de entidade deste caso de uso. Sua função é
armazenar os atributos das pessoas cadastradas, nome; CPF e telefone.
S
A
IN
IM
N
U
49
S
Ator primário: Síndico
Ator(es) secundário(s): Não há
A
Pré-condição: Haver histórico anterior em aberto.
Pós-condição: O histórico foi atualizado.
IN
Fluxo Principal
de uma unidade.
3. O síndico realiza o preenchimento do formulário.
4. O síndico confere os dados inseridos no formulário e confirma.
5. Sistema registra a atualização e encerra o caso de uso
N
S
A
Figura 10 – Diagrama de sequência do caso de uso: Atualizar Histórico.
IN
As classes de análise envolvidas neste caso de uso e os respectivos
papéis são:
IM
uso. Disponibiliza ao usuário o formulário para obter os dados que deverão ser
atualizados.
d) Histórico: representa uma das classes de entidade deste caso de uso. Sua
função é armazenar os atributos das unidades, o número da unidade, a pessoa
que é moradora, assim como a pessoa que é proprietária da unidade em
questão.
e) Unidade: representa uma das classes de entidade deste caso de uso. Sua
função é armazenar os atributos das unidades, o número da unidade, a pessoa
51
S
Ator primário: Síndico.
Ator(es) secundário(s): Haver histórico registrado anteriormente.
Pré-condição: Não há.
A
Pós-condição: A lista com o histórico da unidade é apresentada.
IN
Fluxo Principal
1. O síndico solicita a pesquisa do histórico.
2. O sistema solicita o número da unidade para a pesquisa.
IM
Fluxo de Exceção:
Não há.
S
A
IN
Figura 11 – Diagrama de sequência do caso de uso: Pesquisar Histórico.
d) Histórico: representa uma das classes de entidade deste caso de uso. Sua
função é armazenar os atributos das unidades, o número da unidade, a pessoa
que é moradora, assim como a pessoa que é proprietária da unidade em
questão.
53
S
Ator primário: Síndico.
Ator(es) secundário(s): Não há.
Pré-condição: Não há.
Pós-condição: A conta foi registrada.
A
Fluxo Principal
IN
1. O sindico solicita o registro de contas a pagar.
2. O sistema apresenta as opções do tipo de conta a ser registrada.
3. O síndico escolhe o tipo de conta.
IM
Fluxo Alternativo:
Não há.
U
Fluxo de Exceção:
Não há.
S
A
IN
Figura 12 – Diagrama de sequência do caso de uso: Registrar Contas a Pagar.
papéis são:
a) Menu Inicial: representa a interface de acesso às funcionalidades dos sistema.
No caso, o síndico solicita registrar uma conta que deverá ser paga
posteriormente.
N
Pagar.
S
Pós-condição: O pagamento da conta foi registrado.
Fluxo Principal
A
1. O síndico solicita o registro do pagamento de contas.
2. O sistema apresenta as contas já cadastradas.
IN
3. O síndico seleciona a conta.
4. O sistema apresenta as informações da conta e solicita o preenchimento
dos dados complementares.
5. O síndico informa os dados.
IM
Fluxo Alternativo:
N
Não há.
Fluxo de Exceção [2]: Não há conta cadastrada.
a) O sistema informa que não há conta cadastrada.
U
S
A
IN
IM
d) Contas a Pagar: representa uma das classes de entidade deste caso de uso.
Sua função é armazenar os atributos das contas que serão pagas, a data de
vencimento, a descrição e o valor da conta e também, o mês de referência.
S
A
IN
IM
N
U
58
S
Pós-condição: O valor da taxa ter sido calculado.
Fluxo Principal
1.
2.
3. A
O síndico solicita a geração da taxa mensal de condomínio.
O sistema solicita o período de referência da taxa a ser gerada.
O síndico informa o período.
IN
4. O sistema gera e apresenta a taxa de condomínio do período solicitado.
5. O caso de uso é encerrado.
Fluxo Alternativo:
IM
Não há.
Fluxo de Exceção [4]: Não há conta cadastrada.
a. O sistema informa que não há contas cadastradas e retorna ao item 4.
Regras de Negócio Associadas
N
RN05, RN06 e RN 07
Quadro 12 – Especificação do caso de uso: Gerar Taxa de Condomínio.
U
59
S
A
IN
IM
d) Contas a Pagar: representa uma das classes de entidade deste caso de uso.
Sua função é armazenar os atributos das contas que serão pagas, a data de
vencimento, a descrição e o valor da conta e também, o mês de referência.
S
A
IN
IM
N
U
61
S
Pós-condição: O pagamento da taxa é registrado.
Fluxo Principal
A
1. O síndico solicita o registro de pagamento da taxa.
2. O sistema solicita os dados para registrar o recebimento da taxa de
IN
condomínio.
3. O síndico informa os dados.
4. O sistema solicita a confirmação.
5. O síndico confirma os dados.
IM
a. O sistema informa que a taxa não foi gerada e encerra o caso de uso.
RN 08, RN09 e RN 10
Quadro 13 – Especificação do caso de uso: Receber Taxa de Condomínio.
62
S
A
IN
IM
f) Unidade: representa uma das classes de entidade deste caso de uso. Sua
função é armazenar os atributos das unidades, o número da unidade, a pessoa
que é moradora, assim como a pessoa que é proprietária da unidade em
S
questão.
g) Pessoa: representa outra classe de entidade deste caso de uso. Sua função é
A
armazenar os atributos das pessoas cadastradas, nome; CPF e telefone.
IN
IM
N
U
64
S
Pré-condição: A taxa ter sido paga.
Pós-condição: O recibo foi gerado.
A
Fluxo Principal
Fluxo de Alternativo:
N
Não há.
U
S
A
IN
Figura 16 – Diagrama de sequência do caso de uso: Gerar Recibo.
IM
d) Histórico: representa uma das classes de entidade deste caso de uso. Sua
função é armazenar os atributos das unidades, o número da unidade, a pessoa
66
e) Pessoa: representa outra classe de entidade deste caso de uso. Sua função é
armazenar os atributos das pessoas cadastradas, nome; CPF e telefone.
S
A
IN
IM
N
U
67
S
Pré-condição: Haver registro de movimento no período solicitado.
Pós-condição: O balancete foi gerado.
A
Fluxo Principal
1. O síndico solicita a geração de balancete.
IN
2. O sistema solicita os dados para a geração do balancete.
3. O síndico informa os dados.
4. O sistema solicita confirmação.
5. O síndico confirma os dados.
IM
Fluxo de Alternativo:
N
Não há.
RN 08, RN09 e RN 10
Quadro 15 – Especificação do caso de uso: Gerar Balancete.
68
S
A
IN
IM
e) Contas a Pagar: representa uma das classes de entidade deste caso de uso.
Sua função é armazenar os atributos das contas que serão pagas, a data de
vencimento, a descrição e o valor da conta e também, o mês de referência.
S
A
IN
IM
N
U
70
S
Pós-condição: O Histórico foi gerado.
Fluxo Principal
A
1. O síndico solicita a geração de histórico.
2. O sistema solicita os dados para a geração do histórico.
IN
3. O síndico informa os dados.
4. O sistema solicita confirmação.
5. O síndico confirma os dados.
6. O sistema gera o histórico.
IM
Fluxo de Alternativo:
Não há.
N
S
A
IN
Figura 18 – Diagrama de sequência do caso de uso: Gerar Balancete.
IM
e) Pessoa: representa uma das classes de entidade deste caso de uso. Sua
função é armazenar os atributos das pessoas cadastradas, nome; CPF e
telefone.
3.7. PROJETO
S
serão apresentados com mais detalhes no capítulo 4 “Arquitetura e Código” e
capítulo 6 “Persistência de Dados” ficando limitado ao capítulo atual a apresentação
entre as classes.
A
das classes de projeto e dos diagramas de sequência gerados a partir da interação
− UsuarioEntidade; − UnidadeBO;
− HibernateUtil; − UnidadeDAO;
− LoginBO; − UnidadeHibernateDAO;
N
− LoginCO; − HistoricoBO;
− LoginDAO; − HistoricoDAO.
U
− Login2; − HistoricoHibernateDAO;
− PessoaBO; − CadastrarPessoaAction e
− PessoaDAO; − PesquisarAction.
− PessoaHibernateDAO;
S
A
IN
IM
N
U
S
A
Figura 20 – Classes do pacote bo.
IN
As classes de persistência, aquelas com terminação “DAO” e, ainda, a
IM
S
A
IN
IM
N
U
S
A
IN
IM
N
U
77
U
N
IM
IN
A
S
Figura 23 – Diagrama de sequência com as classes de projeto do caso de uso: Fazer Login.
78
S
A
IN
IM
N
U
79
U
N
IM
IN
A
S
Figura 24 – Diagrama de sequência com as classes de projeto do caso de uso: Cadastrar Dados.
80
S
A
IN
IM
N
U
81
U
N
IM
IN
A
S
Figura 25 – Diagrama de sequência com as classes de projeto do caso de uso: Listar Pessoas.
82
S
A
IN
IM
N
U
83
U
N
IM
IN
A
S
Figura 26 – Diagrama de sequência com as classes de projeto do caso de uso: Consultar Pessoa.
84
S
A
IN
IM
N
U
85
U
N
IM
IN
A
S
Figura 27 – Diagrama de sequência com as classes de projeto do caso de uso: Consultar Unidade.
86
S
A
IN
IM
N
U
87
U
N
IM
IN
A
S
Figura 28 – Diagrama de sequência com as classes de projeto do caso de uso: Atualizar Histórico.
88
4. ARQUITETURA E CÓDIGO
Orlando Alves de Oliveira
S
condomínio, permitindo o acompanhamento de sua ocupação bem como gestão
financeira da manutenção mensal do imóvel. Para essa aplicação o padrão de
utilizado foi de desenvolvimento em camadas para que fique separado por módulos
A
de apresentação, negócios e integração.
A arquitetura de software é a maneira como está estruturado o sistema,
IN
ou seja, quais os componentes estão presentes e as relações entre esses
componentes (AHMED & UMRYSH, 2002).
Através do modelo de arquitetura o desenvolvedor visualiza com mais
facilidade o funcionamento do sistema, como serão dispostos os seus componentes,
IM
orientada a objetos além do uso da arquitetura em três camadas MVC (Model, View,
Controller), plataforma J2EE, através do Eclipse e com os framewoks Struts e
Hibernate.
4.1. JAVA
S
parte do Java como Software Livre sob os termos da GNU General Public
License (GPL). Em 8 de Maio de 2007 a Sun finalizou o processo, tornando
praticamente todo o código Java como software de código aberto, menos
uma pequena porção da qual a Sun não possui copyright.
A
O aumento do uso de aplicações distribuídas provê mudanças nos
IN
projetos de software. Sendo assim no sistema do Edifício Porto Seguro foi utilizada a
arquitetura MVC que é um modelo de aplicação em três camadas, nesse modelo as
responsabilidades ficam divididas.
IM
S
A
IN
IM
N
S
4.3.1. DAO
A
o código de acesso aos dados fique separado da lógica de negócios.
Esse padrão abstrai e encapsula o acesso ao armazenamento
IN
persistente gerenciando a conexão com o banco de dados para armazenar e
consultar dados.
Geralmente se tornam objetos leves porque são implementados como objetos sem
informações de estado e também não armazenam em cachê os resultados de
IM
de dados. Esse padrão permite que a lógica de negócios fique separada da lógica
de persistência, usando-se um objeto. A figura 30 mostra o código da classe
PessoaBO.
package br.uniminas.bo;
import java.util.List;
import br.uniminas.entidades.Pessoa;
import br.uniminas.persistencia.PessoaDAO;
import br.uniminas.persistencia.PessoaHibernateDAO;
public class PessoaBO {
private PessoaDAO dao;
public PessoaBO() {
this.dao = new PessoaHibernateDAO();}
public List getAllPessoas() {
S
return dao.getAllPessoas();}
public void deletePessoa(String string) {
dao.delete(string);}
A
public Pessoa getPessoa(String string) {
return dao.getPessoa(string); }
public void insertPessoa(Pessoa pes) {
dao.insert(pes);}
IN
}
Figura 30 – Classe PessoaBO.
desse objeto são chamados métodos que fazem operações como inserir, pesquisar
e deletar que são métodos da classe DAO responsável pela persistência no banco
de dados.
Portanto o business object mantém os dados de negócio e implementa
N
S
atendimento de uma solicitação e o gerenciamento de visualização, cuja função é
localizar e distribuir a visualização solicitada.
A
Tanto o padrão Front Controller como o Application Controller são
implementados pelo framework Struts.
IN
4.4. TECNOLOGIAS UTILIZADAS
4.4.1. Servlet
IM
Servlet é uma classe Java que acessa uma API com serviços
específicos do protocolo http. Ele recebe uma requisição e apresenta uma resposta
em seguida. Toda vez que recebe uma requisição é iniciado um método chamado
service().
N
S
Figura 31 – Ciclo de vida do servlet.
Adaptado de Angoti (2009a).
aplicação. Quando uma página JSP é requisitada pelo usuário no browser, esta
página é executada pelo servidor, e, então, é gerada uma página HTML, através de
do processo de renderização, e em seguida, essa página é enviada ao browser do
usuário. As páginas JSP contêm código HTML comum e se diferenciam pelo uso
N
<br>
<br>
<br>
<br>
<div id="menu">
<ul>
<li><a href="principal.action">Principal</a></li>
<li><a href="getAllPessoas.action">Listar Cadastros</a></li>
</ul>
</div>
<br>
<br>
<br>
<br>
<br>
<h1><s:text name="Pesquisar Pessoa" /></h1>
S
</s:if>
<s:form action="consultarPessoa">
<table align="center" class="borderAll">
<tr>
</tr>
</table>
A
<td class="tdLabel"><s:text name="label.P_cpf" /></td>
<td><s:textfield name="cpf" size="11" /></td>
IN
<br />
<table>
<tr>
<td><s:submit action="consultarPessoa"
key="button.label.submit2" cssClass="butStnd" /></td>
IM
</html>
Figura 32 – Código da página consultarPessoaForm.jsp.
S
Figura 33 – Página pesquisarPessoa.jsp
4.4.3. JDBC
A
Java Database Conectivity (JDBC) é uma API da linguagem Java que
IN
permite o acesso ao sistema de gerenciamento de banco de dados (SGBD) através
de comandos SQL (Structured Query Language).
Essa API está contida no pacote java.sql, com a sua utilização não há
IM
4.5. J2EE
U
S
Na camada de apresentação encontra-se a lógica de apresentação dos
A
elementos exibidos ao usuário. Essa camada intercepta as solicitações do usuário e
faz o controle do que será exibido como resposta às requisições. Estão nessa
camada as páginas JSP e os servlets, que embora não sejam a interface
IN
propriamente dita são responsáveis pela criação destas. Também, está presente
nessa camada o Front Controller, implementado pelo framework Struts, que é
responsável por controlar e redirecionar as requisições feitas pelo usuário e delegar
IM
camada foi utilizado o DAO para abstrair o acesso ao banco de dados através do
mapeamento objeto relacional.
4.6. TOMCAT
- Otimização de performance;
- Otimização e redução do coletor de lixo;
- Melhoria no tratamento de taglibs;
- Gerenciamento da aplicação e do servidor.
(ANGOTI JR, 2009c).
4.7. IMPLEMENTAÇÃO
4.7.1. Struts
S
desenvolvido entre o ano de 2000 e 2001 onde mais de 30 desenvolvedores
contribuíram para a sua criação (DUMOULIN, FRANCISCUS, WINTERFELDT,
2004).
A
O Struts é responsável por implementar o Front Controller que faz a
IN
centralização da lógica de controle, promovendo também reutilização de código
porque não será necessário código de controle em várias páginas de visualização.
As responsabilidades ficam bem definidas facilitando a manutenção. Na figura 35 é
possível ver o funcionamento do Front Controler que atua na camada de
IM
apresentação.
N
U
S
apresenta um trecho do código desse arquivo.
A
<!DOCTYPE struts PUBLIC "-//Apache Software
Foundation//DTD Struts Configuration 2.0//EN"
"http://struts.apache.org/dtds/struts-2.0.dtd">
IN
<struts>
<package name="default" extends="struts-default">
<!-- mapeamento das ações -->
...
<action name="consultarUnidade" method="consultaUnidade"
class="br.uniminas.action.PesquisarAction">
IM
<result name="success">/page/unidade.jsp</result>
<result name="erro">/page/erro.jsp</result>
</action>
...
</package>
</struts>
N
...
public String consultaUnidade() {
unidade = uniService.getUnidade(numero);
if (unidade != null) {
return "success";
} else {
addActionError("Unidade não existe!");
return "erro";
}
}
...
Figura 37 – Método consultaUnidade.
S
acordo com a solicitação feita pelo usuário.
A
Os diagramas de pacotes do sistema foram gerados pelo Omondo
Eclipse UML que é um plugin que auxilia a geração de diagramas UML. Foi utilizado
IN
o processo de engenharia reversa para geração desses diagramas, onde a partir do
código fonte foi possível gera-los.
O diagrama de pacotes exibe a estrutura de classes e pacotes de como
IM
S
A
Figura 39 – Classes do pacote entidades.
IN
No pacote bo estão as classes de negócio da aplicação, ou seja,
através de métodos que estão contidos nas classes do tipo BO são passados os
objetos de entidades para que sejam executadas as operações pelas classes DAO
(Figura 40).
IM
N
U
S
A
IN
Figura 41 – Classes do pacote persistência.
IM
S
pessoa, unidade e histórico. Essa demonstração parte das premissas de que a
pessoa em questão não foi cadastrada anteriormente e que não há histórico com
A
pendências para a unidade. A figura 43 mostra a tela principal do sistema do Edifício
Porto Seguro onde é selecionada a opção Cadastrar Dados.
IN
IM
N
U
<action name="setUpForInsertOrUpdate"
method="setUpForInsertOrUpdate"
class="br.uniminas.action.CadastrarPessoaAction">
<result name="success">/page/cadastroPessoaForm.jsp</result>
</action>
Figura 44 – Action setUpForInsertOrUpdate mapeada no arquivo struts.xml.
S
CadastrarPessoaAction do pacote action, como apresentado no trecho de código
abaixo (Figura 45).
A
public String setUpForInsertOrUpdate() {
prep();
IN
return "success";
}
...
Figura 45 – Método setUpForInsertOrUpdate() implementado na classe CadastrarPessoaAction.
IM
S
é uma classe Java contendo os objetos e métodos relacionados ao cadastro de
dados, além dos métodos das validações feitas pelo sistema. A seguir é mostrado o
return "erro";
}
if(jaMorador()==false){
gravaMorEnt();
}
U
}
if (mor != null && mor.equals("saida")) {
if (!validaDataSaiMor())
return "erro";
else
gravaMorSai();
}
return "success";
}
}
...
Figura 48 – Método InsertOrUpdate implementado na classe CadastrarPessoaAction.
106
S
é chamado o método gravaPropAquisicao(). Nesse método, estão envolvidas as
entidades pessoa; unidade e histórico e as variáveis pesAux e pessoa, que são do
tipo Pessoa e pesService é do tipo PessoaBO. A linha de código mostrada abaixo
A
permite verificar se já existe uma pessoa cadastrada com o CPF informado. Caso
exista, grava o objeto pessoa correspondente no objeto pesAux, senão grava valor
IN
nulo nesse objeto (Figura 49).
...
public void gravaPropAquisicao() {
pesAux = pesService.getPessoa(pessoa.getP_cpf());
unidade = uniService.getUnidade(unidade.getU_numero());
histAux = histService.getHistorico(historico.getId());
...
Figura 49 – Método gravaPropAquisicao() implementado na classe CadastrarPessoaAction.
N
U
S
tipo PessoaBO chamado pesService já instanciado, passa através do método
insertPessoa(), que pertence a classe PessoaBO, o objeto pessoa criado, quando
submeteu-se os dados do formulário (Figura 51).
A
IN
public class CadastrarPessoaAction{
...
public void gravaPropAquisicao{
...
if (pesAux == null && unidade.getProprietario() == null) {
// grava pessoa
IM
pesService.insertPessoa(pessoa);
...
Figura 51 – Comando de persistência declarado no método gravaPropAquisicao()
implementado na classe CadastrarPessoaAction.
N
S
Esse método recebe o objeto pessoa criado e executa a gravação dos
dados na tabela de pessoas do banco de dados (Figura 54).
tx = session.beginTransaction();
session.save(pes);
tx.commit();
} catch (RuntimeException e) {
if (tx != null)
tx.rollback();
N
throw e;
} finally {
// session.close();
}
U
}
...
Figura 54 – Código do método insert() implementado pela classe PessoaHibernateDAO.
S
Na classe UnidadeBO é criado um objeto do tipo UnidadeDAO e no
construtor dessa classe o objeto do tipo unidadeDAO é instanciado como mostrado
na figura 56 a seguir.
A
IN
public class UnidadeBO {
private UnidadeDAO dao;
public UnidadeBO() {
this.dao = new UnidadeHibernateDAO();
IM
}
...
Figura 56 – Comandos de criação do objeto UnidadeHibernateDAO declarado no construtor
da classe UnidadeBO.
N
S
} catch (RuntimeException e) {
if (tx != null)
tx.rollback();
throw e;
}
}
} finally {
A
IN
...
Figura 58 – Código do método updateUnidade() implementado pela classe
UnidadeHibernateDAO.
historico.setProprietario(unidade.getProprietario());
histService.updateHistorico(historico);
}
...
Figura 59 – Comando de persistência declarado no método gravaPropAquisicao()
implementado na classe CadastrarPessoaAction, quando já há histórico da unidade.
S
public class HistoricoBO {
private HistoricoDAO dao;
public HistoricoBO() {
A
this.dao = new HistoricoHibernateDAO();
}
...
Figura 60 – Comandos de criação do objeto HistoricoHibernateDAO declarado no construtor
IN
da classe HistoricoBO.
61).
...
public void updateHistorico(Historico hist){
dao.updateHistorico(hist);
}
U
...
Figura 61 – Comandos do método updateHistorico() implementado pela classe HistoricoBO.
S
}
}
...
Figura 62 – Código do método updateHistorico() implementado pela classe
HistoricoHibernateDAO.
A
IN
Senão houver histórico criado anteriormente com o código informado
na tela de cadastro de dados um novo objeto do tipo histórico é criado e é repassado
ao BO através de uma variável do tipo HistoricoBO chamada histService pelo
IM
...
// se não existir um histórico com o código digitado cria um novo
// registro de histórico no banco
else {
historico.setProprietario(pessoa);
historico.setNumero(unidade);
historico.setH_proAquiscao(data);
histService.insertHistorico(historico);
}
...
Figura 63 – Comando de persistência declarado no método gravaPropAquisicao()
implementado na classe CadastrarPessoaAction, quando não há histórico da unidade.
113
S
objeto do tipo Histórico e executa a inserção dos dados na tabela de históricos do
banco com o mapeamento objeto relacional realizado através do framework
Hibernate (Figura 65).
A
IN
public class HistoricoHibernatedDAO {
...
public void insert(Historico his) {
session = HibernateUtil.getSessionFactory().openSession();
Transaction tx = null;
IM
try {
tx = session.beginTransaction();
session.save(his);
tx.commit();
} catch (RuntimeException e) {
if (tx != null)
N
tx.rollback();
throw e;
} finally {
// session.close();
U
}
}
...
Figura 65 – Código do método insert() implementado na classe HistoricoHibernateDAO.
S
public class CadastrarPessoaAction{
...
public String insertOrUpdate() {
...
}
A
if (prop != null && prop.equals("aquisicao")) {
gravaPropAquisicao();
IN
...
return "success";
}
}
...
Figura 67 – Código do método isertOrUpdate() implementado na classe
IM
CadastrarPessoaAction.
...
U
S
A
Figura 69 – Tela de confirmação de cadastro.
IN
É importante ressaltar que se a pessoa em questão já estiver
cadastrada no sistema, a parte do cadastro de dados da pessoa não será realizada
pelo software. Serão executados, apenas, os comandos de atualização da unidade e
IM
5. INTERFACE
S
se no trabalho que deverá executar. Para isso, uma interface deve ser amigável e
apresentar usabilidade. Para atingir esses objetivos, ela deverá apresentar as
A
seguintes características: ser de fácil uso; ser fácil de aprender o seu manuseio;
apresentar taxa mínima de erro; favorecer a recordação rápida; ser atrativa;
apresentar alta velocidade na execução de tarefas; gerar satisfação e retenção do
IN
usuário com o tempo (ASCENIO, 1999).
De acordo com Ferreira (2009), a interface estabelece uma interação
do homem com o sistema através de um meio visual. O indivíduo recebe e interpreta
IM
a informação visual com base no tamanho, forma, cor e outras características. Uma
especificação adequada da comunicação visual é o elemento chave para obtenção
de uma interface amigável. A cor é um componente que merece um estudo especial
quando se trata de comunicação, assim, a escolha das cores de uma interface deve
N
S
todas elas. As superfícies pretas se tornam mais negras à medida que o nível de
iluminação aumenta. Contrastes simultâneos fazem com que um contorno preto
A
torne áreas coloridas mais claras e amplas. Torna-se mais legível quando em
contraste com fundos claros, apesar de ser necessário o uso de fontes em “negrito”
IN
quando se usa texto negro em um fundo branco. Linhas pretas são eficientes ao se
separar áreas coloridas através de um aumento da fronteira de contraste. Para uma
boa reprodução de imagens, é desejável ter-se um preto sólido de modo a
estabelecer o limite da variação tonal.
IM
Cinza
Reduz as conotações emocionais. Combina com todas as cores, que
apresentam seu colorido máximo quando contrastando com cinza escuro.
Das cores acromáticas (branco, preto e cinza) o cinza é uma boa cor
N
de fundo para a maioria das interfaces, pois minimiza o contraste entre a cor mais
escura e a mais clara da cena, amortecendo o choque visual ao se passar de uma
U
S
Apresenta grande qualidade acolhedora. Sua associação imediata com
o sol faz com que ela simbolize a vida e o calor. É um bom indicador de atividade,
A
sendo adequada para indicar a janela. Como cor de texto requer fundo preto ou azul
escuro.
IN
Verde
A idéia de que a plantação significa uma certa estabilidade levou à
associação do verde com o sentimento de segurança.
Ambientes com um tom de verde claro promovam um estado de paz na
IM
mente, enquanto que o verde em excesso resulta em uma aparência doentia. Está
indicada quando se deseja passar rapidamente uma informação, sendo também,
recomendada para informar que está tudo normal.
Azul
N
S
Amarelo Verão Colheita Traição Doença
Serenidade Inovação Ciúmes Loucura
Vegetação Fertilidade Decadência Ganância
Verde Natureza
Primavera
Céu A
Esperança
Segurança
Estabilidade
Inexperiência
Inveja
Frio
Fuga à realidade
Má Sorte
Obscenidade
IN
Azul Mar Paz Depressão Mistério
Espiritualidade Unidade Melancolia Conservadorismo
Quadro 17 – Simbologia de cores.
IM
sistema.
120
U
N
IM
IN
A
S
Figura 70 – Diagrama de Navegabilidade.
121
S
Às páginas JSP associou-se a tecnologia Cascade Style Sheets – CSS
- linguagem de estilo, que provém a apresentação de documentos escritos em uma
A
linguagem de marcação, como o HyperText Markup Language – HTML. O principal
benefício é permitir a separação entre o formato e o conteúdo de um documento,
pois formatação não está incorporada ao documento. Os estilos ficam em uma
IN
página separada ligada às páginas de código, de modo que para alterar a
apresentação das páginas de interface, basta proceder as mudanças na página
onde os estilos estão definidos, que as alterações serão percebidas de forma
IM
S
Figura 71 – Tela de Login.
A
IN
IM
N
U
S
Figura 73 – Menu inicial.
A
IN
IM
N
U
S
A
Figura 75 – Tela com mensagem de erro de CPF.
IN
IM
N
U
S
A
Figura 77 – Tela com mensagem de sucesso ao cadastrar os dados.
IN
IM
N
U
S
A
Figura 79 – Tela para solicitar a pesquisa dos dados de uma pessoa.
IN
IM
N
U
S
A
Figura 81 – Tela para solicitar a pesquisa dos dados de uma unidade.
IN
IM
N
U
6. PERSISTÊNCIA DE DADOS
Marco Aurélio Silva Rodrigues
S
armazenar dados em um bando de dados relacional, usando SQL (Structure Query
Language) (BAUER & KING, 2005).
A persistência de dados, na computação, refere-se ao armazenamento
A
não-volátil de dados, por exemplo em um dispositivo físico de armazenamento como
um disco rígido. De forma muito simples, Persistência de Dados nada mais é do que
IN
armazenar dados em um banco de dados relacional.
Pode-se dizer que de maneira geral, o termo persistência é associado
a uma ação que consiste em manter em meio físico recuperável, como banco de
dados, arquivo, de modo a garantir a permanência das informações de um
IM
S
De acordo com Elmasri e Navathe (2005, p. 4) “um banco de dados é
uma coleção de dados relacionais. Os dados sãos fatos que podem ser gravados e
que possuem um significado implícito”.
A
Um sistema de banco de dados é um sistema computadorizado de
manutenção de registros, dados. Desse maneira o banco de dados, por si só, pode
IN
ser considerado como o equivalente eletrônico de um armário de arquivamento onde
os usuários do sistema podem realizar diversas operações (DATE, 2004):
• Busca de dados;
Inserção de dados;
IM
•
• Exclusão de dados;
• Alteração de dados;
• Remoção de dados;
N
empresa”.
Os dados armazenados em um banco de dados representam algum
aspecto específico do mundo real — um universo de discurso de onde os dados são
obtidos — e apresentam algum grau de coerência lógica entre seus componentes.
Portanto, uma coleção aleatória de dados não constitui um banco de dados.
Um sistema de banco de dados é constituído por um banco de dados e
por um sistema gerencia-dor de banco de dados, como mostrado na figura 83. Um
sistema de banco de dados é usualmente uma aplicação que serve de suporte a
130
S
• Armazenamento, organização e obtenção de dados estruturados.
• Compartilhamento dos dados.
• Redução de redundância.
A
• Inconsistência pode ser evitada.
IN
• Fornecimento de suporte a transação.
• Manutenção da Integridade.
• Reforço da segurança.
• Requisitos contraditórios podem ser equilibrados.
IM
• Imposição de padrões.
S
A
Figura 83 – Sistema simplificado de Banco de Dados.
Adaptado de RICARTE. I. L. M (1998, p.2).
IN
O banco do Sistema Gestão de Condomínio foi usado para oferecer um
armazenamento persistente aos objetos programas e estruturas de dados. Essa é
umas das principais justificativas para o sistema de banco de dados orientados a
IM
6.2. MYSQL
N
S
Fornece mecanismos de armazenamento transacional e não
transacional.
É relativamente
armazenamento.
A
fácil se adicionar outro
S
Você pode misturar tabelas de bancos de dados diferentes na mesma
pesquisa.
• Segurança
A
Um sistema de privilégios e senhas que é muito flexível, seguro e que
IN
permite verificação baseada em estações/máquinas. Senhas são
seguras porque todo o tráfico de senhas é criptografado quando você
se conecta ao servidor.
• Escalabilidade
IM
• Conectividade
Os clientes podem se conectar ao servidor MySQL usando sockets
TCP/IP (Transmission Control Protocol/Internet Protocol), em qualquer
plataforma. No sistema Windows na família NT (NT, 2000 ou XP), os
N
S
(Wikipédia, 2009b).
6.3.1. Modelos
A
Um modelo de dados é uma definição abstrata, autônoma e lógica dos
objetos, operadores e outros elementos.
IN
De acordo com a abordagem que utilizada e conforme ilustrado pela
figura 84, os modelos de dados normalmente são classificados da seguinte forma:
IM
N
U
• Modelo Conceitual:
o Representação dos conceitos e características observados no
ambiente;
o Ignorar particularidades de implementação.
A modelagem conceitual é uma fase muito importante no
planejamento de uma aplicação de um banco de dados bem-sucedida.
Geralmente, o termo aplicação de um banco de dados refere-se a um banco de
dados particular e aos programas a eles associados, que implementam consultas
e atualizações (ELMASRI & NAVATHE, 2005, p.35).
S
• Modelo Lógico:
o Regras de Derivação:
A
Normalização das estruturas de dados
Derivação de estruturas de agregação e generalização-
IN
especialização
Derivação de relacionamentos
o Regras de Restrição:
Restrição de domínio
IM
Restrição de Integridade
Restrição de Implementação
Figura 86 apresentada o modelo lógico implementado para Sistema de
Gestão de Condomínio.
N
U
136
S
A
IN
IM
Modelo Físico:
U
•
o Inclui a análise das características e recursos necessários para
armazenamento e manipulação das estruturas de dados (estrutura de
armazenamento, endereçamento, acesso e alocação física).
Figura 85 apresenta o modelo físico implementado para o Sistema de
Gestão de Condomínio.
137
S
A
IN
Figura 86 – Modelo Físico de Banco de Dados.
IM
S
− Relação 1..1 - indica que as tabelas têm relação unívoca entre si. Você
escolhe qual tabela vai receber a chave estrangeira;
A
− Relação 1..n - a chave primária da tabela que tem o lado 1 vai para a
tabela do lado N. No lado N ela é chamada de chave estrangeira;
IN
− Relação n..n - quando tabelas têm entre si relação n..n, é necessário criar
uma nova tabela com as chaves primárias das tabelas envolvidas, ficando
assim uma chave composta, ou seja, formada por diversos campos-chave
de outras tabelas. A relação então se reduz para uma relação 1..n, sendo
IM
Chave primária: (PK - Primary Key) é a chave que identifica cada registro
dando-lhe unicidade. A chave primária nunca se repetirá.
139
S
A entidade TaxaCondominio é composta pelos seguintes atributos:
TC_mesRef (PK), CM_id (FK), TC_valorTaxa, TC_dataGeracao,
TC_dataVencimento. A entidade
A
TaxaCondominio é identificada pelo atributo
chave TC_mesRef. A entidade ContaMensal é composta pelos seguintes atributos:
CM_id (PK), CM_tipo, CM_valorConta, CM_mesreferencia, CM_dataVencimento. A
IN
entidade ContaMensal é identificada pelo atributo CM_id. A entidade
LancamentoMes é composta pelos seguintes atributos: LM_id (PK), TC_mesRef
(FK), CM_id (FK), U_numero (FK), LM_data, LM_referencia, LM_tipo, LM_valor,
IM
Numa aplicação que utilize a arquitetura MVC (Model, View, Controler), todas as
funcionalidades de bancos de dados, tais como obter as conexões, mapear objetos
Java para tipos de dados SQL ou executar comandos SQL, devem ser feitas por
classes de DAO.
Usando-se esse padrão a camada de negócios acessa os dados
persistidos sem ter conhecimento se os dados estão em um banco de dados
relacional ou um arquivo XML (eXtensible Markup Language). O padrão DAO
esconde os detalhes da execução da origem dos dados (SUN, 2009).
Utilizou-se o DAO para abstrair e encapsular todo o acesso à fonte de
dados. O DAO gerencia a conexão com a fonte de dados para obter e armazenar
dados (SUN, 2009).
S
A figura 87 apresenta a estrutura do padrão DAO. A classe
DataAccessObject encapsula o acesso aos dados, que por sua vez é mantido pela
A
classe DataSource que pode ser um arquivo XML, uma base de dados ou
algum serviço remoto, ou seja, a origem dos dados. A classe BusinessObject
IN
representa a aplicação (também conhecida como cliente do padrão), que usa
um objeto DataAccessObject. Ao utilizar esse objeto DataAcessObject, o objeto
cliente recebe ou envia um objeto TransferObject. Esse objeto contém os dados a
serem enviados ou trazidos da origem dos dados, e normalmente referem-se aos
IM
campos de um registro.
N
U
S
orientadas a objeto tornando complicado a integração entre esse tipo de banco de
dados e essas linguagens. Além disso, mesmo em linguagens estruturadas como
Java, trabalhar com banco de dados tornava-se uma tarefa árdua à medida que a
A
aplicação cresce. Um modelo de programação muito usado, mesmo em linguagens
tipicamente orientadas a objeto como Java, é misturar lógica de negócio com código
IN
SQL. Caso o banco de dados de aplicação mude, seria necessário reescrever
praticamente toda a aplicação, para dar suporte ao novo banco.
Assim uma técnica bastante conhecida da orientação a objetos é o
encapsulamento, onde é possível esconder as regras dentro de objetos e definir
IM
alguns métodos nesses objetos que o mundo externo poderá usar para ter acesso
ao resultado dos códigos. Essa idéia foi adaptada à programação com banco de
dados. Os métodos necessários ao acesso e manipulação do banco ficam
escondidos dentro de classes básicas. As outras partes da aplicação usam essas
N
entidade a partir da estrutura das tabelas criadas no Banco de Dados. Tendo sido
essa a maneira utilizada para iniciar-se a codificação do sistema em questão.
S
existe código extra gerado na compilação dos códigos fontes para bytecode.
Alta escalabilidade: tem alta performance com sua arquitetura com 2
caches e pode ser utilizado em cluster.
A
Query language: soluciona ambos os lados, não somente como enviar
os dados para o banco de dados, como também como buscar os mesmos do banco
IN
de dados.
Suporte a transações a “nível de aplicação”: suporta contextos de
persistência de longa duração, detach/reattach e executa lock otimista
automaticamente;
IM
S
Figura 88 – Arquitetura Hibernate.
Adaptado de Hibernate (2009).
A
IN
• Hibernate.properties: configuração do Hibernate com relação ao SGBD (url,
senha, driver JDBC, etc. ).
• Uma API para executar operações CRUD (Create, retrieve, updade, delete)
básicas em objetos de classes persistentes.
• A linguagem ou API para especificar consultas que referenciem classes e
propriedades de classes.
• Um recurso para especificar o mapeamento de metadados.
• Um técnica para a implementação do ORM para interagir com objetos
S
transacionais a fim de executar a verificação suja, buscas de associação
ociosas e outras funções de otimização.
A
Ainda, considerando Bauer e King (2005, p. 32) “o termo ORM é usado
para incluir qualquer camada de persistência onde o SQL seja gerado
automaticamente a partir de uma descrição baseada em metadados”.
IN
O mapeamento é feito utilizando annotations, além disto, é direcionado
para as classes e não para as tabelas diretamente. Uma estrutura específica é
validada, o qual indica as propriedades a serem mapeadas em um objeto, permitindo
IM
mapeado.
As bibliotecas de Mapeamento Objeto Relacional fazem o mapeamento
de tabelas para classes. Como exemplo o banco de dados desenvolvido para o
sistema possui uma tabela chamada Historico, a aplicação possuirá, uma classe
denominada Historico. Essa classe definirá atributos, que serão usados para receber
e alterar os dados dos campos das tabelas, além de métodos para realizar as
operações.
145
S
definem o mapeamento das classes que vão gerar os objetos para serem
persistidos. Todas essas informações ficam dentro da tag <Hibernate-configuration>.
A
Dentre os principais parâmetros destacamos:
SGBDs.
• property name="hibernate.connection.driver_class" informa qual o driver
JDBC deve ser utilizado para a conexão.
• property name="hibernate.connection.username" informa qual o nome do
N
usuário do SGBD.
• property name="hibernate.connection.password" informa qual a senha de
conexão do SGBD.
U
<property name="hibernate.connection.username">root</property>
<property name="hibernate.connection.password"></property>
<property name="hibernate.current_session_context_class">thread</property>
<property
name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>
<property
name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
<property name="show_sql">true</property>
<property name="connection.pool_size">1</property>
<!-- mapeamento das entidades -->
<mapping class="br.uniminas.entidades.UsuarioEntidade" />
<mapping class="br.uniminas.entidades.Unidade" />
<mapping class="br.uniminas.entidades.Pessoa" />
<mapping class="br.uniminas.entidades.Historico" />
</session-factory>
</hibernate-configuration>
S
Figura 89 - Arquivo "hibernate.cfg.xml".
sessionFactory = new
AnnotationConfiguration().configure().buildSessionFactory();
} catch (Throwable ex) {
// Make sure you log the exception, as it might be swallowed
System.err.println("Initial SessionFactory creation failed." + ex);
throw new ExceptionInInitializerError(ex);
N
}
}
public static SessionFactory getSessionFactory() {
return sessionFactory;}
U
}
Figura 90 – Classe Hibernate Útil.
S
...
A
public class HistoricoHibernateDAO implements HistoricoDAO {
id=:Id_Historico");
q.setInteger("Id_Historico", i);
return (Historico) q.uniqueResult();
} finally {
// session.close();
}
N
}
public List consultaHistorico(String numero){
session = HibernateUtil.getSessionFactory().openSession();
try {
U
session.beginTransaction();
Query q = (Query) session.createQuery("from Historico where
numero=:U_numero").list();
q.setString("U_numero", numero);
histList=(List<Historico>) q;
return histList;
} finally {
// session.close();
}
}
public void insert(Historico his) {
session = HibernateUtil.getSessionFactory().openSession();
Transaction tx = null;
try { tx = session.beginTransaction();
148
session.save(his);
tx.commit();
} catch (RuntimeException e) {
if (tx != null)
tx.rollback();
throw e;
} finally {
// session.close();
}
}
public void delete(String id) {
session = HibernateUtil.getSessionFactory().openSession();
Transaction tx = null;
try { tx = session.beginTransaction();
hist = (Historico) session.get(Historico.class, id);
session.delete(hist);
S
tx.commit();
} catch (RuntimeException e) {
if (tx != null)
tx.rollback();
}
throw e;
} finally {
}
A
IN
public void updateHistorico(Historico hist) {
session = HibernateUtil.getSessionFactory().openSession();
Transaction tx = null;
try { tx = session.beginTransaction();
session.update(hist);
IM
tx.commit();
} catch (RuntimeException e) {
if (tx != null)
tx.rollback();
throw e;
} finally {
N
}
}
}
Figura 91 – Classe de persistência HistoricoHibernateDAO.
U
S
Para melhor uma compreensão, é possível visualizar na figura 92 a
classe de entidade Histórico, e as anotações usadas como mecanismos de
persistência.
A
IN
...
@Entity
@Table(name = "historico")
public class Historico {
//@GeneratedValue(strategy=GenerationType.AUTO)
@Id
IM
@ManyToOne
@JoinColumn(name = "U_numero", unique = true)
Unidade numero;
@ManyToOne
@JoinColumn(name = "morador", unique = true)
Pessoa morador;
@ManyToOne
@JoinColumn(name = "proprietario", unique = true)
Pessoa proprietario;
public Historico() {}
public Historico(Date hProVenda, Date hProAqui, Date morEntr,
Date morSaida, Unidade u, Pessoa mor, Pessoa prop) {
this.h_proVenda = hProVenda;
150
this.h_proAquiscao = hProAqui;
this.h_morEntrada = morEntr;
this.h_morSaida = morSaida;
this.numero = u;
this.morador = mor;
this.proprietario = prop;
}
...
Figura 92 – Classe de entidade Histórico.
S
@Table: usada para definir qual tabela será usada para persistir os objetos dessa
classe. Se essa anotação não for usada, o Hibernate irá procurar por uma tabela
com o mesmo nome da classe.
A
@Id: declara qual campo, atributo da classe será usado como identificador. Neste
IN
caso, foi definido o atributo "id".
@Column: usada para definir as propriedades dos atributos.
@ManyToOne: informa que existe um relacionamento de um para muitos.
@JoinColumn: é utilizada para informar que o nome da chave estrangeira
IM
com a customização do usuário em mente (BAUER & KING, 2005). Isso torna a
interação com o banco de dados transparente, do ponto de vista da programação
U
7. CONCLUSÃO
S
sistema uma vez que serão a base para a manutenção e expansão do mesmo.
O uso da linguagem Java permitiu a implementação do software, pois
A
além de não apresentar custo, opera em qualquer sistema operacional. Essa
característica atendeu, logicamente, a uma das exigências do projeto: o software
IN
deveria operar sobre o sistema operacional Windows XP, uma vez que o
equipamento do cliente possuía esta configuração. Além disso, a linguagem
orientada a objeto permitiu uma modelagem dentro da tendência atual, o que, de
acordo com a literatura, deverá facilitar as alterações e adequações necessárias
IM
equipamento e sob esse aspecto, o Eclipse não se mostrou estável. Por diversas
vezes, as bibliotecas tiveram de ser reinseridas, pois não foram reconhecidas apesar
de estarem no projeto.
O uso do Hibernate facilitou a implementação das classes de entidade,
através da engenharia reversa, que embora seja um processo de muitos passos,
garante a correlação entre as classes e as tabelas do banco de dados. Observa-se,
ainda, que esse procedimento pode ser realizado escalonadamente, facilitando a
implementação por iterações, que muitas vezes se fazem necessárias, quando do
desenvolvimento de grandes projetos. As annottations realizaram com facilidade o
152
S
Comprovou-se a importância dos padrões, que apresentam soluções claras para
determinados problemas. No caso se percebeu a necessidade de um controle
A
central da aplicação, como elemento organizador das requisições. Assim, o
controlador foi peça chave na aplicação, cujo desenvolvimento foi facilitado pelo
IN
emprego do Struts, que implementa automaticamente o Front Controller, através do
mapeamento das ações no arquivo Struts.xml.
É importante reforçar que o uso dos frameworks facilitou bastante o
desenvolvimento dessa aplicação multicamadas, quer seja pela implementação dos
IM
S
A
IN
IM
N
U
154
REFERÊNCIAS BIBLIOGRÁFICAS
ALUR, Deepak; CRUPI, John; MALKS, Dan. Core J2EE Patterns: as melhores
práticas e estratégias de design.Tradução de Altair Dias Caldas de Morais. Rio de
Janeiro: Elsevier, 2004. 587 p.
S
ANGOTI JR., Edson. Programação de Aplicações para Internet usando
JSP/SERVLETS. Diponível em: <http://si.uniminas.br/~angoti/arquivos>. Acesso em:
04 jun. 2009a.
A
ANGOTI JR., Edson. Padrões de Projeto JEE. Disponível
em:<http://si.uniminas.br/~angoti/arquivos/PadroesProjetoJEE.pdf> Acesso em: 09
IN
jun. 2009b.
em 16 maio 2009.
S
DATE, C. J. Introdução a Sistemas de Banco de Dados. Tradução de Daniel
Vieira. Rio de Janeiro: Campus, 2004. 865p. Título original: An Introduction to
Database Systems.
A
DEBONI, José Eduardo Zindel. Modelagem orientada a objetos com a UML. São
Paulo: Futura, 2003. 219 p.
IN
DUMOULIN, Cedric; FRANCISCUS, George; WINTERFELDT, David. Struts em
ação. Tradução de Eveline Vieira Machado. Rio de Janeiro: Ciência Moderna, 2004.
604 p.
de Marília Guimarães Pinheiro, Claudio Cesar Canhette, Glenda Cristina Valim Melo,
Claudia Vicci Amadeu e Rinaldo Macedo de Morais. 4 ed. São Paulo: Person
Addison Wesley, 2005. 724p. Título original: Fundamentals of Database Systems.
FERREIRA, Simone Bacellar Leal ET all . Requisitos Não Funcionais para Interfaces
com o Usuário - O Uso de Cores. In: IDEAS 1999 - Segunda Jornada
N
FREUD, Sigmund. O mal estar na civilização. Rio de Janeiro: Imago. 2002. 116 p.
em: <http://twiki.cin.ufpe.br/twiki/pub/SPG/GenteAreaPublications/PLOP02_dias.pdf>.
Acesso em: 27 mai. 2009.
S
MIRANDA, Ângelo Tiago. Conseqüências e características das cidades.
Disponível em: <http://educacao.uol.com.br/geografia/ult1701u57.jhtm>. . Acesso
em: 7 mar 2009.
A
MYSQL. The world's most popular open source. Disponível em:
<http://www.mysql.com>. Acesso em: 15 abr. 2009.
IN
PREFEITURA DE UBERLÂNDIA. Secretaria Municipal de Planejamento. Banco de
dados integrados. Uberlândia, 2007. Disponível em:
<http://www.uberlandia.mg.gov.br/midia/documentos/planejamento_urbano/BDI_200
7_vol_1.pdf>. Acesso em: 7 mar 2009.
IM
SILVA, Paulo C. Barreto da. Utilizando UML: diagrama de classes. SQL Magazine,
Rio de Janeiro, edição 63, ano 5, p. 10-17, 2007.
SILVA, Sonia Maria Antunes da; BONIN, Marcos Rodrigo; PALUDO, Marco Antônio.
U
S
WAZLAWICK, Raul Sidney. Análise e projetos de sistema orientados a objetos. 2.
Ed. Rio de Janeiro: Elsevier, 2004. 295 p.
A
WIKIPEDIA. Java (linguagem de programação). Disponível em: (Orlando)
<http://pt.wikipedia.org/wiki/Java/linguagem_de_programa%C3%A7%C3%A3o>.
Acesso em 15 maio 2009a.
IN
_______. Modelagem de dados. Disponível em (Marco 2)
<http://pt.wikipedia.org/wiki/Modelagem_de_dados>. Acesso em: 2 jun. 2009b.
APÊNDICE
S
<result>/page/login.jsp</result>
<result name="success">/page/principal.jsp</result>
<result name="erro">/page/login.jsp</result>
</action>
<action name="principal">
<result>/page/principal.jsp</result>
A
IN
</action>
<action name="getAllPessoas" method="getAllPessoas"
class="br.uniminas.action.CadastrarPessoaAction">
<result name="success">/page/pessoas.jsp</result>
</action>
IM
<result name="success">/page/cadastroPessoaForm.jsp</result>
</action>
<action name="insertOrUpdate" method="insertOrUpdate"
U
class="br.uniminas.action.CadastrarPessoaAction">
<result name="success">/page/sucesso.jsp</result>
<result name="erro">/page/erro.jsp</result>
</action>
<action name="setUpForInsertOrUpdate2" method="setUpForInsertOrUpdate2"
class="br.uniminas.action.PesquisarAction">
<result name="success">/page/consultaPessoaForm.jsp</result>
</action>
<action name="setUpForInsertOrUpdate3" method="setUpForInsertOrUpdate3"
class="br.uniminas.action.PesquisarAction">
<result name="success">/page/consultaUnidadeForm.jsp</result>
</action>
159
S
<action name="consultarHistorico" method="consultaHistorico"
class="br.uniminas.action.PesquisarAction">
<result name="success">/page/historico.jsp</result>
<result name="erro">/page/erro.jsp</result>
</action>
A
<action name="delete" method="deletePessoa"
class="br.uniminas.action.CadastrarPessoaAction">
IN
<result name="success" type="redirect-action">getAllPessoas</result>
<result name="erro">/page/erro.jsp</result>
</action>
</package>
</struts>
IM
N
U