[links]Grails: do Groovy à Web – Parte 1
Grails: do Groovy à Web – Parte 2
Grails: do Groovy à Web – Parte 4
Grails: do Groovy à Web – Parte 5[/links] [rotulo-curso/]

[lead]De que se trata o artigo:

Veremos em detalhes um dos pilares do Grails, que é a camada de controle. Este é o componente do framework responsável por processar e responder a eventos – normalmente ações do usuário – e invocar alterações no modelo.

Para que serve:

Em um framework MVC como Grails, conhecer a camada de controle facilita a compreensão de basicamente qualquer recurso nativo ou proveniente de plugins oferecidos pela ferramenta. Além de apresentar os controladores, trataremos também do sistema de filtragem, muito utilizado na implantação de módulos de autenticação, segurança e registro de operações (logs) em aplicações web.

Em que situação o tema é útil:

O tema é útil para aqueles que estão iniciando no aprendizado do Grails. Ao tomarmos como ponto de partida a camada de controle do framework, que é considerada uma das mais complexas, o leitor poderá absorver com maior facilidade os demais recursos.

Grails do Groovy à Web – Parte 3:

Após conhecermos melhor a linguagem Groovy e termos uma visão panorâmica do Grails, iniciamos nosso aprofundamento no framework ao tratarmos da camada de controle. Além disso, abordamos os contextos disponíveis aos controladores e a configuração de filtros de requisição. [/lead]

O Grails, assim como a maior parte dos frameworks para desenvolvimento de aplicações web, é baseado no padrão MVC (vide quadro “MVC”). Neste artigo iremos abordar o C da questão, ou seja, a camada de Controle. Este é um ponto crucial de nosso aprendizado no framework, visto que a maioria dos recursos oferecidos por esta ferramenta interage com este componente direta ou indiretamente.

[nota]MVC

Apesar de parecer repetitivo, é importante descrevermos o padrão de projeto MVC, uma vez que o artigo é voltado não só para aqueles que já possuem experiência profissional como também àqueles que estão iniciando sua trajetória.

O padrão de projeto MVC tem como objetivo diminuir o acoplamento do código presente em uma aplicação que possua interface gráfica, agrupando o código em três categorias: Modelo, Visão e Controle.

O modelo consiste no núcleo da aplicação, sendo responsável pela lógica de negócio, persistência, comunicação com outros sistemas, etc. Já a visualização, como o nome sugere, representa a parte do sistema com a qual o usuário interage. Em um sistema web, a camada de visualização é constituída normalmente pelas páginas que são expostas ao usuário a partir do seu navegador web.

Entre o modelo e a visão se situa a camada de controle, responsável por orquestrar os eventos de manipulação da interface gráfica pelo usuário e traduzi-los como chamadas à lógica de negócio, armazenada na camada de modelo. Uma vez feita esta transformação, a camada de modelo irá retornar ao controlador um resultado que será direcionado à camada de visualização. O funcionamento deste padrão encontra-se ilustrado na Figura Q1.

Figura Q1. Funcionamento do MVC.

Imagine o funcionamento de uma página web qualquer: tudo se inicia na camada de visualização. Quando o usuário preenche um formulário, por exemplo, seus dados são enviados ao controlador, que os receberá e transformará em chamadas à camada de negócio (modelo). Estas chamadas são executadas pela camada de modelo que irá retornar um resultado de volta à camada de controle (controlador). Este, por sua vez, os transformará novamente (se necessário) para que sejam enviados de volta à interface com o usuário (visualização), reiniciando o ciclo.

Como pode ser observado, o MVC incentiva o reaproveitamento do código presente no modelo, uma vez que este, se bem implementado, será independente do tipo de visualização adotada. Sendo assim, é perfeitamente possível que o mesmo código desenvolvido para esta camada seja usado tanto em sistemas web como desktop, móvel, etc. [/nota]

[subtitulo]Revisitando nosso controlador de usuários[/subtitulo]

Recordando o artigo anterior, criamos o controlador responsável por gerenciar os usuários do nosso sistema com o comando grails create-controller Usuario. Como consequência, foi criado o arquivo UsuarioController.groovy, presente no diretório grails-app/controller de nossa aplicação (Listagem 1).

Listagem 1. Arquivo UsuarioController.groovy inicial.

  class UsuarioController {
    def scaffolding = Usuario
  }

Como pode ser observado, ele não nos diz muita coisa, pois estamos utilizando o scaffolding dinâmico do Grails. Para sabermos de fato como funcionam nossos controladores, iremos gerar novamente o nosso controlador utilizando o comando ...

Quer ler esse conteúdo completo? Seja um assinante e descubra as vantagens.
  • 473 Cursos
  • 10K Artigos
  • 100 DevCasts
  • 30 Projetos
  • 80 Guias
Tenha acesso completo