desenvolvimento de uma ferramenta para geração automática de

LUCAS POMPEO PONTES SPINELLI
DESENVOLVIMENTO DE UMA FERRAMENTA PARA GERAÇÃO
AUTOMÁTICA DE CÓDIGO ABERTO EM JAVA SERVER FACES
Assis
2015
LUCAS POMPEO PONTES SPINELLI
DESENVOLVIMENTO DE UMA FERRAMENTA PARA GERAÇÃO
AUTOMÁTICA DE CÓDIGO ABERTO EM JAVA SERVER FACES
Trabalho de Conclusão de Curso apresentado
Instituto Municipal de Ensino Superior de Assis,
como requisito do Curso Superior de
Bacharelado em Ciência da Computação.
Orientador: Prof. Douglas Sanches da Cunha
Área de concentração: Ciência da Computação
Assis
2015
FICHA CATALOGRÁFICA
POMPEO PONTES SPINELLI, Lucas
Desenvolvimento de uma Ferramenta para Geração Automática de Código Aberto
em Java Server Faces / Lucas Pompeo Pontes Spinelli. Fundação Educacional do
Município de Assis – Assis, 2015.
46p.
Orientador: Prof. Douglas Sanches da Cunha
Trabalho de Conclusão de Curso – Instituto Municipal de Ensino Superior de
Assis – IMESA.
1. Gerador 2. Java 3. Framework
CDD 001.6
Biblioteca da FEMA
DESENVOLVIMENTO DE UMA FERRAMENTA PARA GERAÇÃO
AUTOMÁTICA DE CÓDIGO ABERTO EM JAVA SERVER FACES
LUCAS POMPEO PONTES SPINELLI
Trabalho de Conclusão de Curso apresentado ao
Instituto Municipal de Ensino Superior de Assis,
como requisito do Curso Bacharelado em
Computação analisado pela seguinte comissão
examinadora:
Orientador: Prof. Douglas Sanches da Cunha
Analisador: Prof. Célio Desiró
Assis
2015
DEDICATÓRIA
Dedico este trabalho primeiramente a Deus,
que me guardou e me deu toda a
perseverança para a realização do trabalho.
Dedico também para todas as pessoas
que contribuíram para que ele fosse
concluído, como familiares e amigos.
AGRADECIMENTOS
Primeiramente a Deus que permitiu que tudo isso se realizasse, e não só por
esses anos, e sim por todos os momentos em minha vida.
A FEMA, pela oportunidade de realizar o curso, e todo o seu corpo docente.
Ao professor Douglas, por toda atenção e suporte dado para a realização do meu
projeto.
Aos familiares e amigos que sempre estiveram comigo, me ajudando e que
fizeram parte da minha formação.
RESUMO
O presente trabalho irá facilitar o desenvolvimento de software, com a criação de
módulos CRUD (Create, Read, Update e Delete) e tabelas no banco de dados,
que são utilizadas para o armazenamento de informações. O framework
fornecerá classes (modelo, bean, dao...) que podem ser usadas por todo o
projeto agilizando a construção da interface gráfica e também no acesso ao
banco de dados. Este trabalho trará diversas vantagens ao usuário, como
padronização, eficiência e o aumento da produtividade. Muitas outras vantagens
podem ser percebidas com o uso do gerador automático de código. O código
será gerado na linguagem Java para a plataforma WEB.
Palavras chave: Gerador, framework, Java.
ABSTRACT
The present work will facilitate the software development, with the creation of
modules CRUD (Create, Read, Update and Delete), reports and tables in the
database. The framework will provide classes that can be used throughout the
project speeding the GUI construction and also in the access to the database.
This work will bring several advantages to the user, such as standardization,
efficiency and increased productivity. Many other advantages can be realized by
using automatic code generator. The code will be generated in the language Java
on the platform WEB.
Tags: Generator, framework, Java.
LISTA DE ILUSTRAÇÕES
Figura 1 – Funcionamento JSF....................................................................16
Figura 2 – Exemplo JDBC...........................................................................18
Figura 3 – PostgreSQL................................................................................18
Figura 4 – Netbeans....................................................................................19
Figura 5 – Java............................................................................................19
Figura 6 – Diagrama de classe Modelo para exemplo................................20
Figura 7 – Diagrama de classe DAO para exemplo....................................21
Figura 8 – Diagrama de classe Bean para exemplo....................................21
Figura 9 – Estrutura analítica do projeto......................................................22
Figura 10 – Caso de uso do projeto.............................................................25
Figura 11 – Caso de uso Manter Projeto.....................................................26
Figura 12 – Diagrama de sequência Manter Projeto...................................27
Figura 13 – Caso de uso manter Classe.....................................................28
Figura 14 – Diagrama de sequência Classe................................................29
Figura 15 – Caso de uso manter Atributo....................................................30
Figura 16 – Diagrama de sequência Atributos.............................................31
Figura 17 – Caso de uso Manter Profissional..............................................32
Figura 18 – Diagrama de sequência Profissional........................................33
Figura 19 – Caso de uso Manter Suporte....................................................34
Figura 20 – Diagrama de sequência Suportes............................................35
Figura 21 – Caso de uso Gerar Tabela.......................................................36
Figura 22 – Diagrama de sequência Gerar Tabela......................................37
Figura 23 – Caso de uso Gerar Modelo.......................................................38
Figura 24 – Diagrama de sequência Gerar Modelo.....................................38
Figura 25 – Caso de uso Gerar DAO...........................................................39
Figura 26 – Diagrama de sequência gerar DAO..........................................40
Figura 27 – Caso de uso Gerar Bean..........................................................41
Figura 28 – Diagrama de sequência gerar Bean.........................................42
Figura 29 – Caso de uso gerar tela JSF......................................................43
Figura 30 – Diagrama de sequência gerar Tela..........................................43
LISTA DE TABELAS
Tabela 1 – Lista de eventos.........................................................................24
Tabela 2 – Orçamento do projeto................................................................25
Tabela 3 – Narrativa Caso de Uso Manter Projeto......................................26
Tabela 4 – Narrativa Caso de Uso Manter Classe......................................28
Tabela 5 – Narrativa Caso de Uso Manter Atributo.....................................29
Tabela 6 – Narrativa Caso de Uso Manter Profissional...............................33
Tabela 7 – Narrativa Caso de Uso Manter Suporte.....................................34
Tabela 8 – Narrativa Caso de Uso Gerar Tabela........................................37
Tabela 9 – Narrativa Caso de Uso Gerar Modelo........................................38
Tabela 10 – Narrativa Caso de Uso Gerar DAO..........................................39
Tabela 11 – Narrativa Caso de Uso Gerar Bean.........................................41
Tabela 12 – Narrativa Caso de Uso Gerar Tela JSF...................................42
LISTA DE ABREVIATURAS E SIGLAS
HTTP – Hypertext Transfer Protocol
JDK – Java Development Kit
IDE – Integrated Development Environment
JSF – JavaServer Faces
DAO - Data Access Object
JDBC - Java Database Connectivity
MVC - Model-view-controller
API – Application Programming Interface
SGBD – Sistema Gerenciador de Banco de Dados
SUMÁRIO
1 INTRODUÇÃO..............................................................................................13
1.1
OBJETIVO................................................................................................14
1.1.1 OBJETIVO ESPECÍFICO........................................................................14
1.2 JUSTIFICATIVA...........................................................................................14
1.3 MOTIVAÇÃO...............................................................................................15
1.4 PÚBLICO ALVO...........................................................................................15
2
GERADOR AUTOMÁTICO DE CÓDIGOS.................................................15
2.1 FERRAMENTAS UTILIZADAS....................................................................16
2.1.1 JSF..........................................................................................................16
2.1.2 JDBC.......................................................................................................18
2.1.3 POSTGRESQL.......................................................................................18
2.1.4 NETBEANS.............................................................................................19
2.1.5 JAVA.......................................................................................................19
2.2 FUNCIONAMENTO.....................................................................................20
3
ESTRUTURA ANALÍTICA DO PROJETO..................................................22
4
ANÁLISE DOS REQUISITOS.....................................................................23
4.1 RESULTADO ESPERADO..........................................................................23
4.2 FORMA ADOTADA PARA O LEVANTAMENTO DOS REQUISITOS.........23
4.3 RESTRIÇÕES DO DESENVOLVIMENTO..................................................23
4.4 PROBLEMAS POTENCIAIS........................................................................24
4.5 LISTA DE EVENTOS...................................................................................24
4.6 ORÇAMENTO DO PROJETO.....................................................................25
5
DIAGRAMAS..............................................................................................25
5.1 CASO DE USO PRINCIPAL/GERAL..........................................................25
5.2 CASO DE USO MANTER PROJETO..........................................................26
5.3 DIAGRAMA DE SEQUENCIA PROJETO....................................................27
5.4 CASO DE USO MANTER CLASSE.............................................................28
5.5 DIAGRAMA DE SEQUENCIA DE CLASSE................................................29
5.6 CASO DE USO MANTER ATRIBUTO.........................................................30
5.7 DIAGRAMA DE SEQUENCIA ATRIBUTO..................................................31
5.8 CASO DE USO MANTER PROFISSIONAL................................................32
5.9 DIAGRAMA DE SEQUENCIA PROFISSIONAL..........................................33
5.10 CASO DE USO MANTER SUPORTE....................................................34
5.11 DIAGRAMA DE SEQUENCIA SUPORTE..............................................35
5.12 CASO DE USO USUÁRIO GERAR TABELA.........................................36
5.13 DIAGRAMA DE SEQUENCIA GERAR TABELA....................................37
5.14 CASO DE USO GERAR A CLASSE MODELO......................................38
5.15 DIAGRAMA DE SEQUENCIA DA GERAÇÃO DA CLASSE MODELO..38
5.16 CASO DE USO GERAR A CLASSE DAO..............................................39
5.17 DIAGRAMA DE SEQUENCIA DA GERAÇÃO DA CLASSE DAO..........40
5.18 CASO DE USO GERAR A CLASSE BEAN............................................41
5.19 DIAGRAMA DE SEQUENCIA DA GERAÇÃO DA CLASSE BEANS......42
5.20 CASO DE USO GERAR A TELA JSF.....................................................43
5.21 DIAGRAMA DE SEQUENCIA DA GERAÇÃO DA TELA........................43
6
CONCLUSÃO..............................................................................................45
7
REFERENCIAS...........................................................................................46
14
1 INTRODUÇÃO
Nos dias de hoje, pode-se dizer que o grande desafio na área da tecnologia é
criar um software com qualidade e que atenda as necessidades do consumidor
no menor tempo possível. O uso de ferramentas geradoras de código oferece
uma grande ajuda às técnicas de desenvolvimento ágil e tende a suprir algumas
dessas necessidades. A falta de padronização de códigos, tarefas repetidas,
gastos desnecessários de tempo, são problemas que ocorrem durante o
desenvolvimento de software, levando a gastos maiores, entre outros problemas.
Segundo Gomes (1998), o desenvolvimento ágil tende a satisfazer o cliente,
entregando o software em um prazo curto de tempo e funcionando.
Segundo Pressman (2011), ter como prioridade satisfazer o cliente por meio de
entrega adiantada e contínua do software, acolher bem os pedidos de alterações
(aproveitando o tempo ganho com o framework), entregar o software em
funcionamento, simplicidade, são os princípios básicos para o desenvolvimento
ágil.
Segundo Coad (1992), um framework pode ser definido como um esqueleto de
classes, objetos e relacionamentos agrupados para construir aplicações
específicas.
Para Johnson (1991), o projeto de um conjunto de objetos que colaboram entre
si para execução de um conjunto de responsabilidades, seria a definição para
framework.
Um framework é a ferramenta certa para o desenvolvimento ágil. Essa
ferramenta enquadra-se perfeitamente no que diz respeito a diminuir o tempo
utilizado para o desenvolvimento, organização, agilidade e códigos genéricos.
Os frameworks são importantíssimos por terem diversas vantagens em sua
utilização, como: redução de custos, redução de time-to-market, entre outros. E
os motivos para isso, são: a maximização de reuso, desenvolvedores do
software adicionam valores em vez de começar do zero, menos manutenção.
15
1.1 OBJETIVO
O Objetivo é construir um sistema que irá gerar códigos Java, inclusive as telas
para um projeto Java para Web, que auxiliará o gerente de projeto no
desenvolvimento de software.
1.1.1 Objetivo Específico
O Gerador Automático de Código, agilizará o processo de desenvolvimento de
software, no tocante à criação de módulos CRUD (Create, Read, Update e
Delete), templates(PrimeFaces) e tabelas no banco de dados (JDBC) e no
controle do projeto, como profissionais e suportes a serem dados.
1.2 JUSTIFICATIVA
Criar um software envolve vários procedimentos, tais como, criação de telas,
páginas, classes e a conexão com o banco de dados. O tempo dedicado para
realizar esses procedimentos é muito importante.
O desenvolvimento do Gerador Automático de Código justifica-se pela tentativa
de agilizar o processo de desenvolvimento do software no estágio inicial,
diminuindo o consumo de tempo de programação dos cadastros CRUD do
sistema.
Uma das motivações para este trabalho é que o Gerador poderá produzir código
para o ambiente WEB proporcionando agilidade de fato na criação de código e
padronização, sobrando tempo para outras funções mais especificas do sistema.
Utilizar um gerador automático de código tem algumas vantagens:
- Qualidade: Os códigos digitados manualmente tendem a ter um nível de
qualidade bastante irregular.
16
- Produtividade: Com o gerador, o número de códigos digitados tem uma queda
muito relevante, ou seja, sobrará mais tempo para o desenvolvimento de outras
rotinas do sistema.
1.3 MOTIVAÇÃO
A principal motivação para o desenvolvimento do Gerador se dá ao fato do tempo
utilizado no desenvolvimento de software ser muito importante. Com a criação
do framework, o desenvolvedor terá tempo para trabalhar em outras
especificações do projeto.
1.4 PÚBLICO ALVO
O fator mais interessante do sistema é o seu público alvo: o gerente de projeto
e o próprio desenvolvedor. O gerador vai ser utilizado pelo gerente de projeto e
programadores. Irá facilitar o trabalho inicial e o de acompanhamento de todas
as rotinas geradas pelo sistema.
2 GERADOR AUTOMÁTICO DE CÓGIDOS
Como já citado anteriormente, o gerador facilitará a vida do usuário durante o
desenvolvimento do software, economizando um tempo bastante significante,
assim, eliminando repetições de códigos, não começando a programar do zero,
aumentando a produtividade do desenvolvimento, a eliminação de algumas
falhas, dentre outras.
Segundo Dollard (2014), as vantagens do gerador são:
Padronização: Com a padronização, diversos erros são evitados na
implementação. Aumentando consideravelmente a qualidade do código.
17
Eficiência: Testes e padrões deixam o código muito eficaz em relação as
suas funcionalidades.
Produtividade: Com o gerador, muito tempo é ganho, então, com o uso
dele, o foco dos desenvolvedores voltam-se às especificações do sistema, como
regras de negócios, etc.
2.1 FERRAMENTAS UTILIZADAS
2.1.1 JSF
JSF é um framework que permite a criação de interfaces web colocando os
componentes em um formulário e conectando-os com objetos Java permitindo a
separação entre lógica e regras de negócio, navegação, conexões com serviços
externos e gerenciamento de configurações. JSF é um padrão MVC, ou seja,
divide a camada em três partes: model, view e controller.A model (modelo) é
responsável pela apresentação dos objetos. A view (visão) é responsável pela
interface. Controller (controlador) é responsável pela conexão entre a view e a
model.
Esse framework é bastante utilizado pelos desenvolvedores por ser flexível, de
fácil entendimento, de fácil manuseio e de diversas opções.
A figura a seguir mostra o funcionamento do framework:
Figura 1 – Funcionamento JSF
18
2.1.2 JDBC
JDBC é uma API que contém classes e interfaces na linguagem Java que
possibilitam conectar através de um driver específico do banco de dados
desejado. Com esse driver, podem-se executar instruções SQL em qualquer tipo
de banco de dados.
É necessário possuir um driver para fazer a conexão entre a aplicação e o
SGBDs.
Figura 2 – Exemplo JDBC
2.1.3 PostgreSQL
PostgreSQL é um sistema de gerenciamento de banco de dados (SGBDs). O
PostgreSQL é descendente de código aberto, que possui várias funcionalidades,
como: comandos complexos, chaves estrangeiras, gatilhos, visões, integridade
transacional e controle de simultaneidade multiversão. Além disso, esse sistema
também pode ser ampliado pelo usuário de muitas maneiras como, por exemplo,
adicionando novos tipos de dado, funções, operadores, funções de agregação,
métodos de índice e linguagens procedurais.
Figura 3 - PostgreSQL
19
2.1.4 NetBeans
O NetBeans é um ambiente de desenvolvimento, ou seja, uma ferramenta para
desenvolvedores, que permite escrever, compilar, depurar e instalar programas.
Esse ambiente é completamente escrito em Java, mas pode suportar qualquer
linguagem de programação. O NetBeans é um produto livre, e também existem
várias extensões de funcionalidades do IDE. A IDE é um projeto de código livre
de sucesso, fundada pela Sun Microsystems.
Figura 4 - NetBeans
2.1.5 Java
Java é uma linguagem de programação e plataforma computacional criada pela
Sun Microsystems.
As principais características da linguagem Java são: orientação a objeto,
portabilidade, recursos de rede e segurança.
É a tecnologia que capacita muitos programas da mais alta qualidade, como
utilitários, jogos e aplicativos corporativos, entre muitos outros, por exemplo. O
Java é executado em mais de 850 milhões de computadores pessoais e em
bilhões de dispositivos em todo o mundo, inclusive telefones celulares e
dispositivos de televisão.
20
Figura 5 - Java
2.2 FUNCIONAMENTO
O gerador funciona da seguinte maneira: O usuário precisará cadastrar o projeto
a ser desenvolvido e os profissionais que irão trabalhar nele. Cada detalhe do
projeto será salvo, como classes e atributos. Há telas para a criação de classes,
atributos, profissionais, suportes e projetos com todas as especificações
requeridas. Na tela do gerador, o projeto e classe serão selecionados, mostrando
todas as informações necessárias para a criação dos modelos, mostrando os
botões para a geração automática de código (Gerar Tabela, Gerar Modelo, Gerar
DAO, Gerar Bean, Gerar Tela JSF).
Segue o exemplo de 3 objetos gerados (Cliente, Cidade e Estado) com as
classes “modelos”, “bean” e “dao”. O exemplo foi feito através de diagramas de
classe:
O diagrama de classe modelo exemplifica a criação das classes com os atributos
21
Figura 6 – Diagrama de classe Modelo para exemplo
O diagrama de classe DAO exemplifica a criação das classes com os objetos e
métodos
Figura 7 – Diagrama de Classe DAO para exemplo
O diagrama de classe Bean exemplifica a criação das classes com os objetos e
métodos
Figura 8 – Diagrama de Classe Bean para exemplo
22
3 ESTRUTURA ANALITICA DO PROJETO
Para o desenvolvimento do Gerador Automático elaborou-se a seguinte
Estrutura Analítica do Projeto:
Figura 9 – Estrutura analítica do projeto
23
4 ANÁLISE DOS REQUISITOS
O problema a ser resolvido, basicamente seria evitar os problemas futuros, pois
o programador terá um auxílio de grande valia, evitando problemas com o tempo,
repetições de códigos desnecessários, geração automática da tabela, etc.
4.1 RESULTADO ESPERADO
O resultado esperado é utilizar o Gerador como uma real ferramenta de trabalho
e de estudo, ajudando a programador a desenvolver o seu software com maior
economia de tempo e maior qualidade.
4.2 FORMA ADOTADA PARA O LEVANTAMENTO DOS REQUISITOS
Para o desenvolvimento do sistema, realizou-se um estudo de todas as
características de um projeto, desde os atributos e suas especificações (nome,
tipo, máscara, entre outros) até os profissionais encarregados de trabalharem no
projeto.
4.3 RESTRIÇÕES DO DESENVOLVIMENTO
O gerador será descrito basicamente em uma tela principal, onde o usuário irá
apenas definir o nome da classe e seus atributos, como a tabela do banco de
dados. Todos os dados serão armazenados no banco de dados, para manter
total controle.
24
4.4 PROBLEMAS POTENCIAIS
O problema a ser estudado do Gerador se dá pelo fato de a estrutura dos códigos
gerados (classes) não poderem ser alteradas. Caso a alteração seja necessária,
o usuário deverá alterar o código fonte.
4.5 LISTA DE EVENTOS
Para o desenvolvimento do projeto elaborou-se a seguinte tabela de eventos:
Nº
Descrição
Caso de Uso
01
Usuário cadastra as informações do
Manter Projeto
projeto
02
Usuário cadastra as informações da classe
Manter Classe
03
Usuário cadastra as informações do
Manter Atributo
atributo
04
Usuário cadastra as informações do
Manter Profissional
profissional
05
Usuário cadastra as informações do
Manter Suporte
suporte
06
Usuário gera a tabela
Gerar Tabela
07
Usuário gera o modelo
Gerar Modelo
08
Usuário gera o DAO
Gerar DAO
09
Usuário gera o Bean
Gerar Bean
10
Usuário gera a tela
Gerar Tela
Tabela 1 – Lista de Eventos
25
4.6 ORÇAMENTO DO PROJETO
Itens
Valor
Notebook
R$ 800,00
Programador
R$ 4.500,00
Netbeans
Sem custo
Servidor
R$ 50,00
Banco de dados PostgreSQL
Sem custo
Tabela 2 – Orçamento do projeto
26
5 DIAGRAMAS
Neste capítulo, os diagramas de casos de uso e de sequência irão ajudar a
especificar o sistema.
5.1 CASO DE USO PRINCIPAL/GERAL
Caso de uso principal do projeto com todos os eventos.
Figura 10 – Caso de uso do projeto
27
5.2 CASO DE USO MANTER PROJETO
Figura 11 – Caso de uso Manter Projeto
Nome Use
Case
Descrição
Manter Projeto
Ator
Usuário
A função deste caso de uso é cadastrar dados de um projeto
O usuário escolhe a opção “Criar Projeto“ na tela principal
Evento Inicial
Fluxo
Principal
Fluxo
Exceção
1 - O sistema solicita os dados necessários para a criação do
Projeto;
2 – O sistema efetiva a criação do projeto.
O sistema informa que não foi adicionado nenhum atributo.
Tabela 3 – Narrativa Caso de Uso Manter Projeto
28
5.3 DIAGRAMA DE SEQUENCIA PROJETO
Para o cadastro do projeto, foi desenvolvido esse diagrama de sequência, onde
o usuário preenche os dados, os dados são enviados para a camada BEAN e
para a camada DAO, onde eles serão salvos. Logo após, será gerada uma
mensagem para o usuário.
Figura 12 – Diagrama de Sequencia Manter Projeto
29
5.4 CASO DE USO MANTER CLASSE
Figura 13 – Caso de uso Manter Classe
Nome Use
Case
Descrição
Manter Classe
Ator
Usuário
A função deste caso de uso é cadastrar dados de uma classe
O usuário escolhe a opção “Criar Classe“ na tela principal
Evento Inicial
Fluxo
Principal
Fluxo
Exceção
1 - O sistema solicita os dados necessários para a criação da
Classe;
2 – O sistema efetiva a criação da classe.
O sistema informa que não foi adicionado nenhum atributo.
Tabela 4 – Narrativa Caso de Uso Manter Classe
30
5.5 DIAGRAMA DE SEQUENCIA CLASSE
Para o cadastro de classe, foi desenvolvido esse diagrama de sequência, onde
o usuário preenche os dados, os dados são enviados para a camada BEAN e
para a camada DAO, onde eles serão salvos. Logo após, será gerada uma
mensagem para o usuário.
Figura 14 – Diagrama de Sequencia Classe
31
5.6 CASO DE USO MANTER ATRIBUTO
Figura 15 – Caso de uso Manter Atributo
Nome Use
Case
Descrição
Manter Atributo
Ator
Usuário
A função deste caso de uso é cadastrar dados de um atributo
O usuário escolhe a opção “Criar Atributo“ na tela principal
Evento Inicial
Fluxo
Principal
Fluxo
Exceção
1 - O sistema solicita os dados necessários para a criação do
Atributo;
2 – O sistema efetiva a criação do atributo.
O sistema informa que não foi adicionado nenhum dado.
Tabela 5 – Narrativa Caso de Uso Manter Atributo
32
5.7 DIAGRAMA DE SEQUENCIA ATRIBUTO
Para o cadastro de atributo, foi desenvolvido esse diagrama de sequência,
onde o usuário preenche os dados, os dados são enviados para a camada
BEAN e para a camada DAO, onde eles serão salvos. Logo após, será gerada
uma mensagem para o usuário.
Figura 16 – Diagrama de Sequencia Atributos
33
5.8 CASO DE USO MANTER PROFISSIONAL
Figura 17 – Caso de uso Manter Profissional
Nome Use
Case
Descrição
Ator
Manter Profissinal
A função deste caso de uso é cadastrar dados de um
profissional
Usuário
O usuário escolhe a opção “Criar Profissional“ na tela principal
Evento Inicial
Fluxo
Principal
Fluxo
Exceção
1 - O sistema solicita os dados necessários para a criação do
profissional;
2 – O sistema efetiva a criação do profissinal.
O sistema informa que não foi adicionado nenhum atributo.
Tabela 6 – Narrativa Caso de Uso Manter Profissional
34
5.9 DIAGRAMA DE SEQUENCIA PROFISSIONAL
Para o cadastro de profissional, foi desenvolvido esse diagrama de sequência,
onde o usuário preenche os dados, os dados são enviados para a camada
BEAN e para a camada DAO, onde eles serão salvos. Logo após, será gerada
uma mensagem para o usuário.
Figura 18 – Diagrama de Sequencia Profissional
35
5.10 CASO DE USO MANTER SUPORTE
Figura 19 – Caso de uso Manter Suporte
Nome Use
Case
Descrição
Manter Suporte
Ator
Usuário
A função deste caso de uso é cadastrar dados de um suporte
O usuário escolhe a opção “Criar Suporte“ na tela principal
Evento Inicial
Fluxo
Principal
Fluxo
Exceção
1 - O sistema solicita os dados necessários para a criação do
Suporte;
2 – O sistema efetiva a criação do suporte.
O sistema informa que não foi adicionado nenhum atributo.
Tabela 7 – Narrativa Caso de Uso Manter Suporte
36
5.11 DIAGRAMA DE SEQUENCIA SUPORTE
Para o cadastro de suporte, foi desenvolvido esse diagrama de sequência,
onde o usuário preenche os dados, os dados são enviados para a camada
BEAN e para a camada DAO, onde eles serão salvos. Logo após, será gerada
uma mensagem para o usuário.
Figura 20 – Diagrama de Sequencia Suportes
37
5.12 CASO DE USO GERAR TABELA
Figura 21 – Caso de uso Gerar Tabela
Nome Use
Case
Descrição
Gerar Tabela
A função deste caso de uso é criar uma tabela no banco de
dados
Usuário
Ator
O usuário escolhe a opção “Gerar Tabela“ na tela principal
Evento Inicial
Fluxo
Principal
Fluxo
Exceção
1 - O sistema solicita os dados necessários para a geração da
Tabela;
2 – O sistema efetiva a criação da tabela.
O sistema informa que não foi adicionado nenhum atributo.
Tabela 8 – Narrativa Caso de Uso Gerar Tabela
38
5.13 DIAGRAMA DE SEQUENCIA GERAR TABELA
Todos os diagramas de sequencia são parecidos, mudando apenas a classe a
ser gerada, pois todo evento necessita dos mesmos dados que serão usados
para gerar as classes.
No diagrama abaixo, a tabela é gerada a partir dos dados preenchidos.
Figura 22 – Diagrama de sequencia gerar Tabela
39
5.14 CASO DE USO GERAR A CLASSE MODELO
Figura 23 – Caso de uso Gerar Modelo
Nome Use
Case
Descrição
Gerar Modelo
Ator
Usuário
A função deste caso de uso é criar um objeto Modelo
O usuário escolhe a opção “Gerar Modelo” na tela principal
Evento Inicial
Fluxo
Principal
Fluxo
Exceção
1 - O sistema solicita os dados necessários para a geração do
Modelo;
2 – O sistema efetiva a criação do objeto.
O sistema informa que não foi adicionado nenhum atributo.
Tabela 9 – Narrativa Caso de Uso Gerar Modelo
40
5.15 DIAGRAMA DE SEQUENCIA DA GERAÇÃO DA CLASSE MODELO
No diagrama abaixo, o modelo é gerado a partir dos dados preenchidos, os
mesmos dados serão salvos na tabela do banco de dados.
Figura 24 – Diagrama de sequencia gerar Modelo
41
5.16 CASO DE USO GERAR A CLASSE DAO
Figura 25 – Caso de uso Gerar DAO
Nome Use Case
Gerar DAO
Descrição
A função deste caso de uso é criar um DAO
Ator
Usuário
O usuário escolhe a opção “Gerar DAO” na tela principal
Evento Inicial
Fluxo Principal
1 - O sistema solicita os dados necessários para a geração
do DAO;
2 – O sistema efetiva a criação do DAO.
Fluxo Exceção
O sistema informa que não foi adicionado nenhum atributo.
Tabela 10 – Narrativa Caso de Uso Gerar DAO
5.17 DIAGRAMA DE SEQUENCIA DA GERAÇÃO DA CLASSE DAO
No diagrama abaixo, a classe Dao é gerada a partir dos dados preenchidos, os
mesmos dados serão salvos na tabela do banco de dados.
42
Figura 26 – Diagrama de sequência gerar DAO
5.18 CASO DE USO ONDE O USUÁRIO GERA A CLASSE BEAN
Figura 27 – Caso de uso Gerar Bean
Nome Use Case
Gerar Bean
Descrição
A função deste caso de uso é criar um Bean
43
Ator
Usuário
O usuário escolhe a opção “Gerar Bean” na tela principal
Evento Inicial
Fluxo Principal
1 - O sistema solicita os dados necessários para a geração
do Bean;
2 – O sistema efetiva a criação do Bean.
Fluxo Exceção
O sistema informa que não foi adicionado nenhum atributo.
Tabela 11– Narrativa Caso de Uso Gerar Bean
5.19 DIAGRAMA DE SEQUENCIA DA GERAÇÃO DA CLASSE BEAN
No diagrama abaixo, o Bean é gerado a partir dos dados preenchidos, os
mesmos dados serão salvos na tabela do banco de dados.
Figura 28 – Diagrama de sequência gerar BEAN
44
5.20 CASO DE USO GERAR A TELA JSF
Figura 29 – Caso de uso Gerar tela JSF
Nome Use Case
Gerar tela JSF
Descrição
A função deste caso de uso é criar um tela JSF
Ator
Usuário
O usuário escolhe a opção “Gerar tela JSF” na tela principal
Evento Inicial
Fluxo Principal
1 - O sistema solicita os dados necessários para a geração da
Tela;
2 – O sistema efetiva a criação da tela.
Fluxo Exceção
O sistema informa que não foi adicionado nenhum atributo.
Tabela 12 – Narrativa Caso de Uso Gerar Tela JSF
5.21 DIAGRAMA DE SEQUENCIA DA GERAÇÃO DA TELA
No diagrama abaixo, a tela é gerada a partir dos dados preenchidos, os
mesmos dados serão salvos na tabela do banco de dados.
45
Figura 30 – Diagrama de sequencia gerar Tela
46
6 CONCLUSÃO
O framework desenvolvido nesse projeto atende todas as necessidades do
usuário (programador). O uso do gerador automático de código proporciona
vantagens como: economia de tempo, padronização de código, eliminação
tarefas repetidas desnecessárias, controle do projeto através de todos os dados
salvos, do primeiro atributo até as especificações do projeto, como profissionais,
suportes, entre outras soluções dos problemas enfrentados durante o
desenvolvimento de um sistema.
A criação de um sistema é dividida em criação de módulos, tais como, criação
de classes (Modelo, DAO e Bean), tela e tabela no banco de dados. Todo o
projeto foi desenvolvido na linguagem Java para o ambiente WEB.
O desenvolvimento deste trabalho trouxe uma contribuição enorme para o
crescimento do autor, proporcionando um aprendizado bastante significativo,
que com certeza levará para a área profissional e paro o resto de seu curso.
O
software
poderá
sofrer
várias
alterações,
podendo
modificar
consideravelmente a sua estrutura. A geração de classes para outras linguagem
é completamente possível.
47
7 REFERÊNCIAS
COAD, Peter. Object-Oriented Patterns. Communications of the ACM, 1992.
DOLLARD, K. Code Generation in Microsoft .Net. EUA: Apress, 2004.
FRANÇA, L.; STAA, A. Geradores de Artefatos: Implementação e
Instanciação de frameworks. Simpósio Brasileiro de Engenharia de Software,
15. SBC, 2001. PP 302-315.
GOMES, André Faria. Ágile. São Paulo: Casa do código
Johnson, Ralph E.; Russo, Vincent. Reusing Object-Oriented Designs. Relatório
Técnico da Universidade de Illinois, UIUCDCS 91-1696, 1991.
PRESSMAN Roger S. Engenharia de Software, 2011.
PALMEIRA, Thiago Vinícius V. Aprendendo Java com JDBC. Disponível em
<http://www.devmedia.com.br/aprendendo-java-com-jdbc/29116> Acessado em
06/11/2014
PostgreSQL.
O
que
é
o
PostgreSQL?
<http://pgdocptbr.sourceforge.net/pg82/intro-whatis.html>
06/11/2014
Disponível
Acessado
NetBeans.
O
que
é
o
NetBeans?
Disponível
<https://netbeans.org/index_pt_PT.html> Acessado em 06/11/2014
em
em
em
Java. O que é a tecnologia Java e por que preciso dela? Disponível em <
https://www.java.com/pt_BR/download/faq/whatis_java.xml>
Acessado em
06/11/2014
BUENO,
Kassia
Jaqueline.
O
que
é
JSF?
Disponível
em
<http://fabrica.ms.senac.br/2013/06/o-que-e-jsf-java-server-faces/> Acessado
em 06/11/2014