Facelets

Origem: Wikipédia, a enciclopédia livre.
Ir para: navegação, pesquisa
Facelets
{{{logotipo}}}
Versão estável 2.0 (28 de junho de 2009; há 282 semanas)
Escrito em Java
Sistema operativo Multiplataforma
Gênero(s) Sistema de template Web
Página oficial URL não preenchido. Favor adicionar.
Facelets standalone
Plataforma Multiplataforma
Versão estável 1.1.15 (24 de novembro de 2009; há 260 semanas e 5 dias)
Versão em teste 1.2-dev (10 de novembro de 2006; há 419 semanas e 2 dias)
Escrito em Java
Gênero(s) Sistema de template web
Licença Licença Apache 2.0
Tamanho 5.07 MB (compactado)
Página oficial http://facelets.java.net/

Em computação, Facelets é um sistema de template Web de código aberto sob a licença Apache e a tecnologia de processador de visões padrão (também conhecido como a linguagem de declaração de visão) para o JavaServer Faces (JSF). A linguagem requer documentos XML de entrada válidos para funcionar. Facelets suporta todos os componentes de IU do JSF e se concentra totalmente na construção da árvore de componentes JSF, refletindo a visão para uma aplicação JSF. É baseado no padrão de projeto de Visão Composta. Isto significa que seções de uma página ou mesmo as próprias páginas podem ser reutilizadas por outras páginas.

Um Facelet pode ser definido como uma seção reutilizável de conteúdo ou uma sub-árvore de componentes em uma página JSF que pode ser por si mesma composta de outros Facelets. Neste sentido, um Facelet é um elemento de uma visão composta que pode ser facilmente combinado com outros Facelets para construir uma visão JSF que será apresentada ao usuário.[1]

Apesar das tecnologias JSF e JSP terem sido melhorados para funcionarem melhor em conjunto, Facelets elimina os problemas observados no artigo de Hans Bergsten "Melhorando o JSF retirando o JSP".[2]

O Facelets baseia-se em algumas das idéias do Apache Tapestry,[3] [4] e é semelhante o suficiente para fazer uma comparação. O projeto é conceitualmente similar ao Tapestry, que trata blocos de elementos HTML como componentes do framework apoiados por classes Java. Facelets também tem algumas semelhanças com o framework Apache Tiles no que diz respeito a suportar templates, bem como composição.

Facelets foi originalmente criado por Jacob Hookom em 2005[5] como uma linguagem de declaração de visão alternativa separada para o JSF 1.1 e JSF 1.2, as quais utilizavam o JSP como a linguagem de declaração de visão padrão. A partir do JSF 2.0, Facelets foi promovido pelo grupo de peritos JSF para ser a linguagem de declaração de visão padrão. JSP se tornou obsoleta como um legado que caiu em desuso.[6] [7]

Conversão de elemento[editar | editar código-fonte]

Em Facelets, tags de templates de uma biblioteca de tags podem ser inseridos em duas formas: diretamente como um elemento xml qualificado ou indiretamente, através do atributo jsfc em um elemento arbitrário não qualificado. Neste último caso, o compilador Facelet ignorará o elemento real e processará o elemento como se ele fosse fornecido pelo atributo jsfc.

O exemplo a seguir mostra o uso direto de tags qualificadas:

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 
Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" xmlns:h="http://java.sun.com/jsf/html">
    <body>
        <h:form>
            <h:outputText value="Bem vindo, #{loggedInUser.name}" disabled="#{empty loggedInUser}" />
            <h:inputText value="#{bean.property}" />
            <h:commandButton value="OK" action="#{bean.doSomething}" /> 
        </h:form>
    </body>
</html>

Usando o atributo jsfc, o mesmo código também pode ser expressado como o exemplo fornecido abaixo:

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 
Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" xmlns:h="http://java.sun.com/jsf/html">
    <body>
        <form jsfc="h:form">
            <span jsfc="h:outputText" value="Bem vindo, #{loggedInUser.name}" disabled="#{empty loggedInUser}" />
            <input type="text" jsfc="h:inputText" value="#{bean.property}" />
            <input type="submit" jsfc="h:commandButton" value="OK" action="#{bean.doSomething}" /> 
        </form>
    </body>
</html>

O código acima pode ser visualizado em um navegador, e editado com as ferramentas de projeto WYSIWYG convencionais. Isso não é possível quando usa-se diretamente as tags qualificados. No entanto, usar diretamente as tags qualificados é a forma mais popular de usar Facelets na prática[8] e é o estilo mais usado em livros e exemplos.[9] [10]

Modelos (templating)[editar | editar código-fonte]

Facelets oferece facilidades para a modelagem (templating). Um arquivo Facelets pode referenciar um modelo (ou template) mestre e fornecer conteúdo para os espaços reservados que este modelo mestre define. O arquivo que faz referência a um tal modelo é chamado de cliente de modelo (template client). Os próprios clientes de modelo, podem novamente ser utilizados como um modelo para outros clientes de modelo e, desta forma, uma hierarquia de modelos pode ser criada.

A seguir é mostrado um exemplo de um modelo mestre simples:

templates / master_template.xhtml

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 
Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" 
    xmlns:h="http://java.sun.com/jsf/html"
    xmlns:ui="http://java.sun.com/jsf/facelets"
>
    <h:head>
        <meta http-equiv="content-type" content="text/html;charset=UTF-8"/>
        <meta http-equiv="pragma" content="no-cache"/>
     </h:head>
 
    <h:body>
         Standard header text for every page.
 
         <ui:insert name="body_content" />        
 
         Standard footer text for every page.
    </h:body>
</html>

O código acima contém um 'frame' HTML padrão e um único espaço reservado chamado body_content. Um cliente de modelo pode usar este modelo como se segue:

template_client.xhtml

<ui:composition template="/templates/master_template.xhtml"
    xmlns="http://www.w3.org/1999/xhtml"
    xmlns:ui="http://java.sun.com/jsf/facelets" 
>
    <ui:define name="body_content">
        This is a template client page that uses the master template.		
    </ui:define>
</ui:composition>

O código acima faz uso do modelo /templates/master_template.xhtml e fornece conteúdo para o espaço reservado nesse modelo. O resultado final será uma página chamada template_client.xhtml, que tem o conteúdo de /templates/master_template.xhtml mas com <ui:insert name="body_content"/> substituído por 'Esta é uma página de cliente de modelo que usa o modelo mestre.'.

Componentes compostos[editar | editar código-fonte]

Além de incluir o conteúdo diretamente, Facelets fornece o mecanismo de componente composto que torna o conteúdo disponível como um componente de primeira classe JSF.[11] [12] Componentes compostos não precisam ser declarados em um arquivo Taglib, mas têm que ser colocados em um diretório especial. Por convenção, o conteúdo é, então, atribuído automaticamente um espaço de nomes e um nome de tag. O espaço de nomes é construído da cadeia fixa 'http://java.sun.com/jsf/composite/' concatenada com o nome do diretório no qual o arquivo de conteúdo reside relativo ao diretório 'resources'.[13] O nome da tag torna-se o nome do arquivo sem o sufixo .xhtml.

O seguinte mostra um exemplo disso:

resources/my/spacer.xhtml

<ui:composition
    xmlns="http://www.w3.org/1999/xhtml"
    xmlns:ui="http://java.sun.com/jsf/facelets" 
    xmlns:h="http://java.sun.com/jsf/html"
    xmlns:cc="http://java.sun.com/jsf/composite"
>
    <cc:interface/>
    <cc:implementation> 
        <h:outputText value="&amp;nbsp;" escape="false"/>
    </cc:implementation>
</ui:composition>

O Facelet acima está automaticamente disponível como um componente no espaço de nomes 'http://java.sun.com/jsf/composite/my' e o nome da tag 'spacer'.

Referências

  1. http://www.jsftoolbox.com/documentation/facelets/03-FaceletsConcepts/composite-view-design-pattern.jsf
  2. Hans Bergsten (June 6, 2004). Improving JSF by Dumping JSP O'Reilly Media.
  3. http://web.archive.org/web/20070706220453/https://facelets.dev.java.net/
  4. http://web.archive.org/web/20130113100928/http://www.jsfcentral.com/articles/facelets_1.html
  5. http://web.archive.org/web/20130113100928/http://www.jsfcentral.com/articles/facelets_1.html
  6. JavaServer Faces 2.0, The Complete Reference by Ed Burns and Chris Schal, page 55: 'The expert group decided to move forward with Facelets as the basis for new features while letting JSP remain as a backward compatibility layer'.
  7. JSF 2.0 (JSR 314, http://jcp.org/en/jsr/detail?id=314) specification, maintenance release 2, section 10.1: 'Facelets is a replacement for JSP that was designed from the outset with JSF in mind. New features introduced in version 2 and later are only exposed to page authors using Facelets. JSP is retained for backwards compatibility.'
  8. http://stackoverflow.com/questions/tagged/jsf
  9. JavaServer Faces 2.0, The Complete Reference by Ed Burns and Chris Schalk
  10. Core JavaServer Faces (3rd Edition) by David Geary and Cay S. Horstmann
  11. http://download.oracle.com/javaee/6/javaserverfaces/2.0/docs/pdldocs/facelets/composite/tld-summary.html
  12. http://andyschwartz.wordpress.com/2009/07/31/whats-new-in-jsf-2/#composite-components
  13. JSR 314, 10.3.3.1, http://jcp.org/en/jsr/detail?id=314
Ícone de esboço Este artigo sobre programação de computadores é um esboço. Você pode ajudar a Wikipédia expandindo-o.