Aplicações sérias em JSF usam Facelets

Não há exagero no título do post, de fato, aplicações sérias desenvolvidas em JSF deveriam utilizar Facelets. Desenvolvedores que abrem mão de todas as vantagens oferecidas por este framework estão “pisando na bola”.

Já é de conhecimento da maioria que JSF sozinho [apenas a implementação] não nos fornece os recursos necessários para desenvolver médias ou grandes aplicações webs de maneira produtiva, o framework possui vários problemas (mas qual não possui?), muitos deles são facilmente resolvidos com a adoção de algum framework ou conjunto de componentes, outros podemos resolver apenas com algum conhecimento/conceito base sobre o framework ou seguindo algumas boas práticas.

E por falar em boas práticas, certamente uma das melhores práticas -e praticamente obrigatória- é a utilização de algum framework de templating para construção das páginas, não somente em JSF, claro.

Pois se estamos trabalhando com páginas, por que então não utilizarmos algum framework para definição de templates?

Templating frameworks

Hoje existem várias opções de frameworks com essa finalidade, porém a grande maioria deles não foi desenvolvido para trabalhar com JSF, a maioria deles não foi desenvolvido para trabalhar de acordo com o ciclo de vida das requisições processadas pelo JSF. Alguns deles funcionam até bem, porém com toda certeza em determinados momentos eles te deixarão na mão.

Acredito que hoje os frameworks para definição de templates mais comuns são o Struts Tiles e o Sitemesh, ambos funcionam bem com JSF até que em algumas situações os problemas começam a surgir, problemas como perda do FacesContext, código duplicado, conflito de componentes, funcionalidades AJAX param de funcionar etc. Sendo, com certeza nem Struts Tiles nem Sitemesh são boas opções de frameworks para se trabalhar com JSF.

Pior do que usar um dos dois frameworks citados acima é criar seu próprio mini-fashion-templating-framework, seja utilizando-se de JSP taglibs ou mesmo de um Servlet Filter, não importa, fuja disso, evite reinventar a roda, aliás, evite reinventar uma roda ainda pior do que as já existentes [não quero entrar na discussão dos malefícios de criar seu framework caseiro].

A melhor opção

Já faz um bom tempo que temos excelentes opções de templating frameworks desenvolvidos especialmente para JavaServer Faces como o Facelets ou JSFTemplating. Ambos trabalham perfeitamente bem com JSF e trazem diversos benefícios tanto em termos de perfomance como em produtividade.

Mas com toda certeza o mais utilizado, mais popular, com maior suporte da comunidade, maior documentação e provavelmente mais estável entre eles é o Facelets.

Iniciar um projeto web com JSF e não adotar Facelets é começar um projeto “pisando na bola”, é abrir mão de diversos benefícios para a equipe de desenvolvedores e para a aplicação em si.

Facelets possui várias vantagens que vão desde a facilidade na criação e reutilização de páginas e componentes, melhor depuração de erros, AJAX nativo, uma melhor compatibilidade entre XHTML, JSTL e os componentes, ele é independente de web container, e claro, Facelets é de 30% a 50% mais rápido que JSP.

Ah, claro, como poderia esquecer, JSF2.0 adotou Facelets como view handler padrão, então, provavelmente migrar uma aplicação de JSF1.2 (ou mesmo JSF1.1) para JSF2.0 será menos trabalhoso ainda caso você não o estive usando.

Estas são somente algumas vantagens ao se adotar Facelets em um projeto, existem várias outras, mas eu considero estas como as principais.

Concluindo

Infelizmente JSF1.2 utiliza-se de JSP como view handler padrão por questões políticas e principalmente comercias, mas acreditem em mim, eles são como água e óleo, não combinam juntos. Para falar a verdade, por que você acha que todos os exemplos dos produtos da JBoss (Richfaces, Seam etc) estão utilizando-se massivamente de Facelets e não de JSP?

Enfim, não há motivos para não adotar Facelets em um novo projeto ou mesmo em um projeto já em andamento [é possível ir migrando de JSP para Facelets aos poucos], todos os conjuntos de componentes que conheço funcionam perfeitamente bem com ele e algumas vezes até melhor, o que não falta são artigos, blogs, tutoriais, fóruns, revistas e listas de discussão com informações suficientes para configurar e tirar melhor proveito do Facelets na sua aplicação.

Volto a dizer, iniciar um projeto sério em JSF sem adotar Facelets como framework para templating é começar errado. Eu falo sério.

O que esperar do JSF 2.0

O lançamento

Acaba de ser lançado a Reference Implementation (RI) Beta do JSF2.0. Com o nome de Mojarra, continuando com o mesmo nome da versão 1.2 da implementação da Sun,  a nova especificação está trazendo diversas melhorias e acertos em relação as versões anteriores, nesta versão realmente há muitas features interessantes e que alavancará a produtividade no desenvolvimento com JavaServer Faces.

As features

Entre as diversas features e melhorias, existem algumas que eu gostaria de destacar:

  • Um novo ciclo de vidas no lado cliente (browser), ou seja, agora será bem mais fácil integrar e criar componentes com frameworks e APIs javascript como ExtJS ou Yahoo API, quem sabe em breve não vejamos um Ext4JSF por aí? Além do mais será mais rápido e prático implementar interfaces do tipo “on a single page interface web application“, já que todo o processamento da interface gráfica ficará no lado cliente!
  • Escopos de conversação, finalmente!! Feature esta que realmente fazia (faz?) falta ao se desenvolver com JSF, atualmente somos obrigados a se utilizar de frameworks ou componentes como Myfaces Tomahawk, JBoss Seam, Spring Annotation entre outros.
  • Agora teremos “Zero Configuration“, ou seja, esqueça faces-config.xml, esqueça web.xml !! Provavelmente configuraremos tudo por annotations.
  • Outra feature necessária e que também fazia uma falta em tanto é a Exception Handler, agora depois de um erro lançado poderemos encaminhar o usuário para uma página de erro.
  • Annotations, e muitas annotations para declarar artefatos como managed bean, componentes, regras de navegação etc.
  • Suporte a templating, algo próximo no estilo do Facelets.
  • Suporte a submissão com método HTTP GET, ou seja, bookmarking.
  • Agora com AJAX nativo no ciclo de vida. A incompatibilidade entre os conjuntos de componentes será absurdamente menor, já que a falta de uma especificação AJAX para JSF era um dos maiores causadores de tanta incompatibilidade!
  • Acessar recursos JSF através de REST, wow!
  • Agora será possível executar uma ação (método?) ao carregar uma página.
  • Salvar e recuperar parcialmente estados da árvore de componentes (Isso vai trazer uma melhoria significativa à perfomance).

Como podem ver, são inúmeras melhorias significativas -na minha opiniao- para esta nova versão, e provavelmente surjam outras já que a especificação está ainda em rascunho. No site da JCP há as demais features e melhorias sobre esta versão.

Concluindo

Uma das maiores dúvidas em relação a esta versão é a tal da retrocompatibilidade, eu particularmente acredito que a versão 2.0 do JSF será compatível com as versões anteriores (ao menos com a JSF1.2) pois há o envolvimento de Big Players na especificação e encarar as versões anteriores como legados descontinuados é algo radical demais para o mercado, porém é quase que certo que será necessário abrir mão da compatibilidade em algum ponto para aproveitar os recursos da nova versão.

Enfim, JSF2.0 está vindo com tudo. Enquanto aguardamos a versão final já podemos brincar com a versão beta do Mojarra para JSF2.0.