Para suprir essa necessidade de usabilidade tivemos que adotar alguns conceitos, como ser totalmente stateless e modificar a arquitetura MVC2 para o MVC3. No server-side trabalhamos com um domain model baseado em Hibernate, Spring e Facades e Services com DWR. Nada de frameworks MVC2, não nos preocupamos com renderização e sim com a API. No lado cliente usamos Extjs com algumas modificações que fiz para integrar de forma suave com o DWR.

Primeiro precisamos entender como o Extjs trabalha com herança. Basicamente há um método no objeto Ext que faz esse trabalho de extensão dos componentes, funciona da seguinte maneira:

//Formato:
var NovoComponente = Ext.extend(velhoComponente, { 
          /* metodos e propriedades que serão reescritas */ 
});
 
//Exemplo:
var MilfontGridPanel = Ext.extend(Ext.grid.GridPanel, {
        //novo construtor
        constructor: function(config) {
            // Seu preprocessamento vai aqui
        	MilfontGridPanel.superclass.constructor.apply(this, arguments);
            // Seu pos-processamento vai aqui
        },
 
        NovoMethod: function() {
            // algum novo método que você queira criar para o novo componente
        }
    });

Para esse projeto, criei um Ext.data.DataProxy (como visto no artigo passado) especialista para o DWR, criativamente denominado DWRProxy. A idéia é modificar o comportamento de buscar os dados para usar um Creator do DWR.

Definimos primeiro o objeto e suas propriedades necessárias:

Ext.ux.data.DWRProxy = function(dwr_facade, dwr_filter, dwr_errorHandler){
 
    Ext.ux.data.DWRProxy.superclass.constructor.call(this);
 
	/* Propriedade que receberá a classe Java configurada como Creator */
    this.data = dwr_facade;
    /*
	 * Propriedade que receberá uma classe java configurada como converter
	 * que servirá como filtro de busca
	 */
 
	this.dwr_filter = dwr_filter;
 
	/**
	 *
	 * Propriedade para fazer paginação, indica que deve cachear a consulta de
	 * total de elementos o controlador [fachada] deve implementar a logica de
	 * negocios adequada, quando for false consulta o total, quando for true
	 * consulta apenas a listagem e repete o total
	 */
 
	this.dwr_total_cache = false;
 
	this.dwr_errorHandler = dwr_errorHandler;
 
};

Após isso extendemos do Ext.data.DataProxy :

Ext.extend(Ext.ux.data.DWRProxy, Ext.data.DataProxy, {
 
    /**
     * Método Load do Ext.data.DataProxy overrided
     */
 
    load : function(params, reader, callback, scope, arg) {
 
	/**
	 * Escopo "this" mapeado para a variável "s" porque dentro do callback do
	 * DWR o escopo "this" não pertence ao objeto Ext.ux.data.DWRProxy.
	 */
 
	var s = this;
 
        params = params || {};
 
        if(params.cache != undefined) {
		this.dwr_total_cache = params.cache;
	}
 
	if(params.filter != undefined) {
		this.dwr_filter = params.filter;
	}
 
        var result;
 
        try {
		this.data(this.dwr_filter, params.start, params.limit, this.dwr_total_cache, {
			callback:function(response) {
                                //aqui passamos o retorno do DWR 
                               // que chamei de response,  para o extjs
				result = reader.readRecords(response);
				callback.call(scope, result, arg, true);
			},
			errorHandler:function(a, e) {
				scope.fireEvent("loadexception", s, arg, null, e);
				s.dwr_errorHandler(a);
			},
			timeout:100000
		});
 
		this.dwr_total_cache = true;
 
        } catch(e) {
            this.fireEvent("loadexception", this, arg, null, e);
            callback.call(scope, null, arg, false);
            return;
        }
 
    }
 
});

A fachada DWR é uma classe comum, segue um exemplo de uso com Hibernate:

//classe para satisfazer o transporte para o Extjs
public final class DataTransferObject {
    private int total;
    private List<? extends Object> results;
    //sets e gets
}
 
public class AjaxFacade {
    //injeta um repositorio, whatever
    private Repository repository = null;
 
    public DataTransferObject find(Object filter, int start, int limit, boolean cache, HttpSession session) {
        DataTransferObject dto = new DataTransferObject();
        //verifica se o Proxy está passando true 
        // indicando que está paginando
        if (cache) {
            Integer total = (Integer) session.getAttribute("totalObject");
            dto.setTotal(total);
       } else {
            session.removeAttribute("totalObject");
            Integer total = repository.count(filter);
            dto.setTotal(total);
            session.setAttribute("totalObject", total);
        }
        List<Object> retorno = (List<Object>) repository.find(filter, start, limit);
        dto.setResults(retorno);
        return dto;
    }

Para o Grid visto no artigo passado, basta instanciar assim no javscript:

var store = new Ext.data.Store({
    proxy: new Ext.ux.data.DWRProxy(
        AjaxFacade.find, 
        {$dwrClassName:"Project"}, 
        errorHandler
    ),
    reader: new Ext.data.JsonReader({
            root: 'results',totalProperty: 'total',id: 'id'
        }, 
        ['id', 'name', 'manager.name', 'manager.address.country']
    )
});

Para entender o {$dwrClassName:”Project”} visite esse post.

Dessa forma o DWR se torna um proxy para todos os componentes do Extjs.

Código fonte da modificação do javascript eu coloquei aqui no github e uma aplicação demo aqui. No próximo vou integrar o DWR com o Rails, aguardem que sai logo… ou não.

Features proprietárias são sedutoras, antigamente usávamos grids com paginação no HTML com a propriedade datasrc na tag table, podíamos ler inclusive de arquivos XML. Isso muito antes de Ajax ou até do Firefox. Evidente que só funcionava no IE.

<XML ID="users">
<?xml version="1.0" ?>
<users>
	<user id="1" name="Christiano Milfont"/>
	<user id="2" name="Rafael Ponte"/>
</users>
</XML>
 
<TABLE DATASRC="#users">
<TR>
<TD><DIV DATAFLD="id"></DIV></TD>
<TD><DIV DATAFLD="name"></DIV></TD>
</TR>
</TABLE>

Com a popularização do Firefox e a necessidade das aplicações serem CrossBrowser, tivemos que nos adaptar às specs da W3C. Praticamente todas as aplicações WEB precisaram serem reescritas -algumas até hoje ainda só “rodam” no IE.

Usar uma Feature proprietária facilita, mas no final você pagará o preço da não interoperabilidade. Agora precisamos usar um Framework Ajax para fazermos coisas que antes era nativo. No IE tínhamos até DnD.

Especificação muito mais frágil do que as implementações nos força a criar uma “Isolation Layer” como solução de refactoring sem comprometer o sistema. Podemos então usar as features nos beneficiando do que a implementação tem a oferecer sem comprometermos o resultado final, o uso fica encapsulado na solução.

Especificação mal feita

O problema é quando a definição de uma especificação fica frágil o suficiente – por problemas políticos – para forçar um refactoring profundo na mudança entre implementações.

No CEJUG, ocorreu uma thread sobre problema com data na JPA, onde eu recomendei retirar a anotação @Temporal – que já tinha me dado trabalho anteriormente – e por “feeling” eu sabia que o problema era nessa anotação, mas nunca tinha pesquisado para saber o real porquê. Como quem ganhou dinheiro com Feeling no Brasil foi apenas Morris Albert – by Cardoso – eu dei uma pesquisada sobre isso e descobri que [como escrevei no email]:

From CMilfont
to discussao@cejug.dev.java.net
date Mon, Oct 27, 2008 at 9:54 AM
subject Re: [cejug-discussao] problema com data

Dei uma pesquisada e a conclusão que cheguei é:
A spec determina que propriedades do tipo Date e Calendar [util java] devem ter a anotação @Temporal.
TopLink obriga, se não tiver lança uma exceção ValidationException [pelo menos foi o que vi na documentação dele, não cheguei a testar].
Hibernate é opcional, mas se você colocar ele devolve uma instância de Calendar, porque entende que a data é completa [como Timestamp] mesmo dizendo que o tipo é Date – aqui entendo como uma falha e vi que as issues sobre isso no projeto já foram fechadas, os últimos builds devem ter consertado, ou não.
A spec não diz que deve lançar exception mesmo dizendo “must be” então o Oracle TopLink assumiu essa responsabilidade.
Claro que essas funcionalidades devem também mudar de build para build então podem ter diferenças nas versões de builds entre os próprios implementadores, como Hibernate e TopLink mudarem da versão x.x.1 para x.x.3 por exemplo.
Coisas de spec mal escrita, JPA tem que ser urgente revista, os capítulos ficam muito ambiguos, tem trechos que você fica bastante confuso, diferente de specs como da JSE que é bastante clara.

O problema disso é que não dá para encapsular a diferença entre as implementações porque o uso dessa anotação é incompatível entre dois desses implementadores.

Outro problema da JPA é a falta de elementos básicos que um ORM deve implementar – como a Criteria – impossibilitando a troca de implementações com um simples refactoring. Tudo bem que em um Domain Model você tem como – e deve – isolar essa diferença entre Engines ORM mas em termos de Refactoring da aplicação no geral, ter que reescrever todas as buscas de uma aplicação porque a Engine não suporta Criteria pode não afetar o modelo mais trará um prejuízo enorme.

Como o Hibernate é OpenSource, maduro e anos-luz à frente até da nova especificação de JPA 2.0, a escolha dele pelos profissionais experientes é a mais adequada. Spring, é outra solução ao JEE sem EJB que permanece como indicação desde o livro do Rod Johson de 2004 que era ainda sobre EJB2, recomendava o uso de JEE sem EJB e apresentou o Spring oficialmente ao mundo. Apesar de que Spring e EJB3 estarem bem nivelados hoje em dia, Spring ainda leva uma certa vantagem, ainda mais pela maturidade e semrpe estar nos trilhos corretos, coisa que o EJB está se ajustando aos trancos e barrancos.

Em regra eu sempre recomendo o uso de especificações, mas em determinados pontos a especificação é desaconselhada e o uso direto da implementação tem suporte mais adequado. Não temos o poder de sempre escolhermos as ferramentas mais adequadas, muitas vezes a política impera – como nos órgãos públicos que são obrigados a usarem Oracle ou IBM por imposição governamental feita em um escritório na Casa Civil.

Fábio Kung publicou no blog da Caelum sobre os problemas enfrentados pelo GUJ (maior e melhor fórum sobre Java e arquitetura de software do Brasil) de quedas e lentidão. Há poucos dias o Diego Plentz também publicou sobre experiência recente, até citando o artigo do Kung e dando explicações sobre as mudanças necessárias que teve que realizar nas aplicações durante a mudança do Tomcat para o Jetty.

Na Java Magazine desse mês, edição 61, o autor OSVALDO PINALI DOEDERLEIN – no artigo denominado “WTP 3.0 – Novidades do Ganymede para desenvolvimento Java EE” – escreveu no quadro: “Glassfish? Por que não Tomcat ou JBoss?”, o seguinte sobre o Tomcat:

O projeto Apache Tomcat não me parece ir bem. O Tomcat 6 (versão atual) só teve dois builds estáveis: o release inicial de 2007 e um único update. Houve defecção de colaboradores importantes “como pessoal da Sun, realocado para o Glassfish quando este começou a levantar vôo, e para outros projetos como o LWUIT. Tecnologicamente o Tomcat parou no tempo há um par de anos. Fez a opção de reusar o APR (biblioteca de código nativo do Apache HTTPD), ao invés de investir forte no caminho “puro Java” de APIs como java.nio – opção que o Glassfish provou ser superior. Não tem havido atualizações de correção & segurança com a regularidade que considero necessária para software dessa natureza. Continuo considerando o Tomcat uma boa opção apenas para ambientes onde toda a comunicação HTTP tem que passar pelo Apache HTTPD.

….

É interessante observar que o Tomcat é o container web embutido no JBoss, e o JBoss é outro colaborador importante do projeto Tomcat. O que possivelmente indica que as dificuldades de ambos os projetos possam estar relacionadas.

Com a onda crescente do Jetty sobre a base instalada do Tomcat é possível que nos próximos meses os retardatários movam seus sistemas jogando a última pá de terra.

E vocês? Já estão usando o Jetty em alternativa ao Tomcat?

Fotos do Evento

Imagem abaixo da Triadworks (sem o Rafael Ponte que estava brilhando no palco nessa hora)

Christiano Milfont, Rafael Carneiro e Handerson Frota

Um evento que a cada mês fica mais interessante, dessa vez o tema será Anatomia do JSF – JavaServer Faces, assunto ainda não explorado nessa terras ensolaradas e portanto oportunidade imperdível.

Mais informações nesse post no blog do Rafael. Eu, Handerson Frota e Rafael Carneiro, Triadworks em peso estará presente.