Hispanopedia WikiEn informática , Facelets es un sistema de plantillas web de código abierto con licencia Apache y la tecnología de manejo de vistas predeterminada (también conocida como lenguaje de declaración de vistas) para Jakarta Faces (JSF; anteriormente Jakarta Server Faces y JavaServer Faces). El lenguaje requiere documentos XML de entrada válidos para funcionar. Facelets admite todos los componentes de interfaz de usuario de JSF y se centra completamente en la creación del árbol de componentes de JSF, lo que refleja la vista para una aplicación JSF.
Aunque tanto las tecnologías JSP como Faces se han mejorado para que funcionen mejor juntas, Facelets elimina los problemas señalados en el artículo de Hans Bergsten "Mejorar JSF mediante el volcado de JSP" [1].
Facelets se basa en algunas de las ideas de Apache Tapestry , [2] [3] y es lo suficientemente similar como para establecer una comparación. El proyecto es conceptualmente similar al de Tapestry, que trata los bloques de elementos HTML como componentes del marco respaldados por clases Java. Facelets también tiene algunas similitudes con el marco Apache Tiles con respecto a la compatibilidad con plantillas y composición.
Facelets fue creado originalmente por Jacob Hookom en 2005 [3] como un lenguaje de declaración de vistas alternativo e independiente para JSF 1.1 y JSF 1.2, que utilizaban JSP como lenguaje de declaración de vistas predeterminado. A partir de JSF 2.0, el grupo de expertos de JSF promovió a Facelets como el lenguaje de declaración de vistas predeterminado. JSP ha quedado obsoleto como un recurso alternativo heredado. [4] [5]
Conversión de elementos
En Facelets, las etiquetas de plantilla de una biblioteca de etiquetas se pueden introducir de dos formas: directamente como un xmlelemento calificado o indirectamente a través del jsfcatributo en un elemento arbitrario no calificado. En el último caso, el compilador de Facelets ignorará el elemento real y procesará el elemento como si fuera el indicado por el jsfcatributo.
El siguiente ejemplo muestra el uso directo de etiquetas calificadas:
<!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= "Bienvenido, #{loggedInUser.name}" disabled= "#{loggedInUser vacío}" /> <h:inputText value= "#{bean.property}" /> <h:commandButton value= "Aceptar" action= "#{bean.doSomething}" /> </h:form> </body> </html>
Utilizando el jsfcatributo, el mismo código también se puede expresar como en el ejemplo que se muestra a continuación:
<!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" >
< cuerpo >
< formulario jsfc = "h:form" >
< span jsfc = "h:outputText" valor = "Bienvenido, #{loggedInUser.name}" deshabilitado = "#{loggedInUser vacío}" />
< tipo de entrada = "texto" jsfc = "h:inputText" valor = "#{bean.property}" /> < tipo de entrada = "enviar" jsfc = "h:commandButton" valor = "Aceptar" acción = "#{bean.doSomething}" /> </ formulario > </ cuerpo > </ html >
El código anterior se puede visualizar en un navegador y editar con herramientas de diseño WYSIWYG convencionales . Esto no es posible cuando se utilizan directamente las etiquetas calificadas. Sin embargo, el uso directo de etiquetas calificadas es la forma más popular de utilizar Facelets en la práctica [6] y es el estilo más utilizado en libros y ejemplos. [7] [8]
Plantillas
Facelets proporciona una función para crear plantillas. [9] [10] Un archivo Facelets puede hacer referencia a una plantilla maestra y proporcionar contenido para los marcadores de posición que esta plantilla maestra define. El archivo que hace referencia a dicha plantilla se denomina cliente de plantilla . Los clientes de plantilla se pueden utilizar a su vez como plantilla para otros clientes de plantilla y, como tal, se puede crear una jerarquía de plantillas.
A continuación se muestra un ejemplo de una plantilla maestra simple:
plantillas/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= "tipo-contenido" contenido= "texto/html;conjunto-de-caracteres=UTF-8" /> <meta http-equiv= "pragma" contenido= "sin-caché" /> </h:head>
<h:body>
Texto de encabezado estándar para cada página.
<ui:insert nombre= "contenido_del_cuerpo" />
Texto de pie de página estándar para cada página.
</h:body> </html>
El código anterior contiene un 'marco' HTML predeterminado y un único marcador de posición llamado body_content . Un cliente de plantilla puede utilizar esta plantilla de la siguiente manera:
plantilla_cliente.xhtml
<ui:composition plantilla= "/templates/master_template.xhtml" xmlns= "http://www.w3.org/1999/xhtml" xmlns:ui= "http://java.sun.com/jsf/facelets" >
<ui:define name= "body_content" > Esta es una página de cliente de plantilla que utiliza la plantilla maestra . </ui:define> </ui:composition>
El código anterior utiliza la plantilla /templates/master_template.xhtmly proporciona contenido para el marcador de posición en esa plantilla. El resultado final será una página llamada template_client.xhtmlque tiene el contenido de /templates/master_template.xhtml, pero con <ui:insert name="body_content"/>reemplazado por 'Esta es una página de cliente de plantilla que utiliza la plantilla maestra.'.
Reutilización de contenidos
Además de las plantillas, Facelets ofrece compatibilidad con la reutilización al permitir que el usuario incluya contenido que se encuentra en un archivo diferente. La inclusión de dicho contenido se puede realizar de tres formas diferentes:
- Hacer referencia a un archivo
- Etiquetas personalizadas
- Componentes compuestos
Hacer referencia a un archivo
La forma más sencilla de incluir el contenido de otro Facelet es hacer referencia a él por su nombre utilizando la <ui:include>etiqueta. [11] [12] Esto hace que el compilador de Facelets incluya directamente el contenido del archivo al que se hace referencia en el Facelet que lo llama. Además de reutilizar el contenido en varias ubicaciones, esto se puede utilizar para dividir un Facelet grande en partes más pequeñas.
A continuación se muestra un ejemplo:
plantillas/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" >
<ui:include src= "html_head.xhtml" />
<h:body>
Texto de encabezado estándar para cada página.
<ui:insert nombre= "contenido_del_cuerpo" />
Texto de pie de página estándar para cada página.
</h:body> </html>
encabezado_html.xhtml
<ui:compositionxmlns
= "http://www.w3.org/1999/xhtml"xmlns:h= " http://java.sun.com/jsf/html" >
<h:head>
<meta http-equiv= "tipo-contenido" contenido= "texto/html;conjunto-de-caracteres=UTF-8" /> <meta http-equiv= "pragma" contenido= "sin-caché" /> </h:head> </ui:composition>
Etiquetas personalizadas
Facelets admite la indirección para incluir contenido mediante etiquetas personalizadas. [13] Una etiqueta personalizada de este tipo se puede asociar con un Facelet en un archivo taglib. Las apariciones de esa etiqueta se reemplazarán con el contenido del Facelet asociado.
A continuación se muestra un ejemplo de esto:
plantillas/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" xmlns:my= "http://ejemplo.com/my" >
<ui:include src= "html_head.xhtml" />
<h:body>
Texto de encabezado estándar para cada página. <my:spacer>
<ui:insert nombre= "contenido_del_cuerpo" />
Texto de pie de página estándar para cada página.
</h:body> </html>
El código anterior utiliza la etiqueta <my:spacer>para marcar el punto en el Facelet donde se insertará el contenido. Dicha etiqueta debe declararse en un archivo Taglib donde se puede asociar con un Facelet de la siguiente manera:
ejemplo.taglib.xml
<?xml version="1.0" encoding="UTF-8"?>
<facelet-taglib xmlns= "http://java.sun.com/xml/ns/javaee" xmlns:xsi= "http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation= "http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-facelettaglibrary_2_0.xsd" version= "2.0" >
<espacio de nombres> http://ejemplo.com/mi < /espacio de nombres>
<tag>
<nombre-de-etiqueta> espaciador </nombre-de-etiqueta> <origen> espaciador.xhtml </origen> </tag> </facelet-taglib>
A continuación se muestra un ejemplo de cómo podría verse el contenido real de Facelet:
espaciador.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" >
<h:outputText valor= " " escape= "falso" /> </ui:composición>
Componentes compuestos
Además de incluir contenido directamente, Facelets proporciona el mecanismo de componente compuesto que hace que el contenido esté disponible como un componente JSF de primera clase. [14] [15] Los componentes compuestos no necesitan ser declarados en un archivo Taglib, sino que deben colocarse en un directorio especial. Por convención, al contenido se le asigna automáticamente un espacio de nombres y un nombre de etiqueta. El espacio de nombres se construye con la cadena fija 'http://java.sun.com/jsf/composite/' concatenada con el nombre del directorio en el que reside el archivo de contenido en relación con el directorio 'resources'. [16] El nombre de la etiqueta se convierte en el nombre del archivo sin el sufijo .xhtml.
A continuación se muestra un ejemplo de esto:
recursos/mi/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= " " escape= "false" /> </cc:implementation> </ui:composition>
El Facelet anterior está disponible automáticamente como un componente en el espacio de nombres 'http://java.sun.com/jsf/composite/my' y el nombre de etiqueta 'spacer'
Incluye parametrizado
Para personalizar el contenido incluido, Facelets permite el uso de parámetros. A través de esos parámetros, se pueden pasar objetos al contenido incluido, donde se pueden usar como variables. Para el <ui:include>mecanismo se <ui:param>puede usar para esto, [17] mientras que para las etiquetas personalizadas y los componentes compuestos, se pueden usar atributos de etiqueta normales. Los componentes compuestos requieren que se declaren parámetros en su sección de interfaz, [18] mientras que para las etiquetas personalizadas no existe tal requisito y los valores proporcionados para atributos arbitrarios se ponen a disposición como variables con el mismo nombre que dicho atributo.
Véase también
.svg/1280px-Free_and_open-source_software_logo_(2009).svg.png){kind=logo}
Referencias
- ^ Bergsten, Hans (9 de junio de 2004). "Mejora de JSF mediante el dumping de JSP". ONJava . O'Reilly Media . Archivado desde el original el 5 de abril de 2018.
- ^ "Facelets: marco de definición de vistas de JavaServer Faces". java.net . Archivado desde el original el 31 de diciembre de 2016.
- ^ ab Hookom, Jacob (17 de agosto de 2005). "Inside Facelets Part 1: An Introduction". JSFCentral . Archivado desde el original el 5 de enero de 2020.
- ^ Burns, Ed; Schalk, Chris (2009). JavaServer Faces 2.0, la referencia completa . McGraw-Hill . ISBN 978-0-07-162509-8. p. 55:
El grupo de expertos decidió seguir adelante con Facelets como base para nuevas funciones y dejar que JSP siga siendo una capa de compatibilidad con versiones anteriores.
- ^ Burns, Ed; Kitain, Roger, eds. (8 de noviembre de 2010). JavaServer Faces Specification, Version 2.1. JCP (Informe técnico) (MR2 ed.). Oracle . JSR-314. p. 10-1:
Facelets es un reemplazo para JSP que fue diseñado desde el principio con JSF en mente. Las nuevas características introducidas en la versión 2 y posteriores solo están expuestas a los autores de páginas que usan Facelets. JSP se conserva para compatibilidad con versiones anteriores.
- ^ "Preguntas más recientes sobre 'jsf'". stackoverflow.com . Consultado el 22 de noviembre de 2016 .
- ^ JavaServer Faces 2.0, la referencia completa de Ed Burns y Chris Schalk
- ^ Core JavaServer Faces (3.ª edición) de David Geary y Cay S. Horstmann
- ^ "JSF 2 fu, Parte 2: Plantillas y componentes compuestos". ibm.com . 2 de junio de 2009 . Consultado el 22 de noviembre de 2016 .
- ^ "ui (lenguaje de creación de páginas JSF 2.0: variante Facelets)". oracle.com . Consultado el 22 de noviembre de 2016 .
- ^ "include (lenguaje de descripción de páginas JSF 2.0: variante Facelets)". oracle.com . Consultado el 22 de noviembre de 2016 .
- ^ "Algunas cosas para recordar: Facelets ui:include se considera poderoso". pilhuhn.blogspot.com . 4 de diciembre de 2009 . Consultado el 22 de noviembre de 2016 .
- ^ "Componentes JSF personalizados con Facelets". wordpress.com . 29 de febrero de 2008. Archivado desde el original el 19 de octubre de 2016 . Consultado el 22 de noviembre de 2016 .
- ^ "composite(JSF 2.0 Page Decraration Language: Facelets Variant)" (Lenguaje de descifrado de páginas JSF 2.0: variante Facelets)". oracle.com . Consultado el 22 de noviembre de 2016 .
- ^ "¿Qué hay de nuevo en JSF 2?". wordpress.com . 31 de julio de 2009 . Consultado el 22 de noviembre de 2016 .
- ^ JSR 314, 10.3.3.1, http://jcp.org/en/jsr/detail?id=314
- ^ "param(JSF 2.0 Page Decraration Language: Facelets Variant)". oracle.com . Consultado el 22 de noviembre de 2016 .
- ^ "interfaz (lenguaje de decodificación de páginas JSF 2.0: variante Facelets)". oracle.com . Consultado el 22 de noviembre de 2016 .
Bibliografía
- Wadia, Zubin; Marinschek, Martin; Saleh, Hazem; Byrne, Dennis (22 de septiembre de 2008). La guía definitiva de Apache MyFaces y Facelets (1.ª ed.). Apress . p. 400. ISBN 978-1-59059-737-8. Archivado desde el original el 2 de enero de 2010 . Consultado el 4 de septiembre de 2009 .
- Wadia, Zubin; Aranda, Bruno (26 de mayo de 2008). Facelets Essentials: Guide to JavaServer Faces View Definition Framework (1.ª ed.). Apress . p. 84. ISBN 978-1-4302-1049-8. Archivado desde el original el 8 de enero de 2010 . Consultado el 4 de septiembre de 2009 .
Enlaces externos
- Capítulo 8 del Tutorial de Jakarta EE "Introducción a Facelets"
- Documentación para desarrolladores de Facelets en Wayback Machine (archivada el 31 de diciembre de 2016)
- Hightower, Richard (21 de febrero de 2006). "Facelets encaja a la perfección con JSF". Java. DeveloperWorks . IBM . Archivado desde el original el 24 de febrero de 2021.
- Página de inicio de Facelets en Wayback Machine (archivada el 4 de abril de 2017)
