te describiré Tapestry de forma teórica, sus principios y características
En este capítulo te describiré Tapestry de forma teórica, sus principios y características que en parte te permitirán
conocer por que puedes considerar útil la inversión de tiempo que vas a dedicar a este libro y a este framework.
Espero que despierten tu curiosidad y continúes leyendo el resto del libro ya viendo como como se hacen de
forma más práctica muchas de las cosas que una aplicación o página web tiene que abordar y que un framework
debe facilitar.

Principios
Tapestry es un framework orientado a componentes para el desarrollo de aplicaciones web programadas en el lenguaje Java dinámicas, robustas y altamente escalables. Se sitúa en el mismo campo que Wicket y JSF en vez de junto con Spring MVC, Grails y Play!, estos últimos orientados a acciones como Struts.
Posee muchas características, algunas muy buenas desde sus inicios como el ser lo máximo informativo que le es posible cuando se producen excepciones y que aún frameworks más recientes y nuevos aún no poseen. Muchas de estas características han cambiado y sido añadidas con cada nueva versión mayor y otras siguen siendo muy similares a como eran anteriormente. Aparte de las características principales hay muchos otros detalles más pequeños que hacen agradable y simple usar este framework. Los principios que guían el desarrollo de Tapestry son los siguientes.
Simplicidad
Esto implica que las plantillas y código sea legible y conciso. También implica que no se extiende de las clases de
Tapestry. Al ser las clases POJO (Plain Old Java Objects) se facilitan las pruebas unitarias y se evitan problemas
al realizar actualizaciones a versiones superiores.
Consistencia
Significa que lo que funciona a un nivel, como en una página completa, funciona también para los componentes
dentro de una página. De esta manera los componentes anidados tienen la misma libertad de persistir datos,
anidar otros componentes y responder a eventos como en la página de nivel superior. De hecho los componentes
y páginas se distinguen más bien en poco salvo por que los componentes están contenidos en otras páginas o
componentes y las páginas están en el nivel superior de la jerarquía.
Feedback
Una de la más importante. En los primeros días de los servlets y JSP la realidad era que en el mejor de los casos
obteníamos una excepción en el navegador o el log del servidor en el momento de producirse una. Únicamente a
partir de esa traza de la excepción uno tenía que averiguar que había sucedido. Tapestry proporciona más información
que una excepción, genera un informe en el que se incluye toda la información necesaria para determinar
la causa real. Disponer de únicamente la traza de un NullPointerException (por citar alguna) se considera un fallo
del framework y simplemente eso no ocurre en Tapestry (al menos en el momento de desarrollo). El informe
incluye líneas precisas de código que pueden decir que tienes un error en la línea 50 de una plantilla y mostrar
un extracto del código directamente en el informe de error además de los parámetros, algunos atributos de la
request, las cabeceras y cookies que envío del navegador además de las variables de entorno, el classpath y
atributos y valores de la sesión, por supuesto también incluye la traza de la excepción.

Eficiencia
A medida que ha evolucionado ha ido mejorando tanto en velocidad operando de forma más concurrente y en
consumo de memoria. Se ha priorizado primero en escalar verticalmente que horizontalmente mediante clusters,
que aún con afinidad de sesiones complican la infraestructura considerablemente y supone retos a solucionar.
Tapestry usa la sesión de forma diferente a otros frameworks tendiendo a usar valores inmutables y simples
como números y cadenas que están más acorde con el diseño de la especificación de la API de los servlets
Estructura estática, comportamiento dinámico
El concepto de comportamiento dinámico debería ser obvio al construir una aplicación web, las cosas deben ser
diferentes ante diferentes usuarios y situaciones. Pero, ¿qué significa que Tapestry tiene estructura estática?
La estructura estática implica que cuando se construye una página en Tapestry se define todos los tipos de
los componentes que son usando en la página. En ninguna circunstancia durante la fase de generación o el
procesado de un evento la página podrá crear dinámicamente un nuevo tipo de componente y colocarlo en el
árbol de componentes de la página.
En un primer momento, esto parece bastante limitante... otros frameworks permiten crear nuevos elementos
dinámicamente, es también una característica común de las interfaces de usuario como Swing. Pero una estructura
estática resulta no tan limitante después de todo. Puedes crear nuevos elementos «re-rendering» componentes
existentes usando diferentes valores para las propiedades y tienes multitud de opciones para obtener
comportamiento dinámico de la estructura estática, desde un simple condicional y componentes de bucle a implementaciones
más avanzadas como los componentes BeanEdit o Grid. Tapestry proporciona el control sobre
que se genera y cuando, e incluso cuando aparece en la página. Y desde Tapestry 5.3 se puede usar incluso el
componente Dynamic que genera lo que esté en un archivo de plantilla externo.
¿Por qué Tapestry eligió una estructura estática como un principio básico?
En realidad es debido a los requerimientos
de agilidad y escalabilidad.
Agilidad
Tapestry está diseñado para ser un entorno de desarrollo ágil , «code less, deliver more». Para permitir escribir
menos código Tapestry realiza mucho trabajo en las clases POJO de páginas y componentes cuando se cargan
por primera vez. También usa instancias de clases compartidas de páginas y componentes (compartidas entre
múltiples hilos y peticiones). Tener una estructura modificable implica que cada petición tiene su instancia, y es
más, que la estructura entera necesitaría ser serializada entre peticiones para que puedan ser restablecidas para
procesar peticiones posteriores
Con Tapestry se es más ágil al acelerar el ciclo de desarrollo con la recarga de clases dinámica. Tapestry monitoriza
el sistema de archivos en búsqueda de cambios a las clases de las páginas, clases de componentes,
implementaciones de servicios, plantillas HTML y archivos de propiedades y aplica los cambios con la aplicación
en ejecución sin requerir un reinicio o perder los datos de sesión. Esto proporciona un ciclo muy corto de
codificación, guardado y visualización que no todos los frameworks pueden igualar
Escalabilidad
Al construir sistemas grandes que escalen es importante considerar como se usan los recursos en cada servidor
y como esa información va a ser compartida entre los servidores. Una estructura estática significa que las instancias
de las páginas no necesitan ser almacenadas dentro de HttpSession y no se requieren recursos extras
en navegaciones simples. Este uso ligero de HttpSession es clave para que Tapestry sea altamente escalable,
especialmente en configuraciones cluster. De nuevo, unir una instancia de una página a un cliente particular requiere
significativamente más recursos de servidor que tener solo una instancia de página compartida.
Adaptabilidad
En los frameworks Java tradicionales (incluyendo Struts, JSF e incluso el antiguo Tapestry 4) el código del
usuario se esperaba que se ajustase al framework. Se creaban clases que extendiesen de las clases base o implementaba interfaces proporcionadas por el framework. Esto funciona bien hasta que actualizas a la siguiente
versión del framework, con nuevas características, y más a menudo que no se rompe la compatibilidad hacia atrás.
Las interfaces o clases base habrán cambiado y el código existente necesitará ser cambiado para ajustarse.
En Tapestry 5, el framework se adapta al código. Se tiene el control sobre los nombres de los métodos, los
parámetros y el valor que es retornado. Esto es posible mediante anotaciones que informan a Tapestry que
métodos invocar. Por ejemplo, podemos tener una página de inicio de sesión y un método que se invoca cuando
el formulario es enviado.
SIGUE APRENDIENDO DESCARGANDO EL ARCHIVO