Grails + GWT = Rock n Roll: Parte 1 - Desbravando um novo mundo

Meus amigos leitores (quantos devem ser estes leitores? deixe uma mensagem dizendo que vc é meu leitor! rs...) ... Bem vindos ao maravilhoso mundo do Rock n Roll. As bandas de rock muitas vezes são mal vistas por pessoas mais tradicionais. Outras vezes são veneradas por jovens rebeldes. Não importa. As boas bandas no final das contas só fazem uma coisa: dão um show de Rock n Roll. Mas o que é isso afinal? Sem dúvida a música é o principal produto desta fábrica rebelde. Por trás de pessoas tatuadas, cheias de brincos e roupa rasgada, por vezes alcoólatras e drogadas, bem no fundo há músicos que juntos ( e aqui está o mais importante: JUNTOS) conseguem tocar almas sedentas de Rock puro e simples. Já ouviu um bom Lynyrd Skynyrd com suas 3 guitarras, piano, batera, etc? É brincadeira o que esses caras tinham de musicalidade. Juntos eles deixam os fãs de rock embasbacados até hoje em dia.


Depois desta introdução metafórica, vou iniciar hoje uma série de posts a respeito de GWT e Grails, duas tecnologias que juntas, para mim, estão despontando como a maior banda de Rock dos últimos tempos.

Sobre o Grails todos sabem que eu acho que é simplesmente o melhor framework para desenvolvimento web na plataforma java (pelo menos daqueles que eu conheço).

Sobre o GWT (Google Web Toolkit), eu sou um mero iniciante, ou melhor, curioso. Para ser sincero, tenho ficado um pouco cansado de lidar diretamente com HTML, CSS e Javascript, principalmente com a montanha de Javascript que se lida ao desenvolver aplicações AJAX. Mesmo usando bibliotecas como jQuery, ou Prototype, mesmo assim, é muito Javascript para se lidar.

Por conta disso (e outros motivos), acho que o GWT pode ser de grande ajuda, de grande ajuda MESMO. Um dos grandes motivos também é a crença que eu estou ficando de que o GWT pode ajudar muito a se ter uma arquitetura decente também na camada View, e não apenas no model, no controller, na DAO, etc. Se formos olhando uma arquitetura de uma aplicação Grails tradicional de baixo para cima, podemos ver que:
  • - a DAO está bem resolvida,
  • - os Serviços estão lá e cumprem seu papel (de controle transacional, por exemplo),
  • - os Controllers também tem seu papel de fronteira entre o mundo HTTP e nossas regras de negócio,
  • - mas aí chega na View e facilmente a gente começa a se perder e fazer uma bagunça com HTMLs, CSSs, Styles, Javascript em arquivos .js, Javascript inline, e por aí vai.
Andei estudando um pouco de GWT para entender mais a fundo e estou começando a acreditar que ele pode ser usado para, mais facilmente, arquitetar decentemente a camada View. Por exemplo, pode-se usar um MVP (Model View Presenter) com o GWT. Alguém aí pode dizer que pode-se fazer isso também com o Javascript diretamente. Sim, até pode, mas que o GWT facilita as coisas, ah facilita. Primeiro: É JAVA! Você ganha ferramentas, refactorings, debugging, e muito mais. Ganha também o fato de que o GWT abstrai você de preocupações mundanas, como por exemplo a ofuscação e minimização do Javascript. Ele faz isso pra gente.

Então é isso galera. Vamos começar.... Vou escrever os posts de acordo com a aventura que eu mesmo estou passando. Nunca desenvolvi uma aplicação real com GWT + Grails. Então vamos desenvolver uma juntos. Será pequena, mas vamos nessa!

Entendendo o GWT

Para começar eu instalei o plugin do GWT para Eclipse. Baixei também o SDK do GWT (neste momento estou usando a versão 2.0.3 do GWT). A página que uso para download de tudo é essa: http://code.google.com/intl/en/webtoolkit/download.html

Fiz uma pequena experiência com o GWT sozinho, sem o Grails ainda. Para isso, pelo Eclipse eu criei um projeto GWT novo, usando os wizards que o plugin me dá. Ele cria um projeto já sendo executado de dentro do eclipse, tudo bonito. E esse novo projeto já tem uma pequena página de exemplo, com um diálogo modal, uma requisição Ajax e tudo mais. Tudo para você começar a entender o tal do EntryPoint, entender os Modules, os Widgets e tudo mais.

Portanto, a primeira sugestão que eu dou é essa: brincar com a aplicação nova gerada pelo plugin do Eclipse.

A primeira coisa que percebi com aplicações GWT é que tudo é AJAX. Toda a comunicação com o servidor é assíncrona. Aí, vi que a aplicação gerada pelo plugin do Eclipse tem um "layout" diferente da aplicação Grails. Então surgiu o primeiro problema: como juntar os dois mundos?

Bom, em último caso, o GWT no fundo só serve para gerar os HTMLs e Javascript. Então você pode compilar seu projeto GWT, pegar o HTML e Javascript gerado, e copiar para seu projeto Grails para a parte de web-app. Simples assim! Mas isso não seria nada produtivo.

Aí me veio a dúvida: como que as pessoas por aí juntam o Grails com o GWT? Elas fazem um projeto GWT e outro Grails, e depois juntam de alguma forma (com maven por exemplo)? Ou vai tudo num projeto só?

E mais: se forem dois projetos distintos, como lidar com a Same Origin Policy (SOP)?

E vi que realmente tem gente que usa a primeira forma, e gente que usa a segunda. E tudo gente de respeito por aí. Por exemplo, eu gosto muito o Matt Raible. Desde meus tempos de AppFuse eu sou fã dele. Aprendi muito com a estrutura que ele montou para o AppFuse.

E não é que o Matt Raible usa a primeira forma? Ele tem dois projetos, um GWT e outro Grails. Aí, em desenvolvimento ele deixa assim mesmo, como duas aplicações web rodando simultaneamente. E simplesmente lida com a SOP através de um Proxy espertinho na aplicação GWT. Este proxy recebe as requisições no servidor do cliente GWT, repassa para a aplicação Grails, recebe de volta a resposta desta, e repassa a mesma para o browser que tem o cliente GWT. Muito doido, mas funciona.
E em produção ele na verdade junta tudo. Ele tem lá um Maven bem esperto que faz tudo isso pra ele automaticamente, gerando um único WAR que tem a aplicação Grails e o cliente GWT. Aí simplesmente o problema do SOP desaparece.

A outra alternativa é juntar tudo desde o início numa única aplicação. Para facilitar esta tarefa, um tal de Peter Ledbrook fez o GWT Plugin para Grails (não se deixe enganar por esta página. O plugin já está na versão 0.5 e suporta GWT 2.0).

Eu, por enquanto, vou seguir este caminho mais simples (sempre gosto da simplicidade): vou usar o GWT Plugin para Grails. Parece tão simples agora......mas eu fiquei umas duas semanas até chegar a esta conclusão. E até agora queria entender porque o Matt Raible não usa o plugin. Talvez ele seja ruim por algum motivo. Se for isso, eu ainda não descobri.

Então amigo, aí vão os passos iniciais:
  • - Instalar o SDK do GWT
  • - Criar a variável de ambiente GWT_HOME apontando para a raiz do SDK do GWT
  • - Instalar o Plugin de Eclipse do GWT
  • - Criar uma aplicação pura e simples GWT usando o plugin do eclipse.
  • - Abrir a aplicação no browser usando a URL apresentada pelo Eclipse (com o parâmetro gwt.codesrv na URL - este parâmetro é que permite você alterar o código Java e imediatamente dar um refresh no browser e ver sua mudança lá).
  • - Garantir que o browser instalou o plugin de execução do GWT.
  • - Executar esta aplicação e brincar um pouco com os diferentes Layouts de GWT.
Pronto. Agora que você brincou o GWT um pouco, vamos juntar os dois ( GWT + Grails ):
  • - Criar uma nova aplicação Grails com o comando grails create-app rockgwt
  • - Vai pra dentro dela ( cd rockgwt )
  • - Instalar o plugin GWT do Grails (usando o comando grails install-plugin gwt ). Eu estou usando o grails 1.2.x e o plugin 0.5
  • - Criar um GWT Module com o comando do plugin grails create-gwt-module com.rockgwt.RockNRoll
  • - Criar a página principal do GWT para o seu Module. Eu fiz isso criando um controller do grails e uma Page index.gsp para este controller. Esta page é que irá hospedar o GWT:
  • 1) grails create-controller com.rockgwt.controller.Principal
  • 2) grails create-gwt-page principal/index.gsp com.rockgwt.RockNRoll (quando este comando te perguntar se você quer criar o Controller, diga que não, pois você acabou de criá-lo no passo anterior --- acho que o plugin não reconhece o Controller criado com package, sei lá).
  • - Compilar o seu módulo com o comando grails compile-gwt-modules (demora um pouquinho mesmo)
  • - Executar o Development Mode com o comando grails run-gwt-client Perceba que vai se abrir a janela da aplicação Development Mode do GWT
  • - Abra outro Terminal , vá para o seu projeto rockgwt e execute a aplicação grails (é isso mesmo, você terá duas coisas rodando: o grails run-app da aplicação, e o grails run-gwt-client anterior, do GWT).
  • - Abra o browser e vá para a Home da sua aplicação GWT + Grails em: http://localhost:8080/rockgwt?gwt.codesvr=127.0.0.1:9997
  • - Na verdade, pode ser que na sua máquina a porta final seja outra, não sei. Para ganrantir sucesso, basta clicar no botão Launch Default Browser existente na janela do Development Mode.
  • - O endereço que você quer acessar no final de tudo será o seu controler Principal, ou seja:
    http://localhost:8080/rockgwt/principal/index?gwt.codesvr=127.0.0.1:9997
  • - Não deixe de colocar este parâmetro maluco. Ele é o responsável por permitir que você altere o código Java e dê um refresh no browser para ver as modificações imediatamente.
Agora, abra a sua classe RockNRoll e deixe ela assim:
(esta classe se encontra no seu projeto rockgwt em src/gwt/com/rockgwt/client)

package com.rockgwt.client;

import com.google.gwt.core.client.EntryPoint;
import com.google.gwt.user.client.ui.Button;
import com.google.gwt.user.client.ui.RootPanel;

/**
* Entry point classes define <code>onModuleLoad()</code>.
*/
public class RockNRoll implements EntryPoint {
/**
* This is the entry point method.
*/
public void onModuleLoad() {

final Button sendButton = new Button("Rock n Roll");

RootPanel.get().add(sendButton);
}
}


Pronto. Dê um refresh no seu browser, e o botão "Rock n Roll" estará lá.

UPDATE (8/3/2010):
- Apenas para completar, para poder usra o Eclipse com tudo redondo, clique no botao direito do mouse em cima de src/gwt e selecione a opção Build Path > Use As Source Folder
- E por último clique com o direito do mouse em cima do projeto rockgwt e selecione a opção Google > Webtoolkit Settings, lá dentro do wizard que se abre, selecione o primeiro checkbox que aprece lá em cima "Use Google Web Toolkit". Assim você terá tudo que precisa no classpath da aplicação no Eclipse.

Até a Parte 2 desta série... Aguardo Comentários para saber se estou agradando com este tema. Abcs

8 comentários:

Edvinas 8 de março de 2010 04:35

Really nice! Thanks :) And by the way, i don't understand your language but I use google translate and it is all well readable :)

Cheers!

Kico (Henrique Lobo Weissmann) 8 de março de 2010 08:25

Conseguiu ume inspirar a estudar o GWT também. :) Tópico do caralho este! Parabéns!

Wanderson Santos 8 de março de 2010 20:52

Parabéns pelo artigo! Grails FTW!

Gilvan Albino de Souza 8 de março de 2010 22:59

Grande Felipe!
Parabéns pelo artigo, muito bom.
Com certeza poupará muitas horas de
dor de cabeça, que certamente vc teve descobrindo este caminho das pedras.

Estou esperando os próximos... rs.

Eduardo 10 de março de 2010 11:56

Grande!!!

A cada dia q passa gosto mais desse blog rsrsrs

Vlw!!!

celeraman+ 22 de março de 2010 02:02

Very nice indeed! I do the same a month ago without very sucess. I jumped into smartgwt, a really impressive custom library for GWT.

I will follow your articles about Grails+GWT and I suggest to you maybe take a look at:

http://www.cacoethes.co.uk/blog/groovyandgrails/introducing-smartgwt-to-grails

It will be great if you could include smartgwt too.

Regards!

Gregory Fontenele 22 de março de 2010 13:00

Muito bom mesmo, quando vem a parte 2?

Abraços

Fer nando Franzini 9 de abril de 2010 08:49

Muito bacana o artigo...parabéns pelo blog !!! A paz