Grails é um framework web baseado em MVC que utiliza a linguagem Groovy, roda sobre a JVM e visa a alta produtividade. Ele combina os principais frameworks utilizados na plataforma Java e respeita o “paradigma” Convention-over-configuration (programação por convenção).

Neste artigo, vamos ver alguns elementos da utilização do framework Grails, demonstrando algumas das principais features dele.

Conceitos

Antes de começarmos com o exemplo, é sempre bom entender um pouco dos conceitos. Vamos lá.

• Groov:  é uma linguagem orientada a objetos com tipagem dinâmica que roda na JVM. A sua sintaxe é extremamente parecida com a do Java, além disso, é possível “integrar” aplicações Java e Groovy de forma transparente. O Groovy, inclusive, simplifica a  implementação por “adicionar” as suas classes os métodos Gets e Sets, economizando tempo e esforço.

• Convention Over Configuration (programação por convenção): o CoC é um paradigma que visa a diminuir a quantidade de decisões que o desenvolvedor precisa tomar, tomando como “padrão” algo que é comumente usado, uma convenção. Se o padrão escolhido pelo framework for a configuração que o desenvolvedor precisar, este não gasta tempo tendo que alterá-la; entretanto, se ele necessitar de algo diferente, fica livre para configurar da forma que desejar.  No caso do Grails, ele assume diversas configurações, como por exemplo as de banco de dados, as de log de erro, entre outras.

• MVC: Model View Controler é um padrão utilizado no desenvolvimento de software que visa a separar a parte lógica, a parte de persistência de dados e a parte de visualização do sistema. 

Criando a nossa primeira aplicação com Grails

A aplicação que vamos criar é uma Lista de Tarefas, onde vamos registrar o nome da tarefa, o horário de início, o horário estimado de fim e se a tarefa está ou não terminada.

Não vou explicar como é feita a instalação do Grails, pois isso vai depender muito do sistema operacional que você está usando. Além disso, existem vários tutoriais que mostram exatamente isso, inclusive no próprio site do Grails. Com o Grails devidamente instalado e configurado, iremos criar nossa primeira aplicação.

Em um terminal, vá até a pasta onde deseja criar o projeto, assegure-se de que tem permissão para criar documentos e diretórios ali e digite:

grails create-app ListaTarefas

Esse comando irá gerar um grande volume de saídas, mas basicamente o que ele vai fazer é criar todos os arquivos e diretórios que serão utilizados na nossa aplicação.

A árvore de diretórios

O comando anterior gerou uma série de arquivos e diretórios para o nosso projeto, vamos analisá-los um a um.

ListaTarefas

• grails – app.
• conf – é onde fica as configurações da aplicação, como a configuração de banco (DataSource.groovy), e onde podem ser feitas as configurações de
  inicialização (bootstrap.groovy), entre outros.
• controllers – é onde fica o C do MVC, os controladores.
• domain – aqui encontra-se o M do MVC, onde ficam as classes de Domínio, ou modelos.
• i18n – arquivos inerentes à internacionalização.
• services – aqui ficariam as classes utilizadas na camada de serviços do Grails, se você for utilizá-la.
• taglib – aqui ficam as TagLibs criadas pelo usuário.
• views – é o V do MVC, as Views. Aqui ficam os templates e os arquivos “.gsp”, Groovy Server Pages utilizada para cada classe de domínio.
• layouts – aqui ficam os templates. Em Grails, templates são views incluídas em outras views.
• grails-tests – aqui ficam os testes unitários.
• lib -aqui ficam as libs externas, como por exemplo os drivers de conexão aos bancos de dados.
• src.
• groovy – aqui ficam outros códigos em groovy que não se encaixam em Domain, em Controller View ou em Service.
• java – idem ao de cima, porém para Java.
• web-app.
• css – folhas de estilo.
• images – imagens.
• js – javascript.
• WEB-INF – arquivos relacionados ao deploy.

Num primeiro momento, o diretório mais importante para nós será o grails-app.

Criando Models

No terminal que usamos para criar o projeto, vamos dar o seguinte comando:

grails create-domain-class Tarefa 

Esse comando irá criar uma classe de domínio (Model) com o nome Tarefa. Como você já sabe, essa classe poderá ser encontrada em:

 grails-app/domain/listatarefas/Tarefa.groovy

A classe criada será parecida com esta:

    package listatarefas
    class Tarefa {
        static constraints = {
       }
    }

Adicione a ela os atributos da tarefa deixando-a desta forma:

    package listatarefas
    class Tarefa {
        String nome
        Date inicio
        Date fim
        boolean terminada
        static constraints = {
        }
    }

Os tipos de dados utilizados no Groovy são os mesmos do Java, portanto eles possuem as mesmas características que você já conhece, como por exemplo o “tipo” Date que guarda tanto hora como data.

Agora, no terminal, com um comando semelhante ao anterior, iremos gerar um Controler para a classe Tarefa:

    grails create-controller Tarefa 

Nosso novo Controller pode ser encontrado no arquivo:

grails-app/control ers/listatarefas/TarefaController.groovy

O controlador gerado possui apenas a closure Index, edite o arquivo deixando-o da seguinte forma:

    package listatarefas

    class TarefaControl er {
         def scaffold = true
    }

Dessa forma estamos dizendo ao Grails para utilizar o Scaffold padrão, onde ele gera tanto as telas, quanto os métodos do Controller.

Volte ao terminal e execute o comando:

grails run-app 

Quando a saída “Server running. Browse to http://localhost:8080/ListaTarefas” aparecer, abra o seu navegador favorito e acesse o endereço indicado, uma tela parecida com esta será apresentada:

Você pode inserir, deletar, editar e tudo mais. Mas se você relembrar o que foi feito, vai perceber que não configurou em momento algum um banco de dados. Por padrão, o Grails utiliza um banco de dados HSQLDB que já vem embutido no framework, para as pretensões deste artigo, suas funcionalidades são mais que suficientes.

Controllers e Views

Até agora utilizamos o Scaffold do Grails de forma que ele gere as Views e os Controlers em “tempo de execução”. Vamos agora gerar os códigos-fonte para podermos analisá-los e modificá-los.

Entre com o comando:

grails generate-al 

Quando aparecer a mensagem “Domain Class name not specified. Please enter:”, apenas pressione enter; logo após ele irá perguntar se deseja sobrescrever os arquivos já existentes. Pressione a tecla “a” para sobrescrever todos e dê enter. Ele irá agora perguntar se deseja sobrescrever os testes, pressione “Y” e depois enter.

Abra o arquivo ListaTarefas/grails-app/controllers/listatarefas/TarefaController.groovy.

Agora o código do controler parece mais com um controlador. Ao invés de termos apenas o método index(), e o scaffold que era “automático” e escondido antes, agora está no nosso código-fonte nos diversos métodos presentes. Você pode livremente alterar esses métodos e também adicionar outros que supram a necessidade do seu sistema.

Voltando à aplicação, você deve ter reparado que no cadastro de tarefas não é possível cadastrar a hora de início e de fim das tarefas, somente a data, apesar de um atributo do tipo Date conter a data. Isso ocorre porque o gerador de código do Grails gera os campos com a precisão apenas para a data. Para deixarmos da forma que precisamos, vamos abrir o arquivo ListaTarefas/grails-app/views/tarefa/create.gsp.

Encontre a seguinte tag (por volta da linha 35):

<g:datePicker name="inicio" precision="day" value="${tarefaInstance?.inicio}"  />

Essa é uma tag própria do Grails que vai gerar os campos pra seleção de data e hora. O Grails possui diversas tags próprias, como <g:datePicker, <g:if,
<g:message, <g:each… enfim, muitas tags para simplificar o trabalho do desenvolvedor.

Edite o atributo precision da tag deixando-a da seguinte forma:

<g:datePicker name="inicio" precision="minute" value="${tarefaInstance?.inicio}"  />

Atualize a página, o resultado deve ser algo como abaixo:

Faça a mesma alteração no campo fim do arquivo create.gsp, e nos campos início e fim do edit.gsp.

Conclusão

Vimos aqui alguns aspectos básicos da utilização do framework Grails. Para um pouco mais de aprofundamento, sugiro o e-book: ‘Getting
Started with Grails‘ que pode ser baixado gratuitamente.

Existe também o fórum da comunidade Grails Brasil, que reúne bastante conteúdo em português. Também é possível encontrar diversos livros sobre a tecnologia.

Abraços e até a próxima.