[email protected]
O que é Grails?
Grails é um framework open source para a
construção de aplicações Java/JEE. Ou seja,
aplicações “enterprise” que executam em um
Web Container ou Application Server.
Por que Grails?



Baseia-se em frameworks como Rails e
Django, sendo guiado pelas mesma práticas e
princípios, como CoC (convention over
configuration) e DRY (don't repeat yourself);
É full stack e construído sobre tecnologias
maduras como Groovy, ANT, Log4J, Sitemesh,
Spring Framework e Hibernate, entre outras;
É extensível via plugins;
Por que Grails?




Dispõe de ampla variedade de plugins (já
implementados e testados) para a realização
das mais diferentes tarefas;
É compatível com a especificação JEE;
Permite a migração incremental de outras
aplicações “legado”;
Dispõe de dynamic or static scaffolding para
operações CRUD (Create, Read, Update and
Delete);
Por que Grails?

Está licenciado sob a Apache License, Version
2.0.
Criando uma aplicação
grails create-app testapp
Iniciando a aplicação
cd testapp ; grails run-app
Acessando a aplicação
Diretórios mais importantes da
aplicação

grails-app - diretório base para os artefatos Grails

conf - arquivos de configuração

controllers - web controllers (C do MVC)

domain - classes de domínio

services - camada de serviço

views - .jsp, .gsp, .ftl (V do MVC)

lib - bibliotecas de suporte (.jar)

src - classes Groovy e Java de suporte para a aplicação

scripts - Gant scripts

test - testes unitários e integrados
Criando uma classe de domínio
grails create-domain-class Trip
Modificando a classe de domínio
Modificando a classe de domínio
Gerando um controller
grails create-controller Trip
Modificando o controller para usar
scaffolding dinâmico
Modificando o controller para usar
scaffolding dinâmico
Iniciando a aplicação novamente
grails run-app
Acessando a aplicação novamente
Acessando a aplicação novamente
Adicionando mais uma propriedade
à classe de domínio
F5/Refresh no browser
Adicionando mais uma action ao
controller
Acessando a nova action criada
http://localhost:8080/testapp/trip/myList
Navegando pela aplicação
Navegando pela aplicação
Navegando pela aplicação
Adicionando obrigatoriedade à
propridade name
Agora, ao tentar cadastrar Trip sem
name
Agora, ao tentar cadastrar Trip sem
name
Gerando o controller e as views
para utilização sem scaffolding
grails generate-all testapp.Trip
Iniciando a aplicação novamente
grails run-app
E acessando a aplicação
Entendendo o controller gerado
Se abrirmos o controller novamente, podemos
entender o que acontece quando a action “save”
é invocada (botão create da tela de cadastro de
Trip).
Entendendo o controller gerado
Entendendo o controller gerado


Uma nova instância de Trip é criada a partir de
um mapa chamado “params” (esse mapa
contém todos os parâmetros e respectivos
valores enviados na requisição);
Há uma tentativa de salvar essa Trip.

Se a Trip pôde ser salva, uma mensagem de
sucesso é exibida e o usuário é
redirecionado para a action “show”;

Se a Trip não pôde ser salva, o usuário é
encaminhado para a view “create”.
Entendendo o controller gerado
Ao encaminhar para a view create, o controler
indica que o model conterá um Map com um
elemento sob a chave 'tripInstance'. Se
observarmos essa view, saberemos como esse
elemento é acessado.
No caso, a view gerada é um gsp (Groovy
Server Page), mas poderíamos usar jsp, ftl
(FreeMarker template) ou qualquer outra forma
de view suportada pelo Spring MVC.
Entendendo a view gerada
Entendendo a view gerada
Na parte marcada do create.gsp, vemos que a
grails tag g:hasErrors é usada para verificar se
há algum erro associado à tripInstance. Se
houver, a grails tag g:renderErrors é usada para
exibir a lista de erros.
É isso que gera a mensagem quando não
preenchemos o valor para o campo name.
Entendendo o controller gerado
Entendendo a view gerada
Entendendo a classe de domínio
Voltando um pouco ao controller, vemos que ele
faz uso de métodos como Trip.save(), Trip.get()
e Trip.list(). Esses são métodos dinâmicos
adicionados pelo GORM (Grails' object relational
mapping), cuja implementação padrão é feita
sobre o Hibernate.
São esses métodos que irão, eventualmente,
inserir os dados no banco de dados, alterá-los
ou consultá-los. Outro método que vale destacar
é o DomainClass.find().
Instalando e usando um plugin
Uma vez que a recomendação é que todo
acesso a dados seja feito a partir de uma classe
de serviço (que conterá a lógica de negócio de
aplicação e também garantirá a
transacionalidade da ação), mas queremos
manter a aplicação simples, vamos instalar um
plugin que torna as “actions” dos controllers
transacionais: É o transactional-controller.
Instalando e usando um plugin
grails install-plugin transactional-controller
Instalando e usando um plugin
De acordo com a documentação do plugin,
precisamos indicar as “actions” que serão
transacionais. Vamos marcar a save e a update,
ainda que, nessa aplicação de exemplo, isso
não seja realmente necessário.
Instalando e usando um plugin
Iniciando a aplicação novamente
grails run-app
Acessando a aplicação e
navegando por ela
E removendo o plugin, no caso de
“imprevistos” ;-)
grails uninstall-plugin transactional-controller
Alterando configurações específicas
de um ambiente
Agora suponha que o banco de dados de
produção não seja do mesmo tipo que o de
desenvolvimento (no caso do nosso exemplo, o
hsqldb que acompanha o Grails) ou não seja
acessado da mesma forma. Para prepararmos
nossa aplicação para produção, poderíamos (por
exemplo), incluir o driver JDBC necessário no
diretório lib e modificar a seção “production” do
arquivo DataSource.groovy.
Alterando configurações específicas
de um ambiente
Gerando o pacote (.war) para a
implantação
Uma vez que a aplicação já esteja testada
(todos os testes automáticos e manuais tenham
sido executados com sucesso) e validada,
podemos gerar o .war para ser implantado em
produção
Gerando o pacote (.war) para a
implantação
grails war
Gerando o pacote (.war) para a
implantação
Fim
Obrigado.
[email protected]