Rafael Ponte

Desde o surgimento dos conjuntos de componentes Ajax passou-se a aproveitar melhor as features do JSF e destes componentes para trazer ao usuário uma UI mais rica e na medida do possível mais leve. Graças a estes componentes ficou mais fácil desenvolver estes tipos de UI quase que transparentemente da mesma forma convencional (sem Ajax) que estávamos acostumados a escrever nossas páginas.

Entre tantos benefícios dessa abordagem apareceram alguns problemas que também não estávamos acostumados a lidar, como saber o que enviar e repintar antes de uma requisição Ajax, ou saber limpar um formulário adequadamente quando necessário ou mesmo repintar determinados componentes de exibição dinâmica.

Pegando este último problema como tema deste post, o que eu tenho notado é que ainda hoje em dia ele é um dos problemas mais comuns de acontecer e ao mesmo tempo um dos mais discutidos em fóruns e listas de discussão. Sendo, nada mais justo do que explana-lo aqui no blog e facilitar a vida de muitos, assim como a minha.

Problema

Este problema, que muitos ainda desconhecem, é comumente conhecido como “problema do rendered dinâmico” (bem, ao menos é como eu o chamo!) e só acontece quando trabalhamos com JSF e Ajax - independente do conjunto de componentes - mais especificamente após tentarmos repintar (ou rerenderizar, como você queira chamar) um componente com o atributo rendered dinâmico, como este:

Este componente poderia ser repintado após algum evento Ajax disparado pelo usuário na tela, como por exemplo ao selecionar o tipo de cadastro entre pessoa física ou jurídica, algo similar a isto:

Aparentemente não há qualquer problema com os trechos de código acima, principalmente se o componente iniciar visível para o usuário (ou seja, a EL ${myBean.pessoaFisica} do rendered estiver sendo avaliada para true).

Após mudar para o tipo pessoa jurídica é disparado um evento Ajax, o componente é repintado e desaparece da tela, como era de se esperar, claro. Contudo se você alterar a opção para o tipo pessoa física o componente não reaparecerá para o usuário. E é aí onde está o problema!

Se você for esperto, após alguns minutos analisando o problema, notará que a requisição Ajax foi disparada pelo componente tipoDePessoa (Firebug, plugin para Firefox, pode te ajudar aqui), o estado do managed bean foi alterado e o ciclo de vida do Faces foi processado sem qualquer erro.

E a partir daí, depois de refazer e analisar todos os passos básicos e sensatos, perde-se inúmeras horas tentando descobrir onde está de fato o problema neste simples cenário. A primeira vista parece ser um bug do JSF ou do conjunto de componentes, mas na verdade não é.

Solução

Sendo direto e sem rodeios: você não pode rerenderizar um componente na qual possua o atributo rendered dinâmico, ou seja, o componente não pode possuir EL para definir seu estado de visibilidade para o usuário.

Para resolver isso, repinte o componente parent do componente que possui o rendered dinâmico. Lembrando que este componente parent não pode ter o atributo rendered dinâmico, ou seja, ele sempre precisa ser renderizado.

Componentes como a4j:outputPanel ou mesmo h:panelGroup são excelentes componentes para servirem como componente parent. Sabendo disto, o código apropriado seria algo como:

E o componente responsável pelo evento Ajax deve repintar, no caso acima, o a4j:outputPanel (componente parent sem rendered dinâmico) e não mais o h:panelGroup.

Entendendo o problema

Para quem ainda não sabe, o atributo rendered (que por padrão é true) dos componentes é responsável por tornar o componente visível ou não para o usuário, ou seja, sempre que este atributo for true o componente poderá gerar código XHTML para ser exibido na página. Caso ele seja false, normalmente, nenhum código XHTML é gerado. Vale lembrar que mesmo o rendered sendo false o componente ainda existe na árvore de componentes no lado servidor.

Não é interessante tentar rerenderizar um componente com rendered dinâmico pois quando o atributo rendered é avaliado para false o componente (código XHTML na verdade) não aparece na árvore DOM da página. Sendo, após repintar este mesmo componente (agora com rendered avaliado para true) o código JavaScript do Richfaces responsável por atualizar o bloco de código onde se encontraria o componente na árvore DOM não consegue achar a posição exata para repintar na página (para injetar o novo código XHTML), já que o código XHTML do componente não existe mais. Então, no final, o Javascript do Richfaces acaba simplesmente não fazendo nada.

Por isso, quando você repinta um componente parent qualquer (que sempre tem o atributo rendered avaliado para true) o Richfaces consegue encontrar a posição exata deste componente na página e injetar o novo código XHTML, e como o componente com rendered dinâmico é um nó (filho) do componente parent ele também é repintado.

Concluindo

O problema é simples e a solução mais simples ainda! Nada como ler a documentação do seu conjunto de componentes favorito para entender e evitar este problema. Vale salientar que este problema ocorre com praticamente todos os conjuntos de componentes Ajax.

Acho que para um assunto simples como este eu falei mais do que devia. Espero que tenha ficado claro ou ao menos tenha dado uma luz para quem está enfrentando essa dor de cabeça. Caso queria saber mais sobre o assunto você poderá consultar a documentação do Richfaces, mais especificamente os tópicos 5.5 e 5.6.1.

Enfim, estou feliz por ter tirado mais um post antigo da minha lista de drafts! Atualmente minha rotina diária não tem me permitido investir o tempo que eu gostaria para blogar, mas cá estamos nós novamente, certo?

Dificuldades todos temos, principalmente quando estamos aprendendo uma nova tecnologia, framework ou paradigma, e isso torna-se ainda pior quando não temos qualquer interesse em aprender sobre os mesmos.

Não é de hoje que percebo que a maioria das dúvidas postadas sobre JSF em listas de discussão e fóruns estão intimamente ligadas a falta de conhecimento base sobre a tecnologia ou mesmo sobre os conceitos na qual o framework (JSF) foi construído - sim, estou falando de conceitos sobre desenvolvimento web e component-based.

É óbvio que JSF existe para tentar abstrair toda a complexidade existente no desenvolvimento web Java, complexidade esta que deveríamos evitar, mas é indispensável termos o mínimo de conhecimento sobre a mesma. Pois se você acha que apenas conhecendo os componentes você construirá uma aplicação decente então você está enganado.

Assusto-me com o número de dúvidas na javasf em que o mínimo de conhecimento sobre web seria suficiente para solucionar o problema, independente do framework utilizado. Evidente que muitas das dúvidas estão ligadas a tecnologia, JSF no caso, mas estes mesmos problemas também seriam facilmente resolvidos se os desenvolvedores se dessem ao trabalho de tentar entender os fundamentos do framework.

Quando falo dos fundamentos de JSF eu estou me referindo ao ciclo de vida, comunicação entre managed beans, escopos de conversação, árvore de componentes, a idéia por trás dos converters e validators, phase listeners, modelo dos componentes etc.

Desenvolver aplicações JSF guiado por “brute-force” é algo que todo desenvolvedor deveria evitar, de fato, ver um exemplinho (ou demo) básico de um componente, copiar o código, joga-lo na aplicação e ainda por cima achar que deveria funcionar é algo ingénuo demais até mesmo para um programador iniciante.

Pior que isso é continuar tentando fazer o componente ou bloco de código funcionar a todo custo sem nem ao menos ler a documentação do mesmo [por isso o termo "brute-force"].

Não adianta correr para tentar usar os componentes se você não possui os fundamentos básicos sobre JSF ou mesmo sobre desenvolvimento web.

Saber o básico é importante

Saber o básico de qualquer tecnologia é obrigatório, e com JSF não seria diferente. Acredito que em primeiro lugar é importante entender o que é JSF e qual a diferença entre uma implementação e um conjunto de componentes.

Criar e configurar um projeto web JSF faz parte do aprendizado, independente da IDE, claro. Como disse, o interessante é não depender exclusivamente da IDE, mas sim conhecer o mínimo necessário para configurar e rodar um projeto com faces (como as libs necessárias e configuração do web.xml).

Entenda que um managed bean é apenas um POJO e que deveria ser o mais simples possível (refletindo estritamente o necessário da GUI). E por favor, coloque uma vez por todas na sua cabeça que os componentes (através de EL) acessam os valores dos managed beans através dos métodos assessores (getters e/ou setters) e não das propriedades.

Depois disso eu aconselharia o entendimento sobre converters e validators, pois eles tornam o desenvolvimento bem mais simples se comparado a outros frameworks MVC. Principalmente os converters, pois eles sim “quebram um galho” danado!

Entenda como o framework e os componentes disparam/tratam os eventos e listeners, e principalmente quando utiliza-los, pois utilizar um listener incorreto para um determinado cenário pode dificultar muito a sua vida, mesmo que no final a coisa funcione. Praticamente tudo o que você precisa saber estará na documentação do componente.

Procure entender o sistema de regras de navegação entre páginas do JSF, principalmente quando e porquê você deveria usar redirect ao invés de um simples forward. E claro, lembre-se que JSF trabalha (submete formulários) apenas com o método POST, não com GET.

Quando as páginas tornam-se grandes e até complexas vale a pena organizar os blocos de componentes através de componentes “maiores”, ou seja, componentes do tipo naming containers, com eles se torna possível manipular os componentes tanto no lado cliente quanto no lado servidor de forma mais simples.

Os fundamentos chaves do framework também fazem parte do conhecimento básico, ou você acha que apenas saber utilizar os componentes, navegar entre páginas e criar seu próprio validator são suficientes?

Sendo, é muito importante que você os compreenda da melhor forma possível. Provavelmente alguns deles você terá alguma dificuldade de entender no inicio, isto é normal, mas é interessante que você ao menos conheça superficialmente cada um deles.

Comece entendendo como e quando a árvore de componentes é gerada (está muito ligado ao ciclo de vida), busque entender como o JSF persiste o estado da árvore de componentes entre requests e porque utilizar JSTL no momento certo é importante.

Os passos necessários para estender ou construir seu próprio componente é algo também importante, mesmo que você não seja um expert nisso, conheça estes passos. Eu particularmente nunca tive a necessidade de criar um componente, apenas estendi um [uma única vez], e com a gama de componentes hoje em dia eu acho muito difícil -mas não improvável- você precisar criar seu próprio componente.

Um fundamento extremamente importante é conhecer as maneiras como os objetos e managed beans se comunicam entre si numa aplicação JSF, pois sem este conhecimento provavelmente você cometeria erros e subutilizaria o framework na sua aplicação.

E por fim, o mais importante fundamento, sem sombra de dúvidas, é entender o ciclo de vida (lifecycle) das requisições no JSF. Procure entende-lo muito bem, pois assim você evitará horas quebrando a cabeça com problemas relativamente simples (quem nunca teve dificuldades de entender como funciona o atributo immediate?).

Vale salientar que independente do(s) conjunto(s) de componentes que você pretenda utilizar os conceitos acima te permitirão trabalhar de forma prática, correta e produtiva.

Mas vá além do básico

Os conhecimentos básicos são obrigatórios quando se pretende desenvolver qualquer aplicação com JSF, por menor que ela seja, mas a partir do momento que se desenvolve aplicações maiores e até complexas se faz necessário adotar certos frameworks, abordagens e até conhecer ou saber que existem algumas soluções mais interessantes.

Assim como a maioria dos frameworks web, JSF trabalha com páginas, muitas páginas para falar a verdade, e isto nos leva a necessidade de um framework para templating. E sempre que falamos em um framework com esta finalidade para JSF nós não devemos esquecer: Aplicações sérias em JSF usam Facelets.

Para quem ainda acha que deve criar seu converter apenas para formatar e remover máscaras de strings deve se interessar por abordagens mais práticas e produtivas de se trabalhar com componentes e conversão de entidades de domínio da aplicação.

Um dos grandes problemas para quem está começando com JSF e componentes AJAX é a maneira como estes desenvolvedores subutilizam os recursos AJAX do framework e dos componentes. Sendo, vale a pena estudar e adotar uma abordagem mais eficiente para isso, uma abordagem com foco em navegação orientada a estados.

Uma abordagem orientada a estados é realmente eficaz e produtiva, mas em certos momentos precisamos “tunar” as requisições AJAX dos componentes ou mesmo diminuir os gargalos em determinadas páginas, buscar melhores práticas para os conjuntos de componentes e/ou frameworks AJAX adotados para um projeto é dever do desenvolvedor, sejam estas práticas para JBoss Richfaces, Myfaces Trinidad ou qualquer outro.

A Expression Language (EL) do JSF por padrão ainda é bem limitada, porém muito extensível, e muitas vezes precisamos de features bem mais arrojadas, logo, não podemos abrir mão de extensões como a JBoss EL para que assim evitemos implementar soluções bizarras.

Como havia dito antes, JSF trabalha apenas com POST, porém algumas vezes precisamos submeter formulários via GET ou disponibilizar links (bookmarking) que acessam recursos ou executam algum método no managed bean antes de renderizar uma página. E antes que você implemente seu próprio phase listener ou alguma solução nada elegante eu indico a você o framework Restfaces.

Nem todas as aplicações web necessitam de um mecanismo arrojado de segurança, muitas vezes uma simples página de login para autenticação e um Servlet Filter (ou phase listener) para autorização de recursos resolve o problema. Mas qualquer coisa além disso você deveria, obrigatoriamente, partir para um framework especializado no assunto: como o Spring Security ou JAAS.

Já cansei muito de bater na tecla que não existe arquitetura de referência (aka bala-de-prata) para solucionar todos os problemas de softwares, já discuti muito isso na lista do javasf, cejug e já comentei sobre isso em vários posts meus e de colegas.

Mas também sei que muitos desenvolvedores/arquitetos tem dificuldades em dar inicio numa arquitetura base que se integre bem com JSF, desta forma, eu aconselho a leitura de dois excelentes posts do Cagatay como referência básica. 1) sobre a integração de JSF+JPA+Spring com o uso massivo de anotações e 2) com a integração anterior mais o Spring Security e Myfaces Orchestra.

Se por algum motivo você não gosta ou não se dá bem com Spring então vale a pena dar uma olhada em um projeto recente de integração entre JSF e Guice, o Guicesf. O Guicesf foi uma iniciativa do Volnei, um dos membros do JavaServer Faces International Group (javasf), e que está caminhando muito bem diga-se de passagem.

Ainda assim, acredito que se você tem tempo para estudar e levantar uma arquitetura para seu projeto então corra e dê uma olhada no JBoss Seam, pois todos os problemas (escopos conversacionais, LazyInitializationException, bookmarking etc) que você encontrará com JSF e solucionará com a integração de alguns frameworks e componentes você com toda certeza poderá ter a mesma solução muito mais simples e muito melhor implementada no JBoss Seam, ou seja, soluções prontas!

Concluindo

A maior parte do conhecimento que você precisa para se tornar um bom desenvolvedor JSF está ligada aos fundamentos do framework, e aos fundamentos sobre desenvolvimento web. Com estes conhecimentos alinhados você não terá muitas dificuldades.

Além do mais, não se assuste se você tiver alguma dificuldade no inicio, principalmente se você já trabalhou com algum framework action-like, como Struts ou Webwork, pois a maioria dos desenvolvedores vindos do “mundo” action-like são os que mais possuem dificuldades em desenvolver aplicações com JSF.

Não pare por aqui, continue pesquisando e estudando sobre a tecnologia, principalmente sobre as novidades do JSF2.0 que estão por vir. Se você já possui experiência com JSF integrado a outros frameworks então aproveite seu tempo e dê uma chance ao JBoss Seam, pois sem dúvida alguma ele está trazendo grande produtivade no desenvolvimento “Enterprisey”.

Enfim, o intuito do post é abrir os olhos de novos desenvolvedores -e até de alguns veteranos- sobre como desenvolver melhor com JSF, e claro, disponibilizar fontes de estudos (quase todos os links levam a outros posts).

No final de tudo, este post nada mais é do que a minha opinião.