Beruflich Dokumente
Kultur Dokumente
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.
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.
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
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
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
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.
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
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.
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!); }
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.
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.
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.
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
Nesta seo sero apresentados os principais conceitos do funcionamento da linguagem Groovy que sero pontos fundamentais para a compreenso do framework Grails.
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();
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'
26
____________________________________
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.
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
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.
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
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.
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
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.
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.
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.
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:
Groovy requer a instalao do Java, por causa da sua JVM. Caso no possua o Java em sua mquina, poder encontr-lo no site15.
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.
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.
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
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.
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.
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:
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.
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
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.
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.
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.
Agora que conhecemos os recursos e as principais bibliotecas dos frameworks integrados ao Grails, vamos entender a sua arquitetura, ilustrada na Figura 5.
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.
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
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.
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.
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
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
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
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.
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
Conforme abordamos na seo 2.2.3, a estrutura e diretrios do projeto foram gerados automaticamente pelo Grails.
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.
59
Observe na Figura 12, dentro do pacote makeup.erp podemos visualizar todas as classes de domnio da nossa aplicao.
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.
Vamos
exibir
contedo
gerado
pelo
Grails
dentro
do
arquivo
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.
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
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
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.
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.
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.
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.
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:
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
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
69
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 |
__
__
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
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
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'] ]
75
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
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.
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
3.3.10
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
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.
30
http://jasperforge.org/uploads/publish/ireportwebsite/IR%20Website/ir_download.html
81
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>
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.
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.
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.
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)
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.
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
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.
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
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.
Na aba de menus clique em Help e depois na guia Dashboard. Feito isso uma nova janela ir abrir.
95
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.
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
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
103
104
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(); } }
106
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 } }
107
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 } }
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
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") } } }
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") } } }
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") } } }
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") } } }
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
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;
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 = { } }
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'
129
"/$controller/$action?/$id?"{ constraints { // apply constraints here } } "/"(view:"/index") "500"(view:'/error') "/login/$action?"(controller: "login") "/logout/$action?"(controller: "logout") } }