jump to navigation

GWT (Parte 1) – Visão Geral Janeiro 4, 2007

Posted by viniciusdiniz in GWT, Java, Web.
7 comments


GWT é uma ferramenta para construção de interfaces Web mais amigáveis e rápidas. Guarde isso… interface… essa é a proposta do GWT, pelo menos por enquanto.
Tenho trabalhado e utilizado o GWT em alguns projetos. Gostaria de passar algumas lições que já aprendi com esse produto que está tão em evidência no momento.

Vou começar destacando os principais pontos que todos deveriam saber para começar a utilizar o GWT.

       

       

        1.      Tudo que você codifica em java na parte cliente, vira javascript (Ver o tópico http://loogica.wordpress.com/2006/11/30/gwt-voce-entendeu/)

    

                Como tudo da parte cliente vira javascript, é muito bom você ter uma boa noção de javascript para não querer  usar Reflection, Serialização, etc na parte cliente. Pois qualquer pessoa que conheça javascprit pode ver que não se consegue ainda fazer essas coisas com essa linguagem.

       

       

        2.      GWT é para a parte da interface do seu sistema.

       

                O GWT foi feito para facilitar e agilizar o processo de desenvolvimento das interfaces de aplicações WEB utilizando AJAX. Não é uma boa prática embutir o código de lógica do negócio nas classes do lado cliente da aplicação. É muito comum as pessoas, utilizando GWT, colocarem toda a lógica da aplicação junto com a lógica de apresentação e só utilizarem o lado servidor para executar lógicas específicas de persistência.        

                Ex: Ter toda a lógica de validação, verificação de privilégios, relacionamentos nas classes do lado cliente e só chamarem uma função  insertUser(User u); no lado servidor. Que vai ter somente a persistência desse objeto User.        

                Meu comentário sobre do post http://loogica.wordpress.com/2006/11/30/gwt-voce-entendeu/ 

                “O que acontece com isso? Perda de escalabilidade. Se você quiser integrar sua aplicação com um ambiente desktop, mobile, etc etc você terá que reescrever toda a lógica de negócio e pior, se tiver que alterá-la, vai ter que repetir a alteração para todos os ambientes, pois o GWT não se aplica a outro ambiente sem ser Web.”.        

                O problema, na minha opinião, está em tudo ser Java. Todo o código são classes Java e os desenvolvedores perdem a referência do conceito MVC. Sempre fomos acostumados a fazer os famosos códigos HTML/Javascript que correspondiam a camada de apresentação da aplicação. Com isso nunca nos preocupamos com a separação desta.

       

       

        3.      Tente entender como o produto funciona e não como utilizá-lo.       

     

                É primordial entender como as coisas são feitas no produto. Como classes Java viram javascript e tem o mesmo comportamento no browser? Como é feita a comunicação cliente/servidor? Como em um evento javascript, é transformado em uma chamada ao servidor?

                Entendendo como o produto funciona, no final, você vai saber muito bem como utilizá-lo.

       

       

        4.      Utilização e leak de memória no browser.

       

                A evolução das aplicações web está acontecendo em uma velocidade que está difícil de acompanhar. Mas não há como negar que existe uma tendência muito grande de se fazer tudo web. Hoje em dia já existem várias aplicações web que são cópias de aplicações desktop.        

                O GWT foi no ponto certo. Pegou uma área ainda meio crua no mercado que é a utilização de ajax e a construção de interfaces mais amigáveis em HTML/Javascript. Junto com isso, existe a possibilidade de organização, reaproveitamento e toda uma organização de código que antes eram bem mais complicadas de se ter.        

                Finalmente, com interfaces cada vez mais poderosas e complexas, automaticamente aumentam o consumo de memória de quem exibe essa interface, que no caso é o browser. Como no GWT tudo vira JavaScript, é bom pensar em como é feita a utilização de memória desse código. Um exemplo básico de leak de memória em javascript utilizando o IE é explicado no link http://javascript.crockford.com/memory/leak.html . Quando criarem um painel e não forem reutilizá-lo, pensem se a memória que o mesmo utiliza está sendo desalocada.        

                Experimente abrir o Firefox e deixar por um ou dois dias uma aba com o GMail aberto para você ver qual será o consumo de memória do Firefox (válido para IE, Opera, etc).

       

       

Se algo estiver equivocado, incompleto, ou se quiserem complementar, fiquem a vontade para escrever.

Essa foi a primeira parte. Vou publicar mais alguns pontos, boas práticas, bibliotecas, etc sobre GWT.

Abraços!

GWT, você entendeu? Server-side code…. Novembro 30, 2006

Posted by felipecruz in GWT, Web.
5 comments

Primeiro, como sempre, começo reclamando de alguma coisa; nesse caso é a página inicial do GWT. O que eu espero de uma página inicial de uma ferramenta é uma descrição básica:

1. O que minha ferramenta faz?

2. Como ela funciona?

 

Nada muito extenso, afinal é uma página inicial, mas na do GWT, não tem “Como ele funciona”. Depois de umas buscas no google e uns clicks(3 clicks exatamente), eu descobri como funciona e depois disso eu realmente entendi como o GWT funciona. A documentação é boa e simples, só faltou na pagina inicial uma informação que é essencial. Não é a toa que *muita* gente se enganou a respeito do GWT.

Como eu levantei as 2 informações que eu acho essenciais pra o site de uma ferramenta, eu mesmo vou responder.

1. O que o GWT faz?

É um framework que ajuda na criação de aplicações AJAX, através de um compilador que transforma código JAVA em Javascript. Você não deve se preocupar com tipo do browser, escrever javascript por exemplo. Apesar disso, em um ambiente de desenvolvimento, o código roda na Jvm, ou seja, é possível debugar o código com seu Debugger preferido. Outras features você encontra aqui: http://code.google.com/webtoolkit/overview.html

Não vou continuar muito por aqui, porque documentação é o que não falta e eu não pesquisei muito essa parte do framework. Mas da pra fazer bastante coisa como por exemplo criar um componente a partir da composição de outros.

A parte que confunde a maioria das pessoas

2. Como funciona?

Quando você escreve uma classe como as que estão nos exemplos do GWT, o código java dessa classe é compilado e vira Javascript.

Como usar então classes que não são suportadas pelo compilador(Hibernate, EJB etc..)?

Você tem que criar as classes chamadas serviços. Precisei de 3 clicks pra chegar na documentação de serviços, que devia estar lá no “Getting Started”. A arquitetura do GWT divide sua aplicação em 2 partes. Client-Side Code e Server-Side Code. O client code é o carro chefe do framework, mas você não faz nada pro mundo real sem usar o Server-Side Code, que vou chamar de SSC.

O SSC, é compilado em .class e roda no servidor. Aqui não existe absolutamente nada de cliente(no máximo um callback para chamadas assíncronas), nem javascript. Nas classes SSC, você esta livre pra usar o que você quiser, pois nessa parte da aplicação é tudo 100% Java, então provavelmente aqui você vai usar o hibernate, o EJB ou até mesmo POJOs. Como o foco do post era mais chamar a atenção para uma deficiência na documentação inicial do GWT, vou continuar explicando um pouco mais essa parte que esta distante 3 clicks de você mas é fundamental.

Como criar um Serviço?

Primeiro cria-se uma interface Client-Side que herda de RemoteService.

public interface MyService extends RemoteService {
public String myMethod(String s);
}

A interface síncrona é a versão definitiva da especificação do serviço. Qualquer implementação desse serviço no lado do servidor deve herdar de RemoteServiceServlet e implementar a interface do serviço

public class MyServiceImpl extends RemoteServiceServlet implements MyService {
public String myMethod(String s) {
return s;
}
}

Você pode ter implementações assíncronas, onde a alem da interface que herda de RemoteService, você tem uma interface correspondende para chamadas assíncronas. O sufixxo Async é *obrigatório* e para cada método na interface síncrona você deve fazer um correspondente seguindo a regra abaixo:

De:

public ReturnType methodName(ParamType1 param1, ParamType2 param2);

Para:

public void methodName(ParamType1 param1, ParamType2 param2, AsyncCallback callback);

Mais informações sobre o CallBack aqui: AsyncCallback

Agora que você já sabe criar um serviço síncrono e assíncrono, você só precisa saber como se comunicar com eles do Client-Side Code.

Para isso basta(se o serviço for síncrono):

MeuServico service = (MeuServico) GWT.create(MeuServico.class);

Se o serviço for assíncrono, veja como fazer em: Actually Making a Call . Adianto que não é muito diferente e a grosso modo, você só precisa informar ao endpoint (seu serviço) aonde esta o entryPoint (que é aonde está o código do callback).

Existem outros detalhes que você deve ler aqui Remote Procedure Calls mas nada muito extenso, como eu disse são mais detalhes.

Do aspecto de arquitetura, o pessoal do GWT exemplifica os serviços de 2 modos:

  • Como o Back-End completo da sua aplicação, ou seja, aonde está a lógica de negocio, as chamadas a outros frameworks etc..
  • Como “gateways” leves que irão ser intermediários entre o cliente e outros recursos como um cluster de servidores JEE

Esse foi o primeiro post mais técnico de vários que ainda estarão por aqui. Espero que seja útil. Duvidas, críticas e comentários, escrevam aqui ou me mandem um email felipecruz AT gmail DOT com.