O documento descreve o framework Grails para desenvolvimento web ágil utilizando Java e Groovy. Grails permite alta produtividade através de programação por convenção, é completo e evita repetições de código. É composto por um framework para Java e uma linguagem de script chamada Groovy.

1. GRAILS
Desenvolvimento Web Ágil
Paradigma:
“Programação por convenção”

2. O que é Grails?
 Framework para desenvolvimento de aplicações
web na plataforma Java utilizando a linguagem
Groovy, principais características:
 ALTA produtividade;
 Programação por convenção;
 Completo;
 Don’t Repeat Yourself (DRY);
Curiosidade: Inicialmente chamado de “Groovy on
Rails” até ser renomeado para Grails, após pedido do
fundador do projeto “Ruby on Rails”, David Heinemeier
Hansson.

3. Alta Produtividade
 Rapidamente você cria toda a estrutura de
sua aplicação web;
 Gera CRUD(Create, Read, Update and Delete)
com apenas alguns comandos;

4. Programação por Convenção
 Modelo de desenvolvimento de software que
busca diminuir as decisões que os
desenvolvedores precisam tomar;
 Caso o programador não queira configurar nada,
basta seguir a convenção do framework;
 Aumenta a produtividade devido ao fato do
programador não precisar se preocupar com as
configurações e sim com a lógica de negócio;

5. Completo
 Possui todos os componentes necessários
para iniciar o trabalho:

6. Don’t Repeat Yourself – Não se Repita
 Tarefas repetitivas são realizadas pelo
framework e não mais pelo
desenvolvedor

7. O que é Groovy?
 Linguagem idealizada por James
Strachan (2003)
 As primeiras versões de testes surgiram em
2004
 A primeira versão oficial (1.0) foi lançada em
2007
 A segunda versão (2.0) foi lançada em 2012

8. • Groovy: linguagem JVM com o objetivo inicial de
extender Java.
• Uso de metaprogramação
• Compila bytecode (assim como Java)
• Interoperabillidade (Java roda Groovy, Groovy roda
Java)

9. • Principais diferenças entre Groovy e Java:
• Enquanto Java tem tipos primitivos e não-primitivos,
tudo em Groovy é objeto (Object)
• Tipagem opcional (duck typing)
• Um comando numa linha não exige ponto-e-vírgula
• Return: sempre é o valor de retorno do último comando
• Conceito de verdade: qualquer valor diferente de null
• Geração dinâmica (implícita) de get() e set()

10. • Principais diferenças entre Groovy e Java
• Enquanto Java tem tipos primitivos e não-primitivos,
tudo em Groovy é objeto (Object)
• Um comando numa linha não exige ponto-e-vírgula

11. • Principais diferenças entre Groovy e Java
• Tipagem opcional (duck typing)
Duck typing: Se aje como um pato, é um pato! Quack!

12. • Principais diferenças entre Groovy e Java
• Return: sempre é o valor de retorno do último comando

13. • Principais diferenças entre Groovy e Java
• Conceito de verdade: qualquer valor diferente de null

14. • Principais diferenças entre Groovy e Java
• Geração dinâmica (implícita) de get() e set()
Java:
Groovy:

15. • E o que eu preciso fazer pra usá-lo?
• Uma versão do Java Development Kit(JDK) instalada
(não um JRE, hein!);
• A criação da variável de ambiente JAVA_HOME;
• Download do Grails;
• A criação da variável de ambiente GRAILS_HOME;
• O desenvolvimento pode ser através do prompt de
comando ou por diversas IDE, no nosso exemplo
utilizamos a IDE Groovy/Grails Tool Suite (GGTS)

16. Projeto Livraria

17. Tabelas no banco

18. Tabelas no banco

19. Criando uma aplicação
Comando: create-app livraria
IDE:

20. Estrutura Criada

21. Plugins e Dependências
 Plugin responsável por efetuar validação de campos CPF,
CNPJ e CEP

22. Configuração do Banco de Dados
Caso precise de um banco mais robusto,
alterar as linhas em vermelho no arquivo
grails-app/conf/DataSource.groovy
Adicionar o driver JDBC na
pasta grails-app/lib

23. Criando as classes de Domínio
Comando: create-domain-class livraria.Livro
IDE:
Os domínios são gerados em grails-app/domain

24. Estrutura de um domínio
Campos de Validação:

25. Estrutura de um domínio

26. Scaffolding
 Abordagem utilizada para geração de
artefatos(controladores, visões, etc) que
implementam as operações CRUD,
existem 2 abordagens:
 Scaffolding Dinâmico;
 Scaffolding Estático;

27. Scaffolding Dinâmico
 Visões são geradas em tempo de execução, facilita o
desenvolvimento pois nenhum código relacionado aos
controladores e visões precisa ser desenvolvido.
 Não útil para equipes que desejam personalizar o sistema.
Comando: create-controller livraria.Livro
IDE:
Código gerado:
Os controladores são gerados em grails-app/controller

28. Scaffolding Estático
 Produz a partir de templates, o código dos controladores e
visões que podem ser personalizados pela equipe web.
 O projeto exemplo utilizou essa abordagem pois necessitou de
algumas customizações nos controladores e visões.
Comando: generate-all livraria.Livro
IDE:
Controladores e Visões geradas:
Os controladores são gerados em grails-app/controller, as visões Groovy Server Pages(GSPs) são geradas em grails-app/
views/livro
Para cada método método correspondente a uma ação no controlador é criada uma visão (arquivo .gsp)

29. BootStrap.groovy
 Essa classe é executada durante o boot da aplicação e serve, entre outros propósitos, para
inicializar a aplicação por exemplo, criando algumas instâncias de objetos.

30. Plugins de Autenticação de Usuário e
Bibliotecas javascript
Adicionar as seguintes linhas no arquivo BuildConfig.groovy para
utilizar o plugin Grails spring-security que auxilia na autenticação
dos usuários:
Adicionar em grails-app/web-app/js os
seguintes .jar que serão utilizados para
efetuar máscaras de CEP, CNPJ e CPF

31. Controle de Acesso de Usuários
Utilizaremos o plugin spring-security-core para controle de acesso de
usuários, ele define uma série de comandos, entre eles o s2-quickstart que
cria tanto as classes de domínio básicas tantos os controladores(e suas
respectivas visões) necessários para lidar com a autenticação de usuários.
Ao executarmos o seguinte comando abaixo:
Será criada a seguinte estrutura:
• livraria.Usuario: classe de domínio que representa os usuários autenticados
• livraria.Papel: classe de domínio que representa os papéis que os usuários
podem desempenhar. Cada papel possui permissões associadas a ele.
• livraria.UsuarioPapel: classe de domínio que representa o relacionamento
muito-para-muitos entre usuário e papéis. Ou seja, um usuário pode
desempenhar vários papéis e um papel pode ser desempenhado por vários
usuários.
• LoginController e LogoutController (e suas respectivas visões) que são
responsáveis pelas operações de login e logout da aplicação.

32. Visão da página principal para
diferentes papéis de usuário
Visão Administrador Visão Cliente

33. Controle de Acesso de Usuários
Por fim adicione o seguinte trecho ao arquivo conf/Config.groovy para
habilitar a chamada HTTP, POST e GET no controlador LogoutController que
é responsável pela operação de logout.

34. Personalização dos templates
utilizados no scaffolding
 Essa personalização tem como objetivo:
 Gerar controladores e visões com
funcionalidades relacionadas ao controle
de acesso já incorporada;
 Gerar visões create.gsp e edit.gsp com
máscaras de entrada para atributo CPF

35. Personalização dos templates
utilizados no scaffolding
Comando: install-templates
IDE:

36. Personalização dos templates
utilizados no scaffolding
O comando anterior copia os templates usados nas atividades de geração de código
para o diretório src/templates. Esse diretório inclui:
 O diretório artifacts contém os templates utilizados pelos comandos create-*
(create-domain-class, create-controller, etc);
 O diretório scaffolding contém os templates utilizados pelos comandos generate-*
(generate-all, generate-controller, generate-views, etc). No contexto da nossa
aplicação apenas serão personalizados os templates presentes nesse diretório;
 O diretório testing contém os templates utilizados na geração de artefatos de teste;
 O diretório war contém o template do arquivo web.xml utilizado na geração do
arquivo deployment da aplicação (arquivo.war)

37. Template: Controller.groovy
O plugin spring-security permite a utilização da anotação @Secured para
aplicar regras de controle de acesso aos controladores( e suas respectivas
ações), o template Controller.groovy é utilizado na geração dos
controladores, ao alterá-lo, todos os controladores gerados após essa
alteração irão seguir o novo formato.
Adicionando o trecho de código em vermelho dizemos que
Para acessar um controlador, o usuário deve ter o papel ‘ROLE_ADMIN’ para
acessar todas as ações ou ‘ROLE_CLIENTE’ para acessar a ação ‘show’

38. Template create.gsp e edit.gsp
O template create.gsp e edit.gsp é utilizado na geração de visões(views) create e edit
associadas a cada um dos controladores da aplicação, modificaremos ambos para
que seja permitido construir máscaras de CPF, CNPJ e CEP utilizando o plugin jQuery
Masked Input.
Para que as visões(views) create.gsp e edit.gsp tenha a seguinte máscara:
Adiciona o seguinte trecho de código em vermelho abaixo:

39. Template: index.gsp
O template index.gsp é utilizado na geração das visões(views) associadas
c cada um dos controladores da aplicação, modificando seguinte trecho
de código em vermelho abaixo, estaremos permitindo a operação de
criação de entidades (ação create()) apenas para usuários autenticados
e que possui o papel necessário para executar essa ação.

40. Template: show.gsp
O template show.gsp é utilizado na geração das visões(views) associadas a cada um dos
controladores da aplicação, modificando seguinte trecho de código em vermelho abaixo,
estaremos realizando as seguintes modificações:
Operação create() apenas será apresentada se o usuário encontra-se autenticado e possui
papel necessário para executar essa ação:
Operação edit() e delete() apenas será apresentada se o usuário encontra-se autenticado e
possui papel necessário para executar essa ação:

41. Personalização dos templates
utilizados no scaffolding
Após realizar as alterações nos templates, é necessário executar o
comando generate-all para que as alterações sejam refletidas nos
controladores e visões da aplicação da livraria, efetuaremos o comando
nas seguintes classes de domínio:
Livro Autor Categoria

42. Mapeamento URL
Por convenção, a página principal é a que lista todos os controladores da
aplicação, iremos alterar o arquivo conf/URLMapping.groovy conforme abaixo
para que aponte para um controlador que iremos criar no próximo passo.

43. Controlador: MainController
Comando: create-controller livraria.Main
IDE:

44. Controlador: MainController
Implemente o controlador conforme imagem abaixo:
Observe que apenas usuários autenticados com os papéis de
‘Role_ADMIN e ‘ROLE_CLIENTE’ tem acesso ao controlador.

45. Controlador: MainController
Crie uma visão(view) chamada index.gsp e coloque na pasta
grails-app/views/main e edite ela de tal maneira que fique
conforme abaixo:

46. Criando usuários e papéis no
BootStrap.groovy

47. Executando a aplicação

48. Executando a aplicação
Abra no seu navegador a url: http://localhost:8080/livraria

49. Perguntas?