Facelets: Desenvolvendo com JavaServer Faces

Você precisa estar logado para dar um feedback. Clique aqui para efetuar o login
Para efetuar o download você precisa estar logado. Clique aqui para efetuar o login
Confirmar voto
0
 (0)  (0)

Abordagem dos principais recursos do Facelets, mostrando a configuração de um projeto JSF e o desenvolvimento de templates e Tag Resource Files.

Atenção: esse artigo tem um vídeo complementar. Clique e assista!

[lead]De que se trata o artigo:

Abordagem dos principais recursos do Facelets, mostrando a configuração de um projeto JSF e o desenvolvimento de templates e Tag Resource Files.

Para que serve:

Apresentar aos desenvolvedores os conceitos e os principais recursos do Facelets, auxiliando o desenvolvimento de views mais eficientes.

Em que situação o tema é útil:

O objetivo de desenvolvedores é usar ferramentas simples, que evitam repetição de código e que sejam produtivas. Para aplicações JSF, o Facelets é uma opção que se aproxima destes objetivos para a criação das views de aplicações. Este artigo aborda recursos como criação e uso de templates, Tag Resource Files e outras funcionalidades importantes do Facelets.

Desenvolvendo com JavaServer Faces:

O JavaServer Faces, até a versão 2.0, não possuía ferramentas como criação de templates e composição de componentes. Como a integração entre JSF e JSP sempre causou certa dor de cabeça, o Facelets foi criado justamente para preencher esta lacuna.

O Facelets é uma ferramenta para desenvolvimento de views JSF implementada a partir do zero, permitindo a criação de páginas usando XHTML. Por não usar mais a tecnologia JSP, a compilação de páginas não é mais necessária, tornando a execução mais performática. Pelo fato da página ser elaborada usando notações XML, a estrutura da página é montada seguindo uma estrutura de árvore, aproximando-se da árvore de componentes JSF.

A criação de templates, composição de componentes e criação de Tag Resource Files são os principais recursos e os mais usados ao longo do desenvolvimento de um projeto Facelets. Claro que os demais recursos também podem auxiliar na solução de diversos problemas. [/lead]

Nos dois primeiros artigos da série, foram abordados os conceitos básicos de JSF e os passos para criação de componentes de interface gráfica. Na primeira parte, foi proposta a criação de um registro de clientes onde foram aplicados alguns dos principais fundamentos e componentes padrões do JSF. A segunda parte mostrou a criação de componentes úteis, para exibição das fotos dos produtos e tooltips customizados, permitindo uma maior valorização das informações presentes na guia de produtos da loja virtual.

Ao longo da abordagem até então, a tecnologia utilizada para construção das páginas foi a JavaServer Pages. O uso da JSP como tecnologia de visualização JSF possui algumas implicações como: o suporte precário à montagem da árvore de componentes, a falta de mecanismos para criação de templates e a falta de suporte para composição de componentes. O Facelets tem como foco a criação de templates, reutilização de código e facilidade de desenvolvimento através da implementação, a partir do zero, de uma tecnologia de interface gráfica para JSF de maior performance. Essas características auxiliam na redução da quantidade de código gasta para geração de interfaces gráficas comparadas com páginas JSP.

O presente artigo objetiva apresentar os conceitos básicos e os principais recursos do Facelets, que auxiliarão o leitor a incrementar suas aplicações JSF. Ao longo do artigo, será criado um template para a loja virtual de livros e serão configurados os componentes criados no artigo anterior para serem reconhecidos no contexto Facelets. Serão abordados também tópicos mais avançados como a criação de tag files e criação de funções EL.

[subtitulo]Conceitos Básicos[/subtitulo]

A JavaServer Pages era a tecnologia padrão usada pela comunidade para criar interfaces gráficas web em Java. A utilização da JSP como tecnologia de criação de páginas JSF possibilitou a adoção de diversos desenvolvedores. Porém, esta decisão expôs alguns problemas, como por exemplo, a falta de sincronismo entre o fluxo de execução JSP e o ciclo de vida dos componentes JSF. O processamento JSP ocorre do topo até o fim da página assim que a página é chamada. Deste modo, a execução do conteúdo JSF e conteúdo não JSF acontece em momentos distintos, conduzindo a problemas indesejados. A Listagem 1 ilustra um exemplo relacionado a esses problemas.

Listagem 1. Problema de renderização de conteúdo JSP.

  1    <h:panelGroup>
  2      <h:outputText value="Texto 1"/>
  3      Texto 2
  4    </h:panelGroup> 

Neste código, há a mistura de componentes JSF com textos livres. Os textos livres também poderiam ser substituídos por tags HTML que o resultado seria semelhante (Figura 1). Analisando esta figura, por que “Texto 2” foi exibido antes do “Texto 1”? Como era de se esperar, o container JSP exibe “Texto 2” assim que ele é encontrado na página, porém, o componente <h:panelGroup> exibe os componentes filhos apenas quando a execução atinge o fim do corpo da tag, ou seja, ao chegar na linha 4. Como o “Texto 2” não é considerado um componente, ele não faz parte desta execução.

Texto 2

Texto 1

Figura 1. Exemplo de execução dentro do container JSP.

O Facelets é uma linguagem de template desenvolvida para a tecnologia JSF. Além de resolver problemas como o exibido acima, ele oferece mecanismos que favorecem a manipulação de componentes, nos quais a geração e a renderização destes componentes são realizadas de acordo com o ciclo de vida. A exemplo disso, as páginas são criadas, por padrão, usando o formato XHTML, permitindo montar a árvore de componentes de forma mais intuitiva, seguindo a abordagem de componentes proposta pelo Faces.

O Facelets possui uma implementação para reduzir as incompatibilidades entre JSTL e JSF associadas ao fluxo de execução das tags JSTL. Deste modo, essas tags podem ser intercaladas com tags JSF, facilitando a implementação de certas funcionalidades. Por exemplo, fazer a iteração dos elementos de uma lista sem a necessidade de usar um DataTable, ou mesmo controlar a exibição de determinados conteúdos que, em muitos casos, o uso da propriedade rendered, para controlar a exibição dos elementos na página, implica na complexidade do código.

[nota] JSTL: A JSTL (JavaServer Pages Standard Tag Library) são componentes web Java EE definidos pela JSR 52 (JSTL 1.0, 1.1 e 1.2) e pela JSR 267 (Web Services). A JSTL oferece componentes para tarefas comuns como iteração e condicionais, tags para documentos XML, internacionalização e manipulação SQL. [/nota]

As Expression Languages (EL) são unificadas e incluem suporte às funções e métodos de validação EL. A unificação basicamente oferece o mesmo suporte oferecido pela JSP EL e adiciona funcionalidades extras como a execução de expressões seguindo a definição do ciclo de vida, permitindo a execução correta de tags de iteração JSTL.

O Facelets também oferece relatórios de erros de execução mais amigáveis, mostrando relatórios mais detalhados informando com precisão a linha onde o problema ocorreu. Por fim, o Facelets possui jsfc, um recurso equivalente ao jwcid do Tapestry, que permite a integração com editores HTML. Essa propriedade é usada dentro de uma tag HTML para indicar ao compilador qual componente deverá ser associado a ela.

Com base nestes conceitos, chegou o momento de converter as páginas da loja virtual de livros implementada nas partes um e dois desta série. Mas antes de criar os templates, tag files e funções EL, é preciso adicionar algumas configurações, conforme veremos a seguir.

[nota]Tag files são arquivos fontes, páginas XHTML em Facelets, que contêm fragmentos de código que são reutilizados na forma de componentes. [/nota]

[subtitulo]Configurando a aplicação [/subtitulo]

Configurar o Facelets em uma aplicação JSF é muito simples; precisamente são necessários três passos: adicionar o JAR do Facelets ao classpath da aplicação, definir os sufixos para as views através de parâmetros de contexto no descritor web, e redefinir o ViewHandler do JSF.

O Facelets possui poucas dependências. Ele é dependente de uma implementação JSF (compatível com RI ou MyFaces nas versões 1.1, 1.2 e 2.0) e de uma implementação EL. Quando o deploy é feito em containers com suporte a JSP 2.1, como o Tomcat 6.0, as bibliotecas EL (el-api.jar e el-impl.jar) não são necessárias. Para o exemplo do artigo, faça o download da versão 1.1.15 do Facelets (ver Links), descompacte-a, copie o arquivo jsf-facelets.jar e cole-o dentro da pasta WEB-INF/lib do projeto. Para saber quais os arquivos JAR já presentes no classpath, consulte a Parte 1 desta série.

[nota]O artigo Desenvolvendo com JavaServer Faces – Parte 1 foi publicado na Edição 72. A segunda parte foi publicada na Edição 73.[/nota]

Para habilitar o Facelets na aplicação, é necessário configurar o descritor web, isto é, incluir o parâmetro de contexto javax.faces.DEFAULT_SUFFIX, o qual define o sufixo para os arquivos usados como "

A exibição deste artigo foi interrompida :(
Este post está disponível para assinantes MVP

 
Você precisa estar logado para dar um feedback. Clique aqui para efetuar o login
Receba nossas novidades
Ficou com alguma dúvida?