Grails e as novidades

Transcrição

1 _capa Grails e as novidades Novidades na versão Neste artigo vamos aprender e conhecer sobre o framework Grails. Vamos desenvolver uma aplicação para web de forma ágil, aprender sobre as convenções e as novidades introduzidas a partir da versão 2.0, e entender como funciona os plugins que facilitam muito a inclusão de novas funcionalidades e muito mais. Carlos Eduardo Zanco Batistão cezbatistao@gmail.com twitter.com/cezbatistao é bacharel em Análise de Sistemas pela PUC-Campinas/SP e pós-graduado em Desenvolvimento de Software para Web pela UFSCar/SP, trabalha com desenvolvimento web com Java há mais de 9 anos e atualmente trabalha como arquiteto e líder técnico utilizando Grails e Java, possui a certificação SCJP 5.0. Grails é um framework/plataforma open source para desenvolvimento de aplicações web através da linguagem de programação Groovy (uma linguagem de programação dinâmica orientada a objetos desenvolvida para a plataforma Java) que utiliza o paradigma de coding by convention, que essencialmente significa que o desenvolvedor precisa definir apenas aspectos não convencionais da aplicação, e o principal objetivo do Grails é ser um framework de alta produtividade para a plataforma Java, para isso ele utiliza tecnologias consagradas e consideradas maduras no mundo Java, tais como Hibernate, Spring e Tomcat. Grails isola do desenvolvedor detalhes complexos de configurações, persistência de dados e camada de apresentação. Foi inicialmente chamado de Groovy on Rails até ser renomeado para Grails, após um pedido do fundador do projeto Ruby on Rails, David Heinemeier Hansson. A versão 2.0 foi 21 \

2 lançada no dia 15/12/2011, contando várias novidades e mudanças, e recentemente foi lançada a versão Pelo roadmap do site oficial está programado três grandes realeases, sendo que dois foram no ano de 2012 e a versão 3.0 do framework prometida para 2013 ( Instalando ao Grails Primeiramente devemos ter o JDK instalado, a partir da versão 2.0 será necessária a versão 1.6 do java. Certifique-se de que a variável de ambiente JAVA_HOME está corretamente configurada. Depois vamos baixar à versão mais atual do Grails no site oficial do framework ( No momento em que escrevo este artigo a versão mais atual é a Depois de baixar descompacte em uma pasta de sua preferência. No meu caso eu coloquei em /usu/dev/grails e configurei a variável de ambiente GRAiLS_HOME. Além disso, adicionei na variável de ambiente PATH. Para validarmos a instalação basta executar o seguinte comando no prompt. grails -version E devemos ter o resultado parecido conforme a figura 1. Figura 1. Prompt mostrando a versão do Grails instalada. Colocando a mão na massa Agora vamos começar realmente o que interessa. Vamos desenvolver uma aplicação Grails para manter dados de contato telefônico, a aplicação é bem simples, mas o objetivo é mostrar o quanto é rápido o desenvolvimento de uma aplicação web e mostrar principalmente as facilidades que o Grails proporciona. Para começarmos, primeiro precisamos criar o projeto, para isso no seu diretório de workspace basta executar o seguinte comando: grails create-app AgendaGrails Quando executar o comando você terá a confirmação da criação da nossa aplicação. Depois de criado o projeto AgendaGrails vamos configurar ele para abrir na ide. No meu caso estou utilizando o intellij, mas o projeto pode ser importado nas principais ides existentes. Com isso podemos observar pela figura 2 a estrutura de diretório que o Grails define. Agora vamos entender o que cada pasta nos oferece. grails-app: contém o que realmente interessa, ou seja, a sua aplicação. 99% das classes que você venha a criar para a mesma deverão estar contidas em um dos subdiretórios presentes nesta entrada. grails-app/conf: armazena arquivos de configuração da sua aplicação, como, por exemplo, acesso a banco de dados e a configuração do Spring ou Hibernate. grails-app/controllers: todas as suas classes de controle serão incluídas neste diretório. grails-app/domain: as classes de domínio de sua aplicação (aquelas que serão persistidas no banco de dados e contém sua lógica de negócio). grails-app/i18n: recursos de internacionalização para a sua aplicação. grails-app/services: armazena os serviços de sua aplicação. O que vem a ser um serviço? Podemos utilizar um serviço para encapsularmos a lógica de negócio quando ela não se aplica a nenhum dos nossos domínios e (por favor, não as inclua (nem um pedacinho!) nos controladores). As classes de serviço são gerenciadas pelo Spring. grails-app/taglib: armazena todas as tags customizadas criadas usando o Grails (mais sobre isto em um post futuro, onde você ficará boquiaberto com a facilidade que Grails nos traz nesta tarefa). grails-app/utils: neste diretório serão armazenadas classes utilitárias para sua aplicação, como, por exemplo, codecs de strings e classes utilizadas por alguns plugins oferecidos para o Grails. grails-app/views: contém todos os arquivos GSP responsáveis por renderizar as páginas utilizadas pela sua aplicação. Cada classe de domínio possui um diretório equivalente dentro deste diretório. Suponha, por exemplo, que exista uma classe de domínio chamada Livro. Seguindo as convenções do Grails, deverá existir também (caso esta classe venha a necessitar de uma camada de visualização) um diretório chamado grails-app/views/livro. lib: neste diretório deverão ser incluídos todos os arquivos.jar referentes a bibliotecas terceirizadas que você queira utilizar, como, por exemplo, drivers JDBC, bibliotecas para geração de PDF e, principalmente, seu código legado, caso seja necessário reaproveitá-lo. scripts: caso seja necessária a criação de novos scripts para facilitar o desenvolvimento da sua aplicação, os mesmos deverão ser incluídos neste diretório. Todos os scripts usados pelo Grails são desenvolvidos usando GANT (Groovy Ant), que consiste em uma camada de abstração para o Ant feita em Groovy. src: no diretório src você pode armazenar código-fonte a ser reaproveitado por sua aplicação. / 22

3 Normalmente, consiste em código-fonte legado que não se encaixa facilmente na estrutura de diretórios propostos pelo Grails. Dentro deste diretório há dois outros: groovy e java, onde é possível armazenar código-fonte das duas linguagens. test: armazena todos os seus testes unitários, funcionais e de integração. web-app: o conteúdo estático de sua aplicação, como, por exemplo, arquivos html, imagens, css etc. Com isso podemos acessar a url indicada no prompt, no caso basta coloca-lá no seu browser favorito e podemos verificar como está a nossa aplicação, conforme a figura 3. Agora com isso vamos criar nosso primeiro domínio, que será a entidade Contato. Ao criar classes de domínio no Grails utilizamos o GORM (Grails Object Relational Mapping) sem precisarmos utilizar arquivos de configurações ou anotações nas nossas entidade de domínio. Para isso dentro da pasta do projeto, $WORKSPACE/AgendaGrails, basta executar o seguinte comando. grails create-domain-class br.com.mundoj. Contato Depois de receber a confirmação de que o domínio foi criado podemos verificar como ele ficou conforme a Listagem 1. Listagem 1. Código gerado pelo Grails na criação de um Domain. class Contato { Figura 2. Estrutura de diretórios do Grails. Agora vamos rodar a aplicação! isso mesmo apenas com o projeto criado já podemos subir a aplicação. Toda a configuração de infraestrutura da aplicação já vêm pronta para subir e gravar registros no banco de dados. Para isso agora execute o seguinte comando dentro da pasta do projeto: grails run-app Com isso veremos uma mensagem com a url para acessarmos a aplicação. Até agora ainda não tivemos que fazer nenhuma programação. Vamos fazer isso dentro do nosso domínio. Primeiramente vamos adicionar os campos que precisamos para manter um contato, vamos alterar conforme a Listagem 2, podemos notar que não foram implementados os métodos getters e setters na classe de domínio, isso não é preciso pelo fato da linguagem Groovy os adicionar dina micamente, mas caso precisemos modificar os métodos getters e setters, apenas criamos os métodos conforme a notação de JavaBeans que o Groovy começa a chamar automaticamente os métodos criados! Listagem 2. Adicionando atributos na classe Contato e implementação de constraints. class Contato { String primeironome String sobrenome String endereco Figura 3. Página inicial da aplicação AgendaGrails. 23 \

4 String complemento String bairro String cep primeironome nullable: false, blank: false sobrenome nullable: false, blank: false endereco nullable: false, blank: false complemento nullable: true bairro nullable: false, blank: false cep nullable: false Conforme a Listagem 2, a closure constraints serve para colocarmos nossas validações nos parâmetros definidos no domínio, podemos fazer vários tipos de validações que já existem no Grails. Na parte de referências está a url para verificar as constraints já existentes e também como criar a sua própria constraint. Agora vamos criar nosso próximo domínio onde vamos armazenar os números dos contatos. Para criarmos vamos utilizar um novo recurso adicionado no grails 2.0 e que está presente no grails 2.1. No prompt dentro da pasta do projeto, $WORKSPACE/ AgendaGrails, vamos executar apenas o comando grails, com isso será executado o console comand do Grails, que conta com o recurso de autocomple de comandos, conforme podemos ver na figura 4. Depois de escrever o comando create- e apertar a tecla TAB é exibido todos os comandos existentes no Grails que comecem com create- Depois executamos o comando para criar o domain class Telefone: Listagem 3. Classe Telefone depois de alterada, incluindo os parâmetros. class Telefone { String numero TipoTelefone tipo numero nullable: false, blank: false tipo nullable: false, blank: false Listagem 4. Enum TipoTelefone. public enum TipoTelefone { RESIDENCIAL, COMERCIAL, CELULAR Para fecharmos os nossos domínios precisamos apenas criar o relacionamento entre eles. Conforme a Listagem 5 que altera o domínio Contato e a Listagem 6 que altera o domínio Telefone. Listagem 5. Classe Contato com o parâmetro para hasmany para o relacionamento um-para-muitos. Figura 4. Console comand do grails com autocomplete. grails create-domain-class br.com.mundoj.contato Depois vamos alterar o nosso domínio conforme Listagem 3. Podemos notar que criamos um enum com o nome TipoTelefone, podemos verificar nosso enum na Listagem 5. Nosso enum é para identificarmos o tipo do telefone. Todo tipo de objeto que não será persistido no banco de dados deve ser criado fora da pasta domain do Grails. Então vamos criar o nosso enum dentro do diretório src/groovy, conforme Listagem 4. class Contato { String primeironome String sobrenome String endereco String complemento String bairro String cep static hasmany = [telefones: Telefone] static mapping ={ telefones cascade: all,delete-orphan primeironome nullable: false, blank: false sobrenome nullable: false, blank: false endereco nullable: false, blank: false complemento nullable: true bairro nullable: false, blank: false cep nullable: false / 24

5 Listagem 6. Classe Telefone com o parâmetro belongsto para o relacionamento um-para-muitos. class Telefone { String numero TipoTelefone tipo static belongsto = [contato: Contato] numero nullable: false, blank: false tipo nullable: false, blank: false No domínio Contato adicionamos um novo atributo, estático, com o nome hasmany sendo um atributo do tipo Map onde a key será o nome da lista de muitos no relacionamento e o value é o tipo do atributo do relacionamento definido, neste caso [telefones: Telefone].Com isso, teremos um atributo List que terá o nome telefones e o tipo será da classe Telefone. Podemos notar que a notação de Map do Groovy que a linguagem proporciona muita produtividade. Podemos notar também o atributo static mapping na classe Contato, nela podemos colocar propriedades de mapeamento do hibernate, no nosso caso dizemos que o relacionamento com telefones foi configurado à propriedade cascade para all e delete-orphan para inclusão, alteração e remoção automática do nosso domínio Contato. Para mais detalhes nas referências está a url sobre mapeamento e com as principais propridades que podem ser configuradas. Já na classe Telefone colocamos um novo atributo, também estático, com o nome belongsto que é a mesma lógica que o hasmany, mas sendo o relacionamento um, com isso no Map [contato: Contato] é criado um atributo com o nome contato da classe Contato. Agora vamos configurar nosso controle de versionamento do nosso banco de dados. Primeiramente vamos alterar o arquivo Datasource.groovy para utilizarmos o banco de dados MySQL 5.5. Vamos alterar a configuração de acesso ao banco de dados conforme a Listagem 7. Listagem 7. Alteração do arquivo DataSource.groovy para conexão com banco de dados MySQL. datasource { driverclassname = com.mysql.jdbc.driver username = grails password = url = jdbc:mysql://localhost:3306/agenda Agora vamos adicionar a dependência do driver de banco de dados MySQL para podermos conectarmos no banco. Para isso vamos abrir o arquivo BuildConfig.groovy e dentro da clousure dependencies vamos adicionar o seguinte trecho de código: runtime mysql:mysql-connector-java: Este arquivo é uma DSL para definirmos as dependências de bibliotecas e também de plugins. Estas configurações ficam definidas na clousure plugins do mesmo arquivo. Podemos ver que alguns plugins já vêm instalados por default, como, por exemplo, Hibernate, JQuery, Resources, Tomcat, Database-Migrations e Cache. Para gerarmos os arquivos de changelog, arquivos que contêm as alterações do banco de dados, primeiramente temos que executar o seguinte comando dentro da pasta do projeto, $WORKSPACE/Agenda- Grails. grails dbm-create-changelog Com isso, geramos o arquivo changelog.groovy que irá armazenar a sequência de scripts de criação e alterações do banco de dados da aplicação, depois disso podemos executar o comando: grails prod dbm-generate-gorm-changelog --add changelog-1.0.groovy Agora teremos as criações das tabelas Contato e Telefone. Podemos ver conforme a figura 5 que mostra o prompt depois de executar o comando e a pasta que foi criada dentro da nossa aplicação (grailsapp/migrations) onde será armazenado os arquivos de alteração de banco de dados. Figura 5. Comando para geração do database-migrations da aplicação e a visualização na pasta grails-app/migrations dos arquivos gerados. Podemos verificar a Listagem 8 com o código do arquivo changelog.groovy, que armazena a sequência em que serão gerados os changelogs das tabelas da aplicação e no arquivo changelog-1.0.groovy podemos verificar as alterações que serão realizadas ao arquivo ser aplicado pelo migrations. Listagem 8. Arquivo changelog.groovy com a sequência de arquivos migrations que será executado. 25 \

6 databasechangelog = { changeset(author: cezbatistao (generated), id: changelog ) { // TODO add changes and preconditions here include file: changelog-1.0.groovy Para nossa aplicação utilizar o migrations e criar nossos objetos do banco de dados, definidos nos arquivos de changelog, devemos alterar no arquivo de configuração do grails, o Config.groovy que se encontra na pasta grails-app/conf. Para isso basta adicionar o trecho da Listagem 9 no arquivo Config.groovy. Listagem 9. Configuração para toda vez que subir a aplicação seja atualizado o changelog das tabelas, caso seja necessário. grails.plugin.databasemigration.updateonstart = true grails.plugin.databasemigration.updateonstartfilenames = [ changelog.groovy ] Agora vamos demonstrar como o migrations atualiza o changelog para adicionar um novo domain. Para isso vamos criar o domínio Cidade e vamos fazer um relacionamento unidirecional com o domínio Contato. Para isso vamos executar o seguinte comando: grails create-domain-class br.com.mundoj.cidade E depois vamos alterar o domínio Cidade conforme Listagem 10. Listagem 10. Alteração do domain Cidade com os atributos e constraints. class Cidade { String nome nome nullable: false, blank: false Agora vamos alterar nosso domínio Contato incluindo o relacionamento unidirecional com o domínio Cidade. Para isso vamos adicionar no domínio Contato o seguinte trecho de código. static belongsto = [cidade: Cidade] Adicionamos apenas o belongsto para termos um relacionamento um-para-um. Agora vamos executar o comando para atualizamos o changelog: grails dbm-generate-gorm-changelog --add criacao_ tabela_cidade_relacionamentos.groovy Com isso será criado o arquivo criacao_tabela_ cidade_relacionamentos.groovy com as instruções de criação da nova tabela Cidade e o relacionamento com a tabela Contato. Agora vamos realizar os testes para garantir nossos relacionamentos, validações e também a exibição das informações dos nossos domínios. Vamos abrir a classe ContatoTests.groovy e vamos implementar nosso primeiro teste, conforme Listagem 11. Listagem 11. Código com a implementação do teste para o método tostring. import class ContatoTests { void testtostring() { def contato = new Contato(primeiroNome: Carlos E Z, sobrenome: Batistão ) assertequals Batistão, Carlos E Z, contato.tostring() Podemos verificar que estamos esperando uma situação ao chamarmos o método tostring do nosso domínio Contato, ao executarmos o seguinte teste com o comando dentro da pasta do projeto, $WORKSPACE/ AgendaGrails: grails test-app br.com.mundoj.contatotests Como não implementamos ainda o método tostring do domínio Contato, vamos receber uma mensagem de erro parecida com a figura 6. Podemos verificar também um relatório gerado pelo Grails com mais detalhes, para isso basta abrir o arquivo index. html que se encontra na pasta $WORKSPACE/ AgendaGrails/target/test-reports/html/. Agora no domínio Contato vamos adicionar o seguinte trecho de código: public String tostring() { $sobrenome, $primeironome Depois podemos executar novamente o teste e verificar que ele irá passar. Este é um teste unitário. No grails existem dois tipos de teste, unit e integration, eles ficam dentro da pasta test. Para executarmos todos os testes da aplicação basta executar o comando. / 26

7 grails test-app minified de javascript. Para saber mais sobre o plugin Resource, veja a parte de referências do artigo. Podemos notar que o arquivo de resource da nossa aplicação, ApplicationResources.groovy, foi alterado conforme Listagem 12. Listagem 12. Arquivo ApplicationResources.groovy com a configuração dos módulos de JavaScript. Figura 6. Imagem com o teste falhando. Camada de apresentação O Grails é um framework MVC também, o que significa que tem modelos, visualizações e controles para separar as responsabilidades. Os controllers podem facilmente ordenar os requests, entregar respostas, e delegá-las para visualizações que são as views. Views são as páginas, nossa camada de apresentação, no grails utilizamos arquivos com extensão GSP(- Groovy Server Page) que são semelhantes aos JSP(Java Server Page), contendo as taglibs para manipularmos os nossos objetos nos GSPs. Agora vamos para uma das grandes vantagens do Grails, o Scaffolding, graças a um comando toda a camada de apresentação é gerada, isto inclui tanto os Controllers quanto as Views, para isso basta executar o seguinte comando dentro da pasta do projeto, $WOR- KSPACE/AgendaGrails: grails generate-all br.com.mundoj.agenda.cidade E dentro da pasta grails-app/controllers será criada a classe CidadeController, e no diretório grailsapp/views é criada uma pasta com o nome do domain, no nosso será cidade e dentro dela 4 GSPs que são de create(criação), edit(edição), list(lista) e show(detalhe) do domain Cidade. Vamos também executar o comando: grails generate-all br.com.mundoj.agenda.contato Para geramos a camada de apresentação do domínio Contato, não será preciso gerar a camada de apresentação do domínio Telefone, pois ele será incluído através do próprio domínio Contato. Não vou entrar no mérito do desenvolvimento das pá ==ginas e nem nos plugins utilizados. Existem as referências no final do artigo, mas vou enfatizar apenas algumas alterações que foram adicionadas no Grails a partir da versão 2.0. Primeiramente foi que o JQuery é o plugin default de biblioteca JavaScript e o Resource plugin vêm instalado por default, este último com a possibilidade de criar módulos de JavaScripts, agrupamento de módulos JS e também a modules = { application { resource url: js/application.js editable { resource url: js/jquery.editable js meiomask { resource url: js/jquery.meio.mask.js Utilizamos aqui dois plugins do jquery, um para adicionar a funcionalidade de editable e outro para adicionar máscara nos campos. Aqui foram criados testes dos controllers para garantir os comportamentos, não irei mencionar aqui, mas deixarei como tarefa de casa o leitor verificar os testes que foram criados. Existem comentários que ajudam na explicação e finalidade nos testes. DBConsole Como último recurso que vamos abordar aqui é a adição de um Console para Banco de Dados. Para acessarmos esta funcionalidade, temos que subir a aplicação, utilizando o comando: grails run-app E acessar a seguinte url: AgendaGrails/dbconsole e com isso veremos a seguinte tela, conforme figura 7. Figura 7. Tela para se conectar no banco da aplicação. Aqui informamos os dados para se conectar no banco de dados da aplicação. Caso você tenha alguma dificuldade dos valores para serem preenchidos bas- 27 \

8 ta abrir o arquivo DataSource.groovy que lá contém todos os dados para preencher os campos desta tela. Ao se conectar no banco será algo parecido com a figura 8.Podemos ver que ele também conta com o recurso de autocomplete dos nomes das tabelas e dos campos das tabelas. Figura 8. Tela com as tabela da aplicação e o autocomplete ao preencher as queries. E por último, na figura 9, podemos ver como os resultados do select são exibidos. que já interessa: na linha 20, conforme trecho da Listagem 13. Listagem 13. Trecho de código exemplificando a nova clousure where para executarmos query no Grails. def query = Contato.where { primeironome =~ paramprimeironome?.tolowercase() && telefones.size() >= numerostelefones && cidade.id in cidades def results = query.list() if (results) { results = results.sort{it.id Podemos verificar que estamos chamando uma clousure where do nosso domain Contato, esta é uma nova forma de escrevermos queries no Grails a partir da versão 2.0, com ela fica muito mais fácil e fluente a escrita da query, como podemos observar na Listagem 13. Dentro da pasta grails-app/views/relatorio estão as views que foram criadas para gerar o relatório. Podemos verificar na figura 10 como ficou a funcionalidade do Relatório. Foram feitas também algumas alterações no CSS da aplicação, para isso foi alterada a classe de estilo main.css dentro da pasta $WORKS- PACE/AgendaGrails/web-app/css. Figura 9. Tela o select executado. Finalizando o exemplo Por último vamos criar um relatório simples, mas vamos mostrar uma nova maneira de se fazer uma query no Grails e também como instalar um plugin. Para isso vamos ter que criar um Controller, aqui vamos ter que criar ele, pois não vamos ter um domain relatório e com isso vamos ter que criar tanto o nosso Controller quanto as nossas Views. Para criar um controller basta executar o seguinte comando dentro da pasta do projeto, $WORKSPACE/AgendaGrails: grails create-controller br.com.mundoj.agenda.relatorio Não precisamos informar o sufixo na nossa classe, neste caso a palavra Controller, pois o próprio Grails fará isso para nós, com isso foi gerada a classe RelatorioController.groovy, aqui vamos ao ponto Figura 10. Tela inicial da funcionalidade de relatório. Para construirmos a tela de detalhe do Relatório foi necessária a instalação de um plugin, neste caso foi utilizado o ModalBox plugin. Com os plugins podemos adicionar novas funcionalidades à nossa aplicação sem muito esforço. Para mais detalhes nas referências está a url para entender mais sobre plugins e sobre o ModalBox plugin.para instalar o plugin é simples, basta executar o seguinte comando dentro da pasta do projeto, $WORKSPACE/AgendaGrails: grails install-plugin modalbox / 28

9 Após executar o comando veremos a confirmação de instalação realizada com sucesso. Podemos verificar no gsp report.gsp que se encontra na pasta $WORKSPACE/AgendaGrails/grails-app/views/relatorio/ como utilizar o plugin modalbox. O trecho de código da Listagem 14 como foi utilizado o plugin. Listagem 14. Trecho de código GSP com a chamada ao plugin modalbox. <modalbox:modalincludes /> <modalbox:createlink controller= Relatorio action= detail id= ${contatoinstance.id title= Detalhe width= 500 > ${fieldvalue(bean: contatoinstance, field: primeironome ) </modalbox:createlink> Primeiro importamos o plugin modalbox com a diretiva <modalbox:modalincludes /> isso fazemos logo depois da tag <body> da página report.gsp, e no link do detalhe do contato adicionamos o código para abrir o modal. Por último alteramos a classe BootStrap.groovy. O papel desta classe no Grails é para podermos incluir alguns dados no sistema e quando subirmos ele as tabelas do nosso domain já terão dados. Você pode verificar na classe BootStrap.groovy que adicionei Cidades e Contatos para podemos navegar pelas telas da aplicação, para isso basta subir a aplicação, executando o comando run-app e vamos navegar entre as páginas da nossa aplicação. Considerações Finais Podemos notar que o framework realmente agiliza o desenvolvimento de uma aplicação para web. O paradigma de programação por convenção tira muito do trabalho de configuração do desenvolvedor, fazendo com que ele realmente foque nas regras de negócios. Como fazermos um mapeamento ORM com o GORM é bem mais simples e fácil. A geração de páginas simples e com pouca alteração de css nos traz muita produtividade. Seu grande suporte de plugin vem crescendo e hoje podemos contar com uma comunidade brasileira que pode nos ajudar com dúvidas e boas práticas ( Vale a pena verificar mais a fundo a tecnologia, pois por se tratar de rodar em cima da plataforma Java trata-se de um promissor framework para os desenvolvedores. /referências > grails.org ( > The Grails Framework - Reference Documentation ( > Constrains existentes no Grails ( doc/2.0.x/ref/domain%20classes/constraints.html) > Como criar sua própria constraint ( com/2011/02/custom-grails-constraints.html) > Mais detalhes sobre o GORM (Grails ORM) ( org/doc/2.1.0/guide/gorm.html) > Mais detalhes sobe a nova closure de buscas ( grails.org/doc/2,1,0/ref/domain%20classes/where.html) > Como criar detached criterias no Grails ( doc/2.1.0/guide/single.html#detachedcriteria) > Entendendo como funciona o sistema de plugins do Grails ( Understanding a Plug-ins Structure) > Sobre o plugin Resources ( resources) > Mais sobre o plugin ModalBox ( ModalBox+Plugin) > grailsbrasil.com.br ( > dev/kico ( > jquery ( > jquery Editable Plugin ( com/jquery/7-editable-jquery-plugin.html) > jquery Plugin meiomask ( projects/meiomask/) > Grails Database Migration Plugin ( plugin/database-migration/) > Grails Resources Plugin ( resources) > Livro Grails in Action 29 \