CESED - CENTRO DE ENSINO SUPERIOR E DESENVOLVIMENTO

FACISA - FACULDADE DE CINCIAS SOCIAIS APLICADAS

CURSO DE BACHARELADO EM SISTEMAS DE INFORMAO

RENAN RIBEIRO BARBOZA ALBUQUERQUE

DESENVOLVENDO APLICAES GEIS E DINMICAS

COM GROOVY E GRAILS

CAMPINA GRANDE - PB
2011

RENAN RIBEIRO BARBOZA ALBUQUERQUE

DESENVOLVENDO APLICAES GEIS E DINMICAS

COM GROOVY E GRAILS

Trabalho de concluso de curso

apresentado como pr-requisito para a
obteno do ttulo Bacharel em Sistemas
de Informao pela Faculdade de
Cincias Sociais Aplicadas.
rea de Concentrao: Desenvolvimento
de sistemas web.
Orientador: Bruno de Brito Leite.

Campina Grande - PB
2011

Trabalho de concluso de curso,

Desenvolvendo aplicaes geis e
dinmicas com Groovy e Grails,
apresentado por Renan Ribeiro Barboza
Albuquerque como parte dos requisitos
para obteno do ttulo de Bacharel em
Sistemas de Informao outorgado pela
Faculdade de Cincias Sociais Aplicadas
de Campina Grande PB.
APROVADO EM: _____/ _____/ _____
BANCA EXAMINADORA:
_________________________________
Prof. da FACISA Bruno de Brito Leite
Orientador

1 Membro da Banca

2 Membro da Banca

AGRADECIMENTOS

Agradeo a Deus por ter me dado o dom da vida e foras para superar as
dificuldades impostas durante todo o curso.
Aos meus pais, pela grande contribuio na minha formao intelectual, moral
e tica e que sempre me incentivaram para lutar pelos meus ideais.
A minha querida av e irm pelo amor, carinho, dedicao e apoio que
sempre me deram.
Aos professores e coordenadores do curso de Sistemas de Informao pelo
incentivo constante no decorrer de todo esse tempo de estudo, em especial, ao
professor Bruno de Brito Leite, orientador da presente dissertao, pelo crdito,
compreenso, pacincia e apoio que me deu durante sua realizao e ao professor
Bruno Gama Cato que muito contribuiu para o meu crescimento intelectual, abrindo
meu campo de viso para novos horizontes.
A todos os meus parentes e amigos.

A experincia dos erros to importante quanto experincia dos

acertos, porque vistos de um jeito certo, os erros nos preparam para
as nossas vitrias e conquistas futuras, porque no h aprendizado
na vida que no passe pela experincia dos erros.
Pe. Fbio de Melo

RESUMO

A plataforma Java EE vem sendo criticada por muitos desenvolvedores, pela sua
complexidade em relao ao seu desenvolvimento na web. Visando suprir estas
complexidades, surgem diversas linguagens de programao com prticas em
metodologias geis e dinmicas. Estas prticas alm de beneficiar na qualidade do
desenvolvimento e manuteno de sistemas web, poupa o desenvolvedor, entre
outras coisas, do trabalho repetitivo e tempo de desenvolvimento. Nesse contexto, o
presente trabalho tem como objetivo apresentar para o leitor duas tecnologias: a
linguagem de programao Groovy e um framework de alta produtividade fullstack
Grails, que seguem esta tendncia de desenvolvimento de sistemas voltado para a
web e tambm, por em prtica todo o contedo visto, atravs de um estudo de caso,
mostrando as vantagens de se trabalhar com elas. O trabalho foi realizado atravs
de pesquisa bibliogrfica, no qual foi baseado em consultas literrias e artigos
cientficos, seguido de um estudo de caso, no qual foi possvel desenvolver uma
aplicao, vivenciando as prticas que estas tecnologias proporcionam, onde
percebe-se claramente, que os recursos e ferramentas que compe o Grails
integrados a linguagem dinmica Groovy, tornam o cotidiano dos desenvolvedores
mais prtico e produtivo no que diz respeito ao desenvolvimento de projetos
corporativos.
PALAVRAS-CHAVE: Groovy, framework Grails, sistemas web.

ABSTRACT

The Java EE platform has been criticized by many developers because of its
complexity in relation to its development on the web. Aiming to overcome these
complexities, there are several programming languages with practices in agile and
dynamic. These practices also benefit the quality of development and maintenance of
web systems, saves the developer, among other things, repetitive work and
development time. In this context, this paper aims to introduce the reader to two
technologies: the Groovy programming language and a framework of high
productivity fullstack Grails, following this development trend of web-facing systems
and also because in practice all the content seen through a case study showing the
benefits of working with them. The study was conducted through literature search,
which was based on consultations literary and scientific articles, followed by a case
study in which it was possible to develop an application, experiencing the practices
that these technologies offer, where it is clear that the resources and tools that
comprise the integrated Grails Groovy dynamic language, make the daily life of the
developers more practical and productive with regard to the development of
corporate projects.
KEYWORDS: Groovy, Grails framework, web systems.

LISTA DE ABREVIATURAS E SIGLAS

API

Application Programming Interface

COC

Convention Over Configuration

CSS

Cascading Style Sheets

DRY

Don't Repeat Yourself

EJB

Enterprise JavaBeans

EL

Expression Language

GANT

Groovy Ant

GDK

Groovy Development Kit

GDT

Groovy Developer Tools

GLS

Groovy Language Specification

GORM

Groovy Object Relational Mapping

GSP

Groovy Server Pages

IDE

Integrated Development Environment

JAR

Java Archive

JAVA SE

Java Standard Edition

Java EE

Java Enterprise Edition

JCP

Java Community Process

JDK

Java Development Kit

JDBC

Java Database Connectivity

JEE

Java Enterprise Edition

JPA

Java Persistence API

JRE

Java Runtime Environment

JSP

Java Server Page

JSR

Java Specification Request

JVM

Java Virtual Machine

HTML

HyperText Markup Language

MVC

Model-View-Controller

MOP

Meta-Object Protocol

MOR

Mapeamento Objeto-Relacional

ORM

Object-Relational Mapping

PDF

Portable Document Format

POGO

Plain Old Groovy Object

POJO

Plain Old Java Object

SDK

Software Development Kit

STS

SpringSource Tool Suite

TCK

Test Compatible Kit

TI

Tecnologia da Informao

URL

Uniform Resource Locator

XML

Extensible Markup Language

LISTA DE TABELAS

Tabela 1 - Operadores do Groovy ......................................................................................................31

Tabela 2 - Operadores relacionais do Groovy ....................................................................................31
Tabela 3- Tipos de dados no Groovy ..................................................................................................33
Tabela 4 - Actions default do Grails ...................................................................................................43
Tabela 5- Arquivos de configurao do banco de dados ....................................................................66

LISTA DE FIGURAS

Figura 1 - Tela do Prompt de Comando, executando o console Groovy ..............................................22

Figura 2 - GroovyConsole, executando o exemplo Alo,Groovy! ..........................................................23
Figura 3 - Tela do Prompt de Comando, verificando a configurao do Groovy ..................................35
Figura 4 - Estrutura de diretrios do Grails ........................................................................................39
Figura 5 - Arquitetura Grails ..............................................................................................................47
Figura 6 - Configurando a varivel de ambiento do Grails ..................................................................49
Figura 7 - Tela do Prompt de Comando, verificando a configurao do Grails ....................................50
Figura 8 - Tela principal do sistema ...................................................................................................52
Figura 9 - Caso de uso do sistema......................................................................................................53
Figura 10 - Diagrama de Classe ..........................................................................................................55
Figura 11 - Estrutura de diretrios da Aplicao ................................................................................57
Figura 12 - Classes Groovy dentro do diretrio domain na Aplicao .................................................58
Figura 13 - Controladores da Aplicao .............................................................................................59
Figura 14 - Aplicao sendo executada no terminal. ..........................................................................60
Figura 15 - Pgina inicial da aplicao. ...............................................................................................61
Figura 16 - Listagem de clientes cadastrados .....................................................................................61
Figura 17 - Tela de cadastro de um cliente ........................................................................................62
Figura 18 - Mapeamento de URL no Grails ........................................................................................62
Figura 19 - Arquivos de configurao do banco de dados ..................................................................65
Figura 20 - Views da Aplicao ..........................................................................................................68
Figura 21 - Abrindo o prompt de commando do Grails ......................................................................69
Figura 22 - Comando grails generate-all makeup.erp.Cliente.............................................................69
Figura 23 - Layout do Index.gsp .........................................................................................................71
Figura 24 - Pgina principal com o usurio logado .............................................................................76
Figura 25 - Tela de login ....................................................................................................................77
Figura 26 - Campo de busca ..............................................................................................................79

Figura 27 - Criando o relatrio de clientes no iReport ........................................................................80

Figura 28 - Diretrio reports ..............................................................................................................81
Figura 29 - Boto do relatrio ...........................................................................................................81
Figura 30 - Botes internacionalizados para pt_BR ............................................................................83
Figura 31 - Arquivo war. gerado dentro do diretrio target ...............................................................84
Figura 32 - Configuraes bsicas do Tomcat ....................................................................................92
Figura 33 - Configurando a varivel de ambiento do Tomcat .............................................................93
Figura 34 - Tela de abertura do SpringSource Tool Suite ....................................................................94
Figura 35 - Dashboard do SpringSource Tool Suite .............................................................................95
Figura 36 - Configurando o Grails na Dashboard................................................................................95

Sumrio

INTRODUO ............................................................................................. 16

FUNDAMENTAO TERICA ................................................................... 18

2.1

LINGUAGEM GROOVY ............................................................................... 18

2.1.1

Histrico ...................................................................................................... 18

2.1.2

Introduo linguagem Groovy................................................................ 20

2.1.3

Groovy: Uma linguagem de Scripting e Dinmica................................... 24

2.1.4

Elementos bsico do Groovy ................................................................... 25

2.1.4.1 Trabalhando com Strings .......................................................................... 25

2.1.4.2 Mtodos e Closures ................................................................................... 26
2.1.4.3 Intervalos, Lista e Mapas (Hashes) .......................................................... 27
2.1.4.4 Expresses Regulares ............................................................................... 29
2.1.4.5 Operadores ................................................................................................. 30
2.1.4.6 Tipos de dados ........................................................................................... 32
2.1.4.7 Groovy Beans ............................................................................................. 33
2.1.3

Instalando o Groovy ................................................................................... 34

2.2

FRAMEWORK GRAILS ................................................................................ 35

2.2.1

Histrico ...................................................................................................... 36

2.2.2

Introduo ao Grails................................................................................... 37

2.2.3

Grails e sua estrutura................................................................................. 38

2.2.4

Recursos do Grails..................................................................................... 41

2.2.4.1 Conveno sobre configurao ................................................................ 41

2.2.4.2 Testes Unitrios.......................................................................................... 42
2.2.4.3 Scaffolding .................................................................................................. 42
2.2.4.4 Mapeamento Objeto Relacional ................................................................ 43
2.2.4.5 Plugins ........................................................................................................ 44

2.2.5

Frameworks Integrados ............................................................................. 44

2.2.5.1 Spring Framework ...................................................................................... 44

2.2.5.2 Hibernate ..................................................................................................... 45
2.2.5.3 SiteMesh ...................................................................................................... 45
2.2.5.4 Ajax Framework .......................................................................................... 45
2.2.5.5 Jetty ............................................................................................................. 46
2.2.5.6 HSQLDB ...................................................................................................... 46
2.2.5.7 JUnit ............................................................................................................ 47
2.2.6

Arquitetura Grails ....................................................................................... 47

2.2.7

Mapeamento Objeto Relacional ................................................................ 48

2.2.3

Instalando o Grails ..................................................................................... 49

ESTUDO DE CASO ..................................................................................... 51

3.1

DESCRIO DO SISTEMA ......................................................................... 51

3.2

ANLISE DE REQUISITOS ......................................................................... 52

3.3

CRIANDO A APLICAO ............................................................................ 55

3.3.1

Criando o Projeto ....................................................................................... 56

3.3.2

Criando classes de domnio ...................................................................... 57

3.3.3

Criando os controllers(Controladores) .................................................... 59

3.3.4

Executando o Projeto................................................................................. 60

3.3.5

Validao..................................................................................................... 63

3.3.6

Criando o banco de dados......................................................................... 64

3.3.7

Configurando o Banco de dados .............................................................. 65

3.3.8

Personalizando a aplicao....................................................................... 68

3.3.9

Adicionando segurana na aplicao ...................................................... 73

3.3.10 Adicionando uma busca ............................................................................ 77

3.3.11 Internacionalizao .................................................................................... 82
3.3.12 Deploy ......................................................................................................... 84

METODOLOGIA .......................................................................................... 85

CONSIDERAES FINAIS ......................................................................... 86

5.1

TRABALHOS RELACIONADOS .................................................................. 87

5.2

TRABALHOS FUTUROS ............................................................................. 88

REFERNCIAS ......................................................................................................... 89
APENDICE ................................................................................................................ 91
A.1 JAVA DEVELOPMENT KIT (JDK) ...................................................................... 91
A.2 SERVIDOR APACHE TOMCAT.......................................................................... 91
A.3 SPRING SOURCE TOOL SUITE 2.5.2.SR1 ....................................................... 93
A.4 MYSQL SERVER 5.5 .......................................................................................... 96
ANEXOS ................................................................................................................... 98

16

1 INTRODUO

Com a crescente disponibilidade de recursos que a Internet oferece aos seus

usurios, as aplicaes na web tornam-se mais atrativas. O desenvolvimento de
aplicaes web utilizando a plataforma Java EE tem crescido nos ltimos anos e
proporcionado novos frameworks e bibliotecas.
A plataforma Java possui uma arquitetura para aplicaes web bastante rica,
porm muito complexa, por tentar atender a diferentes situaes e propsitos. Essa
complexidade, somadas a diversas opes de frameworks, trazem alguns problemas
plataforma Java, tornando-a pouco produtiva comparada a outras tecnologias web.
Pode-se perceber na prtica alguns problemas, como perda no tempo para
configurar uma aplicao, incompatibilidade de alguns frameworks entre si devido as
suas verses, exaustivas repeties em criaes de CRUDs, configurao de logs,
internacionalizao, acesso aos dados, relatrios, etc.
Logo, os desenvolvedores Java nunca conseguiram um nvel de produtividade
exigido pelos princpios e prticas geis. Esta falta de agilidade fez com que
linguagens dinmicas como Ruby e Python crescessem e tivessem cada vez mais
adeptos, dentre os quais se destacavam os que seguem as metodologias geis
(JUDD; NUSAIRAT; SHINGLER, 2008). Com o intuito de suprir estas deficincias
surgiu o Groovy, uma linguagem de programao estvel, rica de recursos que
manteve a compatibilidade com a API existente no Java, que busca o que faltava
para a plataforma: flexibilidade e produtividade.
Neste trabalho sero apresentados uma linguagem de desenvolvimento e um
framework para implementaes de um sistema em metodologias geis. A
linguagem Groovy, que uma linguagem de script e dinmica, construda sobre o
fundamento slido da plataforma Java, vem ganhando notoriedade para o
desenvolvimento web, devido ao seu alto grau de produtividade. O Grails um
framework que surgiu com o intuito de criar software de forma gil e dinmica, dando
ao desenvolvedor mais simplicidade, flexibilidade, poder e robustez tecnolgica,
aumentando a produtividade de codificao.
Para ilustrar os conceitos apresentados, ao final deste trabalho ser
desenvolvida uma simples aplicao web, baseado nos estudos feitos com a

17

linguagem e o framework, para que atravs de um estudo de caso, o leitor possa

compreender o funcionamento, analisar e testar as funcionalidades de uma
aplicao web em camadas. Relacionando as tecnologias utilizadas pelo framework
Grails, avaliando-o com relao facilidade de utilizao e produtividade, que
propem uma metodologia de desenvolvimento rpido.

18

2 FUNDAMENTAO TERICA

Nesta seo ser apresentada a linguagem Groovy, uma nova linguagem de

scripting e dinmica cujo uso vem crescendo no mbito de desenvolvimento de
sistemas web. Aprofundaremos sobre o Groovy, desde a sua criao, a sua
semntica, sua relao com o Java, e por fim sero apresentados os passos
necessrios para configurar o ambiente de desenvolvimento que permita usufruir de
todos os seus recursos.

2.1 LINGUAGEM GROOVY

O Groovy uma linguagem de programao dinmica de altssima

produtividade executada na JVM que oferece algumas melhorias em relao
linguagem Java. Ser apresentado os principais conceitos por traz do funcionamento
da linguagem para auxiliar na compreenso do framework Grails, que baseado
nesta linguagem.

2.1.1 Histrico

Como apresenta KNIG(2007), o Groovy surgiu em meados de 2003, sendo

criado pelo programador James Strachan, um membro do Apache Software
Foundation1, co-fundador de vrios outros projetos com cdigo livre.
O desenvolvimento da linguagem Groovy comeou em consequncia de um
voo atrasado, onde James Strachan e sua esposa estavam espera. Enquanto sua
esposa foi s compras, James Strachan visitou um cybercaf e, espontaneamente,

http://www.apache.org

19

decidiu navegar pelo site2 da linguagem Python e estud-la. No decurso

desta

atividade, ele reconheceu que a linguagem de programao na qual era experiente

(Java) no tinha muitos dos recursos interessantes e teis presentes no Python,
exemplo do suporte ao idioma nativo para tipos de dados comuns em uma sintaxe
expressiva e, o mais importante, comportamento dinmico. Partindo deste ponto,
surgiu a idia de trazer estes recursos para o Java.
No dia 29 de Agosto de 2003, James Strachan publicou em seu blog3 um
artigo com as primeiras descries do Groovy. Sua idia inicial era criar uma
linguagem dinmica, que fosse compilada diretamente em classes Java e que
tivesse a produtividade encontrada no Ruby e Python, mas que permitisse reusar,
estender, implementar e testar cdigo Java j existente. James Strachan no queria
apenas limitar o Groovy uma nova linguagem dinmica, mas sim criar algo que
pudesse ser integrado ao que ele j tinha pronto em Java.
Com a idia formada, James uniu-se a Bob McWhirter e juntos fundaram o
projeto Groovy no segundo semestre de 2003. Junto a eles, algumas pessoas que
partilhavam da mesma idia deram incio ao desenvolvimento da linguagem.
Inicialmente, este projeto ficou hospedado pelo CodeHaus4, um repositrio de
projetos de cdigo aberto com nfase em projetos na linguagem Java.
De acordo com KNIG(2007), em 2004, o nome do projeto foi renomeado
para Groovy-One, a equipe estava crescendo e a entrada de novos desenvolvedores
(entre eles Guillaume Laforge, que posteriormente se tornou um dos lderes) fez o
projeto dar continuidade. Foi ento lanado o Groovy Language Specification (GLS),
o kit para testes de compatibilidade (TCK) e a sua primeira verso. Ainda em 2004, o
Groovy deu incio a sua Java Specification Request (JSR), com o objetivo de
padronizar a nova linguagem Groovy para a plataforma Java SE. Sendo aprovado no
final de maro daquele ano, se tornou a segunda linguagem-padro para a Java
Virtual Machine (JVM), depois da prpria linguagem Java.
No comeo de 2005, Guillaume LaForge, um dos principais auxiliares de
Strachan, assumiu o comando do projeto devido uma forte crise no segundo
semestre de 2004, com alguns dos membros abandonando o projeto, insatisfeitos
com o progresso da especificao formal da linguagem e da implementao, pela
2

http://www.python.org

http://macstrac.blogspot.com

http://groovy.codehaus.org

20

falta de dedicao por parte de James Strachan. Aps Guillaume assumir o cargo, o
projeto voltou ao normal.
At 2006 diversas verses betas foram lanadas. Finalmente, no dia 02 de
Janeiro de 2007 foi lanada a verso 1.0, aps o incio do processo de padronizao
Java Community Process (JCP).
Apesar de sua ascenso, o Groovy cresceu sem muita popularidade e com o
passar do tempo foram lanadas vrias verses sob o nmero 1.1.x. No dia 07 de
dezembro de 2007 foi lanada sua verso final da famlia 1.1. Logo, nomeada para
Groovy 1.5 devido s diversas modificaes realizadas na linguagem.
Por ser um projeto de cdigo-aberto, qualquer desenvolvedor pode participar
do projeto Groovy que financiado pela G2One Inc. Empresa fundada em 2007
pelos lderes do Groovy e Grails, (Guillaume Laforge, Graeme Rocher e Alex
Trackman), que foi adquirida pela SpringSource5 em novembro de 2008, oferecendo
para as empresas, suporte para os desenvolvedores e operaes de TI que utilizam
aplicaes Groovy e Grails.
A ltima verso estvel lanada a 1.7, mas est possvel para baixar as
verses 1.8 e 1.9, que se encontram em estgio beta, no prprio site6 oficial da
linguagem. Hoje a linguagem Groovy uma especificao do JCP (JSR 241)7, sendo
considerada a segunda linguagem oficial da plataforma Java.
Na prxima seo, veremos uma definio e uma abordagem inicial
linguagem Groovy.

2.1.2 Introduo linguagem Groovy

A descrio presente no site oficial8 da linguagem diz que:

Groovy uma linguagem gil e dinmica para a plataforma Java com muitas
caractersticas que so inspirados por linguagens como Python, Ruby e

http://www.springsource.com
http://groovy.codehaus.org/Download
7
http://www.jcp.org/en/jsr/detail?id=241
8
http://groovy.codehaus.org
5
6

21

Smalltalk, trazendo uma sintaxe Java-like para os desenvolvedores Java.

Segundo o site oficial da linguagem Groovy.(LAFORGE,2011).

O Groovy relativamente uma linguagem dinmica que pode ser interpretada

ou compilada pela JVM, projetado especificamente para a plataforma Java9. Sua
criao foi influenciada por linguagens como o Ruby10, Python, Perl11, e Smalltalk12.
Considerada segunda linguagem-padro para a JVM, a linguagem Groovy fornece
para programadores Java, facilidade em sua utilizao, pois o Groovy baseado na
API Java. O que torna fcil a integrao entre as duas linguagens.
De acordo com JUDD(2008) uma das vantagens da linguagem Groovy em
relao as demais linguagens citadas acima, que o Groovy no se limita apenas
ao acesso API Java existente. O Groovy possui sua prpria API, Groovy
Development Kit (GDK), que se complementa a API Java, adicionando novos
mtodos para as classes Java existentes.
JUDD(2008) ainda afirma que, a sintaxe do Groovy muito mais flexvel e
poderosa se comparando ao Java. Dezenas de linhas de cdigo na linguagem Java,
podem ser reduzidas para algumas linhas de cdigo em Groovy. A linguagem
Groovy tambm tem provado ser uma plataforma eficiente para conceitos como
meta-programao e linguagens especficas de domnio.
O Groovy uma linguagem orientada a objetos baseada em classes, se
igualando neste aspecto linguagem Java. Desta forma, as classes suportam
(heranas simples) e interfaces (com herana mltipla), sobrescrita de mtodos, etc.
A maior diferena que o Groovy no possui tipos primitivos, onde todos os tipos
so objetos.
Para comearmos a entender melhor esta linguagem vamos criar um exemplo
clssico Alo Java na linguagem Java, em seguida, para linguagem Groovy:
Listagem 1. A classe AloJava.java _________________________________________________________
public class AloJava {
public static void main ( String[] args ) {
System.out.println(Alo, Java!);
}

http://www.java.org
http://www.ruby-lang.org/en
11
http://www.perl.org/
12
http://www.smalltalk.org/main/
9

10

22

Agora veremos a mesma classe AloGroovy na linguagem Groovy.

Listagem 2. A classe AloMundo.groovy_______________________________________________________
class AloGroovy {
static main( args ){
println "Alo, Groovy!"
}
}

Para executar o cdigo Groovy, siga os passos da instalao da linguagem

Groovy na seo 2.1.5.
Feito a instalao, existem vrias opes de execuo para

as classes

Groovy implementadas. A mais simples, abra o prompt de comando, localize o

diretrio bin dentro da pasta de instalao do Groovy, digite o comando
groovyConsole e pressione enter, de acordo com Figura 1.

Figura 1 - Tela do Prompt de Comando, executando o console Groovy

O utilitrio GroovyConsole, somente um .bat ou script de shell que invoca a

JVM aps confirmar o classpath com os arquivos de biblioteca (jars) de runtime do
Groovy.
Os usurios do Eclipse13 podem instalar o Groovy Developer Tools (GDT), um
plugin que facilita a edio e execuo de scripts Groovy. Aps seguir estes passos

13

http://www.eclipse.org

23

o console ir abrir e nela o usurio poder criar, alterar e executar as suas classes
Groovy, como apresentado na Figura 2.

Figura 2 - GroovyConsole, executando o exemplo Alo,Groovy!

Por estas linhas de cdigo, j podemos observar algumas caractersticas de

linguagens dinmicas. O Groovy possibilita ao desenvolvedor, no precisar declarar
classes e mtodos, permitindo executar o cdigo em um escopo global. A
terminao por ; opcional, exceto para separar statements na mesma linha, que
segue as mesmas regras de outras linguagens dinmicas como JavaScript. Outra
caracterstica comum nas classes Groovy sua visibilidade por padro de mtodos
e campos pblicos e o acesso facilitado a APIs importantes, conforme explicou
DEARLE(2010). Neste caso, importaes implcitas como o pacote java.util .* e a
invocao do mtodo println() sem a necessidade do prefixo System.out.
JUDD(2008) afirma que com as melhorias feitas na linguagem, usando o seu
conceito de script: a implementao de mtodos bsicos como o get/set no

necessria, contudo possvel redefinir caso a implementao padro no

satisfaa as necessidades; podemos rescrev-las se quisermos implementaes
no-default. O comando return muito usado na linguagem Java suportado pela
linguagem Groovy, mas no necessrio pois mtodos com retorno diferente de
void retornam o resultado da ltima expresso avaliada.

24

Os recursos dinmicos contidos no Groovy nos permite definir variveis e

mtodos sem declarar tipos (de variveis, atributos, parmetros ou retornos). E
dentro de strings, a sintaxe ${...} d acesso ao valor formatado de variveis ou
expresses arbitrrias, de forma semelhante s expresses da Expression
Language (EL) do JSP 2.0.

2.1.3 Groovy: Uma linguagem de Scripting e Dinmica

Groovy uma linguagem que pertence a ambas categorias: tanto uma

linguagem de scripting, como uma linguagem dinmica. De acordo com
DOEDERLEIN(2007), estas categorias esto assim definidas:
a) Linguagem de script: Tambm conhecido como linguagem de scripting,
ou linguagem de extenso, so linhas de comandos escritas em arquivos, referidos
como scripts, que so interpretadas e executados no interior de programas e/ou de
outras linguagens de programao, no se restringindo a esses ambientes. As
linguagens de script tem como finalidade estender a funcionalidade de um programa
e/ou control-lo, acessando sua API e so frequentemente usadas como
ferramentas de configurao e instalao em sistemas operacionais. A interpretao
direta dos cdigo-fontes desses scripts permite alterar o cdigo sem reiniciar a
aplicao executada. Exemplos de linguagens de script (JavaScript, Php, Ruby e
Python).
b) Linguagem dinmica: So linguagens de alto nvel, em sua maioria com
tipagem dinmica e com um Protocolo de Meta-Objeto (Meta-Object Protocol), ou
MOP. Estas caractersticas proporcionam muitas facilidades e um enorme poder no
desenvolvimento da aplicao. Linguagens dinmicas no so compiladas, portanto
a tipagem dinmica faz todo sentido. Porm, existe algumas linguagens dinmicas
que utilizam de tipagem esttica, como o caso do Groovy, para utilizar de tcnicas
como overloading de mtodos e de construtor. O Meta-Object Protocol sem dvida
a grande vantagem das linguagens dinmicas. Alm de economizar a digitao com
declaraes de tipos, as linguagens dinmicas permitem usar tcnicas de
programao muito expressivas e reusveis.

25

2.1.4 Elementos bsico do Groovy

Nesta seo sero apresentados os principais conceitos do funcionamento da

linguagem Groovy que sero pontos fundamentais para a compreenso do
framework Grails.

2.1.4.1 Trabalhando com Strings

Como a maioria das linguagens modernas, o Groovy tem o conceito de uma

string. Um problema muito comum em Java ocorre na concatenao de strings.
Frequentemente possvel encontrar trechos de cdigo como:
String mensagem = Bem vindo + pessoa.getNome();

Em Groovy, o mesmo comando poderia ser digitado como:

String mensagem = Bem vindo $(pessoa.nome)

A sintaxe bastante simples, dentro de uma string, a expresso que estiver

entre ${ e } ser interpretada e, em seguida, o valor de retorno ser includo na
string a ser formada. No necessrio o uso do operador de concatenao e nem a
chamada ao mtodo acessador get (BARCLAY; SAVAGE,2007).
Na linguagem Groovy uma string pode ser definida de trs formas: Single
quote (aspas simples), Double quote (aspas duplas) ou Triple quote (aspas triplas).
(JUDD,2008):
Listagem 3. Single quote (Aspas simples)_______________________________________
def OiRenan = 'Oi, Renan'

Listagem 4. Double quote (Aspas duplas)_______________________________________

def OiRenan = Oi, Renan

26

Listagem 5. Triple quote (Aspas triplas)

____________________________________

def OiRenan = Oi, Renan

sou uma string com muitas linhas
de cdigo groovy

Existe uma diferena entre o funcionamento destes trs tipos de declarao:

strings com aspas duplas e triplas permitem strings com mltiplas linhas, enquanto
strings com aspas simples no.

2.1.4.2 Mtodos e Closures

Mtodo um nome dado a um conjunto de comandos que pode ser

executado ou chamado uma ou mais vezes em um programa.
Closures um objeto que contm um conjunto de comandos limitados por
chaves ({ }). Sendo um objeto, pode ser atribudo a uma propriedade ou uma
varivel, ou passado como parmetro para mtodos associado ao contexto esttico
da sua definio. Pode tambm ser retornada, atribuda a variveis e manipulada de
diversas formas. Sendo assim, o conjunto de comandos s ser executado quando a
closures for invocada.
Uma das vantagens das closures sobre os mtodos que elas capturam as
variveis contidas no escopo final do conjunto de comandos e poder sempre
acess-lo enquanto a closure existir.
A diferena entre os mtodos que as closures so objetos e os mtodos
no. Um mtodo s pode acessar os seus parmetros e os atributos da classe
qual pertence, j uma closure pode acessar tambm as variveis locais do escopo
onde foi declarada. Para entender isso, vamos invocar uma closure:
/* Def a definio de varivel usado para indicar um tipo. Isso necessrio para
que as variveis sejam detectveis ao analisador do Groovy.Podemos pensar em
"def" como um pseudnimo de "Objeto". */
def name = Joo
def printClosure = { println Oi, ${name} }
printClosure()
name = Pedro

27

printClosure()
Sada
Oi, Joo
Oi, Pedro

Este exemplo demonstra que, assim como os mtodos, os closures podem

acessar variveis definidas no mesmo mbito que o closure. E assim como com os
mtodos, os parmetros podem ser passados para o closure tambm.

2.1.4.3 Intervalos, Lista e Mapas (Hashes)

A linguagem Groovy, assim como a linguagem Perl, traz consigo operadores

para trabalhar com hashes e colees. Podemos encontrar muitas das Collections
do Java na prpria sintaxe da linguagem Groovy. No h necessidade de referenciar
o pacote java.util. Groovy j referencia este pacote automaticamente para o usurio.
Entre os operadores disponveis na linguagem Groovy, podemos citar:
a) Intervalos: Apresentado como escalas pelo livro (Groovy in Action), este
operador consistem em um recurso extremamente til na linguagem. Veja um
exemplo de um loop escrito em Java:
for (int i = 0; i < 10; i++) {
cdigo....
}

A definio do loop, na realidade um intervalo, porm aplicado de uma

forma mais complexa, pois envolve uma declarao de varireis, uma condio
lgica e um incremento. Veja agora como o mesmo cdigo em Java, ficaria na
linguagem Groovy:
for (a in 0..9) {
cdigo....
}

Analisando o cdigo acima este 0..9 consiste em uma escala, que implementa
a interface Collection do Java. Sendo assim, mais do que sintaxe: um objeto por

28

si s. Declarar uma escala bastante simples. Basta usar a sintaxe [limite

inferior]..[limite superior].
O .. consiste em um operador de precedncia baixa, sendo assim uma boa
prtica de programao sempre definir seus intervalos dentro de parnteses, tal
como (0..9).
Existe tambm outro operador que ser utilizado ao definir escalas. O operador
..<. Neste caso, significa que o valor da direita no includo entre os valores da
escala. O cdigo em Java exposto no primeiro exemplo poderia portanto ser
reescrito como:
for (a in 0..<10) {
cdigo.....
}

Como mencionamos, os intervalos so tratados como objetos. Sendo assim,

existem alguns mtodos e funes que podemos executar como:
Listagem 6. Exemplos de mtodos com intervalos _________________________________
// Verifica se dentro do intervalo contm o valor 4
(0..10).contains(4)
// O mtodo each executa uma closure
(0..10).each {elemento ->
print elemento}

Basicamente, as Escalas podem ser construdas no s por nmeros, mas

por qualquer tipo de objeto desde que as condies abaixo sejam satisfeitas:

O tipo implementa prximo e anterior, ou seja, sobrescreve os operadores ++ e

. O Groovy sobrescreve os operadores ++ e em java.util.Date e alguns
outros tipos bsicos.

O tipo implementa a interface java.lang.Comparable.

b) Listas : Uma lista declarada em Groovy usando a seguinte sintaxe:
[ (valores separados por vgula) ]. Como apresentado na listagem 7:
Listagem 7. Uma lista em Groovy

____

____________________________________ _______

lista = ["uma", "lista", "de", "strings"]

/*
Teremos acesso todos os mtodos da interface java.util.List
*/
lista.contains("uma")
lista.add("coisas da vida")
print "A lista possui ${lista.size()} itens!"

29

E ainda h alguns operadores para manipular listas, tal como podemos observar na
Listagem 8:
Listagem 8. Uma lista com operadores Groovy

lista = [ ]
// Como incluir um novo item na lista?
lista += primeiro item
// Como incluir mais de um item?
lista += [segundo, terceiro, quarto]
// E como eu removo um item?
lista -= [terceiro

c) Mapas (Hashes)? Mapas em Groovy tambm esto embutidos na sintaxe da

linguagem, como apresentado pela Listagem 9:
Listagem 9. Exemplo de Mapa (Hashes

// Definio do mapa
def mapa = [nome:Pedro, endereco:Rua Joo Tavares]
// A sintaxe de um Hash bastante simples: [chave1:valor1, chave2:valor2, , chaveN:valorN
// Todos os mtodos da interface java.util.Map podem ser chamados aqui, tal como:
println "Eis que nosso mapa possui ${mapa.size()}"
println "E o valor de nome ... ${mapa.get("Pedrp")}"

Em Groovy, mapas podem ser passados como argumentos em mtodos

construturores, sendo utilizados para informar os valores iniciais de atributos
conforme apresentado na Listagem 10:
Listagem 10. Exemplo de mapas em construtores

class Pessoa{
String nome
String idade
}
Pessoa pessoa = new Pessoa(nome: Pedro , idade:23)

O mtodo construtor recebe um hashmap, que percorre suas chaves, as

compara com os atributos da classe Pessoa e as preenche, tudo isso em apenas
uma linha de comando.

2.1.4.4

Expresses Regulares

Expresses regulares so uma forma de representar conjuntos de caracteres

que esto sobre uma certa regra. Essas expresses regulares so muito comuns em

30

linguagens de script e esto presentes na biblioteca Java desde o JDK 1.4. O

Groovy se baseia no Regex (Suporte de expresses regulares do Java) e acrescenta
trs operadores por convenincia, DEARLE(2010):
O regex pattern(padro) operator ~ - Precedendo uma string, ir criar
automaticamente um objeto do tipo Java Pattern.
assert java.util.regex.Pattern = (~/groovy/).getClass()

O regex find(encontrar) operator =~ Vai receber uma string e uma regex e

criar um objeto Matcher.
def myMatcher = ("54417" =~/\d{5}) //Procura por exatos 5 dgitos
assert myMatcher.matches()
assert java.util.regex.Matcher == myMatcher.getClass()

O regex match(combinar) operator ==~ - Faz um match mais restrito, que

exige um match exato.
def regex = /Renan/
assert ("Renan" ==~ regex)

2.1.4.5 Operadores

Em termos de sintaxe, vimos que a linguagem Groovy segue a maioria das

definies da linguagem Java. O Groovy permite redefinir os seus operadores para
facilitar o uso de objetos que possuam uma semntica adequada. A linguagem
Groovy introduz uma srie de novos mtodos e modifica de maneira sutil o
comportamento de alguns operadores da linguagem Java, conforme a Tabela 1:

31

Tabela 1 - Operadores do Groovy

Fonte: JUDD, C. M.; NUSAIRAT, J. F.; SHINGLER, J. Beginning Groovy and Grails:
From Novice to Professional. 1. ed. [S.l.]: Apress, 2008 Pag. 40.,2008.
O Groovy tambm redefine os operadores relacionais, mapeando-os para os
mtodos equals() e comparteTo() padres do Java SE:
Tabela 2 - Operadores relacionais do Groovy

32

Fonte: DOEDERLEIN, OSVALDO. Aprendendo Groovy - Scripting e Dinamismo na

Plataforma Java. Revista Java Magazine,Ed.32,Pag 38,[2007].
Podemos observar que o Groovy utiliza o operador a == b para igualdade de
valor, no Java este mesmo operador testa a igualdade de referncias. Os
operadores de desigualdade so mapeados para o mtodo compareTo(). O novo
operador < = > retorna o mesmo inteiro gerado pelo compareTo(), j os operadores
> , >=, < e <= se comportam da maneira usual.

2.1.4.6 Tipos de dados

Diferente da linguagem de programao Java, o Groovy no possui tipos

primitivos, embora em alguns script aparenta ter. Vejamos um exemplo:
// Cdigo Groovy
int numeroQueParecePrimitivo = 1
Integer numeroQueNaoParecePrimitivo = 2

Embora a declarao acima seja do tipo primitivo (int), o Groovy converte

automaticamente avarivel numeroQueParecePrimitivo para o tipo Integer.
Segue na Tabela 3, as relaes de converso entre os tipos primitivos da
linguagem Java:

33

Tabela 3- Tipos de dados no Groovy

Essa converso de tipos comumente chamada de boxing e a ao reversa

unboxing. O Groovy executa essas operaes automaticamente, tornando
desnecessria a utilizao de casting.
importante notar que, por se tratar de objetos, o Groovy utiliza os mtodos
existentes na API Java para efetuar os clculos.
def a = 1
def b = 2
int soma = a + b
// O Groovy executa:
Integer soma = a.plus(b)

Isso vlido para todas as operaes de tipos primitivos do Java e seus

mtodos como plus(), minus(), div(), mod(), next() e previous() etc.

2.1.4.7 Groovy Beans

O Groovy possui um conceito de Beans um pouco diferente em relao

linguagem Java. Uma de suas caractersticas no ter o conceito de visibilidade
padro para classes. Em vez disso, qualquer propriedade definida sem a visibilidade
(private, public ou protected) subentendida como uma propriedade de um

34

JavaBean (ou seja, private) e os seus mtodos acessadores e modificadores so

automaticamente gerados.
No caso de mtodos, na ausncia de modificadores, eles sero sempre
considerados como mtodos pblicos. Segue abaixo um exemplo de Groovy Beans.
Listagem 11. Classe exemplo Usuario.groovy_______________________________________________
class Usuario {
Integer id
String nome
Date data

static void main(args) {

def usuario= new Usuario(id:1, name:"Renan", data:new Date())
println("Ola ${usuario.name}")
}

Observando este exemplo, j percebe-se o grande diferencial em relao ao

Java propriamente dito. No h construtores, mtodos acessadores e modificadores.
O objetivo deste captulo dar-lhe conhecimento suficiente para comear a
construir uma aplicao junto com o Grails. A prxima seo ir gui-los na
instalao e configurao do Groovy.

2.1.3 Instalando o Groovy

Nesta seo sero apresentados os cinco passos para instalao do Groovy,

de acordo com DEARLE(2010).
O projeto Grovvy hospedado pela Codehaus14 e pode ser baixado como um
arquivo de extenso ZIP, um instalador especfico da plataforma Windows ou
pacotes para determinadas distribuies Linux. Para instalar e configurar o Groovy,
siga estes passos:
1.sFaa

download

da

verso

mais

recente

no

site

http://groovy.codehaus.org/Download.
2. Descompacte o arquivo baixado em um diretrio desejado em seu
computador.

14

http://groovy.codehaus.org

35

3.

Defina uma varivel de ambiente GROOVY_HOME para o diretrio no

qual foi descompactado o arquivo.

4. Adicione o diretrio bin ao seu PATH. Este ser %GROOVY_HOME%\bin
(Windows) ou US $GROOVY_HOME/bin em sistemas Linux e Unix.
5. Abra o Prompt de comando e digite groovy-v.
Se a configurao estiver correta, ser apresentada uma mensagem
semelhante a da janela na Figura 3:

Figura 3 - Tela do Prompt de Comando, verificando a configurao do Groovy

Groovy requer a instalao do Java, por causa da sua JVM. Caso no possua
o Java em sua mquina, poder encontr-lo no site15.

2.2 FRAMEWORK GRAILS

Grails um framework fullstack, ou seja, o desenvolvedor no necessita se

preocupar com os componentes bsicos da infraestrutura, como persistncia, logs,
etc, por j virem pr-configurados no prprio framework. Baseado no padro MVC16,
tem se destacado na comunidade Java por simplificar diversas tarefas do dia-a-dia
15

http://java.sun.com/javase/downloads/index.jsp

16

http://pt.wikipedia.org/wiki/MVC

36

seguindo a tendncia de novos frameworks voltados ao desenvolvimento de

aplicaes web: a programao baseada em convenes (RUDOLPH ,2006).
Veremos neste captulo com detalhes uma viso panormica deste framework que
reduz a complexidade no desenvolvimento das aplicaes.

2.2.1 Histrico

Criada em 2005, pela G2One(Grails Groovy Company), Grails (Groovy on

Rails) um framework criado para o desenvolvimento de aplicaes web. Foi
desenvolvido em cdigo aberto e interage com a linguagem de programao Groovy.
Seguindo a configurao por conveno e o alto nvel de produtividade.
Inicialmente, o projeto se chamava Groovy on Rails, mas teve que ser
renomeado para Grails, aps um pedido do fundador do projeto Ruby on Rails,
David Heinemeier Hansson, para o lder do projeto Grails, Greaeme Rocher, que no
utilizasse o sufixo on Rails. Ento, por respeito ao David Heinemeier e no desejar
conflitos com a comunidade Ruby, Greaeme Rocher alterou o nome do projeto para
Grails.
Ainda em 2005, os trabalhos foram iniciados e a verso 0.1 lanada em
maro de 2006. O Grails passou a ser usado de maneira mais ampla na Inglaterra e
na Alemanha e por ser uma tecnologia relativamente nova, quem a utilizava,
ganhava destaque em sua rea de atuao.
Atualmente, em maio de 2011, o Grails se encontra na verso 1.3.7 (utilizada
neste trabalho) e conta com mais de 580 plugins, nmero que no para de crescer
devido a facilidade de se constru-los, seguindo uma arquitetura modular que permite
usar diversos componentes no desenvolvimento gil das aplicaes web com a
mesma desenvoltura de uma aplicao desktop, s que com o paradigma de
programao por conveno, que j cria todo um esqueleto (Rails) que alm de
otimizar o trabalho do programador, estimula a utilizao de padres de projeto e
engenharia de software em geral.

37

Em novembro de 2008, a empresa SpringSource17 anunciou a compra da

empresa G2One. Com a aquisio da G2One, a Springsource passou a oferecer
suporte mundial as empresas e desenvolvedores que utilizam aplicaes Groovy e
Grails.

2.2.2 Introduo ao Grails

De acordo com WEISMANN(2010), a plataforma Java EE vem sendo alvo de

crticas relacionadas complexidade envolvida no desenvolvimento de aplicaes
web como:
a) Muito trabalho gasto na edio de arquivos de configurao.
b) Apesar de possuir diversas bibliotecas e frameworks ao seu dispor, como por
exemplo, Hibernate, Spring, Log4J, entre outros. O desenvolvimento de aplicaes
web, ainda possui um gerenciamento de dependncias complexo.
c) Trabalho repetitivo, como na criao de formulrios para incluso, edio e
Listagem de registros em bancos de dados.
Visando suprir essas deficincias, eis que surge o Grails, um framework
fullstack para desenvolvimento de aplicaes web inspirado no Ruby on Rails que,
compartilha dos seguintes princpios, segundo WEISSMANN (2010):
a) Dont Repeat Yourself (DRY): muitas vezes quando desenvolvemos uma
aplicaes web, boa parte do trabalho feito pelo desenvolvedor repetitivo. O Grails
resolve este problema automatizando a gerao de diversos artefatos, como o
CRUD e os controladores, por exemplo. Diminuindo significativamente a execuo
dessas tarefas repetitivas e aumentando a produtividade.
b) Convenes sobre configurao: um grande problema no desenvolvimento
de aplicaes corporativas, est no gerenciamento de arquivos de configurao. O
Grails, resolve este problema a partir de uma srie de convenes, aplicadas de
forma simples, onde definem os padres de comportamento adotados pelo

17

http://www.springsource.com

38

framework,

oferecendo

flexibilidade

necessria

na

integrao

destas

configuraes.
c) Extensibilidade: o framework Grails oferece suporte criao de plugins de
maneira bastante simples. Existe uma grande quantidade de componentes criados
pela

comunidade.

Podemos

acessar

lista

completa

de

plugins

no

http://grails.org/plugin/list.
d) Ambiente de desenvolvimento completo: diversas IDEs j oferecem suporte
ao Grails (Eclipse, Netbeans e Intellij IDEA). O Grails j vem com todos os
componentes necessrios pr-configurados e integrados para que o desenvolvedor
possa iniciar o seu trabalho, mantendo o foco: a lgica de negcio, e no nos
detalhes no funcionais da aplicao.
O Grails no somente um framework web de cdigo aberto para a
plataforma Java, mas uma completa plataforma de desenvolvimento tambm. Como
a maioria dos frameworks web, Grails um framework MVC. JUDD(2008, p.65).
Glen SMITH(2009) afirma que o Grails a prxima gerao do Java
framework de desenvolvimento web. Ele traz para o desenvolver enormes ganhos
em termos de produtividade atravs da integrao de uma linguagem dinmica na
qual tratamos no captulo anterior.

2.2.3 Grails e sua estrutura

Para comearmos a trabalhar com o framework Grails, importante

conhecermos bem a sua estrutura de diretrios. Composta de uma estrutura
bastante simples. Iremos identific-las uma a uma e descrever o funcionamento
dentro do framework, segundo (SMITH;LEDBROOK,2009). Como ilustrado na Figura
4.

39

Figura 4 - Estrutura de diretrios do Grails

a) src/java: Contm os arquivos com cdigos Java. Quando a aplicao

executada, todo o cdigo fonte deste diretrio ser automaticamente compilado e se
tornar disponvel de forma transparente para o restante do projeto.
b) src/groovy: Contm arquivos com cdigos Groovy (outros que no so
controllers, domain, ou classes de servio).
c) conf: Dentro deste diretrio estaro presentes todos os arquivos de configurao
da aplicao, como por exemplo, padres de URL e configuraes de acesso s
bases de dados e a configurao do Spring ou Hibernate.
d) controllers: Toda aplicao feita no Grails baseada no padro MVC. Contm
neste diretrio os controladores.
e) domain: Contm todas as classes de domnio da aplicao do sistema. nesta
classe que responsvel por representar as entidades do problema a ser solucionado,
entidades estas que sero persistidas em um banco de dados relacional.
f) services: Contm classes que oferecem algum servio para a aplicao. Um
servio responsvel por armazenar aspectos referentes lgica de negcio da
aplicao do sistema, evitando assim que o desenvolvedor inclua partes dela nas

40

classes de controle. As classes de servio so gerenciadas pelo Spring, e so

responsveis portanto por encapsular determinados aspectos da lgica de negcios
de sua aplicao.
g) taglib: neste diretrio que so armazenados todos os arquivos responsveis
pelas tags criadas usando este framework, as tag libraries. O Grails oferece uma
maneira muito simples de lidar com elas.
h) teste/integration: Dentro deste diretrio fica armazenado todos os testes de
integrao que iro testar os componentes externos como: banco de dados, web
services ou outros servios de natureza diversa.
i) test/unit: Dentro deste diretrio fica armazenado todos os testes de unidade,
testes unitrios e funcionais. Estes testes no possuem conexes com bancos de
dados, web services ou qualquer outro tipo de componente, ao contrrio dos testes
de integrao.
j) plugins: neste diretrio que so armazenados todos os plugins implantados na
aplicao do sistema.
k) JRE System Library: neste diretrio que ficam armazenadas todas as
bibliotecas do JRE.
l) Grails Dependencies: Dentro deste diretrio que so armazenados todas as
bibliotecas que se integram ao Grails.
m) i18n: Uma aplicao feita pelo Grails pode ser internacionalizada de maneira
muito simples. Neste diretrio devem ser armazenados os arquivos de mensagem
segundo padro de internacionalizao.
n) scripts: Contm neste diretrio, arquivos de scripts. No Grails, os scripts so
escritos em Groovy Ant (GANT), que uma camada de abstrao para as
funcionalidades da biblioteca Ant18.
o) views: Contm templates de visualizao, conhecidos como os arquivos Groovy
Server Pages (GSP), responsveis por renderizar as pginas da aplicao do
sistema. No caso de classes de domnio, ao criarmos novos controladores,
automaticamente ser criado um diretrio com o mesmo nome da classe, onde
sero armazenados os arquivos GSP.

18

http://ant.apache.org/

41

p) grails-app/: Apontado como diretrio mais importante da aplicao do sistema.

Contm os principais arquivos da aplicao, como as classes do domnio e os
controladores, organizados em subdiretrios.
q) lib: Neste diretrio devero ser includos todos os arquivos jar referentes a
bibliotecas terceirizadas que voc queira utilizar, como por exemplo, drivers JDBC,
bibliotecas para gerao de PDF e, principalmente, cdigo legado, caso seja
necessrio reaproveit-lo.
r) target: Quando o sistema executado e compilado, neste diretrio que os
arquivos temporrios ficam alm de conter os arquivos war gerados da aplicao
do sistema
s) web-app: Contm arquivos de configurao relacionados a customizao da
aplicao. O contedo esttico de sua aplicao, como por exemplo, arquivos html,
imagens, css, etc.
t) application.properties: um arquivo gerado automaticamente, que define o
nome da aplicao e as verses das bibliotecas que ela utiliza.

2.2.4

Recursos do Grails

framework

Grails

possui

diversos

recursos

que

facilitam

no

desenvolvimento dos sistemas web. JUDD(2008,p.65) classifica os mais importantes

para o desenvolvimento da aplicao.

2.2.4.1 Conveno sobre configurao

Ao invs de usar vrios arquivos de configurao XML, Grails se baseia em

convenes para tornar o desenvolvimento de aplicaes mais fcil e mais
produtivo. Isso tambm ajuda a incentivar o princpio Don't Repeat Yourself (DRY).

42

Muitas das convenes dizem respeito sua estrutura de diretrios, que

abordaremos mais frente.

2.2.4.2 Testes Unitrios

O teste unitrio agora reconhecido como uma prtica fundamental para

melhorar a qualidade dos produtos de software e permitindo a manuteno do longo
prazo de uma aplicao. Alm disso, o teste de unidade ainda mais importante
para aplicativos escritos usando linguagens de tipagem dinmica, como Groovy, pois
a identificao dos efeitos das mudanas sem a ajuda do compilador e testes de
unidade pode ser difcil. por isso que o teste de unidade uma das principais
convenes do Grails.
Como veremos mais frente, quando estivermos desenvolvendo a aplicao,
uma unidade de teste criado automaticamente quando criamos no Grails uma
classe de domnio ou um controlador. O Grails separa seus testes de unidade em
duas categorias: unidade e integrao, como podemos observar na Figura 4, na
estrutura do Grails, do captulo anterior. Os testes de unidade so testes autnomos,
sem dependncias de outros objetos. J os testes de integrao, por outro lado, tm
acesso a todo o ambiente Grails, incluindo o banco de dados. Grails tambm inclui
testes funcionais para automatizar a interface web.

2.2.4.3

Scaffolding

O Grails possui uma estrutura scaffolding, um recurso que gera aplicaes

CRUD (Create Read Update Delete) de forma automtica e com pouco cdigo,
permitindo o desenvolvedor se preocupar apenas em definir na classe de domnio
Groovy as propriedades do atributo, seu comportamento e restries. Feito o CRUD
das classes, o scaffolding identifica o comportamento do controlador e cria as GSP

43

(Groovy Server Pages) que esto associadas com as funcionalidades do CRUD nas
classes de domnio. Ao mesmo tempo, o scaffolding gera o esquema de banco de
dados, incluindo tabelas para cada uma das classes de domnio.
Visto que o scaffolding uma action presente na maioria das aplicaes
desenvolvidas em Grails, interessante conhecermos as actions default deste
recurso, conforme apresenta a tabela 4:

Tabela 4 - Actions default do Grails

2.2.4.4 Mapeamento Objeto Relacional

O Grails inclui um poderoso framework de mapeamento objeto relacional

chamado Grails Object Relational Mapping (GORM). Como a maioria dos
frameworks de mapeamento objeto relacional (MOR), GORM pode mapear objetos
para bancos de dados relacionais e representar as relaes entre os objetos, como
um-para-um ou um-para-muitos. Mas o que diferencia o GORM, de outros
frameworks ORMs que ele foi construdo para uma linguagem dinmica, como

44

Groovy. Atravs dessa integrao, os mtodo CRUD so introduzidos sem ter que
implement-los ou herd-los da persistncia de uma super classe.
2.2.4.5 Plugins

O Grails fornece uma arquitetura plug-in e uma comunidade onde podemos

encontrar plugins para aspectos como segurana, Ajax, anlise, pesquisa,
comunicao e web services. Esta arquitetura de plug-in torna fcil adicionar
funcionalidade a sua aplicao.

2.2.5 Frameworks Integrados

De acordo com JUDD(2008), o Grails possui diversas bibliotecas de

frameworks integrados ao seu framework, que trazem para o desenvolvimento uma
verdadeira abstrao de toda a complexidade nas configuraes economizando o
tempo do desenvolvedor. Vejamos quais so os principais

2.2.5.1 Spring Framework

Desenvolvido por Rod Johnson, ele define o Framework Spring19 como o uma
ferramenta que fornece um nvel de aplicao de abstrao em cima da API Java
EE. , oferecendo aos POJOs20 caractersticas como mecanismos de segurana

e tratamento de transaes. Tambm facilita os testes unitrios e surge como

uma alternativa complexidade existente no uso de EJBs que tenta simplificar

19
20

http://www.springframework.org
http://pt.wikipedia.org/wiki/Plain_Old_Java_Objects

45

o desenvolvimento de Java EE. Assim o desenvolvedor poder se concentrar na

implementao da lgica de negcio, aumentando assim a produtividade.

2.2.5.2 Hibernate

Hibernate21 um dos muitos projetos do grupo JBoss, um framework de

persistncia objeto-relacional que fornece a base para o GORM. O Hibernate teve
uma grande influncia sobre a especificao EJB 3.0, especificamente o Java
Persistence API (JPA). Ele capaz de mapear as relaes entre as tabelas do
banco de dados das classes de domnio como o POJO ou POGOS. .

2.2.5.3 SiteMesh

SiteMesh22 um framework web layout de pgina que implementa o padro

de projeto Decorator para renderizao HTML, como o cabealho, rodaps e
navegao. um dos componentes encontrados no conjunto OpenSymphony e est
hospedado no OpenSymphony site23. O Grails esconde do desenvolvedor a maioria
dos detalhes do SiteMesh, de como criar layouts de pginas web e componentes,
tais como GSP.

2.2.5.4 Ajax Framework

http://www.hibernate.org
http://www.opensymphony.com/sitemesh/
23
http://www.opensymphony.com
21
22

46

Com a chegada da web 2.0, o Ajax se tornou to popular que o Grails incluiu
trs frameworks do Ajax, por padro, em todas as aplicaes web: script.aculo.us,
Rico, eprototype.

2.2.5.5 Jetty

Para garantir um ambiente de desenvolvimento completo, o Grails

disponibiliza de um servidor web Jetty24, que j vem configurado para qualquer
aplicao gerada, isso permite realizar testes sem a necessidade de instalar um
Apache Tomcat.

2.2.5.6 HSQLDB

O Grails possui em seu ambiente de desenvolvimento um banco de dados

relacional construdo a base do Java, conhecido como HSQLDB25. possvel usar
este banco de dados como um servidor de dados independente ou como um banco
de dados incorporado. Por padro, o HSQLDB armazena todas as informaes em
um banco de dados em memria. Assim, quando encerramos a execuo da
aplicao todos os dados que persistimos so removidos. Para testes uma boa
opo, mas para ambientes de produo no a escolha ideal. Iremos explicar no
decorrer deste trabalho como configurar o Grails para usar outras bases de dados
como MySQL26, persistindo as informaes no disco.

http://www.mortbay.org
http://hsqldb.org
26
http://www.mysql.com
24
25

47

2.2.5.7 JUnit

O Grails utiliza para os testes de unidade, o framework JUnit27 que faz parte
da famlia de ferramentas de testes xUnit. Este framework oferece um ambiente
completo para a realizao de testes de unidade e ainda suporta extenses. Os
testes de unidade garantem que cada mtodo testado esteja produzindo o esperado
pelo desenvolvedor.

2.2.6 Arquitetura Grails

Agora que conhecemos os recursos e as principais bibliotecas dos

frameworks integrados ao Grails, vamos entender a sua arquitetura, ilustrada na
Figura 5.

Figura 5 - Arquitetura Grails

Fonte: JUDD, C. M.; NUSAIRAT, J. F.; SHINGLER, J. Beginning Groovy and

Grails:From Novice to Professional. 1. ed. [S.l.]: Apress, 2008.

Podemos perceber atravs da Figura 5, que a base do Grails a mquina

virtual Java, no nvel acima da JVM, temos duas linguagens de programao sendo

27

http://www.junit.org

48

usados, o Java e o Groovy, respectivamente. Acima das linguagens encontramos o

Grails em si, que como vimos em sees anteriores, composta por vrios
componentes, exemplo do Spring, SiteMesh e GORM. O Grails no se limita
apenas ao uso de bibliotecas Groovy, pode usar qualquer biblioteca Java, seja de
cdigo aberto ou proprietrio.
A camada final da arquitetura a de aplicaes. nesta camada que
desenvolvemos toda a aplicao do sistema (CRUD, classes de domnio,
controladores), seguindo um padro MVC que torna mais simples a sua organizao
e execuo. O Grails inclui uma ferramenta de linha de comando construda em cima
do Gant, com a tarefa de criao de muitos recursos Grails e gerenciamento de
projetos.

2.2.7 Mapeamento Objeto Relacional

O Grails emprega o framework Hibernate para o mapeamento objeto

relacional. Mas no necessrio conhecer a API do Hibernate, nem descritores de
mapeamento. Pois toda a configurao feita por conveno do Grails, que ento
cria um novo sistema de persistncia, chamado GORM (Grails Object Relation
Mapping), uma camada de abstrao sobre o Hibernate 3. Uma diferena do Grails
para outros frameworks que enquanto diversos frameworks definem o
comportamento da aplicao a partir de arquivos de configurao, o Grails, por
padro, os define de acordo com as convenes feitas pelo seu framework.
Vamos entender o relacionamento do Grails com o banco de dados. Ao
definirmos as classes de domnio, estamos definindo tambm quais tabelas do
banco de dados o sistema ir acessar, assim como os relacionamentos existentes
entre as tabelas. Tudo isso de uma forma automtica. O nome da tabela ser o
mesmo da classe (caso o nome da classe estiver em formato CamelCase, por
exemplo UsuarioController, o underscore ser utilizado como separador). A cada
classe gerada, um ID criado implicitamente para representar o identificador nativo
no banco de dados. Tudo isso feito de forma transparente.

49

2.2.3 Instalando o Grails

Antes de comearmos a instalao, o Grails exige que o Java SDK esteja

instalado na sua mquina (no apenas o JRE) e a sua varivel de ambiente
JAVA_HOME configurada, esses so os pr-requisitos para o funcionamento do
framework. Siga as instrues no apndice para a instalao e configurao do Java
SDK. Caso j possua em sua mquina o SDK Java instalado, siga os passos para a
instalao do Grails de acordo com Glen SMITH(2009).
1.sFaa o download da ltima distribuio do Grails no endereo
www.grails.org/download.
2. Descompacte o arquivo baixado em um diretrio desejado no computador.
3. Defina uma varivel de ambiente GRAILS_HOME .
4. Adicione o caminho onde foi instalado o Grails ao valor da varivel como
apresentado na Figura 6.

Figura 6 - Configurando a varivel de ambiento do Grails

50

No Mac OS X e Linux, isso normalmente feito editando o arquivo ~ / profile.

script para conter linhas como estas:
export GRAILS_HOME = / opt / grails
export PATH = $ PATH: $ GRAILS_HOME bin /
5. Abra o Prompt de comando e digite grails help e verifique se o Grails est
funcionando, conforme ilustra Figura 7.
Figura 7 - Tela do Prompt de Comando, verificando a configurao do Grails

Agora que conhecemos os principais conceitos da linguagem Groovy e seus

pontos fundamentais e os seus conceitos para a compreenso do framework Grails.
Ser apresentado no prximo captulo, um estudo de caso para o desenvolvimento
de uma aplicao com as tecnologias estudadas neste trabalho.

51

3 ESTUDO DE CASO

Para ilustrar os apectos tericos das tecnologias apresentadas neste trabalho,

ser apresentado etapas de como desenvolver um sistema web. Um estudo de caso
ser realizado, levantando os requisitos necessrios para a implementao do
sistema.

3.1 DESCRIO DO SISTEMA

Ser apresentado como foi implementado algumas funcionalidades de um

sistema de automao comercial para uso da empresa Andreza Andrade, que atua
na rea comercial em Campina Grande-PB. O sistema desenvolvido permite a
empresa ter um maior controle de seu negcio e de fornecer ao usurio informaes
rpidas sobre os clientes e produtos cadastrados, assim como controle de estoque e
relatrios. O sistema gerencia o processo das vendas dentro da empresa, incluindo
as informaes como formas de pagamentos e descontos, automatizando as
funcionalidades executadas nas vendas, auxiliando os usurios no seu dia-a-dia,
proporcionando informaes rpidas e seguras sobre as movimentaes dirias na
empresa.
Para o desenvolvimento deste projeto, utilizaremos os conhecimentos
descritos nos Captulos 1 e 2 deste trabalho, preparando o leitor para vivenciar as
facilidades no desenvolvimento utilizando a linguagem de programao Groovy e o
framework Grails. Conforme apresentado na Figura 8, podemos observar a tela
principal do sistema rodando em um servidor local. Ao final deste captulo, o leitor
ser capaz de criar as classes bsicas da aplicao, persistir dados no banco de
dados, instalar plugins, alterar layouts, inserir segurana, internacionalizar idiomas e
gerar relatrios.

52

Figura 8 - Tela principal do sistema

3.2 ANLISE DE REQUISITOS

A anlise de requisitos fundamental para o desenvolvimento do sistema,

pois est associada ao processo de levantamento das funcionalidades e requisitos
que o sistema ir operar.
De acordo com os requisitos funcionais e as necessidades levantadas pelo
usurio para o sistema, foi elaborada a descrio do sistema. Uma srie de
requisitos funcionais ser ilustrada no caso de uso presente na Figura 9 e os nofuncionais listados logo abaixo.

53

Figura 9 - Caso de uso do sistema

a) Logar no sistema, onde o usurio do sistema passaria seu login e sua senha para
ter acesso s outras funcionalidades.
b) Cadastrar os clientes que efetuaram compras no estabelecimento.
c) Listar os clientes que realizaram compras ao estabelecimento.

54

d) Pesquisar os clientes cadastrados.

e) Cadastrar os produtos que estaro disponveis para a venda.
f) Listar os produtos que esto cadastrados.
g) Gerar relatrio dos produtos que constam cadastrados.
h) Pesquisar os produtos cadastrados.
i) Cadastrar uma venda feita de um cliente ao estabelecimento.
j) Listar as vendas que foram feitas.
k) Cadastrar as devolues de vendas feitas ao estabelecimento.
l) Listar as devolues das vendas feitas ao estabelecimento.
m) Consultar as devolues das vendas realizadas ao estabelecimento.
n) Gerar relatrio de movimentao das vendas realizadas no sistema em um
perodo com data inicial e data final.
o) Cadastrar usurios no sistema.
p) Listar usurios do sistema.
J os requisitos no funcionais seriam dois: desempenho e portabilidade.
a) Em termos de desempenho o sistema apresenta um tempo de resposta de 1.28
segundos.
b) Portabilidade: o sistema poder rodar em qualquer computador ou dispositivo que
tenha a mquina virtual Java (JVM) instalado.
Podemos visualizar na Figura 10 o diagrama de classes, no qual foram
definidas todas as classes, atributos e o seu relacionamento.

55

Figura 10 - Diagrama de Classe

3.3 CRIANDO A APLICAO

Para o desenvolvimento das funcionalidades da aplicao apresentada neste

trabalho, utilizaremos a ferramenta IDE SpringSource Tool Suite 2.5.2.SR1.

56

Informaes de como instalar e configurar esta IDE no computador esto contidas

no Apndice deste trabalho. possvel perceber a simplicidade e a facilidade de
desenvolver um sistema web utilizando essas ferramentas de alta produtividade,
possibilitando que os conceitos vistos na linguagem Groovy e o framework Grails
sejam validados.

3.3.1 Criando o Projeto

Utilizando a IDE, crie um projeto Grails, seguindo os passos File>New>Grails

Project., insira o nome do projeto e selecione uma verso do Grails. Definimos o
nome da aplicao como makeup.erp. Finalizado o processo de criao, uma
mensagem requisitando colocar o projeto em perspectiva Grails aparecer. Assim
como a perspectiva Java fornece um conjunto de pontos de vista / menus / barras de
ferramentas adaptadas para trabalhar com Java, a perspectiva Grails oferece para
seus projetos, ento escolha a opo Sim.
O Grails executar o comando create-app para construir o projeto. A estrutura
de diretrios e arquivos do projeto ser gerada de forma automtica, como podemos
observar no Project Explorer do Grails na Figura 12.

57

Figura 11 - Estrutura de diretrios da Aplicao

Conforme abordamos na seo 2.2.3, a estrutura e diretrios do projeto foram

gerados automaticamente pelo Grails.

3.3.2 Criando classes de domnio

Criado o projeto, a primeira etapa criarmos as classes de domnio, de

acordo o estudo de caso realizado neste trabalho e o diagrama de classe
apresentados pela Figura 11.
As classes de domnio contm toda a lgica de negcio do sistema. Para
construirmos a aplicao, ser demonstrado o Cliente.groovy, onde definiremos na
classe todos os atributos do cliente, conforme a Listagem 12.:
Listagem 12. A classe de domnio Cliente.groovy__________________________________________

58

package makeup.erp
import java.util.Date;
class Cliente {
String nome
String campoEmail
Date dataNascimento
String endereco
String cidade
String estado
String telefone
String celular
Date dateCreated
static constraints = {
}
}

Podemos seguir com mesmo procedimento para as outras classes de domnio

definidas no diagrama de classes.
A classe Cliente similar ao POJO, para quem est acostumado a trabalhar
em Java, a diferena que estamos lidando com um POGO. Podemos perceber a
ausncia de mtodos acessadores e modificadores na classe, esses mtodos so
criados automaticamente pelo Grails atravs de recursos de conveno por
configurao, no havendo a necessidade de digit-los.
Ao criar uma classe de domnio, o Grails, se encarrega de criar arquivos de
testes unitrios da aplicao dentro do diretrio grails-app/test/unit. , conforme vimos
na seo 2.2.4.2, exemplo do ClienteTests.groovy.

Figura 12 - Classes Groovy dentro do diretrio domain na Aplicao

59

Observe na Figura 12, dentro do pacote makeup.erp podemos visualizar

todas as classes de domnio da nossa aplicao.

3.3.3 Criando os controllers(Controladores)

Criada as classes de domnio, trabalharemos com validao dos dados

contidas nelas. Assim, ser necessrio criar um controlador para cada uma delas
com o mesmo nome da classe de domnio. O controlador responsvel por
gerenciar a classe de domnio. Conforme ilustra a Figura 13, clique com o boto
direito do mouse, em cima do diretrio controllers, selecione o item New>Controller,
para criar novos controladores dentro do diretrio Controllers.

Figura 13 - Controladores da Aplicao

Vamos

exibir

contedo

gerado

pelo

Grails

dentro

do

arquivo

ClienteController.grovy na Listagem 13.

Listagem 13. O arquivo ClienteController.groovy__________________________________________
package makeup.erp
class ClienteController {
def scaffold = Cliente
{

60

A funo scaffold delega ao Grails, a tarefa de automatizar a gerao de

cdigos responsveis pela execuo do CRUD (Create Read Update Delete) bsico
da aplicao. Ento, ao definirmos scaffold = cliente, o Grails atravs de sua
conveno por configurao, gera o CRUD de todos os atributos presentes na
classe de domnio Cliente.

3.3.4

Executando o Projeto

Aps criar os controladores, vamos executar nosso projeto pela primeira vez
clicando com o boto direito do mouse, encima do projeto, selecione a aba Run as >
2 Grails Command (run-app). Este comando dar inicio ao servidor Jetty, que far o
deploy da aplicao. Em seguida uma mensagem ser exibida na sada, conforme a
Figura 14.

Figura 14 - Aplicao sendo executada no terminal.

Para visiualizar o resultado da construo do projeto, basta acessar o

endereo que consta no console, de acordo com a Figura 14. Ao acessar o
endereo, seremos saudados pela pgina de boas vindas do Grails, com a lista de
controladores que implementamos, como ilustra a Figura 15.

61

Figura 15 - Pgina inicial da aplicao.

Para entender a funo do scaffolding, podemos acessar conforme a Figura

16, o link ClienteController, presente na pgina inicial da aplicao, sendo
redirecionados a uma nova pgina, criada dinamicamente pelo Grails, aonde nos
depararmos com uma Listagem de Clientes.
Figura 16 - Listagem de clientes cadastrados

At o momento, as funcionalidades geradas pelo scaffolding proporcionam ao

usurio utilizar o CRUD. Ao clicar em Novo Cliente, uma nova pgina com o
formulrio de cadastro de novos clientes ser aberta, como ilustra a Figura 17.

62

Figura 17 - Tela de cadastro de um cliente

Todos os atributos inseridos na classe de domnio constam dentro do

formulrio. Caso seja preenchido o formulrio com dados e acionado o boto Criar
do cadastro, os dados sero persistidos no banco de dados, que por padro o
HSQLDB e salvo em memria. Mais adiante, veremos como configurar o banco para
o MySQL.
Para compreender a forma com que o Grails trata as URLs criadas por
conveno a partir do scaffolding, ser identificado cada ao do mapeamento das
URLs conforme ilustra a Figura 18.

Figura 18 - Mapeamento de URL no Grails

Como apresenta Figura 18, o servidor o primeiro item identificado, sendo

o local em que a aplicao est hospedada, acompanhado da porta (segundo item).
O terceiro item a aplicao propriamente dita. O cliente (quarto item) aparece

63

como o controller que pode estar ou no associado a uma action(neste caso show,
quinto item), conforme foi apresentado na seo 2.2.4.3 .

3.3.5

Validao

Para validar as informaes inseridas dentro de um formulrio, necessrio

definir atravs de restries a forma com que os atributos sero validados. O Grails
fornece recursos de validao sob forma de constraints. So nas constraints que
definimos as regras a serem seguidas na validao das informaes. importante
destacar que elas tambm exercem influncia no modo como o Grails criar as
tabelas no banco de dados e como os dados sero expostos nas pginas GSP.
A ordem em que as constraints so definidas tambm importante, pois ser
atravs delas que o Grails ir definir a ordem na qual os campos devero ser
renderizados nas pginas GSP, bem como os tipos de campos do formulrio HTML
prestados pelo scaffolding, geradas automaticamente pelo framework.
Seguindo o exemplo que tomamos na classe de domnio, vamos adicionar as
constraints dentro da classe.
Listagem 14. As constraints na classe de domnio Cliente.groovy
package makeup.erp
import java.util.Date;
class Cliente {
String nome
String campoEmail
Date dataNascimento
String endereco
String cidade = "Campina Grande"
String estado = "PB"
String telefone
String celular
Date dateCreated
static constraints = {
nome(blank:false)
campoEmail(email:true, nullable:true)
dataNascimento(nullable:true)
endereco(maxSize:100,nullable:true)
cidade(nullable:true)

____________________

64

estado(inList:["AC","AL","AP","AM","BA","CE","DF","ES","GO","MA",
"MT","MS","MG","PA","PB","PR","PE","PI","RJ","RN","RS","RO",
"RR","SC","SP","SE","TO"], nullable:true)
telefone(/*matches:"\\(?\\d{2}\\)?\\d{4}-\\d{4}",
*/nullable:true)
celular(nullable:true)
}
static searchable = true
String toString(){
nome
}
}

A sua sintaxe bastante simples, definimos o nome do atributo a ser avaliado

seguido de um par de parnteses cujo o contedo ser uma srie de valores que
definem as regras de validao. Podemos encontrar no site oficial do Grails, um guia
de usurio, na seo Constraints28, uma lista com todas estas regras de validao.

3.3.6 Criando o banco de dados

Conforme mencionado na seo 2.2.5.6, o Grails possui por padro, um

banco escrito totalmente em Java, o HSQLDB. Este banco armazena todas as
informaes em memria, o que torna a persistncia desinteressante, pois ao
encerraramos a aplicao, todos os dados persistidos no banco sero apagados,
perdendo-se a cada reincio. Ento, veremos como criar um banco de dados para
que sejam persistidos no MySQL.
Aps instalar o MySQL 5.5 (tutorial de instalao no Apndice), siga abaixo as
instrunes passo passo para a criao do banco.
Ao instalar o MYSQL, deve ser configurado o administrador com o username
e password padro root.

28

http://grails.org/doc/1.1

65

Para criar o banco, execute o prompt de comando com permisso do

administrador e localize a pasta do MySQL.
Execute o arquivo mysql.exe, dando a permisso do super usurio, -u root -p.
Digite a senha do administrador do MySQL, root, como ilustra a Figura 19.
Figura 19 - Arquivos de configurao do banco de dados

Uma mensagem de Bem-Vindos do MySQL ser exibido na tela, em seguida

para criar o banco de dados, digite no prompt CREATE DATABASE 'makeup-erp'
(nome do projeto);
Finalmente, o banco est criado, na prxima seo, veremos como configurar
o ambiente do banco de dados no Grails.

3.3.7 Configurando o Banco de dados

Aps criar o banco de dados, ser necessrio configurar o projeto para que os
dados sejam persistidos no MySQL.
Um dos objetivos propostos pelo Grails de fornecer para desenvolvedor
todo um ambiente de trabalho completo, sem se preocupar com arquivos de
configurao e dependncias de bibliotecas.

66

O Grails possui quatro arquivos de configurao dentro do diretrio grailsapp/conf, so eles: BootStrap.groovy, Config.groovy, DataSource.groovy e o
UrlMappings.groovy. Veja na Tabela 5, cada um com suas respectivas definies:

Tabela 5- Arquivos de configurao do banco de dados

O primeiro passo para configurar o banco obter o driver JDBC do banco de

dados. Podemos encontr-lo no site oficial do MySQL29. Em seguida, insira o arquivo
jar do driver como uma dependncia do projeto dentro do diretrio lib. Realizada
essa etapa, definiremos as configuraes do driver, usurio e senha dentro do
arquivo DataSource.groovy, localizado pasta app-grails/conf.
Este arquivo est dividido em trs partes, dentre elas as configuraes
bsicas de acesso ao banco de dados encontrada no primeiro bloco chamado de
dataSource. Dentro desse bloco ser definido em propriedade driverClassName o
driver JDBC a ser carregado, seguido do nome do usurio que ter acesso ao
SGBD, login e senha, e um pool de conexes (cuja a propriedade default ser true).
O segundo bloco chamado hibernate, armazena as configuraes especficas
do Hibernate.
No terceiro bloco, encontramos as environments, que representam os
ambientes de desenvolvimento. Para cada ambiente, o Grails permite utilizar bases
de dados diferentes. Dentro de cada ambiente, existe uma propriedade chamada
dbcreate, esta responsvel por definir qual o comportamento a ser adotado pela
aplicao com relao base de dados no momento em que o servidor for iniciado.
As trs possibilidades para esta propriedade so:
29

http://dev.mysql.com/downloads/connector/j/

67

1. create-drop: Remove toda a base de dados existente e em seguida a

recria quando a aplicao iniciada.
2. create: Cria a base de dados caso ela no tenha sido criada, porm sua
estrutura nas prximas inicializaes no alterada.
3. update: Cria a base de dados caso ela no tenha sido criada e altera caso
novos atributos sejam includos nas classes de domnio.
Segue abaixo o cdigo do arquivo de configurao DataSource.groovy.
Listagem 15. DataSource.groovy

___

_________________

// Aqui so definidas as configuraes de acesso ao banco de dados, que por padro feito
com o H2
dataSource {
pooled = true
driverClassName = "com.mysql.jdbc.Driver"
//Driver do banco de
dados
username = "root"
//Usurio
password = "root"
// Senha
}
hibernate {
cache.use_second_level_cache = true
cache.use_query_cache = true
cache.provider_class = 'net.sf.ehcache.hibernate.EhCacheProvider'

as

}
// environment specific settings
//Abaixo so descritos os ambientes de acesso ao banco (desenvolvimento, teste e produo)
environments {
development {
/*O ambiente de desenvolvimento por padro, apaga e recria todos
*/ tabelas sempre que executado
dataSource {
dbCreate = "create-drop" // one of 'create', create-drop','update'
url = "jdbc:mysql://localhost:3306/makeup-erp?autoreconnect=true"
}
}
//O ambiente de desenvolvimento por padro, cria as tabelas caso no tenha sido criada e
atualiza caso seja inserido atributos nas nossas classes de domnio //
test {
dataSource {
dbCreate = "update"
url = "jdbc:mysql://localhost:3306/makeup-

erp?autoreconnect=true"

}
}
production {
dataSource {
dbCreate = "update"
url = "jdbc:mysql://localhost:3306/makeuperp?autoreconnect=true"

68

3.3.8 Personalizando a aplicao

Voltando ao controlador ClienteController.groovy, possvel perceber que o

controlador no possui nenhuma implementao. Isso por que todos os mtodos so
gerados automaticamente pelo scaffolding.
Listagem 16. O arquivo ClienteController.groovy _______________________________________
package makeup.erp
class ClienteController {
def scaffold = Cliente
{

Perceba na Figura 20 tambm, que na pasta views/cliente, no existe

nenhuma pgina GSP, pois elas tambm so geradas automaticamente pelo
scaffolding quando a aplicao executada.
Figura 20 - Views da Aplicao

Para melhor compreender o funcionamento dos controladores, ser gerado

novamente, atravs do prompt de comandos do Grails, um controlador esttico
utilizando o comando,

grails generate-all makeup.erp.Cliente como ilustrado

nas Figura 21 e Figura 22.

69

Figura 21 - Abrindo o prompt de commando do Grails

Figura 22 - Comando grails generate-all makeup.erp.Cliente

Esse comando ir gerar um scaffolding esttico. Ao definirmos em nossas

classes de controle o atributo scaffolding, o Grails gera todo o cdigo necessrio
para o funcionamento desta classe. Uma vantagem desta abordagem est no fato de
que qualquer alterao feita na classe de domnio pelo usurio automaticamente
ser refletida no controlador e nas pginas relacionadas.
Com o scaffolding esttico, todas as pginas, bem como todo o cdigo
necessrio para a execuo dos controladores sero geradas de forma esttica,
onde o desenvolvedor poder facilmente customiz-la. Observe o contedo dentro

70

do ClienteController criado pelo scaffolding dinmico e o novo controlador gerado

pelo prompt de comandos do Grails, o ClienteController esttico.
Listagem 17. Arquivo ClienteController.groovy inicial _

__

package makeup.erp
class ClienteController {
def scaffold = Cliente
|

Listagem 18. Arquivo ClienteController.groovy gerado novamente pelo Grails

__

package makeup
class ClienteController {
static allowedMethods = [save: "POST", update: "POST", delete:
"POST"]
def index = {
redirect(action: "list", params: params)
}
def list = {
params.max = Math.min(params.max ? params.int('max') : 10, 100)
[clienteInstanceList: Cliente.list(params), clienteInstanceTotal:
Cliente.count()]
}
def create = {
def clienteInstance = new Cliente()
clienteInstance.properties = params
return [clienteInstance: clienteInstance]
}
[...]
// restante do controlador excludo por questes de espao (97 linhas de cdigo)

Ao gerar um controlador esttico, dentro do console Grails, ser exibido uma

pergunta solicitando a substituio do arquivo existente pelo novo controlador.
Dentro da pasta grails-app/views encontra-se todas as pginas da nossa
aplicao, o arquivo index.gsp a pgina inicial default. Aps definir os
controladores estticos, ser possvel costumizar a nossa pgina principal.
Assim como as JSPs, os arquivos GSP tambm possibilitam para o
desenvolvedor trabalhar com expresses dentro do cdigo HTML.
Listagem 19. Parte do cdigo da view Index.gsp
</style>
</head>
<body>

71

<div id="pageBody">
<table style="border:0px;">
<tbody>
<tr>
<td><a href="cliente"><img
src="${resource(dir:'images',file:'clientes-sm.png')}" border="0"
/></a></td>
<td><a href="produto"><img
src="${resource(dir:'images',file:'produtos-sm.png')}" border="0"
/></a></td>
# Adicione as imagens dentro da pasta web-app/images
</tr>
</tbody>
</table>
</div>
</body>
</html>

Do arquivo inicial, foi removida toda a parte que listava automaticamente os

controladores, substituda por links diretos, sendo estes exibido por imagens para o
usurio, como ilustrada na Figura 23.
Figura 23 - Layout do Index.gsp

Todas as pginas herdam sua estrutura da pgina main.gsp, localizada dentro

do diretrio views/layouts. Ser dentro da main.gsp que ser removida a logomarca

72

do Grails e inserida a do sistema. A partir disso, todas as pginas sero

renderizadas de forma a exibir a nova logomarca.
Listagem 20. cdigo padro do Main.gsp

<!DOCTYPE html>
<html>
<head>
<title><g:layoutTitle default="Grails" /></title>
<link rel="stylesheet" href="${resource(dir:'css',file:'main.css')}"
/>
<link
rel="shortcut
icon"
href="${resource(dir:'images',file:'favicon.ico')}" type="image/x-icon" />
<g:layoutHead />
<g:javascript library="application" />
</head>
<body>
<div id="spinner" class="spinner" style="display:none;">
<img
src="${resource(dir:'images',file:'spinner.gif')}"
alt="${message(code:'spinner.alt',default:'Loading...')}" />
</div>
<div
id="grailsLogo"><a
href="http://grails.org"><img
src="${resource(dir:'images',file:'grails_logo.png')}"
alt="Grails"
border="0" /></a></div>
<g:layoutBody />
</body>
</html>

A Listagem 20, exibe o cdigo main.gsp gerado por padro framework Grails.
Este cdigo ser substitudo pelo trecho de cdigo marcado na Listagem 21:
Listagem 21. Trecho do cdigo Main.gsp

<div id="grailsLogo" style="background-color:#141516;">

<table style="border:0px">
<tbody>
<tr>
<td
style="text-align:left;"><img
src="${resource(dir:'images',file:'andreza_logo.jpg')}" border="0" /></td>
</tr>
</tbody>
</table>
</div>

O cdigo alterado define para todas as pginas GSP um plano de fundo com
a propriedade background-color e adiciona uma imagem, no canto esquerdo da tela.
Podemos notar que nas Listagens 19 e 20, algumas imagens foram referenciadas no
cdigo, estas imagens foram salvas dentro do diretrio web-app/images.

73

3.3.9 Adicionando segurana na aplicao

Uma das vantagens de trabalhar com Grails est na integrao de plugins aos
projetos. Para adicionar segurana na aplicao, ser usado o plugin

Spring

Security. Baseado no Spring, esse plugin pode ser facilmente configurado na

aplicao. Nesta seo saberemos como proteger a aplicao criando uma tela de
login e restries de acesso a usurios, de acordo com LedBrook(2010).
Para instalar o plugin Spring Security, abra o prompt de comando do Grails e
execute a linha de comando:
grails install-plugin spring-security-core

Aps a instalao o plugin do Spring Security, execute no prompt de

comando:
grails s2-quickstart makeup.erp Usuario Papel

Este comando ir criar as trs classes de domnio bsicas necessrias para

armazenar informaes do usurio e dos controladores que gerenciam a
autenticao, so elas:
makeup.erp Usuario;
makeup.erp Papel;
makeup.erp UsuarioPapel;
E dois controladores:
LoginController
LogoutController
Precisamos agora adicionar em conf/UrlMappings, os mapeamentos de URLs
dos controladores de login e logout, para que seja obrigatrio efetuar o processo de
login na aplicao.
Listagem 22. Arquivo de configurao UrlMappings.groovy
class UrlMappings {

74

static mappings = {
"/$controller/$action?/$id?"{
constraints {
// apply constraints here
}
}
"/"(view:"/index")
"500"(view:'/error')
"/login/$action?"(controller: "login")
"/logout/$action?"(controller: "logout")
}
}

Aps configurar a UrlMappings, ser possvel ter acesso a tela de login do

sistema, mas sem nenhuma regra de controle de acesso. Podemos definir essas
regras de controle de acesso atravs de um mapa esttico em Config.groovy. A
vantagem que podemos manter as regras de restrio em um nico lugar.
necessrio a importao do SecurityConfigType para o arquivo, conforme a
Listagem 23.
Listagem 23. Arquivo de configurao Config.groovy

import grails.plugins.springsecurity.SecurityConfigType

Em seguida, definir as regras de acesso, para que se tenha o controle de que

tipo de usurio ir ter acesso uma determinada pgina ou funcionalidade.
grails.plugins.springsecurity.securityConfigType =
SecurityConfigType.InterceptUrlMap
grails.plugins.springsecurity.interceptUrlMap = [
'/logout/**':
['IS_AUTHENTICATED_ANONYMOUSLY'],
'/login/**':
['IS_AUTHENTICATED_ANONYMOUSLY'],
'/j_spring_security_check/**':
['IS_AUTHENTICATED_ANONYMOUSLY'],
'/js/**':
['IS_AUTHENTICATED_ANONYMOUSLY'],
'/css/**': ['IS_AUTHENTICATED_ANONYMOUSLY'],
'/images/**': ['IS_AUTHENTICATED_ANONYMOUSLY'],
'/usuario/*': ['ROLE_ADMIN', 'IS_AUTHENTICATED_FULLY'],
'/jasper/*': ['ROLE_ADMIN', 'IS_AUTHENTICATED_FULLY'],
'/movimentacao/*': ['ROLE_ADMIN', 'IS_AUTHENTICATED_FULLY'],
'/produto/edit/*': ['ROLE_ADMIN', 'IS_AUTHENTICATED_FULLY'],
'/produto/create/*': ['ROLE_ADMIN', 'IS_AUTHENTICATED_FULLY'],
'/**':
['IS_AUTHENTICATED_REMEMBERED']
]

Uma breve definio dos tipos de usurios:

75

IS_AUTHENTICATED_ANONYMOUSLY

Ningum

tem

acesso,

sem

necessidade de o usurio login.

IS_AUTHENTICATED_REMEMBERED Apenas usurios conhecidos que

tenha logado ou se lembram de uma sesso anterior permitido o acesso.

IS_AUTHENTICATED_FULLY Os usurios devem fazer login para ter acesso.

Para que a aplicao tenha controle sobre quem tem acesso a determinadas

funcionalidades, necessrio definir papis. Esses papis so tipicamente definidos

no incio da vida da aplicao e correspondem aos dados de referncia imutvel, no
arquivo de configurao BootSrap.groovy ser criado dois tipos de usurio o user e
admin.
Listagem 24. Arquivo de configurao BootStrap.groovy
.
class BootStrap {
def init = {
....
def userRole = Papel.findByAuthority('ROLE_USUARIO') ?: new
Papel(authority: 'ROLE_USUARIO').save(failOnError: true)
def adminRole = Papel.findByAuthority('ROLE_ADMIN') ?: new
Papel(authority: 'ROLE_ADMIN').save(failOnError: true)
...
}

Para criar um usurio administrador no sistema, necessrio definir no

arquivo de configurao BootStrap.groovy os seguintes parmetros:
Listagem 25. Adicionando um usurio admin no BootStrap.groovy
.
import
import
import
import
import
import

makeup.erp.Produto;
makeup.erp.Cliente;
makeup.erp.Papel;
makeup.erp.Usuario;
makeup.erp.UsuarioPapel;
grails.util.GrailsUtil;

class BootStrap {
// O springSecurityService oferece um servio de condificao
def springSecurityService
def init = servletContext -> {
...
}
def adminUser = Usuario.findByUsername('admin') ?: new Usuario(
username: 'admin',
password: springSecurityService.encodePassword('admin'),
papel: adminRole,
enabled: true).save(failOnError: true)

76

if (!adminUser.authorities.contains(adminRole)) {
UsuarioPapel.create adminUser, adminRole
}
}
def destroy = {
}
}

A aplicao de segurana est quase pronta, falta inserir na tela do sistema

um link para que quando o usurio estiver logado, possuir a opo de deslogar.
Ento, precisamos inserir um painel lateral no views/layouts/main.gsp
Listagem 26. Adicionando painel lateral no main.gsp
<sec:ifLoggedIn>
<h1 style="text-align:right;color:white;">
<sec:username/> (<g:link controller="logout">Sair</g:link>)
</h1>
</sec:ifLoggedIn>

O trecho de cdigo acima exibe um painel lateral que exibe o nome do

usurio logado e um link para sair, conforme podemos observar na Figura 24.

Figura 24 - Pgina principal com o usurio logado

Caso o usurio efetue o logout do sistema, ser redirecionado para a pgina

de login, como ilustra Figura 25, como definido pelas configuraes do controle de
acesso no arquivo Config.groovy.

77

Figura 25 - Tela de login

3.3.10

Adicionando uma busca

Para adicionar um mtodo de busca na aplicao, foi utilizado o plugin

Searchable. Este plugin fornece recursos de pesquisa para o aplicativo. Nesta seo
ser visto como aplic-lo para o sistema de acordo com DAVIS(2009).
Para instalar o plugin Searchable, abra o prompt de comando do Grails e
execute a linha de comando:
grails install-plugin searchable

Aps a instalao do plugin no projeto, incluiremos em todas as classes de

domnio, em que se deseja um campo de pesquisa, a linha de cdigo abaixo.
class Cliente {
[...]
static constraints = {
[...]
}
/* Este parmetro torna true o acesso do mtodo searchable aos
atributos da classe de domnio persistidos no banco de dados.
static searchable = true
[...]
}

78

E adicionar ao controlador pertencente a classe de domnio o mtodo que far

uma busca no banco dados retornando uma lista. Assim, quando o usurio do
sistema digitar o que deseja encontrar e executar o boto de busca, a requisio
ser feita pelo navegador ao servidor, que processar o pedido do usurio e em
seguida retornar um mapa de metadados sobre a pesquisa, juntamente com uma
lista de classes de domnio que correspondem aos critrios da busca.
def search = {
def query = params.q
if(query){
def srchResults = Cliente.search('*'+query+'*')
render(view: "list",
model:
[clientesInstanceList:srchResults.results,
clientesInstanceTotal:srchResults.total])
}else{
redirect(action: "list")
}
}

Por fim, s precisaremos inserir o campo com o parmetro de busca na

pgina list do Cliente colocando o cdigo a abaixo dentro do arquivo list.gsp
localizado no diretrio views/clientes/list.gsp.
# Adicionando um boto, com uma action search, que far um get retornando
os atributos da classe de domnio cadastrados.
<span class="menuButton">
<g:form action="search" method="get" style="display: inline;">
<g:textField name="q" value="${params.q}"/>
<g:submitButton name="Buscar"/>
</g:form>
</span>

O resultado ser o campo de busca na view de Cliente.list como apresenta

Figura 26.

79

Figura 26 - Campo de busca

3.3.10 Gerando relatrios

Para integrar relatrios JasperReport dentro da aplicao, ser necessrio

instalar o plugin Jasper. Este plugin suporta os seguintes tipos de formatos: PDF,
HTML, XML, CSV, XLS, RTF, TEXT, ODT, ODS, DOCX, XLSX, PPTX. Para instalar
este plugin, abra o prompt de comando do Grails e execute a linha de comando:
grails install-plugin jasper

Aps a instalao do plugin, ser inserido na view do Cliente, onde se

encontra a lista dos clientes cadastrados, dentro do arquivo List.gsp, um boto com
a funo gerar um relatrio:
[...]
<div class="paginateButtons">
<g:paginate total="${Cliente.count()}" />
</div>
<g:jasperReport jasper="clientes-reports" format="PDF" name="Cliente"
/>

80

</div>
</body>

Dentro do parmetro <g:jasReport ...> ser configurado o nome do relatrio e

os tipos de formato. Para personalizar os modelos de relatrios ser necessrio a
instalao do programa iReport30. Esta ferramenta cria diversos tipos de relatrio
usando uma interface muito simples, ilustrada na Figura 27. Crie um relatrio e
arraste para dentro dele elementos do report localizado na paleta definindo com
atributos da classe de domnio e salve para dentro da pasta \web-app\reports, com
o nome clientes-reports, de acordo com a Figura 28.

Figura 27 - Criando o relatrio de clientes no iReport

30

http://jasperforge.org/uploads/publish/ireportwebsite/IR%20Website/ir_download.html

81

Figura 28 - Diretrio reports

Com resultado, teremos na view/list.gsp do Cliente o boto para a gerao de

relatrios, como apresenta a Figura 29.
Figura 29 - Boto do relatrio

82

3.3.11 Internacionalizao

De

acordo

com

ROCHER(2009)

Grails

traz

suporte

para

internacionalizao31 de aplicaes web, sendo bastante simples de manusear. O

Grails determina automaticamente a localidade do usurio com base no cabealho
Accept-Language que o seu navegador envia.
Quando criamos uma aplicao em Grails, o projeto inclui uma srie de
arquivos de propriedades localizados dentro do diretrio grails-app/i18n/. O arquivo
messages.properties contm validao padro de mensagens em ingls. Essas
mensagens sero usadas quando ocorrer algum erro de validao em uma classe
de domnio ou algum comando de objeto. Dentro do diretrio grails-app/i18n/, so
gerados

arquivos

com

propriedades

em

vrios

idiomas.

Por

exemplo,

messages_pt.properties, contm mensagens de validao em portugus. Essas

propriedades, so definidas por campos de espao reservado:

{0} para um nome de propriedade

{1} para um nome de classe

{2} para um valor
O Grails oferece uma tag chamada message dentro da GSP, que recupera os
valores de propriedades a partir dos arquivos de mensagens no grails-app/i18n/.
Buscaremos no arquivo views/cliente/list.gsp, as tags com o parmetro dos botes
Home e New.
<span class="menuButton"><a class="home" href="${createLink(uri:
'/')}"><g:message code="default.home.label"/></a></span>

<span class="menuButton"><g:link class="create" action="create"><g:message

code="default.new.label" args="[entityName]" /></g:link></span>

31

http://grails.org/doc/1.1/guide/single.html#10.%20Internationalization

83

Aps identificar as tags g:message , abra o arquivo de configurao

messages.properties e pesquise no cdigo pelo texto default.home.label. e
default.new.label .Como j haviamos citado anteriormente, o Grails contm todas

as mensagens da aplicao, por padro, em ingls. Neste caso, identificamos o

texto da mensagem default.home.label. = Home e default.new.label = New.
Vamos abrir o arquivo de configurao messages_pt_BR.properties e adicionar as
mensagens que queremos que sejam traduzidas.
# Trecho do cdigo: Vamos adicionar aqui nossas mensagens de erro
default.home.label=Incio
default.new.label=Novo {0}
default.add.label=Adicionar {0}
default.list.label=Listar {0}
#Ateno ao parmetro {0}, ele ser substitudo pelo nome de uma propriedade.

Podemos atualizar a pgina Cliente.list e automaticamente ela far a traduo

dos campos alterados, como podemos observar na figura 30.

Figura 30 - Botes internacionalizados para pt_BR

84

3.3.12 Deploy

Uma vez estando a aplicao finalizada, possvel efetuar o deploy do

projeto. O processo bastante simples, tudo o que precisa ser feito executar o
comando grails war no prompt de comando do Grails. Este comando far o build
do projeto, empacotar no formato war padro do JEE e ser salvo dentro do
diretrio target do projeto, conforme Figura 31.

Figura 31 - Arquivo war. gerado dentro do diretrio target

Aps a gerao do arquivo war da aplicao, podemos implantar em qualquer

servidor. Os passos necessrios para implantar o war variam de acordo com os tipos
servidores. Usaremos o servidor web Tomcat para testar a nossa aplicao.
Com o war gerado, devemos apenas copiar o arquivo gerado para dentro do
diretrio webapps, onde est instalado o Tomcat e rodarmos e executarmos o
servidor. Um tutorial de instalao e configurao do Apache Tomcat est disponvel
no Apndice.

85

4 METODOLOGIA

Este trabalho foi desenvolvido baseado em uma metodologia especfica

voltada para a rea de Sistemas de Informao, com o intuito de realizar um estudo
sobre novas tecnologias que adotam metodologias geis para o desenvolvimento de
sistemas web.
Na primeira etapa, foi feito uma pesquisa exploratria atravs de um
levantamento bibliogrfico sobre a linguagem Groovy, um estudo de suas
caractersticas, desde sua estrutura (mtodos, closures, expresses regulares,
operadores), a sua configurao para o desenvolvimento. Aps esta etapa, foi feito
um estudo sobre o framework Grails, desde sua arquitetura, caractersticas,
estrutura, configuraes e seus recursos que integrados formam uma verstil
ferramenta para o desenvolvimento de aplicaes web.
A populao alvo deste trabalho so os prprios desenvolvedores web que
podero ter uma nova viso e conhecimento sobre estas tecnologias que tornam o
desenvolvimento de aplicaes web cada vez mais geis e dinmicas, aumentando
o nvel de produtividade e reduzindo o nvel de complexidade na criao de
sistemas.
Concludo a fundamentao terica, foi realizado um estudo de caso,
definindo as funcionalidades necessrias para o sistema, criando diagrama de
classes e o caso de uso, que facilitaram o entendimento do problema. Com a
utilizao do framework Grails foi possvel criar toda a parte relacional do banco de
dados automaticamente, de acordo com as classes de domnio, levantadas no
estudo de caso e instalados plugins com funcionalidades especificas de pesquisa e
segurana para incrementar o sistema.
Finalmente, sero apresentados nas consideraes finais os resultados da
implantao do sistema na empresa.

86

5 CONSIDERAES FINAIS

possvel notar os grandes avanos feitos no campo de desenvolvimento em

aplicaes web, a linguagem Groovy e o framework Grails trazem para os
desenvolvedores um novo paradigma de programao, combinao perfeita que
integra diversas tcnicas e tecnologias existentes do framework Grails, com as
caractersticas dinmicas da linguagem dinmica Groovy, resultando em uma
estrutura favorvel ao desenvolvimento com relao a facilidade de utilizao e
produtividade.
Durante parte do trabalho foi focado nos conceitos fundamentais da
linguagem Groovy, apresentando toda a sintaxe bsica para que o leitor pudesse
absorver o contedo desta linguagem dinmica e o potencial do framework Grails,
relacionando as tecnologias utilizadas pelo framework, assim como a compreenso
de sua estrutura e funcionamento em aplicaes web e no desenvolvimento em
camadas.
Ento os objetivos propostos neste trabalho, alm de apresentar o contedo
de uma forma simples sobre os conceitos fundamentais das tecnologias em questo,
foi possvel tambm vivenciar o lado prtico, desenvolvendo um sistema web, sendo
implementado algumas funcionalidades do sistema, proposto para a empresa
Andreza Andrade, que passou a utilizar o sistema desenvolvido por este trabalho.
Como resultado foi constatada vantagens desde a implantao do sistema em sua
empresa, tais como: agilidade no cadastro de produtos e clientes, facilidade em
suas vendas e controle de estoque (atravs de relatrios gerados pelo sistema), de
acordo com os questionrios elaborados e respondidos por ela, anexados neste
trabalho.
Podemos destacar os Prs e Contras, da utilizao do sistema na empresa:
Prs:

Idioma est portugus.

Interface amigvel.
Fcil usabilidade.
Controle de usurios.
CRUD (clientes, produto e vendas)
Relatrios em PDF.
Rpido acesso as funcionalidades.

Contras:
Apesar de ser um sistema web,
roda apenas em um servidor
local.
Instalar o Tomcat na mquina.

Instalar o MYSQL na mquina.

87

Nos anexos segues dois questionrios elaborados, relatando a experincia do

usurio antes e depois da implantao do sistema na empresa.
Foi possvel constatar que aps 4 8 horas de inatividade, o framework Grails
perde a conexo com o banco de dados, havendo a necessidade de reiniciar o
programa. Para evitar esta situao, adicionamos ao DataSource.groovy seguinte
propriedade:
properties {
validationQuery="select 1"
testWhileIdle=true
timeBetweenEvictionRunsMillis=60000
}

No foi possvel se fazer presente de toda a instruo de como foi criado o

sistema neste trabalho, a idia inicial, era mostrar para desenvolvedores web,
conceitos da linguagem e do framework, para que o leitor tivesse uma noo bsica
de como construir uma aplicao utilizando Grails (classes de domnio,
controladores, entre os outros recursos) citados no decorrer do desenvolvimento da
aplicao.

5.1 TRABALHOS RELACIONADOS

Alguns trabalhos relacionados foram encontrados dentre eles pode-se citar o

artigo:
a)

GRAILS:

DO

GROOVY

WEB

ALTA

PRODUTIVIDADE

NO

DESENVOLVIMENTO DE APLICAES WEB. Este artigo apresenta uma viso

panormica do funcionamento do Grails, um framework fullstack para o
desenvolvimento de aplicaes web que baseado na linguagem Groovy.

88

b)

CRIANDO UM BLOG EM CINCO MINUTOS COM GRAILS.

Este artigo32

apresenta as vantagens de se trabalhar com Groovy e Grails, desenvolvendo passoa-passo um blog.

O Grails prima por ser um framework de alta produtividade ao adotar o
princpio de padres sobre configuraes aliado aos ganhos obtidos com uma
linguagem dinmica. Neste artigo relacionado podemos ver o funcionamento bsico:
como criar classes de domnio, controladores e a execuo do scaffolding, que
agiliza muito a vida do desenvolvedor ao fornecer um ponto de partida na criao de
suas aplicaes.
Dada a escassez de artigos em desenvolvimento de sistemas web utilizando
Groovy e Grails, assim como as restries do contedo em apenas apresentar a
teoria ou de desenvolver simples blogs e micro-blogs, percebe-se limitaes ao
passar para o leitor, algumas funcionalidades necessrias principalmente para o
desenvolvimento na rea comercial. O presente trabalho vai mais alm desses
artigos trazendo formas de implementao de buscas no banco de dados e a
integrao de relatrios usando plugins criados para o framework.

5.2 TRABALHOS FUTUROS

Como trabalho futuro, sugere-se o aprofundamento em outras tecnologias de

desenvolvimento de aplicaes geis e dinmicas para web, fazendo comparativos
da linguagem Groovy com outras linguagens dinmicas, exemplo do Ruby e Scala,
abrindo novos horizontes no que diz respeito ao desenvolvimento de sistemas para a
web.

32

http://www.michelsilva.net/index.php?option=com_content&task=view&id=49&Itemid=12

89

REFERNCIAS

ROCHER, Graeme; BROWN, Jeff. The Definitive Guide to Grails. 2nd ed. [S.I]:
Apress, 2009.
JUDD, C. M.; NUSAIRAT, J. F.; SHINGLER, J. Beginning Groovy and Grails:
From Novice to Professional. 1. ed. [S.l.]: Apress, 2008.
KONIG, D.; GLOVER, A.; KING, P.; LAFORGE, G.; SKEET, J. Groovy in
Action. 1. ed. [S.l.]: Manning Publications, 2007.
BARCLAY, Kenneth; SAVAGE John. Grovvy Programming an introduction for
Java Developers. San Francisco: Elsevier, 2007.
DEARLE, Fergal. Groovy for Domain Specific Languages. [S.I.]: Packt
Publications, 2010.
SMITH, Glen; LEDBROOK, Peter. Grails in Action .1st ed. [S.I.]: Manning
Publications, 2009.
JAWAD, Bashar Abdul. Groovy and Grails Recipes. 1st ed. [SI.]: Apress, 2009.
RUDOLPH, Jason. Getting Started with Grails. 1st ed. [S.I.]: InfoQ Publisher, 2006.
DOEDERLEIN, OSVALDO. Aprendendo Groovy - Scripting e Dinamismo na
Plataforma Java. Revista Java Magazine,Ed.32, [S.I], p. 30-44, [2007].
WEISSMANN, HENRIQUE. Grails: do Groovy Web - Alta produtividade no
desenvolvimento - Parte 1. Revista Java Magazine,Ed.75, [S.I], p. 28-34, 2010.
WEISSMANN, HENRIQUE. Grails: do Groovy Web - Alta produtividade no
desenvolvimento - Parte 2. Revista Java Magazine,Ed.76, [S.I], p. 48-56, 2010.
WEISSMANN, HENRIQUE. Grails: do Groovy Web - Alta produtividade no
desenvolvimento - Parte 3. Revista Java Magazine,Ed.77, [S.I], p. 46-53, 2010.
WEISSMANN, HENRIQUE. Grails: do Groovy Web - Alta produtividade no
desenvolvimento - Parte 4. Revista Java Magazine,Ed.78, [S.I], p. 38-50, 2010.
WEISSMANN, HENRIQUE. Grails: do Groovy Web - Alta produtividade no
desenvolvimento - Parte 5. Revista Java Magazine,Ed.79, [S.I], p. 30-41, 2010.
COMMUNITY, C. G. Groovy Home. Disponvel em: http://groovy.codehaus.org/.
Acessado em 20 de Maio 2011.

90

LEDBROOK, Peter. Simplified Spring Security with Grails. Disponvel em:

http://blog.springsource.com/2010/08/11/simplified-spring-security-with-grails.
Acessado em 20 de Maio de 2011.
DAVIS, Scott. Dominando Grails: Entendendo Plug-ins. Disponvel em:
http://www.ibm.com/developerworks/br/java/library/j-grails07219/ . Acessado em 20
de Maio de 2011.
CASTELLANI, Marcelo. Um pouco de Groovy. Disponvel em:
http://www.devmedia.com.br/websys.2/webreader.asp?cat=6&revista=javamagazine
_69#a-1572 . Acessado em 20 de Maio de 2011.
LAFORGE, Guillaume. Groovy - An agile dynamic language for the Java
Platform. Disponvel em: http://groovy.codehaus.org/ . Acessado em 20 de Maio de
2011

91

APENDICE

O material apresentado nesta monografia foi fornecido sob licenas de cdigo

aberto, no infringindo nenhuma lei. O cdigo fonte e binrios esto disponveis
gratuitamente. O material inteiramente acadmico e esto livres para os usurios.
O exemplo utilizado neste trabalho foi desenvolvido na plataforma Microsoft
Windows. As sees a seguir esto atualizadas at presente data e podem estar
sujeitos a alteraes. Por tanto, os leitores devem consultar o site do livro e do site
das ferramentas para obter mais detalhes e atualizaes

A.1 JAVA DEVELOPMENT KIT (JDK)

O Java Development Kit (JDK) est disponvel no site da Oracle33. O arquivo

encontra-se disponveis para uma variedade de plataformas. No Windows, clique
duas vezes no arquivo executvel (por exemplo, jdk-6u24-windowsi586.exe) para
iniciar o processo de instalao. Por padro o JDK se localizar na pasta
C:\Program Files\Java.

A.2 SERVIDOR APACHE TOMCAT

O servidor Tomcat est disponvel no site34, na seo de downloads. No item

Binary Distributions, clique em Windows service Installer e faa o download.
Atualmente o Tomcat encontra-se na verso 6.0.32, antes de baixar verifique o seu
sistema operacional. No windows, clique duas vezes no arquivo executvel (por
exemplo, apache-tomcat-6.0.32.exe) para iniciar o processo de

instalao. Nas

33

http://www.oracle.com/technetwork/java/javase/downloads/index.html

34

http://tomcat.apache.org/

92

etapas de instalao defina o diretrio onde o Tomcat ser instalado, em nossa

instalao vamos adicionar o caminho: C:\Arquivos de Programas\Tomcat 6.0.
Figura 32 - Configuraes bsicas do Tomcat

Como ilustra a figura 32, as configuraes bsicas do Tomcat so:

Porta de instalao: Porta de acesso exclusiva ao Tomcat, por padro a porta
de instalao do Tomcat a 8080.
a) Username: Define um nome de usurio para acesso a administrao do
Tomcat, por padro admin.
b) Password: Define uma senha para o administrador do Tomcat, por padro
admin. Feito isso avance a etapa.
Para finalizar, indique onde esta instalada a Java Runtime Environment (JRE)
e clique em Install.
Para configurar o Tomcat, teremos que definir uma varivel de ambiente. Para
acessar as variveis de ambiente do sistema, clique com o boto direito do mouse
no cone Meu Computador, clique na aba Avanado, e clique no boto Variveis de
Ambiente. Agora defina o nome para a varivel de ambiente para CATALINA_HOME

93

e o valor da varivel para o caminho onde foi instalado o Tomcat como

apresentado na Figura 33.
Figura 33 - Configurando a varivel de ambiento do Tomcat

Para testar a instalao do Tomcat basta digitar no browser o endereo

http://localhost:8080.

A.3 SPRING SOURCE TOOL SUITE 2.5.2.SR1

A ferramenta que usaremos para desenvolver o aplicativo web est disponvel

no site35 oficial, na seo de downloads. Trata-se de uma verso do Eclipse j
pronta para rodar o Grails, faa o download do Installer.
Feito o download, siga este tutorial para o apoio do Grails Eclipse na
ferramenta Spring Source Tool Suite (STS).
35

http://www.springsource.com/products/springsource-tool-suite-download

94

Neste tutorial, iremos fazer a instalao do suporte ao idioma Groovy e

instalar as ferramentas Grails no SringSource Tool Suite. Aps a instalao, execute
o programa, uma tela de Bem-vindos ir aparecer na tela conforme Figura 34.

Figura 34 - Tela de abertura do SpringSource Tool Suite

Na aba de menus clique em Help e depois na guia Dashboard. Feito isso uma
nova janela ir abrir.

95

Figura 35 - Dashboard do SpringSource Tool Suite

Na parte inferior, em um painel separador, clique em Extensions de acordo

com Figura 35.
Figura 36 - Configurando o Grails na Dashboard

96

Como ilustra Figura 36, na seo Languages and Frameworks,

encontramos a ltima verso do framework Grails. Caso possua o Grails instalado
em sua mquina, ento no h a necessidade de marcar. Na seo Language and
Framework Tooling, marque as duas opes, para instalar o suporte ao Grails e o
Groovy Eclipse plugin e clique em Install.
Aps a instalao, reinicie o SpringSource Tool Suite e este estar habilitado
para o desenvolvimento com o Groovy e Grails.

A.4 MYSQL SERVER 5.5

Faa

download

do

MySQL

Community

Server

pelo

site

dev.mysql.com/downloads/. Aps acessar o link acima, clique na opo MySQL

Community Server. Nesta pgina, teremos a opes de escolha de acordo com o
sistema operacional utilizado. Para fazer o donwload preciso ser cadastrado. Faa
o rpido cadastro e clique em donwload. Aps baixar o arquivo execute-o e siga os
passos conforme abaixo:
1. Siga a instalao, dando next , aceite os termos de acordo.
2. Escolha a opo Custom para poder interagir com as configuraes e clique em
next.
3. Siga dando next e clique em Install.
4. Aguarde enquanto a instalao automtica configura e efetua alguns
procedimentos.
5. Finalizada a instalao do MySQL Server 5.5, vamos configurar o servidor. Uma
janela do MySQL Serve Instance Configuration Wizard ir abrir, marque a primeira
opo - Detailed configuration e depois next.
6. Em seguida marque a primeira opo novamente - Developer Machine e depois
em next.
7. Marque a primeira opo - Multifuncional Database e depois em next.
8. Mantenha as configuraes padro e depois next.
9. Marque a primeira opo - Decision Suppots (DSS)/OLAP e depois em next.

97

10. Mantenha as opes Enable TCP/IP Networking e Enable Strict Mode

marcadas e clique em next.
11. Em relao ao Charset padro, escolha a opo - Best Support for
Multilinguism.
12. Na prxima janela marque a opo - Install as windows service, e siga
avanando.
13. Agora deixe marcada a opo Modify Security Settings e defina a senha root
e clique em next.
14. Aparecer uma janela informando os passos que o assistente de configurao
seguir automaticamente a partir desse ponto. Clique em Execute.
15. Pronto, o servidor de banco de dados MySQL esta devidamente instalado e
configurado.

98

ANEXOS

99

ANEXOS A QUESTIONRIO 1.
Roteiro de perguntas respondidas por Andreza Andrade (Empresria) sobre o
comportamento da empresa antes da instalao do sistema

De que forma organizada os dados dos clientes na empresa?

Resposta: Eram organizadas atravs de fichas, onde todos os dados dos clientes
eram guardados em fichrios, por ordem alfabtica.
De que forma organizada os dados dos produtos na empresa?
Resposta: Os dados dos produtos eram anotados em cadernos de estoque,
organizados por fornecedores,referncias,preo de custo,entre outros.
De que forma organizada os dados das vendas na empresa?
Resposta: As vendas eram feitas atravs do livro caixa, onde eram discriminados
todos os produtos vendidos diariamente, e tiradas s respectivas notas fiscais, tudo
manualmente.
Como eram feitos os relatrios na empresa?
Resposta: Os relatrios eram feitos semanalmente, para o controle fsico/ financeira
da empresa.
Como voc classifica a eficincia na prtica do cadastro manual do cliente na
empresa?
1 2 3 4 5
Pouco Eficiente

Muito Eficiente

Como voc classifica a eficincia na prtica de consultar informaes sobre os

clientes na empresa?
1 2 3 4 5
Pouco Eficiente

Muito Eficiente

Como voc classifica a eficincia na prtica do cadastro manual dos produtos na

empresa?
1 2 3 4 5
Pouco Eficiente

Muito Eficiente

100

Como voc classifica a eficincia na prtica de consultar informaes sobre o

produto na empresa?
1 2 3 4 5
Pouco Eficiente

Muito Eficiente

Como voc classifica a eficincia nas prticas manuais de vendas na empresa?

1 2 3 4 5
Pouco Eficiente

ANEXO B QUESTIONRIO 2.

Muito Eficiente

101

Roteiro de perguntas respondidas por Andreza Andrade (Empresria) aps

implantao do sistema em sua empresa.

Como voc classifica a eficincia na prtica do cadastro de Clientes aps a

implantao do sistema?
1
2 3 4 5
Pouco Eficiente

Muito Eficiente

Como voc classifica a eficincia na prtica de consulta de Clientes aps a

implantao do sistema?
1
2 3 4 5
Pouco Eficiente

Muito Eficiente

Como voc classifica a eficincia dos relatrios de Clientes aps a implantao do

sistema?
1
2 3 4 5
Pouco Eficiente

Muito Eficiente

Como voc classifica a eficincia na prtica do cadastro de produtos aps a

implantao do sistema?
1
2 3 4 5
Pouco Eficiente

Muito Eficiente

Como voc classifica a eficincia na prtica de consulta de produtos aps a

implantao do sistema?
1
2 3 4 5
Pouco Eficiente

Muito Eficiente

Como voc classifica a eficincia dos relatrios de Produtos do cadastro aps a

implantao do sistema?
1
2 3 4 5
Pouco Eficiente

Muito Eficiente

Como voc classifica a eficincia em criar Vendas aps a implantao do sistema?

102

Pouco Eficiente

5
Muito Eficiente

Como voc classifica a eficincia em consultar Vendas aps a implantao do

sistema?
1
2 3 4 5
Pouco Eficiente

Muito Eficiente

Como voc classifica a eficincia dos relatrios de Vendas aps a implantao do

sistema?
1
2 3 4 5
Pouco Eficiente

ANEXO C CDIGOS FONTES

Muito Eficiente

103

Segue abaixo as classes de domnio que foram desenvolvidas no sistema

makeup-erp.

Listagem 27. Classe de domnio Cliente.groovy ____________________________________________

package makeup.erp
import java.util.Date;
class Cliente {
String nome
String campoEmail
Date dataNascimento
String endereco
String cidade = "Campina Grande"
String estado = "PB"
String telefone
String celular
Date dateCreated
static constraints = {
nome(blank:false)
campoEmail(email:true, nullable:true)
dataNascimento(nullable:true)
endereco(maxSize:100,nullable:true)
cidade(nullable:true)
estado(inList:["AC","AL","AP","AM","BA","CE","DF","ES","GO","MA",
"MT","MS","MG","PA","PB","PR","PE","PI","RJ","RN","RS","RO",
"RR","SC","SP","SE","TO"], nullable:true)
telefone(/*matches:"\\(?\\d{2}\\)?\\d{4}-\\d{4}",
*/nullable:true)
celular(nullable:true)
}
static searchable = true
String toString(){
nome
}
}

104

Listagem 28. Classe de domnio Devolucao.groovy _______________________________________

package makeup.erp
import java.util.Date;
class Devolucao {
Cliente cliente
double valorRetornado
Date dateCreated
static hasMany = [itens:ItemDevolucao]
List itens
static constraints = {
cliente(nullable: true)
valorRetornado(scale:2, min:0d)
}
static searchable = {
itens component:true
cliente component:true
}
}

Listagem 29. Classe de domnio ItemDevolucao.groovy __________________________________

package makeup.erp
class ItemDevolucao {
static belongsTo = [devolucao:Devolucao]
Produto produto
double quantidade = 1
double valorUnitario
double valorTotal
int sequencia
static constraints = {
valorUnitario(scale:2, min:0d)
valorTotal(scale:2, min:0d)
quantidade(min:0d)
}
static searchable = true
String toString(){
quantidade + ": " + produto.toString();
}
}

Listagem 30. Classe de domnio ItemVenda.groovy __________________________________

package makeup.erp

105

class ItemVenda {
static belongsTo = [venda:Venda]
Produto produto
double quantidade = 1
double valorUnitario
double valorTotal
int sequencia
static constraints = {
valorUnitario(scale:2, min:0d)
valorTotal(scale:2, min:0d)
quantidade(min:0d)
}
static searchable = true
String toString(){
quantidade + ": " + produto.toString();
}
}

Listagem 31. Classe de domnio Papel.groovy __________________________________

package makeup.erp
class Papel {
String authority
static mapping = {
cache true
}
static constraints = {
authority blank: false, unique: true
}
String toString(){
authority
}
}

Listagem 32. Classe de domnio Produto.groovy __________________________________

package makeup.erp
import java.util.Date;
class Produto {

106

String
String
double
double
double
String

descricao
barCode
quantidade
precoCusto
precoVenda
observacoes

Date dateCreated
static constraints = {
descricao()
precoCusto(scale:2, min:0d)
precoVenda(scale:2, min:0d)
quantidade(min: 0d)
barCode(nullable:true)
observacoes(nullable:true, maxSize:300)
}
static searchable = true
String toString(){
descricao
}
}

Listagem 33. Classe de domnio Usuario.groovy __________________________________

package makeup.erp
class Usuario {
String username
String password
boolean enabled = true
boolean accountExpired = false
boolean accountLocked = false
boolean passwordExpired = false
Papel papel
static constraints = {
username blank: false, unique: true
password blank: false, password: true
enabled display: false
accountExpired display: false
accountLocked display: false
passwordExpired display: false
}
static mapping = {
password column: '`password`'
}

107

static searchable = true

Set<Papel> getAuthorities() {
UsuarioPapel.findAllByUsuario(this).collect { it.papel } as Set
}
}

Listagem 34. Classe de domnio UsuarioPapel.groovy __________________________________

package makeup.erp
import org.apache.commons.lang.builder.HashCodeBuilder
class UsuarioPapel implements Serializable {
Usuario usuario
Papel papel
boolean equals(other) {
if (!(other instanceof UsuarioPapel)) {
return false
}
other.usuario?.id == usuario?.id &&
other.papel?.id == papel?.id
}
int hashCode() {
def builder = new HashCodeBuilder()
if (usuario) builder.append(usuario.id)
if (papel) builder.append(papel.id)
builder.toHashCode()
}
static UsuarioPapel get(long usuarioId, long papelId) {
find 'from UsuarioPapel where usuario.id=:usuarioId and
papel.id=:papelId',
[usuarioId: usuarioId, papelId: papelId]
}
static UsuarioPapel create(Usuario usuario, Papel papel, boolean
flush = false) {
new UsuarioPapel(usuario: usuario, papel: papel).save(flush:
flush, insert: true)
}
static boolean remove(Usuario usuario, Papel papel, boolean flush =
false) {
UsuarioPapel instance =
UsuarioPapel.findByUsuarioAndPapel(usuario, papel)
instance ? instance.delete(flush: flush) : false
}

108

static void removeAll(Usuario usuario) {

executeUpdate 'DELETE FROM UsuarioPapel WHERE
usuario=:usuario', [usuario: usuario]
}
static void removeAll(Papel papel) {
executeUpdate 'DELETE FROM UsuarioPapel WHERE papel=:papel',
[papel: papel]
}
static mapping = {
id composite: ['papel', 'usuario']
version false
}
}

Listagem 35. Classe de domnio Venda.groovy __________________________________

package makeup.erp
import org.apache.commons.collections.FactoryUtils
import org.apache.commons.collections.list.LazyList
class Venda {
double
double
double
double
double

valorTotal
desconto
valorAPagar
valorRecebido
troco

String formaPagamento
Cliente cliente
Date dateCreated
static hasMany = [itens:ItemVenda]
List itens

static constraints = {
cliente(nullable: true)
itens()
valorTotal(scale:2, min:0d)
formaPagamento(inList:["Carto","Cheque","Dinheiro"],
nullable:false)
}
static searchable = {
itens component:true
cliente component:true
}
}

109

Os controladores do sistema makeup-erp.

Listagem 36. Controlador ClienteController.groovy __________________________________
package makeup.erp
class ClienteController {
def scaffold = Cliente
def search = {
def query = params.q
if(query){
def srchResults = Cliente.search('*'+query+'*')
render(view: "list",
model: [clienteInstanceList:srchResults.results,
clienteInstanceTotal:srchResults.total])
}else{
redirect(action: "list")
}
}
}

Listagem 37. Controlador ItemDevolucaoController.groovy

__________________________________

package makeup.erp
class ItemDevolucaoController {
def scaffold = ItemDevolucao
}

Listagem 38. Controlador ItemVendaController.groovy __________________________________

package makeup.erp
class ItemVendaController {
def scaffold = ItemVenda
}

Listagem 39. Controlador DevolucaoController.groovy __________________________________

package makeup.erp
class DevolucaoController {
static allowedMethods = [save: "POST", update: "POST", delete:
"POST"]

110

def index = {
redirect(action: "list", params: params)
}
def list = {
params.max = Math.min(params.max ? params.int('max') : 10, 100)
[devolucaoInstanceList: Devolucao.list(params),
devolucaoInstanceTotal: Devolucao.count()]
}
def search = {
def query = params.q
if(query){
def srchResults = Devolucao.search('*'+query+'*')
render(view: "list",
model: [vendaInstanceList:srchResults.results,
vendaInstanceTotal:srchResults.total])
}else{
redirect(action: "list")
}
}
def create = {
def devolucaoInstance = new Devolucao()
devolucaoInstance.properties = params
return [devolucaoInstance: devolucaoInstance]
}
def save = {
def devolucaoInstance = new Devolucao(params)
adicionarItens(devolucaoInstance, params)
if (devolucaoInstance.save(flush: true)) {
flash.message = "${message(code: 'default.created.message',
args: [message(code: 'devolucao.label', default: 'Devolucao'),
devolucaoInstance.id])}"
redirect(action: "show", id: devolucaoInstance.id)
}
else {
render(view: "create", model: [devolucaoInstance:
devolucaoInstance])
}
}
def adicionarItens(devolucao, params) {
def itemCount = params["produtoCount"].toInteger()
def success = true
for (int i = 0; i < itemCount; i++) {
def itemArr = params["itensVenda[" + i + "]"]
if ( itemArr != null) {
Produto produto =
Produto.get(itemArr.produto.toInteger())

111

ItemDevolucao itemDevolucao = new

ItemDevolucao(itemArr)
itemDevolucao.devolucao = devolucao
itemDevolucao.produto = produto
itemDevolucao.sequencia = i
def quantidadeAnterior = produto.quantidade
def novaQuantidade = quantidadeAnterior +
itemDevolucao.quantidade
produto.quantidade = novaQuantidade
produto.save();
devolucao.addToItens(itemDevolucao)
}
}
}
def show = {
def devolucaoInstance = Devolucao.get(params.id)
if (!devolucaoInstance) {
flash.message = "${message(code: 'default.not.found.message',
args: [message(code: 'devolucao.label', default: 'Devolucao'),
params.id])}"
redirect(action: "list")
}
else {
[devolucaoInstance: devolucaoInstance]
}
}
def edit = {
def devolucaoInstance = Devolucao.get(params.id)
if (!devolucaoInstance) {
flash.message = "${message(code: 'default.not.found.message',
args: [message(code: 'devolucao.label', default: 'Devolucao'),
params.id])}"
redirect(action: "list")
}
else {
return [devolucaoInstance: devolucaoInstance]
}
}
def update = {
def devolucaoInstance = Devolucao.get(params.id)
if (devolucaoInstance) {
if (params.version) {
def version = params.version.toLong()
if (devolucaoInstance.version > version) {
devolucaoInstance.errors.rejectValue("version",
"default.optimistic.locking.failure", [message(code: 'devolucao.label',

112

default: 'Devolucao')] as Object[], "Another user has updated this

Devolucao while you were editing")
render(view: "edit", model: [devolucaoInstance:
devolucaoInstance])
return
}
}
devolucaoInstance.properties = params
if (!devolucaoInstance.hasErrors() &&
devolucaoInstance.save(flush: true)) {
flash.message = "${message(code:
'default.updated.message', args: [message(code: 'devolucao.label', default:
'Devolucao'), devolucaoInstance.id])}"
redirect(action: "show", id: devolucaoInstance.id)
}
else {
render(view: "edit", model: [devolucaoInstance:
devolucaoInstance])
}
}
else {
flash.message = "${message(code: 'default.not.found.message',
args: [message(code: 'devolucao.label', default: 'Devolucao'),
params.id])}"
redirect(action: "list")
}
}
def delete = {
def devolucaoInstance = Devolucao.get(params.id)
if (devolucaoInstance) {
try {
def transactionError = false
Devolucao.withTransaction() { status ->
Iterator<ItemDevolucao> iterator =
devolucaoInstance.itens.iterator()
while (iterator.hasNext()) {
ItemDevolucao itemDevolucao =
iterator.next();
def quantidadeAnterior =
itemDevolucao.produto.quantidade
def quantidadeNova = quantidadeAnterior
- itemDevolucao.quantidade
if (quantidadeNova < 0) {
status.setRollbackOnly()
flash.message = "Quantidade
insfuciente para o produto " + itemDevolucao.produto.descricao +"."

113

redirect(action: "show", id:

params.id)
transactionError = true
return
}
itemDevolucao.produto.quantidade =
quantidadeNova
itemDevolucao.produto.save()
iterator.remove()
itemDevolucao.delete(flush:true)
}
}
if (transactionError) {
return
}
devolucaoInstance.delete(flush: true)
flash.message = "${message(code:
'default.deleted.message', args: [message(code: 'devolucao.label', default:
'Devolucao'), params.id])}"
redirect(action: "list")
}
catch (org.springframework.dao.DataIntegrityViolationException
e) {
flash.message = "${message(code:
'default.not.deleted.message', args: [message(code: 'devolucao.label',
default: 'Devolucao'), params.id])}"
redirect(action: "show", id: params.id)
}
}
else {
flash.message = "${message(code: 'default.not.found.message',
args: [message(code: 'devolucao.label', default: 'Devolucao'),
params.id])}"
redirect(action: "list")
}
}
}

Listagem 40. Controlador ProdutoController.groovy __________________________________

package makeup.erp
import grails.converters.JSON;
class ProdutoController {

114

def scaffold = Produto

def produtoByBarCode = {
def produto = Produto.findByBarCode(params.barCode)
def produtoId = produto == null ? null : produto.id
render(contentType:"application/json", text:"${produtoId}")
}
def produtoById = {
def produto = Produto.findById(params.idProduto)
render produto as JSON
}
def search = {
def query = params.q
if(query){
def srchResults = Produto.search('*'+query+'*')
render(view: "list",
model: [produtoInstanceList:srchResults.results,
produtoInstanceTotal:srchResults.total])
}else{
redirect(action: "list")
}
}
}

Listagem 41. Controlador UsuarioController.groovy __________________________________

package makeup.erp
class UsuarioController {
def scaffold = Usuario
def springSecurityService
static allowedMethods = [save: "POST", update: "POST", delete:
"POST"]
def index = {
redirect(action: "list", params: params)
}
def list = {
params.max = Math.min(params.max ? params.int('max') : 10, 100)
[usuarioInstanceList: Usuario.list(params), usuarioInstanceTotal:
Usuario.count()]
}
def search = {
def query = params.q
if(query){
def srchResults = Usuario.search('*'+query+'*')

115

render(view: "list",
model: [usuarioInstanceList:srchResults.results,
usuarioInstanceTotal:srchResults.total])
}else{
redirect(action: "list")
}
}
def create = {
def usuarioInstance = new Usuario()
usuarioInstance.properties = params
return [usuarioInstance: usuarioInstance]
}
def save = {
def usuarioInstance = new Usuario(params)
usuarioInstance.password =
springSecurityService.encodePassword(usuarioInstance.password)
if (usuarioInstance.save(flush: true)) {
if
(!usuarioInstance.authorities.contains(usuarioInstance.papel)) {
UsuarioPapel.create usuarioInstance,
usuarioInstance.papel
}
flash.message = "${message(code: 'default.created.message',
args: [message(code: 'usuario.label', default: 'Usuario'),
usuarioInstance.id])}"
redirect(action: "show", id: usuarioInstance.id)
}
else {
render(view: "create", model: [usuarioInstance:
usuarioInstance])
}
}
def show = {
def usuarioInstance = Usuario.get(params.id)
if (!usuarioInstance) {
flash.message = "${message(code: 'default.not.found.message',
args: [message(code: 'usuario.label', default: 'Usuario'), params.id])}"
redirect(action: "list")
}
else {
[usuarioInstance: usuarioInstance]
}
}
def edit = {
def usuarioInstance = Usuario.get(params.id)
if (!usuarioInstance) {

116

flash.message = "${message(code: 'default.not.found.message',

args: [message(code: 'usuario.label', default: 'Usuario'), params.id])}"
redirect(action: "list")
}
else {
return [usuarioInstance: usuarioInstance]
}
}
def update = {
def usuarioInstance = Usuario.get(params.id)
if (usuarioInstance) {
if (params.version) {
def version = params.version.toLong()
if (usuarioInstance.version > version) {
usuarioInstance.errors.rejectValue("version",
"default.optimistic.locking.failure", [message(code: 'usuario.label',
default: 'Usuario')] as Object[], "Another user has updated this Usuario
while you were editing")
render(view: "edit", model: [usuarioInstance:
usuarioInstance])
return
}
}
Papel papelAntigo = usuarioInstance.papel
def senhaAntiga = usuarioInstance.password
usuarioInstance.properties = params
if (!senhaAntiga.equals(usuarioInstance.password)) {
usuarioInstance.password =
springSecurityService.encodePassword(usuarioInstance.password)
}
if (!usuarioInstance.hasErrors() &&
usuarioInstance.save(flush: true)) {
if
(!usuarioInstance.authorities.contains(usuarioInstance.papel)) {
UsuarioPapel.create usuarioInstance,
usuarioInstance.papel
}
if
(!usuarioInstance.authorities.contains(papelAntigo)) {
UsuarioPapel.remove usuarioInstance,
papelAntigo
}
flash.message = "${message(code:
'default.updated.message', args: [message(code: 'usuario.label', default:
'Usuario'), usuarioInstance.id])}"

117

redirect(action: "show", id: usuarioInstance.id)

}
else {
render(view: "edit", model: [usuarioInstance:
usuarioInstance])
}
}
else {
flash.message = "${message(code: 'default.not.found.message',
args: [message(code: 'usuario.label', default: 'Usuario'), params.id])}"
redirect(action: "list")
}
}
def delete = {
def usuarioInstance = Usuario.get(params.id)
if (usuarioInstance) {
try {
usuarioInstance.delete(flush: true)
flash.message = "${message(code:
'default.deleted.message', args: [message(code: 'usuario.label', default:
'Usuario'), params.id])}"
redirect(action: "list")
}
catch (org.springframework.dao.DataIntegrityViolationException
e) {
flash.message = "${message(code:
'default.not.deleted.message', args: [message(code: 'usuario.label',
default: 'Usuario'), params.id])}"
redirect(action: "show", id: params.id)
}
}
else {
flash.message = "${message(code: 'default.not.found.message',
args: [message(code: 'usuario.label', default: 'Usuario'), params.id])}"
redirect(action: "list")
}
}
}

Listagem 42. Controlador VendaController.groovy __________________________________

package makeup.erp
class VendaController {
static allowedMethods = [save: "POST", update: "POST", delete:
"POST"]
def index = {
redirect(action: "list", params: params)

118

}
def list = {
params.max = Math.min(params.max ? params.int('max') : 10, 100)
[vendaInstanceList: Venda.list(params), vendaInstanceTotal:
Venda.count()]
}
def search = {
def query = params.q
if(query){
def srchResults = Venda.search('*'+query+'*')
render(view: "list",
model: [vendaInstanceList:srchResults.results,
vendaInstanceTotal:srchResults.total])
}else{
redirect(action: "list")
}
}
def create = {
def vendaInstance = new Venda()
vendaInstance.properties = params
return [vendaInstance: vendaInstance]
}
def save = {
def vendaInstance = new Venda(params)
def adicionouSucesso = true
Venda.withTransaction() { status ->
adicionouSucesso = adicionarItens(vendaInstance, params)
if (!adicionouSucesso) {
status.setRollbackOnly();
}
}
if (adicionouSucesso && vendaInstance.save(flush: true)) {
flash.message = "${message(code: 'default.created.message',
args: [message(code: 'venda.label', default: 'Venda'), vendaInstance.id])}"
redirect(action: "show", id: vendaInstance.id)
}
else {
render(view: "create", model: [vendaInstance: vendaInstance])
}
}
def adicionarItens(venda, params) {
def itemCount = params["produtoCount"].toInteger()
def success = true
for (int i = 0; i < itemCount; i++) {
def itemArr = params["itensVenda[" + i + "]"]

119

if ( itemArr != null) {
Produto produto =
Produto.get(itemArr.produto.toInteger())
ItemVenda itemVenda = new ItemVenda(itemArr)
itemVenda.venda = venda
itemVenda.produto = produto
itemVenda.sequencia = i
def quantidadeAnterior = produto.quantidade
def novaQuantidade = quantidadeAnterior itemVenda.quantidade
if (novaQuantidade < 0) {
venda.errors.rejectValue("itens", "Produto "
+ produto.descricao + " com quantidade insuficiente. Existem " +
quantidadeAnterior + " unidades desse produto em estoque.")
success = false
} else {
produto.quantidade = novaQuantidade
produto.save();
}
venda.addToItens(itemVenda)
}
}
return success
}
def show = {
def vendaInstance = Venda.get(params.id)
if (!vendaInstance) {
flash.message = "${message(code: 'default.not.found.message',
args: [message(code: 'venda.label', default: 'Venda'), params.id])}"
redirect(action: "list")
}
else {
[vendaInstance: vendaInstance]
}
}
def edit = {
def vendaInstance = Venda.get(params.id)
if (!vendaInstance) {
flash.message = "${message(code: 'default.not.found.message',
args: [message(code: 'venda.label', default: 'Venda'), params.id])}"
redirect(action: "list")
}
else {
return [vendaInstance: vendaInstance]
}
}

120

def update = {
def vendaInstance = Venda.get(params.id)
if (vendaInstance) {
if (params.version) {
def version = params.version.toLong()
if (vendaInstance.version > version) {
vendaInstance.errors.rejectValue("version",
"default.optimistic.locking.failure", [message(code: 'venda.label',
default: 'Venda')] as Object[], "Another user has updated this Venda while
you were editing")
render(view: "edit", model: [vendaInstance:
vendaInstance])
return
}
}
vendaInstance.properties = params
if (!vendaInstance.hasErrors() && vendaInstance.save(flush:
true)) {
flash.message = "${message(code:
'default.updated.message', args: [message(code: 'venda.label', default:
'Venda'), vendaInstance.id])}"
redirect(action: "show", id: vendaInstance.id)
}
else {
render(view: "edit", model: [vendaInstance:
vendaInstance])
}
}
else {
flash.message = "${message(code: 'default.not.found.message',
args: [message(code: 'venda.label', default: 'Venda'), params.id])}"
redirect(action: "list")
}
}
def delete = {
def vendaInstance = Venda.get(params.id)
if (vendaInstance) {
try {
Iterator<ItemVenda> iterator =
vendaInstance.itens.iterator()
while (iterator.hasNext()) {
ItemVenda itemVenda = iterator.next()
itemVenda.produto.quantidade +=
itemVenda.quantidade
itemVenda.produto.save()
iterator.remove()
itemVenda.delete()
}

121

vendaInstance.delete(flush: true)
flash.message = "${message(code:
'default.deleted.message', args: [message(code: 'venda.label', default:
'Venda'), params.id])}"
redirect(action: "list")
}
catch (org.springframework.dao.DataIntegrityViolationException
e) {
flash.message = "${message(code:
'default.not.deleted.message', args: [message(code: 'venda.label', default:
'Venda'), params.id])}"
redirect(action: "show", id: params.id)
}
}
else {
flash.message = "${message(code: 'default.not.found.message',
args: [message(code: 'venda.label', default: 'Venda'), params.id])}"
redirect(action: "list")
}
}
}

Listagem 43. Controlador LoginController.groovy __________________________________

import grails.converters.JSON
import javax.servlet.http.HttpServletResponse
import org.codehaus.groovy.grails.plugins.springsecurity.SpringSecurityUtils
import org.springframework.security.authentication.AccountExpiredException
import org.springframework.security.authentication.CredentialsExpiredException
import org.springframework.security.authentication.DisabledException
import org.springframework.security.authentication.LockedException
import org.springframework.security.core.context.SecurityContextHolder as SCH
import org.springframework.security.web.WebAttributes
import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter
class LoginController {
/**
* Dependency injection for the authenticationTrustResolver.
*/
def authenticationTrustResolver
/**
* Dependency injection for the springSecurityService.
*/
def springSecurityService
/**

122

* Default action; redirects to 'defaultTargetUrl' if logged in,

/login/auth otherwise.
*/
def index = {
if (springSecurityService.isLoggedIn()) {
redirect uri:
SpringSecurityUtils.securityConfig.successHandler.defaultTargetUrl
}
else {
redirect action: auth, params: params
}
}
/**
* Show the login page.
*/
def auth = {
def config = SpringSecurityUtils.securityConfig
if (springSecurityService.isLoggedIn()) {
redirect uri: config.successHandler.defaultTargetUrl
return
}
String view = 'auth'
String postUrl =
"${request.contextPath}${config.apf.filterProcessesUrl}"
render view: view, model: [postUrl: postUrl,
rememberMeParameter:
config.rememberMe.parameter]
}
/**
* Login page for users with a remember-me cookie but accessing a
IS_AUTHENTICATED_FULLY page.
*/
def full = {
def config = SpringSecurityUtils.securityConfig
render view: 'auth', params: params,
model: [hasCookie:
authenticationTrustResolver.isRememberMe(SCH.context?.authentication),
postUrl:
"${request.contextPath}${config.apf.filterProcessesUrl}"]
}
/**
* Callback after a failed login. Redirects to the auth page with a
warning message.
*/
def authfail = {

123

def username =
session[UsernamePasswordAuthenticationFilter.SPRING_SECURITY_LAST_USERNAME_
KEY]
String msg = ''
def exception = session[WebAttributes.AUTHENTICATION_EXCEPTION]
if (exception) {
if (exception instanceof AccountExpiredException) {
msg =
SpringSecurityUtils.securityConfig.errors.login.expired
}
else if (exception instanceof
CredentialsExpiredException) {
msg =
SpringSecurityUtils.securityConfig.errors.login.passwordExpired
}
else if (exception instanceof DisabledException) {
msg =
SpringSecurityUtils.securityConfig.errors.login.disabled
}
else if (exception instanceof LockedException) {
msg =
SpringSecurityUtils.securityConfig.errors.login.locked
}
else {
msg =
SpringSecurityUtils.securityConfig.errors.login.fail
}
}
if (springSecurityService.isAjax(request)) {
render([error: msg] as JSON)
}
else {
flash.message = msg
redirect action: auth, params: params
}
}
/**
* The Ajax success redirect url.
*/
def ajaxSuccess = {
render([success: true, username:
springSecurityService.authentication.name] as JSON)
}
/**
* The Ajax denied redirect url.
*/
def ajaxDenied = {
render([error: 'access denied'] as JSON)
}
}

124

Listagem 44. Controlador LogoutController.groovy __________________________________

import
org.codehaus.groovy.grails.plugins.springsecurity.SpringSecurityUtils
class LogoutController {
/**
* Index action. Redirects to the Spring security logout uri.
*/
def index = {
// TODO put any pre-logout code here
redirect uri:
SpringSecurityUtils.securityConfig.logout.filterProcessesUrl //
'/j_spring_security_logout'
}
}

Os arquivos de configurao do sistema makeup-erp.

Listagem 45. Arquivo de configurao BootStrap.groovy ____________________________
import
import
import
import

advogasystem.Cliente;
seguranca.Papel;
seguranca.Usuario;
seguranca.UsuarioPapel;

import grails.util.GrailsUtil;

class BootStrap {
def springSecurityService
def init = { servletContext ->

def userRole = Papel.findByAuthority('ROLE_USUARIO') ?: new

Papel(authority: 'ROLE_USUARIO').save(failOnError: true)
def adminRole = Papel.findByAuthority('ROLE_ADMIN') ?: new
Papel(authority: 'ROLE_ADMIN').save(failOnError: true)
def adminUser = Usuario.findByUsername('admin') ?: new Usuario(
username: 'admin',
password:
springSecurityService.encodePassword('admin'),
papel: adminRole,
enabled: true).save(failOnError: true)
if (!adminUser.authorities.contains(adminRole)) {
UsuarioPapel.create adminUser, adminRole
}

125

}
def destroy = {
}
}

Listagem 46. Arquivo de configurao BuildConfig.groovy ____________________________

grails.project.class.dir = "target/classes"
grails.project.test.class.dir = "target/test-classes"
grails.project.test.reports.dir = "target/test-reports"
//grails.project.war.file = "target/${appName}-${appVersion}.war"
grails.project.dependency.resolution = {
// inherit Grails' default dependencies
inherits("global") {
// uncomment to disable ehcache
// excludes 'ehcache'
}
log "warn" // log level of Ivy resolver, either 'error', 'warn',
'info', 'debug' or 'verbose'
repositories {
grailsPlugins()
grailsHome()
grailsCentral()
// uncomment the below to enable remote dependency resolution
// from public Maven repositories
//mavenLocal()
//mavenCentral()
//mavenRepo "http://snapshots.repository.codehaus.org"
//mavenRepo "http://repository.codehaus.org"
//mavenRepo "http://download.java.net/maven/2/"
//mavenRepo "http://repository.jboss.com/maven2/"
}
dependencies {
// specify dependencies here under either 'build', 'compile',
'runtime', 'test' or 'provided' scopes eg.
// runtime 'mysql:mysql-connector-java:5.1.13'
}
}

Listagem 47. Arquivo de configurao Config.groovy ________________________________

import grails.plugins.springsecurity.SecurityConfigType
// locations to search for config files that get merged into the main
config
// config files can either be Java properties files or ConfigSlurper
scripts
// grails.config.locations = [ "classpath:${appName}-config.properties",
//
"classpath:${appName}-config.groovy",
//
"file:${userHome}/.grails/${appName}config.properties",

126

//
config.groovy"]

"file:${userHome}/.grails/${appName}-

// if(System.properties["${appName}.config.location"]) {
//
grails.config.locations << "file:" +
System.properties["${appName}.config.location"]
// }
grails.project.groupId = appName // change this to alter the default
package name and Maven publishing destination
grails.mime.file.extensions = true // enables the parsing of file
extensions from URLs into the request format
grails.mime.use.accept.header = false
grails.mime.types = [ html: ['text/html','application/xhtml+xml'],
xml: ['text/xml', 'application/xml'],
text: 'text/plain',
js: 'text/javascript',
rss: 'application/rss+xml',
atom: 'application/atom+xml',
css: 'text/css',
csv: 'text/csv',
all: '*/*',
json: ['application/json','text/json'],
form: 'application/x-www-form-urlencoded',
multipartForm: 'multipart/form-data'
]
grails.plugins.springsecurity.securityConfigType =
SecurityConfigType.InterceptUrlMap
grails.plugins.springsecurity.interceptUrlMap = [
'/logout/**':
['IS_AUTHENTICATED_ANONYMOUSLY'],
'/login/**':
['IS_AUTHENTICATED_ANONYMOUSLY'],
'/j_spring_security_check/**':
['IS_AUTHENTICATED_ANONYMOUSLY'],
'/js/**':
['IS_AUTHENTICATED_ANONYMOUSLY'],
'/css/**': ['IS_AUTHENTICATED_ANONYMOUSLY'],
'/images/**': ['IS_AUTHENTICATED_ANONYMOUSLY'],
'/usuario/*': ['ROLE_ADMIN', 'IS_AUTHENTICATED_FULLY'],
'/jasper/*': ['ROLE_ADMIN', 'IS_AUTHENTICATED_FULLY'],
'/movimentacao/*': ['ROLE_ADMIN', 'IS_AUTHENTICATED_FULLY'],
'/produto/edit/*': ['ROLE_ADMIN', 'IS_AUTHENTICATED_FULLY'],
'/produto/create/*': ['ROLE_ADMIN', 'IS_AUTHENTICATED_FULLY'],
'/**':
['IS_AUTHENTICATED_REMEMBERED']
]
// URL Mapping Cache Max Size, defaults to 5000
//grails.urlmapping.cache.maxsize = 1000
// The default codec used to encode data with ${}
grails.views.default.codec = "none" // none, html, base64
grails.views.gsp.encoding = "UTF-8"
grails.converters.encoding = "UTF-8"
// enable Sitemesh preprocessing of GSP pages
grails.views.gsp.sitemesh.preprocess = true
// scaffolding templates configuration

127

grails.scaffolding.templates.domainSuffix = 'Instance'
// Set to false to use the new Grails 1.2 JSONBuilder in the render method
grails.json.legacy.builder = false
// enabled native2ascii conversion of i18n properties files
grails.enable.native2ascii = true
// whether to install the java.util.logging bridge for sl4j. Disable for
AppEngine!
grails.logging.jul.usebridge = true
// packages to include in Spring bean scanning
grails.spring.bean.packages = []
// request parameters to mask when logging exceptions
grails.exceptionresolver.params.exclude = ['password']
// set per-environment
environments {
production {
grails.serverURL
}
development {
grails.serverURL
}
test {
grails.serverURL
}

serverURL stem for creating absolute links

= "http://www.changeme.com"

= "http://localhost:8080/${appName}"

= "http://localhost:8080/${appName}"

}
// log4j configuration
log4j = {
// Example of changing the log pattern for the default console
// appender:
//
//appenders {
//
console name:'stdout', layout:pattern(conversionPattern: '%c{2}
%m%n')
//}
error

'org.codehaus.groovy.grails.web.servlet', // controllers
'org.codehaus.groovy.grails.web.pages', // GSP
'org.codehaus.groovy.grails.web.sitemesh', // layouts
'org.codehaus.groovy.grails.web.mapping.filter', // URL mapping
'org.codehaus.groovy.grails.web.mapping', // URL mapping
'org.codehaus.groovy.grails.commons', // core / classloading
'org.codehaus.groovy.grails.plugins', // plugins
'org.codehaus.groovy.grails.orm.hibernate', // hibernate

integration
'org.springframework',
'org.hibernate',
'net.sf.ehcache.hibernate'
warn

'org.mortbay.log'

128

}
// Added by the Spring Security Core plugin:
grails.plugins.springsecurity.userLookup.userDomainClassName =
'seguranca.Usuario'
grails.plugins.springsecurity.userLookup.authorityJoinClassName =
'seguranca.UsuarioPapel'
grails.plugins.springsecurity.authority.className = 'seguranca.Papel'

Listagem 48. Arquivo de configurao DataSource.groovy _____________________________

dataSource {
pooled = true
driverClassName = "org.hsqldb.jdbcDriver"
username = "sa"
password = ""
}
hibernate {
cache.use_second_level_cache = true
cache.use_query_cache = true
cache.provider_class = 'net.sf.ehcache.hibernate.EhCacheProvider'
}
// environment specific settings
environments {
development {
dataSource {
dbCreate = "create-drop" // one of 'create', 'createdrop','update'
url = "jdbc:hsqldb:mem:devDB"
}
}
test {
dataSource {
dbCreate = "update"
url = "jdbc:hsqldb:mem:testDb"
}
}
production {
dataSource {
dbCreate = "update"
url = "jdbc:hsqldb:file:prodDb;shutdown=true"
}
}
}

Listagem 49. Arquivo de configurao UrlMapping.groovy ______________________________

class UrlMappings {
static mappings = {

129

"/$controller/$action?/$id?"{
constraints {
// apply constraints here
}
}
"/"(view:"/index")
"500"(view:'/error')
"/login/$action?"(controller: "login")
"/logout/$action?"(controller: "logout")
}
}