Monografia_FelipeAugusto

FACULDADE CATÓLICA DO TOCANTINS

BACHARELADO EM SISTEMAS DE INFORMAÇÃO

FELIPE AUGUSTO FEITOSA

DESENVOLVIMENTO DE SOFTWARE COM O FRAMEWORK

GRAILS: Sistema de Gerenciamento do Processo de Criação de

Produtos Publicitários

PALMAS

2012

FELIPE AUGUSTO FEITOSA

DESENVOLVIMENTO DE SOFTWARE COM O FRAMEWORK

GRAILS: Sistema de Gerenciamento do Processo de Criação de

Produtos Publicitários

Trabalho apresentado como requisito parcial de

avaliação da disciplina de Trabalho de Conclusão

de Curso do curso de Sistemas de Informação da

Faculdade Católica do Tocantins – FACTO.

Orientadora: Professora Especialista Thatiane de

Oliveira Rosa

PALMAS

2012

ABSTRACT

In recent years, the job market has been demanding greater flexibility and

efficiency in the process of developing information systems, in consequence, the

frameworks has emerged that aim to offer the developer tools and standards that

help to meet the needs and requirements imposed by the market. One can’t deny

that in the current scenario, the Java platform is very important to offer a wide array

of tools, so compared to other technology systems development. Moreover, Java

presents a series of problems such as complexity in developing systems for the web.

Thus, it becomes difficult to meet the requirements imposed by the labor market,

without sacrificing productivity provided by Java. Therefore, in order to solve the

problem of complexity in Java development for web frameworks and languages were

created alternatives that leverage the full potential of the platform, Java, however

with higher productivity. From this it appeared that Grails is a framework that is

intended to allow systems to be developed in an agile and simple, based on the

Groovy programming language, which runs on the JVM. Thus, this work has as main

goal to present a study on the Grails framework, and demonstrate the process of

developing a system to streamline and automate the process of managing the

creation of products for an advertising agency.

Keywords: Framework, Grails, Agile Development.

RESUMO

Nos últimos anos, o mercado de trabalho vem exigindo maior agilidade e

eficiência no processo de desenvolvimento de sistemas de informação, em

decorrência disto, surgiram os frameworks, que têm como objetivo oferecer ao

desenvolvedor ferramentas e padrões, que o auxiliem a atender às necessidades e

exigências impostas pelo mercado. Não se pode negar, que no cenário atual, a

plataforma Java é muito importante, por oferecer uma vasta quantidade de

ferramentas, isso se comparada a outras tecnologias de desenvolvimento de

sistemas. Por outro lado, Java apresenta uma série de problemas, como por

exemplo, a complexidade no desenvolvimento de sistemas para a web. Desta forma,

torna-se difícil atender às necessidades impostas pelo mercado de trabalho, sem

abrir mão da produtividade proporcionada por Java. Por tanto, com o objetivo de

solucionar o problema de complexidade do desenvolvimento em Java para web,

foram criados frameworks e linguagens alternativas, que aproveitam todo o potencial

da plataforma, Java, entretanto com maior produtividade. A partir disto, surgiu o

Grails que é um framework, que tem o intuito permitir que sistemas sejam

desenvolvidos de forma ágil e simples, baseando-se na linguagem de programação

Groovy, a qual roda sobre a JVM. Desta forma, este trabalho possui como objetivo

principal apresentar um estudo sobre o framework Grails, assim como demonstrar o

processo de desenvolvimento de um sistema para otimizar e automatizar o

gerenciamento do processo de criação de produtos de uma agência de publicidade.

Palavras-chave: Framework, Grails, Desenvolvimento ágil.

LISTA DE ILSUTRAÇÕES

Figura 1 - Ciclo de vida do modelo espiral (Modificado de SOMMERVILLE, 2010, p. 33) 13 Figura 2 - Estrutura de diretórios do Grails. .............................................................. 22 Figura 3 - Criação do projeto em Grails. ................................................................... 25 Figura 4 - Executando a aplicação. .......................................................................... 25 Figura 5 - Aplicação em execução. .......................................................................... 26 Figura 6 - Criação da classe de domínio. ................................................................. 27 Figura 7 - Criação do controlador ............................................................................. 27 Figura 8 - Apresentação do controler ....................................................................... 28 Figura 9 - Casse de domínio: CadastraContato ....................................................... 29 Figura 10 - Controlador: CadastraContato .............................................................. 29 Figura 11 - Tela de cadastro ................................................................................... 30 Figura 12 - Configuração do driver de conexão do banco de dados. ...................... 30 Figura 13 - Ambientes do banco de dadados. ......................................................... 31 Figura 14 - GSP’s do controle CadastraContato ..................................................... 32 Figura 15 - Código dos campos nome .................................................................... 33 Figura 16 - Instalando plug-in .................................................................................. 33 Figura 17 - Diagrama de caso de uso geral ............................................................ 38 Figura 18 - Módulo a ser desenvolvido ................................................................... 40 Figura 19 - Diagrama de classe do módulo desenvolvido ....................................... 41 Figura 20 - Classe de domínio do Produto .............................................................. 42 Figura 21 - Classe de domínio do Atributo .............................................................. 42 Figura 22 - Classe de domínio do Valor do Atributo ................................................ 42 Figura 23 - Classe de domínio Processo ................................................................ 43 Figura 24 - Classe de domínio Movimentação ........................................................ 43 Figura 25 - Classe de serviço de transações – método saveProduto() ................... 44 Figura 26 - Controlador produto – Action save ........................................................ 44 Figura 27 - Tela de login ......................................................................................... 45 Figura 28 - View login.gsp ....................................................................................... 46 Figura 29 - Controlador Login – Action authenticate ............................................... 47 Figura 30 - Tela Gerenciar Produto ......................................................................... 47 Figura 31 - View create da pátina Gerenciar Produto ............................................. 48 Figura 32 - Tela Visualizar Produto ......................................................................... 49 Figura 33 - Tela de ilustração do caso de uso Gerenciar Produto .......................... 57 Figura 34 - Tela de ilustração do caso de uso Visualizar Produto .......................... 59 Figura 35 - Tela de ilustração do caso de uso Listar Processo ............................... 61 Figura 36 - Tela de ilustração do caso de uso Inserir Processo .............................. 63 Figura 37 - Tela de ilustração do caso de uso Visualizar Processo ........................ 65 Figura 38 - Tela de ilustração do caso de uso Excluir Processo ............................. 67 Figura 39 - Tela de ilustração do caso de uso Inserir Movimentação ..................... 69 Figura 40 - Tela de ilustração do caso de uso Visualizar Movimentação ................ 71 Figura 41 - Diagrama de Sequência do requisito Visualizar Produto ...................... 73 Figura 42 - Diagrama de Sequência do requisito Inserir movimentação ................. 74

LISTA DE ABREVIATURAS E SIGLAS

COC - Convention Over Configuration

CRUD - Create - Read - Update - Delete

DI - Dependency Injection

DRY - Don't Repeat Yourself

GGTS - Groovy/Grails Tool Suite

GORM - Grails Object Relational Mapping

Grant - Groovy Ant

GSP - Groovy Server Pages

HTML - HyperText Markup Language

IDE - Integrated Development Enveronment

IoC - Invertion of Control

JDBC - Java Database Connectivity

JDK - Java Development Kit

JSP - Java Server Pages

JVM – Java Virtual Machine

MVC - Model View Controller

ORM - Objetc Relational Mapping

RoR - Ruby on Rails

SQL - Structured Query Language

UML - Unified Modeling Language

XML - Extensible Markup Language

SUMÁRIO

1. INTRODUÇÃO ..................................................................................................... 9 1.1. Contexto ........................................................................................................ 9 1.2. Objetivos ..................................................................................................... 10

1.2.1. Objetivo Geral ....................................................................................... 10 1.2.2. Objetivos Específicos ............................................................................ 10

1.3. Justificativas ................................................................................................ 11 2. REFERENCIAL TEÓRICO ................................................................................. 12

2.1. Processo de Desenvolvimento Ágil ............................................................. 12 2.2. Frameworks de Desenvolvimento Ágil ........................................................ 14 2.3. Framework Grails ........................................................................................ 15

2.3.1. Definição ............................................................................................... 16 2.3.1.1. Origem do Framework .................................................................... 16 2.3.1.2. Groovy ............................................................................................ 17

2.3.2. Principais Tecnologias Relacionadas ................................................... 18 2.3.2.1. Spring ............................................................................................. 18 2.3.2.2. Hibernate ........................................................................................ 18 2.3.2.3. SiteMesh ........................................................................................ 19 2.3.2.4. Outras tecnologias.......................................................................... 19

2.3.3. Funcionamento ..................................................................................... 20 2.3.3.1. Grails .............................................................................................. 20 2.3.3.2. Estrutura de Diretórios .................................................................... 21 2.3.3.3. Persistência de Dados .................................................................... 23 2.3.3.4. Scaffold .......................................................................................... 23 2.3.3.5. Camada de Visualização ................................................................ 24

2.4. Estudo de Caso – Aplicação Agenda Desenvolvida em Grails ................... 24 2.4.1.1. Preparação do Ambiente ................................................................ 25 2.4.1.2. Classes de Domínio e Controladores ............................................. 26 2.4.1.3. Conexão com o Banco de Dados ................................................... 30 2.4.1.4. Camada de Visualização da Aplicação .......................................... 32 2.4.1.5. Pluglins ........................................................................................... 33

3. Metodologia ....................................................................................................... 35 4. DESENVOLVIMENTO ....................................................................................... 37

4.1. Memora Inteligência Gráfica ........................................................................ 37 4.2. Visão Geral do Sistema ............................................................................... 37 4.3. Módulo de Gerenciamento do Processo de Criação de Produtos ............... 39 4.4. Utilização do Grails para Desenvolvimento do Módulo de Gerenciamento do Processo de Criação de Produtos ......................................................................... 40

4.4.1. Classes de Domínio e Controladores ................................................... 40 4.4.2. Views .................................................................................................... 45

5. CONSIDERAÇÕES FINAIS ............................................................................... 50 6. REFERÊNCIAS .................................................................................................. 52 7. ANEXO A ........................................................................................................... 55

7.1. Requisitos funcionais ................................................................................... 55 7.1.1. Requisitos Funcionais ........................................................................... 55 7.1.2. Requisitos Não-Funcionais ................................................................... 56

7.2. Caso de uso expandido e Wireframe do Módulo de Gerenciamento do Processo de Criação de Produtos ......................................................................... 56

7.2.1. Gerenciar Produto ................................................................................. 56 7.2.2. Visualizar Produto ................................................................................. 58 7.2.3. Listar Processo ..................................................................................... 60 7.2.4. Inserir Processo .................................................................................... 62 7.2.5. Visualizar Processo .............................................................................. 64 7.2.6. Excluir Processo ................................................................................... 66 7.2.7. Inserir Movimentação ............................................................................ 68 7.2.8. Visualizar Movimentação ...................................................................... 70

7.3. Diagrama de Sequências e Contratos ......................................................... 72 7.3.1. Visualizar Produto ................................................................................. 72 7.3.2. Inserir Movimentação ............................................................................ 73

9

1. INTRODUÇÃO

1.1. Contexto

O mercado de trabalho vem exigindo, cada vez mais, que os sistemas de

informação sejam desenvolvidos com maior qualidade, agilidade e eficiência. Neste

sentindo, visando atender a esta necessidade latente, foram criados os frameworks,

que consistem em tecnologias, que objetivam oferecer ao desenvolvedor

ferramentas e padrões, que o auxiliem a atender às exigências impostas pelo

mercado. Ainda é importante ressaltar, que no contexto de desenvolvimento de

sistemas de informação, a plataforma Java possui grande destaque, pelo fato de ser

uma tecnologia robusta e que oferece recursos poderosos. Por outro lado, apresenta

alguns problemas, se considerado contexto web, sendo complexa para

determinados procedimentos.

Os frameworks permitem que os engenheiros de software preocupem-se

pouco com a escrita de código e os reaproveite bastante, assim como obtenham

rápidos resultados. Desta forma, visando sanar os problemas do desenvolvimento

web baseado em Java, surgiram diversos frameworks, dentre eles destaca-se o

projeto Grails, que foi iniciado em 2005, baseado em outro framework denominado

Ruby on Rails, além disso, oferece várias tecnologias necessárias para o

desenvolvimento de sistemas web como o Hibernate, Tomcat, SiteMesh, Spring e

outras, o tornando um framework Ful Stack.

Portanto, é possível afirmar que o framework Grails tem o objetivo de tornar o

desenvolvimento web, baseado em Java, mais amigável, rápido e eficiente,

utilizando para isto a linguagem Groovy, que foi desenvolvida com o intuito de ser

uma linguagem open source, que roda sobre a JVM (Java Virtual Machine) e permite

desfrutar de todo o poder proporcionado pelas bibliotecas e scripts, desenvolvidos

em Java.

Rocher (2006) considera Grails a próxima geração de framework de

aplicações web para Java, que utilizando a linguagem Groovy, prove simplicidade e

a convenção. A partir disto, o trabalho em questão propõe o estudo do framework

Grails como uma alternativa para desenvolvimento de sistemas de forma ágil, a fim

10

de compreender a sua forma de trabalho e organização, assim como sua as

vantagens e desvantagens, quando comparado a outros frameworks disponíveis no

mercado. Para tanto, com a finalidade de constatar a agilidade e dinamicidade

promovidas pelo framework em questão, propõe-se ainda desenvolver um sistema

para a agência de publicidade Memora Inteligência Gráfica.

A agência de publicidade Memora Inteligência Gráfica, vem crescendo muito

desde 2005 e aumentando suas demandas de atividades, o que por sua vez, exige

maior controle e criteriosidade na produção de seus produtos. Neste contexto, o

sistema a ser desenvolvido, visa automatizar e permitir melhor gerenciamento de

diversas tarefas e práticas, que atualmente são realizadas de forma manual, via e-

mail e telefone, assim como presencialmente. Dentre as tarefas que serão

consideradas durante a análise para serem automatizadas, com a finalidade de

proporcionar maior agilidade e confiabilidade, destacam-se: coleta de informações

relativas ao produto a ser desenvolvido; e acompanhamento das alterações do

mesmo.

1.2. Objetivos

1.2.1. Objetivo Geral

Este trabalho possui como objetivo principal apresentar um estudo sobre o

framework Grails, assim como apresentar o processo de desenvolvimento de um

sistema para otimizar e automatizar o gerenciamento do processo de criação de

produtos de uma empresa de publicidade.

1.2.2. Objetivos Específicos

11

• Realizar um estudo teórico do framework Grails, e a partir disto um

comparativo com os principais frameworks de desenvolvimento ágil, disponíveis no

mercado;

• Apresentar um estudo prático do framework Grails, demonstrando seu

funcionamento básico, por meio de um estudo de caso;

• Desenvolver o módulo de um sistema web, baseado em Grails, que atenda às

reais necessidades de gerenciamento do processo de criação de produtos, da

empresa de publicidade Memora Inteligência Gráfica;

• Testar a eficiência do framework Grails, aplicado ao contexto da empresa de

publicidade;

1.3. Justificativas

Com o avanço da internet o mercado tecnológico trouxe uma migração dos

sistemas desktop para os sistemas web, sendo necessários recursos e ferramentas

que permitam ao mercado de software realizar o processo de desenvolvimento de

forma mais ágil. Segundo Adriano Antunes (2011, p. 26), o framework Grails foi

criado no intuito de fornecer um maior nível de abstração com o enfoque em

simplificar e facilitar as configurações e aproveitar mais a sintaxe bem expressiva e

limpa da linguagem dinâmica Groovy. Desta forma, o Grails apresenta-se como uma

solução ágil para ser utilizada com a plataforma Java na web, com o objetivo de

deixar os programadores menos preocupados com detalhes desnecessários (como

configuração de XML (Extensible Markup Language), funcionalidades básicas de

controle e a criação do layout básico de apresentação), que consomem o tempo do

que realmente é importante, tornando novamente o desenvolvimento da robusta e

poderosa plataforma Java mais divertida. Desta maneira, pode-se criar ou melhorar

(assim como reaproveitar códigos Java já existentes) de uma forma mais prática,

sistemas já atuantes em empresas assim como desenvolver, de acordo com a

necessidade, novos sistemas de forma mais ágil atendendo demandas em curto

prazo.

12

2. REFERENCIAL TEÓRICO

2.1. Processo de Desenvolvimento Ágil

Por volta de 2001 profissionais da área de tecnologia da informação

perceberam que o processo de desenvolvimento de sistemas de informação estava

se tornando muito burocrático, a partir disto, alguns especialistas sem reuniram para

propor alguns princípios e valores para agilizar tal processo de desenvolvimento,

tendo como base suas próprias experiências com programação. Em conjunto, tais

especialistas, baseando-se nas teorias e práticas dominadas por cada um,

concordaram que, normalmente, os projetos de sucesso tinham um conjunto de

princípios em comum, desta forma, com base nestes princípios foi criado o Manifesto

de Desenvolvimento Ágil de Software, mais conhecido como Manifesto Ágil. Sendo

assim, o termo desenvolvimento ágil refere-se a metodologias de desenvolvimento,

que adotam os valores do manifesto ágil, que de acordo com a Agile Manifesto

(2001), são:

• Indivíduos e interação são mais importantes que processos e ferramentas;

• Software em funcionamento é mais importante que documentação

abrangente;

• Colaboração do cliente é mais importante que negociação de contratos;

• Responder a mudanças é mais importante que seguir um plano.

• Devido às características do processo de desenvolvimento ágil, o modelo de

desenvolvimento adotado é o espiral, onde as etapas do modelo em cascata são

executadas várias vezes, ao longo de todo o processo de desenvolvimento do

sistema. Desta forma, ao final de cada ciclo, obtém-se um software funcional,

testado e aprovado.

O Modelo espiral é evolucionário, pois combina a natureza iterativa da

prototipagem, com o intuito de diminuir riscos. Desta forma, o processo de

desenvolvimento é representado por uma espiral dividida em quatro quadrantes,

onde em cada uma é abordado um aspecto do processo de desenvolvimento:

13

1. Determinação dos objetos, alternativas e restrições: onde são identificados os

objetivos específicos para a etapa, assim como as alternativas para realizar os

objetivos e restrições;

2. Análise das alternativas e identificação e/ou resolução de riscos: onde são

identificados os riscos principais, assim como analisadas e definidas maneiras para

reduzir tais riscos;

3. Desenvolvimento e validação da versão corrente do produto: nesta etapa é

escolhido um modelo apropriado para o desenvolvimento, podendo ser qualquer um

dos modelos de ciclo de vida;

4. Planejamento: O projeto é revisado, podendo dar início ao próximo passo do

ciclo espiral planejado.

Figura 1 - Ciclo de vida do modelo espiral (Modificado de SOMMERVILLE, 2010, p. 33)

Assim como pode ser verificado na figura 1, com o modelo espiral, o software

é desenvolvido em várias versões evolucionárias, podendo elas serem, de início,

modelos em papel ou prototipagem, e durante as últimas iterações, serem

produzidas versões cada vez mais completas do sistema, fazendo com que o

desenvolvedor e o cliente o entendam melhor, além de permitir que os riscos sejam

melhor tratados em cada nível evolucionário.

A seção seguinte abordará alguns dos diversos frameworks de

desenvolvimento ágil existentes no mercado atual, que apresentam soluções

similares ao framework Grails, que é objeto de estudo deste trabalho.

14

2.2. Frameworks de Desenvolvimento Ágil

Atualmente, existem diversos frameworks que prometem agilizar o processo

de desenvolvimento de sistemas utilizando algumas tecnologias, tais como: o padrão

MVC (Model View Controller – Modelagem, Visualização e Controle); o modelo COC

(Convention Over Configuration – convenção sobre configuração); o framework

hibernate, entre outras ferramentas. Desta forma, baseando-se em pesquisas

bibliográficas, os principais frameworks de desenvolvimento ágil disponível no

mercado hoje são:

• Django: escrito na linguagem Phyton foi desenvolvido para criações rápidas

de aplicações web, utilizando os padrões MVC, ORM (Objetc Relational Mapping –

Mapeamento Objeto-Relacional) e DRY (Don’t Repeat Yourself – Não se repita). O

mesmo possui o objetivo de reduzir o tempo, e automatizar as tarefas, que os

programadores teriam que executar para tornar a aplicação funcional (DJANGO

BRASIL, 2012);

• Rails ou RoR (Ruby on Rails): foi criado com o intuito de aumentar a

velocidade e facilidade no desenvolvimento de sistemas web. Rails foi desenvolvido

sobre Ruby , que é uma linguagem robusta, orientada a objetos e bem ágil, que

também utiliza os padrões MVC, ORM e DRY, entre outros (RUBY ON RAILS,

2012);

• VRaptor: é um framework desenvolvido no Brasil, que tem como intuito prover

um desenvolvimento de sistemas web de forma ágil, utilizando a linguagem Java. É

uma tecnologia nova, e que tende a crescer cada vez mais (VRAPTOR, 2012);

• CakePHP: assim como o nome sugere, é um framework escrito em PHP, e

seu principal objetivo é fornecer aos programadores uma estrutura de

desenvolvimento de sistemas robustos e de forma rápida. Ele utiliza padrões de

projetos conhecidos, tais como ActiveRecord, Assossiation Data Mapping, Front

Controller e MVC (CAKE PHP, 2012);

• Codieigniter: também utiliza a linguagem PHP para o desenvolvimento de

suas aplicações web, e por meio de sua vasta quantidade de bibliotecas, tem como

15

objetivo promover um desenvolvimento de sistemas bem simples e ágil, permitindo

ao programador concentrar todo seu tempo em atividades mais úteis e lógicas

(CODIEIGNITER BRASIL, 2012);

• JRuby : Foi criado para que os desenvolvedores possam implementar com a

linguagem Ruby para a plataforma Java, sendo então possível rodar na JVM (Java

Virtual Machine) (JRUBY, 2012);

• Grails: Foi desenvolvido pensando nos programadores e no mercado Java,

inspirado principalmente no Rails. Grails, antes chamado de Groovy on Rails, é

desenvolvido em Groovy, uma linguagem totalmente dinâmica inspirada no Java,

que os programadores “carinhosamente” afirmam ser um Java melhorado, tal

afirmação é realizada por ele rodar perfeitamente sobre a JVM, ganhando todo o

poder que o Java fornece, como bibliotecas (GRAILS, 2012).

Como visto, é possível verificar que existem atualmente vários frameworks

disponíveis, de forma livre, para o desenvolvimento de sistemas web, os quais

prometem um desenvolvimento ágil. Mas apesar de todos servirem para o mesmo

propósito, cada um reside sua preferência e particularidade como a linguagem de

programação. Dentre os frameworks de desenvolvimento ágil expostos, este

trabalho apresentará um estudo detalhado do Grails, desta forma, a próxima seção

aborda sua definição, origem, principais tecnologias, dentre outras características.

2.3. Framework Grails

Grails é um framework para desenvolvimento de aplicações web, que utiliza a

linguagem dinâmica groovy, originada da linguagem Java. Tal framework, por ter a

pretensão de ser de alta produtividade, baseia-se no paradigma de convenção.

Desta forma, para que seja possível compreender melhor o objeto de estudo deste

trabalho, esta seção abordará, de forma sucinta e didática, o framework Grails, a

linguagem dinâmica Groovy, assim como algumas de suas principais tecnologias

como Spring, Hibernate e SiteMesh. Além disso, são apresentadas algumas de suas

principais características de funcionamento, como a organização da estrutura de

diretórios, a persistência de dados, scaffold e a camada de visualização.

16

2.3.1. Definição

Grails tem como principal objetivo ser um framework open source de alta

produtividade, e para isso ele utiliza tecnologias, tais como, os frameworks Hibernate

e Spring, por meio de uma interface simples e consistente. O framework Grails utiliza

o padrão de desenvolvimento MVC (Model View Control) de forma natural, livrando o

desenvolvedor dos detalhes complexos da persistência de dados, assim como

também fornecendo um template web para facilitar a implementação da interface

com o usuário (ANTUNES, 2011, p. 26).

Para que seja possível melhor compreender como tal framework foi

idealizado, a seção seguinte discorre o processo que originou o Grails.

2.3.1.1. Origem do Framework

"Framework é um conjunto de classes que colaboram para realizar uma

responsabilidade para um domínio de um subsistema da aplicação." (FAYAD;

SCHMIDT, 2007).

Entende-se por framework um conjunto de classes e bibliotecas, que auxiliam

no desenvolvimento de software, que tem por objetivo poupar trabalho na execução

de procedimentos repetitivos, mas que são importantes (DEPA, 2010), como por

exemplo, as configurações do projeto de software. Muitos destes procedimentos

repetitivos já são executados, de forma automática, pela maioria dos frameworks

existentes atualmente.

Com a popularização do Ruby on Rails em 2006, a programação para web

tonou-se mais ágil, por adotar princípios ágeis como o DRY e CoC (Convention Over

Configuration - Convenção sobre Configuração), que tratam respectivamente sobre

o reaproveitamento de código e o foco na convenção com o mínimo de

configuração, utilizando a estrutura MVC como padrão, passando assim a se tornar

uma ameaça ao Java, por fornecer principalmente algumas características como

plug-ins, Scaffold e expansividade. Neste contexto, plug-ins pode ser entendido

17

como componentes pré-integrados, que eliminam a necessidade de associar cada

componente de um projeto a uma aplicação. Já Scaffold visa eliminar a repetição de

tarefas, criando uma base para construção da aplicação. Por fim, a expansibilidade

permite a criação de plug-ins, de maneira intuitiva, para recursos que a linguagem

não suporta (ANTUNES, p. 24-25, 2011).

Desta maneira, buscou-se algumas soluções para manter a linguagem Java

dentro do que o mercado precisava, e ao mesmo tempo, possibilitar a fácil utilização

de sua vasta quantidade de bibliotecas. A partir disto, surgiram os projetos JRuby e

Jython, ambos usando as linguagens Ruby e Phyton, dentro da plataforma Java.

Entretanto tais projetos não foram bem aceitos, por apresentarem muitas diferenças

no código, para quem estava acostumando com o Java. Sendo assim, a solução

idealizada foi a criação de um framework baseado em Ruby on Rails (RoR)

utilizando a linguagem Groovy, que é originada do Java, assim juntando Groovy com

o Rails, surgi o Grails que veio para enfim manter a plataforma Java em nível de

competição com os novos modelos de desenvolvimento de softwares para web.

2.3.1.2. Groovy

Em 2004, James Strachan, um programador experiente em Java, estava

estudando a linguagem Phyton, e ao descobrir essa linguagem percebeu que seria

interessante integrar à linguagem Java algumas das características de Phyton, como

por exemplo, o suporte sintático para operações habituais como tipos comuns e sua

natureza dinâmica.

Portanto, Groovy foi criado com a intenção de se comunicar bem com Java, e

adquirir características dinâmicas e sintáticas presentes nas linguagens como

Phyton, Ruby e Smalltalk. Assim como Java, Groovy é compilado em bytecode e

executado sobre a JVM (Java Virtual Machine), sendo possível importar objetos

Java em Groovy e vice-versa. Além disso, Groovy adota uma sintaxe que possibilita

aumentar, de maneira significativa, a produtividade em tempo de execução,

permitindo assim que objetos sejam manuseados de forma que em Java seriam

extremamente complicados (ANTUNES, 2011, p. 29-30; ROCHER, 2006, p. 17).

18

Após compreender o conceito e origem do framework Grails, assim como da

linguagem Groovy, a próxima seção apresenta as principais tecnologias

relacionadas a tal framework.

2.3.2. Principais Tecnologias Relacionadas

2.3.2.1. Spring

O Spring é um framework criado por Rod Jonhnson e descrito no seu livro,

Expert One-on-One: J2EE Design e Development. Ele é um poderoso container de

injeção de dependências, que tem como objetivo livrar o desenvolvedor de grandes

trabalhos revivendo a questão da agilidade no desenvolvimento (SANTOS, 2012).

Usado hoje por muitos em desenvolvimento de sistemas para a plataforma Java, o

Spring é uma ferramenta integrante do Grails, sendo assim, boa parte das

funcionalidades que o Grails executa está ligado ao Spring e todo o poder de injeção

de dependências que ele oferece. É importante ressalta, que o Spring é baseado no

princípio de Invertion of Control - IoC (Inversão de Controle), que tem a função de

retirar do programador o trabalho de acoplamento, e no princípio de Dependency

Injection – DI (Injeção de Dependência), que é encarregado de montar

dependências como bibliotecas que serão utilizadas em uma determinada classe,

para que o desenvolvedor não perca tempo fazendo isso (ANTUNES, 2011, p. 37;

(WALLS; BREIDENBACH 2005, p. 8; WEISSMANN, 2010).

2.3.2.2. Hibernate

Com o objetivo de simplificar os processos de persistência de dados, para a

programação orientada a objetos, no modelo relacional de banco de dados, o

Hibernate atua no Grails por meio do GORM (Grails Object Relational Mapping).

Deste modo, auxilia o desenvolvedor a ter pouco trabalho com a escrita de códigos

19

de acesso a banco de dados e de comandos SQL (Structured Query Language -

Linguagem de Consulta Estruturada), utilizando o padrão de convenção para sua

comunicação com as classes e as tabelas do banco (ANTUNES, 2011, p. 38).

2.3.2.3. SiteMesh

SiteMesh consiste em um gerenciador e manipulador de layout, que foi criado

pela OpenSymphony para auxiliar no desenvolvimento de layouts, que seguem o

padrão decorator, para sistemas grandes. Tal gerenciador auxilia na criação de

templates com comandos e objetos padrões livrando o desenvolvedor de criar

manualmente tais estruturas básicas. Vale ressaltar que, por padrão, o SiteMesh

vem configurado como o provedor de layout do Grails (DAVIS; RUDOLPH, 2010, p.

79; WEISSMANN, 2010).

2.3.2.4. Outras tecnologias

O Grails por ser um framework “Full Stack”, oferece ao desenvolvedor as

ferramentas necessárias para que a aplicação seja executada, sem a necessidade

de realizar muitas configurações. Desta forma, é preciso apenas instalar o

framework e criar o projeto, a partir disto, a aplicação já estará pronta para funcionar.

É importante ressaltar, que além das tecnologias apresentadas, nas seções

anteriores, o framework Grails baseia-se em outras, as quais também são muito

importantes para o seu funcionamento (SANTOS, 2012). Dentre tais tecnologias,

destacam-se:

� Tomcat: Servidor web, que foi integrado ao framework Grails na versão 1.2,

tal fato possibilitou que não houvesse mais a necessidade de os desenvolvedores

terem que instalá-lo e configurá-lo. No que se refere à relação entre o Tomcat e o

Grails, vale ainda ressaltar, que é possível realizar o deploy da aplicação, para isto,

é necessário apenas configurar o arquivo config.groovy e, logo em seguida, executar

o comando “grails tomcat deploy”.

20

� H2 Database: Por padrão, o Grails já trás consigo o banco de dados H2

configurado, para que seja possível testar as aplicações. Portanto, o mesmo vem

junto ao pacote de instalação do framework e é pré-configurado no arquivo

DataSource.groovy. O H2 é um banco de dados leve, o qual é escrito em Java,

sendo muito útil para realizar testes de aplicações de pequeno porte, desenvolvidas

pelo Grails. Tal banco de dados armazena, em tempo de execução, as informações

da aplicação em memória, entretanto possibilita que tais informações também sejam

armazenadas permanentemente no banco de dados, para isto, é necessário apenas

indicar no arquivo DataSoruce.groovy como a aplicação deve se comportar.

� JUnit: Para a realização de testes de funcionamento da aplicação, o Grails

trouxe junto a si o JUnit criado para realizar testes automatizados na linguagem Java

e gerar relatórios de resultados. Com ele pode-se realizar testes em métodos de

uma classe, verificando se o mesmo funciona da maneira esperada, exibindo

possíveis erros ou falhas.

Após conhecer as principais tecnologias que integram o framework Grails, a

próxima seção discorre sobre o funcionamento do mesmo.

2.3.3. Funcionamento

2.3.3.1. Grails

Para iniciar o estudo do framework Grails é bastante interessante

compreender os conceitos básicos sobre as tecnologias apresentadas

anteriormente, como o Hibernate e Spring, assim como as linguagens Groovy e

Java.

Uma das principais características do Grails é a agilidade, sendo esta

percebida até mesmo no procedimento de instalação, visto que em poucos passos

todo o ambiente está pronto para iniciar o desenvolvimento de uma aplicação.

Basicamente, para que o framework Grails esteja pronto deve-se instalar o JDK

(Java Development Kit) e configurar as variáveis de ambiente para o Grails, assim

como para o Java, informando o diretório da pasta bin e do Grails_HOME. Pelo fato

21

de a linguagem Groovy compor as ferramentas integradas do framework não é

necessário declarar as variáveis de ambientes para ele. Além disso, vale ressaltar

ainda, que conforme explicitado anteriormente, pelo fato de o Grails ser um

framework “Full Stack”, as ferramentas como Hibernate, Spring, H2 e SiteMesh já

vêm embutidas em seu pacote de instalação, não sendo necessário que o

desenvolvedor as configure.

Com o Grails devidamente instalado e as variáveis de ambiente configuradas,

o desenvolvedor já está pronto para iniciar seu projeto. Como tal framework é

bastante completo e simples de se utilizar, todas as operações necessárias podem

ser realizadas utilizando o prompt de comando, mas as IDE’s (Integrated

Development Environment - Ambiente Integrado para Desenvolvimento) como Net

Beans, Eclipse e a Spring Source Tool Suite (IDE feito pela empresa Spring baseada

no eclipse), podem ser utilizadas para auxiliar no desenvolvimento do projeto, para

isto, é necessário apenas configurá-las para receber o Grails.

2.3.3.2. Estrutura de Diretórios

Para criar um projeto em Grails é de extrema importância conhecer bem a sua

estrutura de diretórios. Tal estrutura pode ser criada após executar o comando

“grails create-app [nome da aplicação]”, dentro do diretório com o nome

escolhido para a aplicação, a partir disto, é gerada a estrutura apresentada na figura

2.

22

Figura 2 - Estrutura de diretórios do Grails.

Conforme ilustrado na figura 2, o primeiro diretório da estrutura é nomeado

como grails-app, o mesmo contém os principais conteúdos do projeto, uma vez que

99% das classes criadas durante o desenvolvimento do sistema deverão estar em

um dos seus subdiretórios, os quais são discriminados a seguir.

O subdiretório grails-app/conf contém os arquivos de configuração do banco

de dados e de inicialização do sistema (BootStrap), Hibertate, entre outras. Já no

subdiretório grails-app/controllers são encontrados todos os controles da aplicação,

onde os fluxos de informações são gerenciados.

No subdiretório grails-app/domain estão as classes de domínio, são elas que

representarão as tabelas do banco. Já no subdiretório grails-app/i18n são

encontrados os Propers, que armazenam as mensagens do sistema e as linguagens

textuais existentes.

No subdiretório grails-app/services são armazenados os serviços (regras de

negócios) desacoplados do contexto da aplicação, um exemplo seria uma classe

que faz uma conexão secundária entre a aplicação e o banco de dados. O

subdiretório grails-app/taglib armazena todas as tags customizadas criadas usando

o Grails.

O subdiretório grails-app/utils armazena os codecs, classes utilitárias e

classes utilizadas por plug-ins. Por fim, no subdiretório grails-app/views ficam todas

as GSP’s (Groovy Server Pages) que farão parte da aplicação.

23

O segundo diretório apresentado é o lib, que armazena todos os arquivos

com extensão .jar, os quais fazem referência a bibliotecas de terceiros, que serão

utilizadas no sistema como o JDBC (Java Database Connectivity).

O diretório seguinte é o scripts, no qual devem ser armazenados todos os

scripts que serão utilizados para facilitar o desenvolvimento da aplicação. Todos os

scripts para o Grails são desenvolvidos em Grant (Groovy Ant), que é uma abstração

do Ant feita em Groovy.

Já no diretório src devem ser armazenados os códigos fonte que não se

encaixam na estrutura de diretórios do Grails. Dentro deste diretório há dois outros

chamados de Java e Groovy, onde serão colocados os códigos implementados em

Java e os códigos implementados em Groovy.

O diretório test é responsável por armazenar todos os testes unitários,

funcionais e de integração do projeto.

Por fim, o diretório web-app contém todo o conteúdo estático da aplicação

como imagens e arquivos .html.

2.3.3.3. Persistência de Dados

O Grails oferece um conforto muito grande quando se trata de persistência de

dados, uma vez que trás consigo o banco de dados já configurado para testar as

aplicações em desenvolvimento. O mais interessante nisso é que o desenvolvedor

terá o mínimo de trabalho para configurar o processo de comunicação da aplicação

com o banco de dados, uma vez que a mesma já é criada de forma automática,

seguindo regras de convenção, tabelas e códigos SQL padrões. Vale ainda

ressaltar, que o framework permite o acesso a base de dados legadas e geração de

comandos SQL para bancos de dados externos como o MySQL.

2.3.3.4. Scaffold

24

Scaffold é um recurso poderoso implementado pelas ferramentas de

desenvolvimento ágil, que surgiu para facilitar a criação de componentes da camada

de visualização e de controle da aplicação. Desta forma, o Scaffold cria toda a

estrutura necessária retirando do desenvolvedor o trabalho de criar os componentes

de controle da aplicação. Existem dois tipos de scaffold, o dinâmico e o estático. O

scaffold dinâmico é responsável por gerar toda a estrutura em memória, e o scaffold

estático, através do comando “grails generate-all”, cria as camadas de

controllers e visualização correspondentes às classes de domínios definidas. É

importante ressaltar, que o scaffold, criará o CRUD (Create – Read – Update –

Delete) da aplicação, dentro dos controladores (CALAHORRO, 2009 p. 29-31;

SANTOS, 2010).

2.3.3.5. Camada de Visualização

Dentro do padrão MVC, a camada de visualização é responsável por toda a

parte de apresentação da aplicação. Tal camada utiliza a tecnologia GSP (Groovy

Server Pages), inspirada no JSP (Java Server Pages), que é identificada nos

arquivos html (HyperText Markup Language) pelas tags específicas indicadas por

<g:>, que são responsáveis por mostrarem os recursos exclusivos do Grails. Os

arquivos gsp são armazenados dentro do diretório grails-app/views, após utilizar a

função scaffold com o comando “grails generate-all”.

Após apresentar o funcionamento do framework Grails, torna-se possível

então apresentar um estudo de caso baseando-se na utilização do mesmo, portanto,

a próxima seção apresenta uma demonstração simples da construção uma

aplicação com o framework Grails.

2.4. Estudo de Caso – Aplicação Agenda Desenvolvida em Grails

Com base no que foi visto no decorrer do trabalho, esta seção apresenta o

framework Grails de forma uma pouco mais prática, sendo detalhados alguns dos

25

seus comportamentos, assim como a preparação do ambiente do projeto, as classes

de controle e de domínio, configuração do banco de dados, a camada de

visualização e algumas outras funcionalidades.

2.4.1.1. Preparação do Ambiente

Depois de configuradas as variáveis de ambiente do Grails, o próximo passo

é acessar o prompt de comando, e navegar até o diretório onde são armazenados

os projetos baseados em Grails e digitar o seguinte comando: “grails create-

app [nome do projeto]” para criar o projeto, conforme ilustrado na figura 3.

Figura 3 - Criação do projeto em Grails.

Com a execução deste comando, será criada uma pasta no diretório corrente

com o nome escolhido. Feito isso, toda a estrutura do sistema já estará pronta.

Neste momento, já é possível executar a aplicação com o comando “grails run-

app”, que ela já estará pronta para funcionar normalmente, como ilustrado na figura

4. Isso é concedido pelo fato de, como afirmado anteriormente, o Grails ser “Full

Stack” e já trazer consigo todas as dependências configuradas e funcionando, como

por exemplo, o Tomcat, banco de dados H2, entre outras ferramentas necessárias.

Figura 4 - Executando a aplicação.

26

Figura 5 - Aplicação em execução.

A figura 5 mostra a aplicação em funcionamento. Esta tela é uma

apresentação padrão, oferecida pelo Grails que na área Avaliable Controllers, lista

os controladores gerados, entretanto como, até momento nenhum foi criado, a lista é

apresentada vazia. Além disso, tal tela apresenta na área Application Status,

informações tais como a versão do framework, quantidade de controllers que

existem na aplicação, quantidade de domains, entre outras informações. Além disso,

na área Installed Plug-ins são identificados os pluguins que já estão configurados e

prontos para uso.

2.4.1.2. Classes de Domínio e Controladores

27

As classes de domínio representam as tabelas do banco de dados, sendo que

as mesmas devem conter os atributos (colunas do banco) de uma determinada

página. Para criar uma domain class é necessário executar o comando “grails

create-domain-class [nome da domain]”, como pode ser observado na

figura 6.

Figura 6 - Criação da classe de domínio.

Assim como pode ser verificado na figura 6, após executar o comando, a

domain é criada no diretório “domain/agenda”. Com a domain existente, é

necessário agora criar o controlador relacionado a ela, tal procedimento pode ser

realizado por meio do comando “grails create-controller [nome da

domain]”, conforme mostrado na figura 7.

Figura 7 - Criação do controlador

Após executado o comando o controlador da domain é criado no diretório

“controller/agenda”. Conforme visto na figura 8, é possível perceber que após a

criação do controlador o mesmo é apresentado na área Available Controller.

28

Figura 8 - Apresentação do controler

É importante ressaltar que é necessário preencher os atributos da domain

criada, neste caso, uma agenda, como nome, telefone, endereço e e-mail. Para tal

fim, é necessário abrir o arquivo “CadastraContato.groovy”, que encontra-se dentro

do diretório “domain/agenda”, conforme mostra a figura 9:

29

Figura 9 - Casse de domínio: CadastraContato

No controller será adotado o scaffold dinâmico, para que o CRUD seja gerado

em memória, para tanto, deve-se implementar o controller conforme a ilustra a figura

10.

Figura 10 - Controlador: CadastraContato

Como visto na linha 3 do código acima (figura 10), o scaffold dinâmico é

ativado, ao atribuir o valor true. Vale ressaltar que é possível gerar o CRUD de forma

estática, ao executar o comando “grails generate-all”.

Após realizar todos os passos descritos anteriormente, é possível executar a

aplicação para testar o controlador funcionando, com os atributos definidos na

domain previamente criada. Após executar o comando “grails run-app”, deve-se

clicar no controller “CadastraContato”, e logo em seguida criar um contato, clicando

no botão “Novo CadastraContato”, por conseguinte é apresentada a tela de

preenchimento dos dados um novo contato (Figura 11):

30

Figura 11 - Tela de cadastro

2.4.1.3. Conexão com o Banco de Dados

O framework Grails traz consigo um arquivo de configuração para a conexão

com o banco de dados. Conforme explicitado anteriormente, por padrão, ele já vem

configurado com o banco de dados H2, mas nada impede que possa ser utilizado

outro banco de dados para a aplicação como o MySQL e Oracle. No arquivo

DataSource.groovy, encontrado no diretório grails-app/conf, são definidas todas as

configurações necessárias para que a conexão da aplicação com o banco de dados

funcione corretamente.

Figura 12 - Configuração do driver de conexão do banco de dados.

31

Conforme pode ser observado na figura 12, é bem simples a chamada do

driver de conexão com o banco de dados. Na linha 3, à variável driverClassName

é atribuído o endereço do driver do banco escolhido, neste exemplo é utilizado o

drive do banco padrão do framework (H2 Database). Já os atributos username e

password devem ser preenchidos de acordo como o que foi configurado no banco

de dados escolhido, para que o sistema consiga estabelecer a conexão, como

acessar o banco de forma correta.

Figura 13 - Ambientes do banco de dadados.

É importante resslatar que o Grails já traz configurado 3 (três) ambientes de

execusão da aplicação, o ambiente de desenvolvimento, o de teste e o de produção.

O Grails também permite que possa ser utilizado um banco de dados para cada

ambiente, assim como aplicar configurações de comportamentos diferentes,

conforme pode ser observado nas linhas 17, 23 e 29 contidas na figura 13.

32

No momento da execução da aplicação, é necessário informar qual ambiente

será utilizado, por padrão o framework grails inicia a aplicação no modo de

desenvolvimento, entretanto, caso seja necessário, é possível configurar para que

seja iniciada no ambiente de produção, com o comando “grails prod run-app”,

ou ainda ao executar o comando “grails test run-app”, a aplicação ser

iniciada no modo de teste. Já o comando “grails dev run-app” força a

aplicação ser iniciada para o ambiente de desenvolvimento.

2.4.1.4. Camada de Visualização da Aplicação

Para a camada de visualização da aplicação, existem duas maneiras de gera-

la, de forma estática ou em memória, no decorrer do desenvolvimento do sistema,

pode-se usar o modo dinâmico para gerar as gsp’s (Groovy Server Page), mas

quando partir para a modificação da estrutura das views, é necessário gerá-las com

o comando [grails generate-all], assim serão criadas, no diretório “grails-

app/view” (como ilustra a figura 14). As views criadas nesse diretório estarão

diretamente ligadas a determinada closures das classes de controle, são elas as

create.gsp, edit.gsp, list.gsp e show.gsp.

Figura 14 - GSP’s do controle CadastraContato

Como mostra na figura 14, uma gsp chamada “_form” é responsável por criar

os campos das telas de cadastro. Os arquivos da camada de visualização foram

separados desta forma a partir da versão 2.0 do grails, para facilitar a edição dos

campos e desvincula-los da create.gsp. Pode-se observar um trecho do código na

figura 15 onde é criado uma label e um textField para a inserção de um valor do tipo

texto.

33

Figura 15 - Código dos campos nome

Por meio do SiteMesh o Grails criará o layout das páginas, mas nada impede

que as gsp’s sejam acessadas e modifique-se o código para a maneira desejada.

Para isto, basta abrir a gsp desejada e editar conforme a necessidade.

2.4.1.5. Pluglins

Existe uma vasta quantidade de plug-ins prontos para Grails, o fato de ele

utilizar a linguagem dinâmica Groovy, derivada do Java, faz com que ele absorva

sua vasta riqueza, no que diz respeito aos scripts e plug-ins. Portanto Grails permite

trabalhar com plug-ins de forma bastante simples, fazendo com que em pouco

tempo seja possível colocar um plug-in em funcionamento. Sendo assim, para

instalar um plug-in, utiliza-se o comando “grails install-plug-in [nome do

plug-in]”, conforme pode ser verificado na figura 16.

Figura 16 - Instalando plug-in

Uma observação muito importante é que, cada plug-in necessita de ser

configurado para que seu funcionamento ocorra da maneira desejada, para tal fim,

deve-se seguir a orientação da documentação do mesmo, uma vez que a

configuração é realizada de forma específica.

34

Vale ressaltar ainda, que existe outra forma de instalar um plug-in, a qual

baseia-se no arquivo BildConfig.groovy, localizado no dentro do diretório grails-

app/conf.

35

3. METODOLOGIA

Para que fosse possível compreender o objeto de estudo deste trabalho,

adotou-se inicialmente a metodologia de pesquisa bibliográfica a qual caracterizou-

se principalmente pelo estudo de livros, trabalho de conclusão de curso, artigos

científicos, periódicos, guias de usuário e sites com conteúdos relacionados a

métodos ágeis, aos diversos frameworks de desenvolvimento ágil e Grails. Além

disso, durante o período de estudo e compreensão do framework Grails participou-

se de cursos introdutórios a Grails, que foram extremamente úteis para aquisição do

conhecimento necessário para execução deste trabalho. Todos os documentos e

conteúdos pesquisados foram de suma importância para o desenvolvimento

bibliográfico deste projeto, pois forneceram embasamento teórico e prático para

entendimento dos conceitos e procedimento relacionados à tecnologia Grails.

Além disso, para que fosse possível melhor compreender o sistema que seria

desenvolvido, bem como o seu contexto de utilização, adotou-se os procedimentos

de pesquisa de campo e descritiva. Desta forma, durante todo o período de

desenvolvimento do trabalho em questão, realizou o acompanhamento do dia a dia

do funcionamento da empresa, bem como foram realizadas entrevistas, com os

proprietários e funcionários da mesma, com o objetivo de compreender de forma

consistente a real necessidade da empresa.

Após realizar os estudos bibliográficos foi possível compreender os principais

conceitos relacionados ao trabalho em questão, tais como métodos de

desenvolvimento ágil, assim como conhecer e compreender os principais

frameworks de desenvolvimento ágil. Além disso, foi possível entender como o

framework Grails surgiu, a sua ideologia, principais ferramentas e forma de

funcionamento. Já com as pesquisas de campo e descritiva foi possível conhecer a

dinâmica de trabalho da empresa Memora Inteligência Gráfica, e a partir disto, criar

o projeto de software e modelar uma solução tecnológica, que atendesse às suas

reais necessidades. Com isto, utilizando o Grails, deu-se início ao processo de

implementação do módulo de gerenciamento de criação de produtos, o qual foi

constantemente testado e validado pelo cliente.

Vale ainda ressaltar, que durante o processo de desenvolvimento do trabalho

em questão foram utilizadas algumas ferramentas, que auxiliaram no processo de

36

desenvolvimento da solução. Desta forma, durante a fase de análise adotou-se a

ferramenta Astah Community, utilizada para criar os diagramas UML (Unified

Modeling Language), além disso, foi adotada a IDE GGTS (Groovy/Grails Tool Suite)

para implementação dos códigos em Groovy.

37

4. DESENVOLVIMENTO

4.1. Memora Inteligência Gráfica

Em 2005 a empresaria Nilcione Messias dos Santos fundou a agência de

eventos, cujo nome foi definido como Memora Cerimonial e Publicidade. Assim que

surgiu, a empresa prestava serviços voltados a cerimonial e secretaria, mas com o

passar dos anos foi empregado a publicidade, focando em convites de formaturas,

mas também abrangendo publicidade gráfica em geral, passando então a se tornar o

foco principal da empresa, isso levou a mudança do nome para Memora Inteligência

Gráfica, passando assim a assumir a publicidade como principal fonte rentável da

mesma.

A Memora é reconhecida hoje como agência de publicidade, e tem uma

demanda de trabalho muito grande, atendendo todo o estado e explorando estados

próximos, conquistando clientes de diversas cidades circunvizinhas ao estado do

Tocantins, essa demanda de projetos à distância passou a se tornar algo comum à

empresa, pois grande parte do processo de desenvolvimento do produto pode ser

feita por meio de internet e telefone, não sendo totalmente dispensadas as

presenças física do cliente e da empresa, mas reduzindo-as para situações

extremas. Neste ponto surgiu a necessidade de um sistema que auxilie e facilite na

produção e acompanhamento do desenvolvimento dos produtos, em relação a

clientes e funcionários. Sistema este, capaz de em tempo real, poder acompanhar

passo-a-passo o processo de desenvolvimento, bem como a troca de informações

necessárias para o andamento da produção, visando conforto e qualidade no

processo.

4.2. Visão Geral do Sistema

O sistema desenvolvido neste trabalho, possibilita realizar o controle de todo

o fluxo de criação dos produtos elaborados pela agência de publicidade Memora,

38

fazendo com que todos os dados e processos sejam unificados, simplificando, desta

forma, o acompanhamento e gerenciamento do desenvolvimento dos produtos, tanto

por parte da empresa, quanto do cliente.

Conforme explicitado anteriormente, o sistema em questão é desenvolvido

baseando-se em uma necessidade real da empresa, possuindo o objetivo de

automatizar ações, que hoje são realizadas/registradas de formas diversas, como e-

mail, telefone, e outros meios de comunicação. Portanto, com a implantação do

sistema, todas as informações, de cada produto, são reunidas em um único local.

Sendo assim, o sistema possibilita cadastrar informações básicas tanto do cliente,

quanto do produto, assim como registra todas as etapas de criação do produto, por

meio dos processos executados, e suas respectivas movimentações. Os requisitos

funcionais que compõem o sistema podem ser observados na figura 17, a qual

ilustra o diagrama de casos de uso.

Figura 17 - Diagrama de caso de uso geral

39

Conforme pode ser observado na figura 17, interagem com o sistema diversos

atores, como Usuário, Cliente, Funcionário, Vendedor e Administrador. Dentre os

requisitos ilustrados, tem-se o gerenciamento de instituições, onde será possível

realizar cadastros de diversos tipos de instituições, ou seja, tanto instituições de

ensino e/ou empresas. Além disso, o sistema permite o cadastro de comissões,

requisito que visa promover a oportunidade de reunir um grupo de clientes para

gerenciar/acompanhar a criação de um determinado produto.

É importante ressaltar, que tal gerenciamento/acompanhamento será

realizado de forma dinâmica, sendo o processo de criação do produto dividido em

etapas: em um primeiro momento é realizado o cadastro do tipo de produto, logo em

seguida, o cadastro dos atributos referentes a determinado tipo de produto, por

conseguinte, é disponibilizada a funcionalidade de gerenciamento de produtos, de

acordo com o tipo selecionado. Para cada produto cadastrado será disponibilizado o

cadastro de processos, e para cada processo será disponibilizado o cadastro de

movimentações, desta forma, será possível armazenar todo o fluxo de

desenvolvimento do produto no sistema.

No decorrer deste trabalho, o módulo desenvolvido foi o responsável por

automatizar o processo de gerenciamento do processo de criação de produtos,

portanto, na próxima seção o módulo em questão é descrito.

4.3. Módulo de Gerenciamento do Processo de Criação de Produtos

Para implementação neste trabalho, foi selecionado o módulo mais crítico do

sistema, ou seja, o de gerenciamento do processo de criação dos produtos, e assim

comprovar que o framework Grails cumpre sua promessa de desenvolvimento ágil. A

figura 18 ilustra o diagrama de casos de uso, com os atores e requisitos funcionais

do módulo que será trabalhado.

40

Figura 18 - Módulo a ser desenvolvido

Conforme ilustrado na figura 18, os requisitos que compõem o módulo

em questão estão relacionados ao gerenciamento de produto, bem como de

seus processos e suas respectivas movimentações. Este módulo é

considerado o mais crítico do sistema, pelo fato concentrar as informações

mais importantes, desde o início do desenvolvimento do produto, até a

conclusão do mesmo, além de permitir maior interação do cliente sobre o

gerenciamento das movimentações dos processos, assim como maior

controle por parte da empresa. Para que seja possível melhor compreender

cada um dos casos de uso que compõem este módulo do sistema, a seção de

Anexos apresenta os artefatos modelados, como: os casos de uso

expandidos; wireframes; assim como os diagramas de sequência dos casos

de uso, com fluxo considerado mais complexo.

4.4. Utilização do Grails para Desenvolvimento do Módulo de Gerenciamento

do Processo de Criação de Produtos

4.4.1. Classes de Domínio e Controladores

41

Em um primeiro momento, o projeto foi criado, seguindo os passos descritos

na sessão 2.2.1.1. Logo em seguida, as classes de domínio e controle também

foram geradas, seguindo os mesmos passos descritos na sessão 2.2.1.2. É

importante ressaltar, que até o momento, as classes criadas foram apenas as

necessárias para a implementação do módulo de gerenciamento do processo de

criação de produtos. O diagrama de classes do módulo em questão pode ser

observado na figura 19.

Figura 19 - Diagrama de classe do módulo desenvolvido

É importante reforçar, que conforme explicado anteriormente, no modelo de

desenvolvimento proposto pelo Grails, as classes de domínio representam as

tabelas do banco de dados, sendo que as mesmas devem conter os atributos

(colunas do banco) de uma determinada página. Sendo assim, na classe “Produto”,

estão condidas as informações relacionadas ao tipo do produto, cliente vinculado,

data do contrato e data de conclusão. Tal classe possui relacionamento com a

42

classe de domínio denominada “TipoDeProduto, que contém os atributos referentes

ao um tipo de produto específico. Pode-se observar na figura 20, que todos os

atributos da classe de domínio “Produto”, foram marcados como obrigatório, pois

tratam-se de informações extremamente necessárias para efetivação do cadastro.

Figura 20 - Classe de domínio do Produto

As informações específicas de cada tipo de produto são cadastradas pelo próprio

administrador do sistema, tais informações estão concentradas na classe de domínio

“Atributo” (Figura 21), sendo que valores atribuídos a cada atributo são mencionados

na classe de domínio “ValorDoAtributo” (Figura 22).

Figura 21 - Classe de domínio do Atributo

Figura 22 - Classe de domínio do Valor do Atributo

Com o produto previamente cadastrado, torna-se possível organizar seus

processos, com essa finalidade, foi criada uma classe de domínio chamada

“Processo”, que é responsável por separar as etapas de criação do produto. Desta

43

forma, para cada processo cadastrado, de um determinado produto, são criadas

diversas movimentações, sendo tais movimentações responsáveis por armazenar os

dados do fluxo de determinado processo de criação.

Na etapa em questão, tanto o cliente quanto os funcionários da empresa têm

permissão de inserção de dados. Para tanto, foi criada uma classe de domínio

chamada “Movimentação” (Figura 24), que está relacionada à classe “Processo”

(Figura 23), descrita anteriormente, a fim de estabelecer um vínculo dos anexos, que

podem ou não vir a existir, e uma descrição a ser passada para a parte envolvente,

contendo informações sobre o andamento da movimentação. A classe

“Movimentação” (Figura 24) contém ainda o titulo, e a data de criação. Os processos

e as movimentações do produto são as partes mais críticas do sistema, pois são

nelas onde serão concentradas todas as informações pertinentes ao

desenvolvimento geral do produto.

Figura 23 - Classe de domínio Processo

Figura 24 - Classe de domínio Movimentação

Com a finalidade de atender a dinamicidade de tipos de produtos oferecidos

pela empresa, o diagrama de classes foi elaborado de forma que o sistema

mantivesse tal flexibilidade, no que se referente aos atributos e tipos de produtos.

44

Desta forma, para garantir a consistência e integridade dos valores dos atributos,

salvos no banco de dados, foi utilizada a técnica de Rollback, implementada na

classe de serviço, que conforme explicado anteriormente, compõe a estrutura do

Grails, sendo salva no subdiretório grails-app/services. A configuração de tal

procedimento pode ser observada na figura 25.

Figura 25 - Classe de serviço de transações – método saveProduto()

Ainda relacionado ao processo de armazenamento das informações de um

produto, a figura 26 ilustra a chamada ao método de transação na action “save”

do controlador “Produto”.

Figura 26 - Controlador produto – Action save

45

Conforme pode ser observado na figura 26, a linha 56 é responsável por

realizar uma chamada ao método de transação “saveProduto” da classe

“transacoesServices”, sendo responsável por realizar todos os tratamentos

necessários durante o processo de armazenamento de um determinado produto.

4.4.2. Views

O framework Grails traz consigo um BootStrap com o CRUD básico muito

bem estruturado, conforme mencionado nas sessões 2.3.3.5 e 2.4.1.4 após a

execução do comando “grails generate-all”, são geradas as telas de

visualização padrões, mas como mostra na figura 27, é possível modifica-las de

acordo com as necessidade. Desta forma, para a implementação do layout do

sistema em questão foi utilizado o BootStrap do Twitter.

Figura 27 - Tela de login

Para que fosse possível gerar a visualização apresentada na figura 27, foi

implementado o código ilustrado na figura 28. Na linha 42 é criado um formulário

46

com a tag <g:form action="authenticate" method="post">, portanto,

quando o usuário pressionar o botão “Entrar”, a tag em questão enviará o formulário

para a action authenticate, contida no controlador padrão. Deste modo, por

convenção, pode-se afirmar que, neste caso, o controlador é o “LoginController”

como ilustrado na figura 28.

Figura 28 - View login.gsp

Assim que o controlador “LoginController” é acionado, a operação executada

é bem simples, isto porque o framewok Grails realizada grande parte do trabalho

para o desenvolvedor. A linha 15, da figura 29, apresentada a instrução

“findByLoginAndPassword(params.login,params,password)”, que é

responsável por realizar uma consulta ao banco resgatando os dados equivalentes a

expressão enviada. Nas linhas que se seguem, é adicionado o objeto usuário na

sessão, bem como o perfil de acesso dele. Entretanto, caso a consulta retorne

nenhum valor, é exibida uma mensagem de informativa, e o usuário é redirecionado

para a tela de login.

47

Figura 29 - Controlador Login – Action authenticate

A figura 30, ilustra uma das principais telas do sistema, ou seja, a de

gerenciamento de produtos. Conforme pode ser observado, a figura apresenta o

formulário com os dados de cadastro de um produto, assim como uma tabela com a

listagem dos produtos já cadastrados, em ordem decrescente. Sendo assim

possível, nesta mesma tela, acessar as funções de visualização do produto, edição

e exclusão.

Figura 30 - Tela Gerenciar Produto

48

É importante ressaltar que nesta tela, quando o valor do campo “Tipo De

Produto” é alterado na combobox, a página é renderizada novamente, sendo então

apresentados os dados do produto relacionado ao tipo selecionado. Isso é possível

por uma ação realizada na tag referente a combobox, <g:select

onchange="submit()">, que pode ser observada na linha 27, da figura 31, onde

é ativada a ação submit(), responsável por ativar a action create do controlador

“Produto”, onde a mesma retorna para a mesma página o id do tipo de produto

selecionado, para que os dados referentes a ele sejam carregados na tela.

Figura 31 - View create da pátina Gerenciar Produto

Ao solicitar a opção de visualização dos dados do produto, o usuário será

redirecionado para a tela Visualização do Produto, apresentada na figura 32. Esta

tela contém as informações de cadastro do produto, bem como seus processos e

suas respectivas movimentações.

49

Figura 32 - Tela Visualizar Produto

A tela ilustrada na figura 32 é a responsável por apresentar a todos os

envolvidos na criação de um produto o passo a passo da evolução do mesmo,

permitindo assim que todas as informações de um produto sejam

registradas/encontradas/acompanhadas em um único lugar. Portanto, nesta tela,

tanto os funcionários quanto os clientes, poderão acompanhar o andamento do

desenvolvimento do produto, assim como adicionar novas movimentações aos

processos, mas somente o funcionário e o administrador poderão acrescentar

processos, os clientes apenas poderão visualiza-los e cadastrar movimentações.

50

5. CONSIDERAÇÕES FINAIS

A realidade atual no mercado de trabalho é a necessidade de

desenvolvimento de sistemas de qualidade de forma ágil e prática, que facilitam o

trabalho dos desenvolvedores aproveitando seu tempo em focar-se na criatividade

no processo de desenvolvimento, ao invés de configurações e visualização.

Neste contexto, conforme citado no decorrer do trabalho, hoje em dia, existe

uma vasta quantidade de frameworks que atendem às necessidades de

desenvolvimento ágil, e em diversas linguagens. Dentre tais framework o Grails

destaca-se, por além de oferecer um conjunto de ferramentas, que auxiliam na

produção de sistemas para web, o mesmo foi desenvolvido para funcionar sobre a

JVM. Outra característica importante é o fato de o mesmo usar a linguagem de

programação Groovy, que permite ao desenvolvedor ter acesso a todo o poder da

linguagem Java, uma vez que possui total compatibilidade com as bibliotecas e

scripts já existentes em Java. Com isto, pode-se afirmar, que com Grails, programar

passou a ser mais divertido.

Com a implementação do módulo de gerenciamento do processo de criação

de produtos, foi possível verificar a eficiência do framework Grails, o qual mostrou

ser bastante ágil, simples e prático, visto que nenhuma configuração de banco de

dados e XML foram necessárias no decorrer do desenvolvimento. No que diz

respeito ao processo de implementação do layout personalizado, utilizou-se o plug-in

do Twitter, onde o mesmo se comportou de maneira bem homogenia com o

framework Grails, proporcionando uma vantagem significativa na construção e

adaptação do layout do sistema.

Além disso, foi possível verificar algumas vantagens que são proporcionadas

pela linguagem dinâmica Groovy, dentre elas pode-se citar: a facilidade e

simplicidade de implementação da lógica do sistema, onde operações que em Java

poderiam ser mais complexas, em Groovy as mesmas foram reduzidas em uma

linha código, além disso, a sua sintaxe mostra ser bem simples e eficiente.

De forma geral, ao somar a dinamicidade da linguagem Groovy, com a

consistência e a agilidade que o framework Grails oferece, foi possível constatar que

o processo de desenvolvimento de sistema tornou-se mais prazeroso, rápido e

simples.

51

Como proposta de trabalhos futuros, propõem-se realizar a efetiva

implantação do módulo implementado durante este trabalho, bem como o

treinamento dos usuários, a fim de inserir aos poucos o sistema na rotina de trabalho

da empresa. Além disso, pretende-se finalizar a implementação dos demais módulos

do sistema que já foram analisados.

52

6. REFERÊNCIAS

(AGILE MANIFESTO, 2001) AGILE MANIFESTO. Manifesto for Agile Software Development. 2001. Disponível em <http://www.agilemanifesto.org>. Acesso em 16 de setembro de 2012. (ANTUNES, 2011) ANTUNES, Adriano Bastos. Introdução ao Framework Grails. Cabo Frio. Universidade Veiga de Almeida – UVA, 2011. (CAKE PHP, 2012) CAKEPHP. Documentation. 2012. Disponível em: <http://cakephp.org/>. Acesso em: 17 de ago. de 2012. (CALAHORRO), CALAHORRO, Nacho Brito. Manual de Desarrollo Web Con Grails: JavaEE, como Siempre Debió Haber Sido. Criative Commons, Espanã. 2009, 167 p. (CARVALHO, 2006) CARVALHO, Marlon. Spring Framework: Introdução. iMasters. Ago. de 2006. Disponível em: <http://www.imasters.com.br/artigo/4497/java/spring_framework_introducao/>. Acessado em: 30 de abr. de2012. (CARVALHO, 2008) CARVALHO, Marlon. Spring Framework: Introdução. Ago. de 2008. Disponível em: <http://imasters.com.br/artigo/4497/spring_framework_introducao>. Acessado em 02/05/2012. (CODIEIGNITER BRASIL, 2012) CODEIGNITER. CodeIgniter Brasil. 2012. Disponível em: <http://codeigniterbrasil.com/>. Acesso em: 17 de ago. de 2012. (DAVIS; RUDOLPH, 2010) DAVIS, Scott; Jason, RUDOLPH. Getting Started With Grails Second Edition: A modern web framework fot the Java Plataform. 2 ed. InfoQ. 2010. 148 p. (DEPA, 2010) DEPA, Departamento de Sistemas e Computação da UFCG. O que são frameworks?. Disponível em: <http://www.dsc.ufcg.edu.br/~jacques/cursos/map/html/frame/oque.htm>. Acessado em 17 de ago. de 2012. (DJANGO BRASIL, 2012) DJANGO. Documentação do Django. 2012. Disponível em: <http://www.djangobrasil.org/>. Acesso em: 17 de ago. de 2012. (FAYAD; SCHMIDT, 2007) FAYAD, M. E; SCHMIDT, D. C.. Object-oriented application frameworks. Comm. ACM 40(10), 1997. 32-8. (GRAILS, 2012) GRAILS. The Grails Framework: Reference Documentation. Disponível em: <http://grails.org/doc/latest/>. Acesso em: 06 de fev. de 2012.

53

(GRAILSBRASIL, 2012) GRAILSBRASIL. 2012. Disponível em: <http://grailsbrasil.com.br>. Acesso em: 05 de mar. de 2012. (GROOVY, 2012) GROOVY. Portuguese Documentation. 2012. Disponível em: <http://groovy.codehaus.org/Portuguese+Home>. Acesso em: 18 de ago. de 2012. (H2, 2012) H2. Database Engine. H2 Database EngineDisponível: <http://www.h2database.com/html/performance.html>.Acessado em 04 de mai. De 2012. (JRUBY, 2012) JRUBY. Documentation. 2012: Disponível em: <http://jruby.org/>. Acesso em: 17 de ago. de 2012. (JAVAFREE.ORG, 2009) JAVAFREE.ORG. Integração: Spring e Hibernate. Ago. de 2009. Disponível em: <http://javafree.uol.com.br/artigo/871470/Integracao-Spring-e-Hibernate.html>. Acessado em: 01 de mai. De 2012. (___, 2009) JAVAFREE.ORG. Inversion Of Control: Containers de Inversão de Controle e o padrão Dependency Injection. Ago. de 2009. Disponível em: <http://javafree.uol.com.br/artigo/871453/Inversion-Of-Control-Containers-de-Inversao-de-Controle-e-o-padrao-Dependency-Injection.html>. Acessado em: 01 de mai. de 2012. (JUN, 2009) JUN, Ricardo. Spring Framework: O que é afinal de contas e para onde ele vai?. Blobal Code: Informação + colaboração + discussão. Set. de 2009. Disponível em: <http://blog.globalcode.com.br/2009/09/spring-framework-o-que-e-afinal-de.html>. Acessado em: 30 de abr. de 2012. (JUNIT, 2012) JUNIT. Resources for Test Driven Development. Disponível em: <http://www.junit.org/>. Acessado em: 04 de mai. de 2012. (MACORATTI, 2010) MACORATTI, José Carlos. Padrões de Projeto: O modelo MVC – Model View Controller. Disponível em < http://www.macoratti.net/vbn_mvc>. Acessado em: 02 de mai. de 2012. (MOREIRA, 2009) MOREIRA, Daniela. Desenvolvimento ágil funciona?, Info Online. São Paulo, jun. de 2009. Disponível em: <http://info.abril.com.br/noticias/ti/desenvolvimento-agil-funciona-30062009-3.shl>. Acessado em: 24 de abr. de 2012. (ROCHER, 2006) ROCHER, Graeme Keith. The Definitive Guide to Grails. Apress. Springer-Verlag New York. 2006. 360 p. (RUBY, 2012) RUBY. Documentação. 2012. Disponível em: <http://www.ruby-lang.org/pt/>. Acesso em: 17 de ago. de 2012. (RUBY ON RAILS, 2012) RUBY ON RAILS Desenvolvimento Web Sem Dor. 2012. Disponível em: <http://rubyonrails.com.br/>. Acesso em: 17 de ag. de 2012.

54

(SANTOS, 2012) SANTOS, Cleórbete. Desenvolvimento de sistemas em Grails. Disponível em: <http://cleorbete.com/cursos/desenvgrails/>. Acessado em: 25 de set. de 2012. (SOMMERVILLE, 2011) SOMMERVILLE, Ian, Engenharia de Software. 9º Edição, Person Education do Brasil, 2011. (VRAPTOR, 2012) VRAPTOR, Documentation. 2012. Disponível em: <http://vraptor.caelum.com.br/en>. Acesso em: 17 de ago. de 2012. (WALLS; BREIDENBACH, 2005) WALLS, Craig; BREIDENBACH Ryan. Spring In Action. Editora Manning. Greenwich, 2005, 209 p. (WEISSMANN, 2010) WEISSMANN. Henrique Lobo. Grails: um Guia rápido e indireto. Disponível em: <http://www.itexto.net/devkico/?page_id=220>. Acessado em: 5 de mar. de 2012.

55

7. ANEXO A

7.1. Requisitos funcionais

7.1.1. Requisitos Funcionais

RF1 - Cadastrar Usuário: O cadastro de usuários do sistema deve ser unificado e as

permissões dentro do sistema separadas por perfil de acesso.

RF2 - Cadastro de instituições: Deve-se manter um cadastro com os dados básicos

das instituições no sistema, o mesmo poderá ser usado para futuros contatos.

RF3 - Cadastrar produtos: O sistema deve ser desenvolvido de forma que possa ser

facilmente adaptável a mudanças nos produtos cadastrados, bem como o cadastro

de novos tipos de produtos.

RF4 - Cadastro de comissão: O sistema deve conter o cadastro de comissão, onde

serão vinculados vários clientes e instituições, assim como, vinculados vários

clientes (pessoas) a um produto específico.

RF5 - Cadastrar cursos: É de bastante proveito ter uma base de cadastro de cursos,

para poder vincula-los a instituições de ensino.

RF6 - Cadastrar processos: Para melhor organização no processo de

desenvolvimento dos produtos, deve ser permitido o cadastro de processos para

cada produto, devidamente cadastrado no sistema.

RF7 - Cadastrar movimentação: para cada processo cadastrado, deve-se

possibilitar o cadastro de movimentações do processo específico. Esta ação também

será gerenciada pelo cliente.

RF8 - Gerar relatório: O sistema deve permitir que os funcionários possam gerar

relatórios do sistemas em geral.

RF9 - Listar produtos cadastrados: O sistema deve exibir uma lista dos produtos

cadastrados.

RF10 - Listar Usuários Cadastrados: O sistema deve exibir uma lista com os

usuários cadastrados.

RF11 - Alterar perfil dos Usuários Cadastrados: O sistema deve permitir a

alteração dos perfis dos usuários cadastrados.

56

7.1.2. Requisitos Não-Funcionais

RNF 1 – Usabilidade – O sistema deverá realizar as tarefas de maneira eficaz,

eficiente e agradável.

RNF 2 – Consistência – O sistema deverá executar as funcionalidades de forma

coerente ao contexto.

RNF 3 – Confiabilidade – O sistema deverá sempre realizar as funcionalidades

requeridas e apresentar um bom desempenho.

RNF 4 – Acessibilidade – O sistema deverá ser acessível a deficientes visuais.

7.2. Caso de uso expandido e Wireframe do Módulo de Gerenciamento do

Processo de Criação de Produtos

7.2.1. Gerenciar Produto

57

Figura 33 - Tela de ilustração do caso de uso Gerenciar Produto

Caso de Uso: Gerenciar Produto

Ator: Administrador

Finalidade: Permite ao ator Inserir novos produtos, Editar, Excluir

e Listar todos os produtos cadastrados.

Visão Geral:

O ator poderá Listar Todos os produtos cadastrado ou

efetuar uma busca de produtos com um filtro de

pesquisa. Também poderá editar ou excluir (apenas

produtos que não houver processos), bem como

visualizar seus dados cadastrais, processos e

movimentações.

Pré–Condições:

Pós–Condições: É criada uma instância do produto no sistema e a

relação do mesmo com Cliente.

Ação do Ator Resposta do Sistema

Fluxo 1

Fluxo 2

Fluxo 3 Fluxo 4

58

Sequencia Típica de Evento

1. O ator seleciona Gerenciar Produto. 2. O sistema realiza uma consulta de

produtos cadastrados.

3. O sistema apresenta o tela de

gerencia.

Fluxo 1

4. O ator seleciona a opção cadastrar

novo produto.

5. O sistema apresenta o formulário

de Cadastro

6. O ator preenche os dados do

formulário e confirma a ação.

7. O sistema exibe o resultado de

sucesso.

Fluxo 2

8. O ator, na listagem de produtos,

seleciona a opção editar.


preenchido com os dados do produto.

10. O ator altera os dados desejados e

escolhe a ação Editar.


sucesso.

Fluxo 3


seleciona a opção excluir.

13. O sistema apresenta a mensagem

de confirmação.

14. O ator confirma a opção. 15. O sistema apresenta o resultado

da operação.

Fluxo 4


seleciona a opção visualizar.

17. O sistema apresenta a página

Visualizar Produto.

Sequências Alternativa.

Linha 7 O usuário não informa os dados corretamente. O sistema exibe

uma mensagem de erro correspondente

Linha 11 O usuário não informa os dados corretamente. O sistema exibe

uma mensagem de erro correspondente

Linha 14 O ator, na mensagem de confirmação, não confirma a ação. O

sistema não realiza nenhuma ação.

7.2.2. Visualizar Produto

59

Figura 34 - Tela de ilustração do caso de uso Visualizar Produto

Caso de Uso: Visualizar Produto

Ator: Administrador

Finalidade: Visualizar dados do produto, listar e inserir processos e

movimentações.

60

Visão Geral: Tem como finalidades visualizar os dados do produto,

listar e inserir processos e suas movimentações.

Pré–Condições: Ter acessado a opção visualizar do caso de uso

Gerenciar Produto.

Pós–Condições:

Sequência Típica de Eventos


1. O sistema apresenta os dados de

cadastro do produto bem como os

Casos de Uso Inserir processo e Listar

Processos.

Sequências Alternativa.

7.2.3. Listar Processo

61

Figura 35 - Tela de ilustração do caso de uso Listar Processo

Caso de Uso: Listar Processo

Ator: Administrador

Finalidade: Listar processos cadastrados.

Visão Geral: Permite ao ator listar todos os processos cadastrados

de um determinado produto.

62

Pré–Condições: O ator ter acessado a o caso de uso Visualizar

Produto.

Pós–Condições:



1. O ator seleciona Processo no caso

de uso Visualizar Produto.

2. O sistema exibe a lista de todos os

processos cadastrados.

Sequências Alternativas

Linha 2 Se não houver registros, o sistema informa uma mensagem

correspondente.

7.2.4. Inserir Processo

63

Figura 36 - Tela de ilustração do caso de uso Inserir Processo

Caso de Uso: Inserir Processo

Ator: Administrador

Finalidade: Inserir novo processo.

Visão Geral: Permite ao ator inserir um novo processo a um

determinado produto.

64


Produto.

Pós–Condições: É criada uma instância do processo e vinculada ao

produto.



1. O ator seleciona a opção Inserir

Processo.


de Cadastro




sucesso.


Linha 3 O ator seleciona a opção limpar. O sistema limpa os campos do

formulário.

7.2.5. Visualizar Processo

65

Figura 37 - Tela de ilustração do caso de uso Visualizar Processo

Caso de Uso: Visualizar Processo

Ator: Administrador

Finalidade: Visualizar movimentações vinculadas ao processo.

Visão Geral: Permite ao ator, visualizar todas as movimentações

vinculadas a um determinado processo.

66

Pré–Condições: O ator ter acessado o caso de uso Listar Processos.

Pós–Condições:

São apresentadas todas as movimentações vinculadas

a tal processo, bem como o caso de uso Inserir

Movimentação.



1. O ator seleciona um dos

processos listados.

2. O sistema apresenta a lista de

todas as movimentações vinculadas a

tal processo.


7.2.6. Excluir Processo

67

Figura 38 - Tela de ilustração do caso de uso Excluir Processo

Caso de Uso: Excluir Processo

Ator: Administrador

Finalidade: Excluir um processos cadastrado.

68

Visão Geral: Permite ao ator, excluir um determinado processo caso

o mesmo não haja movimentações.

Pré–Condições: O ator ter acessado o caso de uso Visualizar

Processo.

Pós–Condições: É apagada a instancia do processo.



1. O ator solicita a exclusão do

processo.

2. O sistema apresenta a mensagem

de confirmação.

3. O ator confirma a opção. 4. O sistema apresenta o resultado de

sucesso.


Linha 3 O ator, na mensagem de confirmação, não confirma a ação. O

sistema não realiza nenhuma ação.

7.2.7. Inserir Movimentação

69

Figura 39 - Tela de ilustração do caso de uso Inserir Movimentação

Caso de Uso: Inserir Movimentação

Ator: Administrador

Finalidade: Inserir uma movimentação e vincula-la a um

determinado processo..

Visão Geral: Permite ao ator, o cadastro de uma nova

movimentação para um determinado processo.

70


Processo.

Pós–Condições: É criada uma instância da movimentação e vinculada a

um determinado processo.



1. O ator seleciona a opção visualizar

processo.

2. O sistema apresenta a opção

Inserir Movimentação.

3. O ator seleciona a opção Inserir

movimentação.


de cadastro.




sucesso.


Linha 5 O ator seleciona a opção limpar. O sistema limpa os campos do

formulário.

Linha 6 Se houver erros na inserção dos dados obrigatórios, o sistema

informa uma mensagem correspondente.

7.2.8. Visualizar Movimentação

71

Figura 40 - Tela de ilustração do caso de uso Visualizar Movimentação

Caso de Uso: Visualizar Movimentação

Ator: Administrador

Finalidade: Visualizar dados de cadastro.

Visão Geral: Permite ao ator, visualizar os dados de cadastro da

movimentação

72

Pré–Condições: O ator ter acessado o caso de uso Visualizar

Processo.

Pós–Condições:



1. O ator seleciona a movimentação

desejada.

2. O sistema apresenta os dados de

cadastro de uma determinada

movimentação.


Linha 2 Se não houver registros o sistema informa uma mensagem

correspondente.

7.3. Diagrama de Sequências e Contratos

7.3.1. Visualizar Produto

73

Figura 41 - Diagrama de Sequência do requisito Visualizar Produto

7.3.2. Inserir Movimentação

74

Figura 42 - Diagrama de Sequência do requisito Inserir movimentação

Monografia_FelipeAugusto

Documents

Transcript of Monografia_FelipeAugusto