martes, 17 de marzo de 2009

Facelets: el fin de la crisis diseño/desarrollo provocada por JSF

Típicamente se define Facelets como un sistema de plantillas para JSF al estilo de Tapestry para Struts, pero en realidad la definición se queda pobre y, desde mi punto de vista, no es representativa de sus características más importantes. En este artículo expondré por qué es tan importante y daré las suficientes razones como para que nadie que desarrolle JSF se resista a usarlo.

JSF: La crisis diseño/desarrollo

JSF tiene muchas ventajas para el desarrollo de aplicaciones web, especialmente para las aplicaciones ricas tipo RIA que tengan necesidades de presentación de datos de forma interactivas, ya que nos permite ver las aplicaciones como "formularios" y "componentes" al estilo de las aplicaciones de escritorio y nos oculta todo el engorro de bajo nivel web (POST, GET, trabajo con objetos del contenedor de Servlet directamente, etc,..). Sin embargo, el modelo de desarrollo de JSF requiere un cambio conceptual en los equipos de desarrollo que en algunas ocasiones es duro:
  • Los desarrolladores que están acostumbrados a una programación lineal tipo scripting (JSP/JSTL, PHP, ASP, etc...) se encuentran ahora con un modelo de componentes con su "ciclo de vida" específico: un elemento bajo otro no necesariamente se interpreta/ejecuta después de otro.
  • La forma de trabajar clásica era partir de un diseño realizado y "hacerlo dinámico" o al revés, el equipo de diseño/desarrollo toma la aplicación "fea" de desarrolladores y le aplica el diseño. Con JSF esta forma de trabajar es muy complicada y frustrante:
    • Para aplicar diseño a los componentes hay que conocer los componentes y el modelo de trabajo, así que los diseñadores/maquetadores se encuentran con su pequeño infierno teniendo que pegarse con "cosas de los desarrolladores" que desconocen.
    • Partir de un diseño y aplicar componentes es igual de frustrante y de poco exitoso. Y justo al igual que en el otro caso, la mayoría de los desarrolladores pierden mucho tiempo en intentar "pegarse" con CSS y "cosas de los maquetadores" que desconocen. Mantener la maquetación y composición que han realizado los diseñadores se convierte en un infierno.
  • Los controles de layout (panels, tabs, boxes, etc...) son un dolor de cabeza para los maquetadores/diseñadores que se ven obligados a aprender las técnicas de skinning de cada librería de componentes y se encuentran con que es imposible aplicar sus diseños correctamente
  • Con JSP/JSTL se puede utilizar la reutilización de presentación vía Custom Tag Files y/o includes... pero hacer componentes con JSF es es un verdadero engorro y los f:subviews son imprácticos en la mayoría de los casos.
En definitiva, el ahorro de tiempo en y las ventajas en robustez y legibilidad de la aplicación no acaban de compensar el mayor coste de desarrollo y la inconveniencia de dos equipos de trabajo que han empezado a trabajar incómodos y descoordinados. Así que el uso de JSF parece que se relega a aplicaciones donde el diseño tenga poco peso e importancia, o al menos en favor de la interactividad y la riqueza de la experiencia de usuario, es decir: intranets o aplicaciones de gestión/administración de sistemas.


Facelets al rescate

Desde luego, las aplicaciones donde JSF presta todas sus ventajas son aquellas en las que no es necesario un diseño previo. Para este tipo de aplicaciones el desarrollador puede usar las librerías de componentes existentes para crear interfaces muy usables, funcionales y con un aspecto realmente espectacular para un en entorno web, sin tareas de maquetación y/o diseño adicionales.

Sin embargo hay proyectos en los que se opta por una tecnología más tradicional, como JSTL, para que los desarrolladores, pero especialmente los diseñadores/maquetadores tengan total libertad en el aspecto final de la interfaz, sacrificando las ventajas de la programación con JSF y sus útiles componentes.

Sin embargo, Facelets puede ofrecernos esa libertad sin renunciar a trabajar con un modelo MVC como JSF:
  • Las páginas con facelets son XHTML, tal cual. Los diseñadores/maquetadores se sentirán tan cómodos como con una página JSTL/JSP, y las herramientas de diseño podrán interpretarlas como HTML que son.
  • Se puede poner texto, tags HTML y expresiones EL en cualquier parte de la página y Facelets las evaluará correctamente: se acabó tener que usar los engorrosos h:outputText o f:verbatim sólo para poner una propiedad de un bean o un tag HTML. Esto te permite, por ejemplo, que sean los diseñadores/maquetadores los que establezcan el layout de los componentes y su aspecto, y así evitar tener que usar componentes para alinear dos campos o centrar un texto.
  • Te permite trabajar "al estilo JSTL", es decir, como usando JSP con tags: lo que  ponemos "debajo de" se interpretará "después de". Esto es así porque aunque con Facelets se produce un árbol de componentes (no un servlet como con JSP), el árbol de componentes es coherente con el ciclo de vida de JSF.
En definitiva, Facelets te permite trabajar con JSF de una forma más natural, y la curva de aprendizaje para desarrolladores que no hayan trabajado con JSF es mucho más liviana. Con Facelets podemos volver a conciliar la crisis de los equipos de trabajo en los proyectos web, ya que la forma de trabajo vuelve a ser más amistosa con los diseñadores y el modelo de componentes "encaja" de nuevo con una visión orientada a documentos desde el punto de vista del diseño.

Aún hay más

Desde mi punto de vista y en el mundo de desarrollo en el que me muevo, las características comentadas son las más importantes de Facelets, y sólo por ello, ya merecería la pena usarlo. No obstante, Facelets es una tecnología de "Vista" específicamente diseñada para JSF, así que nos depara muchas gratas sorpresas funcionales extremadamente interesantes:
  • Plantillas. Facelets es un sistema de plantillas con JSF en mente, lo que nos permite acelerar el desarrollo enormemente con la misma facilidad y enfoque con el que se puede considerar a JSP un sistema de plantillas para servlets (el cuerpo de una JSP acaba siendo el método jspService()).
  • Desarrollo cero para componentes. Hacer un componente JSF (o "componentizar" un trozo de una página) es tan simple como extraerlo en un fichero aparte. Facelets es a los componentes JSF lo que fueron los Custom Tag Files a JSP 2.0. Una maravilla.
  • Informes de errores precisos. El tiempo que tarda un desarrollador JSF en interpretar los ininteligibles mensajes de error es indirectamente proporcional a sus "horas de vuelo". Los mensajes de error nunca indican en qué componente, y menos aún en qué línea se ha producido. Es un proceso de adivinación a base de leer las decenas de líneas del Stack trace. Con Facelets tenemos por fin errores precisos sobre la línea, tag y atributo donde se ha producido. Otra de ésas razones por las que merecería la pena usarlo, aunque fuese la única.

Conclusiones

Facelets se debe añadir por defecto a cualquier proyecto JSF, aunque no se vayan a hacer componentes ni plantillas. Usar HTML y tener errores informados son razones suficientes para incorporarlo siempre. De hecho se añadirá al estándar en JSF 2.0.

Más información:
https://facelets.dev.java.net/
http://wiki.java.net/bin/view/Projects/Facelets
http://www.ibm.com/developerworks/java/library/j-facelets/
https://facelets.dev.java.net/nonav/docs/dev/docbook.html

No hay comentarios :

Publicar un comentario

Related Posts Plugin for WordPress, Blogger...
cookieassistant.com