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 COC CSS DRY EJB EL GANT GDK GDT GLS GORM GSP IDE JAR JAVA SE Java EE JCP JDK JDBC JEE JPA JRE JSP JSR JVM HTML MVC MOP MOR ORM

Application Programming Interface Convention Over Configuration Cascading Style Sheets Don't Repeat Yourself Enterprise JavaBeans Expression Language Groovy Ant Groovy Development Kit Groovy Developer Tools Groovy Language Specification Groovy Object Relational Mapping Groovy Server Pages Integrated Development Environment Java Archive Java Standard Edition Java Enterprise Edition Java Community Process Java Development Kit Java Database Connectivity Java Enterprise Edition Java Persistence API Java Runtime Environment Java Server Page Java Specification Request Java Virtual Machine HyperText Markup Language Model-View-Controller Meta-Object Protocol Mapeamento Objeto-Relacional Object-Relational Mapping

PDF POGO POJO SDK STS TCK TI URL XML

Portable Document Format Plain Old Groovy Object Plain Old Java Object Software Development Kit SpringSource Tool Suite Test Compatible Kit Tecnologia da Informao Uniform Resource Locator 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

1 2 2.1 2.1.1 2.1.2 2.1.3 2.1.4

INTRODUO ............................................................................................. 16 FUNDAMENTAO TERICA ................................................................... 18 LINGUAGEM GROOVY ............................................................................... 18 Histrico ...................................................................................................... 18 Introduo linguagem Groovy................................................................ 20 Groovy: Uma linguagem de Scripting e Dinmica................................... 24 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 2.2 2.2.1 2.2.2 2.2.3 2.2.4 Instalando o Groovy ................................................................................... 34 FRAMEWORK GRAILS ................................................................................ 35 Histrico ...................................................................................................... 36 Introduo ao Grails................................................................................... 37 Grails e sua estrutura................................................................................. 38 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 2.2.7 2.2.3 3 3.1 3.2 3.3 3.3.1 3.3.2 3.3.3 3.3.4 3.3.5 3.3.6 3.3.7 3.3.8 3.3.9 Arquitetura Grails ....................................................................................... 47 Mapeamento Objeto Relacional ................................................................ 48 Instalando o Grails ..................................................................................... 49 ESTUDO DE CASO ..................................................................................... 51 DESCRIO DO SISTEMA ......................................................................... 51 ANLISE DE REQUISITOS ......................................................................... 52 CRIANDO A APLICAO ............................................................................ 55 Criando o Projeto ....................................................................................... 56 Criando classes de domnio ...................................................................... 57 Criando os controllers(Controladores) .................................................... 59 Executando o Projeto................................................................................. 60 Validao..................................................................................................... 63 Criando o banco de dados......................................................................... 64 Configurando o Banco de dados .............................................................. 65 Personalizando a aplicao....................................................................... 68 Adicionando segurana na aplicao ...................................................... 73

3.3.10 Adicionando uma busca ............................................................................ 77 3.3.11 Internacionalizao .................................................................................... 82 3.3.12 Deploy ......................................................................................................... 84

4 5 5.1 5.2

METODOLOGIA .......................................................................................... 85 CONSIDERAES FINAIS ......................................................................... 86 TRABALHOS RELACIONADOS .................................................................. 87 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 3 4

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 o download da verso mais recente no site http://groovy.codehaus.org/Download. 2. Descompacte o arquivo baixado em um diretrio desejado em seu computador. http://groovy.codehaus.org

14

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 16

http://java.sun.com/javase/downloads/index.jsp
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 a 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' } // 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} } production { dataSource { dbCreate = "update" url = "jdbc:mysql://localhost:3306/makeuperp?autoreconnect=true"

as

erp?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 necessidade de o usurio login.

Ningum

tem

acesso,

sem

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 http://tomcat.apache.org/

34

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 Muito Eficiente

ANEXO B QUESTIONRIO 2.

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

1 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 Muito Eficiente

ANEXO C CDIGOS FONTES

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 } } // 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 'org.springframework', 'org.hibernate', 'net.sf.ehcache.hibernate' warn 'org.mortbay.log' serverURL stem for creating absolute links

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

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

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

integration

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") } }