Introduction à la tapisserie Apache

1. Vue d'ensemble

De nos jours, des réseaux sociaux aux services bancaires, des soins de santé aux services gouvernementaux, toutes les activités sont disponibles en ligne. Par conséquent, ils s'appuient fortement sur les applications Web.

Une application Web permet aux utilisateurs de consommer / profiter des services en ligne fournis par une entreprise. En même temps, il agit comme une interface avec le logiciel backend.

Dans ce didacticiel d'introduction, nous explorerons le framework Web Apache Tapestry et créerons une application Web simple en utilisant les fonctionnalités de base qu'il fournit.

2. Tapisserie Apache

Apache Tapestry est un framework basé sur des composants pour créer des applications Web évolutives.

Il suit le paradigme de la convention sur la configuration et utilise des annotations et des conventions de dénomination pour les configurations.

Tous les composants sont de simples POJO. En même temps, ils sont développés à partir de zéro et n'ont aucune dépendance vis-à-vis d'autres bibliothèques.

Outre la prise en charge d'Ajax, Tapestry dispose également d'excellentes capacités de rapport d'exception. Il fournit également une bibliothèque étendue de composants communs intégrés.

Parmi les autres fonctionnalités intéressantes, l'une des principales est le rechargement à chaud du code. Par conséquent, en utilisant cette fonctionnalité, nous pouvons voir les changements instantanément dans l'environnement de développement.

3. Configuration

Apache Tapestry nécessite un ensemble simple d'outils pour créer une application Web:

  • Java 1.6 ou version ultérieure
  • Outil de création (Maven ou Gradle)
  • IDE (Eclipse ou IntelliJ)
  • Serveur d'applications (Tomcat ou Jetty)

Dans ce didacticiel, nous utiliserons la combinaison de Java 8, Maven, Eclipse et Jetty Server.

Pour configurer le dernier projet Apache Tapestry, nous utiliserons l'archétype Maven et suivrons les instructions fournies par la documentation officielle:

$ mvn archetype:generate -DarchetypeCatalog=//tapestry.apache.org

Ou, si nous avons un projet existant, nous pouvons simplement ajouter la dépendance Maven tapestry-core au pom.xml :

 org.apache.tapestry tapestry-core 5.4.5 

Une fois que nous sommes prêts avec la configuration, nous pouvons démarrer l'application apache-tapestry par la commande Maven suivante:

$ mvn jetty:run

Par défaut, l'application sera accessible sur localhost: 8080 / apache-tapestry :

4. Structure du projet

Explorons la mise en page du projet créée par Apache Tapestry:

Nous pouvons voir une structure de projet de type Maven, ainsi que quelques packages basés sur des conventions.

Les classes Java sont placées dans src / main / java et classées en tant que composants , pages et services.

De même, src / main / resources contient nos modèles (similaires aux fichiers HTML) - ceux-ci ont l' extension .tml .

Pour chaque classe Java placée sous les répertoires de composants et de pages , un fichier modèle portant le même nom doit être créé.

Le répertoire src / main / webapp contient des ressources telles que des images, des feuilles de style et des fichiers JavaScript. De même, les fichiers de test sont placés dans src / test .

Enfin, src / site contiendra les fichiers de documentation.

Pour une meilleure idée, jetons un coup d'œil à la structure du projet ouverte dans Eclipse IDE:

5. Annotations

Discutons de quelques annotations pratiques fournies par Apache Tapestry pour une utilisation quotidienne. À l'avenir, nous utiliserons ces annotations dans nos implémentations.

5.1. @Injecter

L' annotation @Inject est disponible dans le package org.apache.tapestry5.ioc.annotations et fournit un moyen simple d'injecter des dépendances dans les classes Java.

Cette annotation est assez pratique pour injecter un actif, un bloc, une ressource et un service.

5.2. @InjectPage

Disponible dans le package org.apache.tapestry5.annotations , l' annotation @InjectPage nous permet d'injecter une page dans un autre composant. De plus, la page injectée est toujours une propriété en lecture seule.

5.3. @InjectComponent

De même, l' annotation @InjectComponent nous permet d'injecter un composant défini dans le modèle.

5.4. @Journal

L' annotation @Log est disponible dans le package org.apache.tapestry5.annotations et est pratique pour activer la journalisation de niveau DEBUG sur n'importe quelle méthode. Il enregistre l'entrée et la sortie de méthode, ainsi que les valeurs des paramètres.

5.5. @Propriété

Disponible dans le package org.apache.tapestry5.annotations , l' annotation @Property marque un champ comme une propriété. Dans le même temps, il crée automatiquement des getters et des setters pour la propriété.

5.6. @Paramètre

De même, l' annotation @Parameter indique qu'un champ est un paramètre de composant.

6. Page

Nous sommes donc tous prêts à explorer les fonctionnalités de base du framework. Créons une nouvelle page d' accueil dans notre application.

Tout d'abord, nous allons définir une classe Java Home dans le répertoire pages de src / main / java :

public class Home { }

6.1. Modèle

Then, we'll create a corresponding Home.tml template in the pages directory under src/main/resources.

A file with the extension .tml (Tapestry Markup Language) is similar to an HTML/XHTML file with XML markup provided by Apache Tapestry.

For instance, let's have a look at the Home.tml template:

  apache-tapestry Home   

Voila! Simply by restarting the Jetty server, we can access the Home page at localhost:8080/apache-tapestry/home:

6.2. Property

Let's explore how to render a property on the Home page.

For this, we'll add a property and a getter method in the Home class:

@Property private String appName = "apache-tapestry"; public Date getCurrentTime() { return new Date(); }

To render the appName property on the Home page, we can simply use ${appName}.

Similarly, we can write ${currentTime} to access the getCurrentTime method from the page.

6.3. Localization

Apache Tapestry provides integrated localization support. As per convention, a page name property file keeps the list of all the local messages to render on the page.

For instance, we'll create a home.properties file in the pages directory for the Home page with a local message:

introMsg=Welcome to the Apache Tapestry Tutorial

The message properties are different from the Java properties.

For the same reason, the key name with the message prefix is used to render a message property — for instance, ${message:introMsg}.

6.4. Layout Component

Let's define a basic layout component by creating the Layout.java class. We'll keep the file in the components directory in src/main/java:

public class Layout { @Property @Parameter(required = true, defaultPrefix = BindingConstants.LITERAL) private String title; }

Here, the title property is marked required, and the default prefix for binding is set as literal String.

Then, we'll write a corresponding template file Layout.tml in the components directory in src/main/resources:

  ${title} 
     

© Your Company

Now, let's use the layout on the home page:

${message:introMsg}

${currentTime}

Note, the namespace is used to identify the elements (t:type and t:body) provided by Apache Tapestry. At the same time, the namespace also provides components and attributes.

Here, the t:type will set the layout on the home page. And, the t:body element will insert the content of the page.

Let's take a look at the Home page with the layout:

7. Form

Let's create a Login page with a form, to allow users to sign-in.

As already explored, we'll first create a Java class Login:

public class Login { // ... @InjectComponent private Form login; @Property private String email; @Property private String password; }

Here, we've defined two properties — email and password. Also, we've injected a Form component for the login.

Then, let's create a corresponding template login.tml:

Please sign in

Now, we can access the login page at localhost:8080/apache-tapestry/login:

8. Validation

Apache Tapestry provides a few built-in methods for form validation. It also provides ways to handle the success or failure of the form submission.

The built-in method follows the convention of the event and the component name. For instance, the method onValidationFromLogin will validate the Login component.

Likewise, methods like onSuccessFromLogin and onFailureFromLogin are for success and failure events respectively.

So, let's add these built-in methods to the Login class:

public class Login { // ... void onValidateFromLogin() { if (email == null) System.out.println("Email is null); if (password == null) System.out.println("Password is null); } Object onSuccessFromLogin() { System.out.println("Welcome! Login Successful"); return Home.class; } void onFailureFromLogin() { System.out.println("Please try again with correct credentials"); } }

9. Alerts

Form validation is incomplete without proper alerts. Not to mention, the framework also has built-in support for alert messages.

For this, we'll first inject the instance of the AlertManager in the Login class to manage the alerts. Then, replace the println statements in existing methods with the alert messages:

public class Login { // ... @Inject private AlertManager alertManager; void onValidateFromLogin() { if(email == null || password == null) { alertManager.error("Email/Password is null"); login.recordError("Validation failed"); //submission failure on the form } } Object onSuccessFromLogin() { alertManager.success("Welcome! Login Successful"); return Home.class; } void onFailureFromLogin() { alertManager.error("Please try again with correct credentials"); } }

Let's see the alerts in action when the login fails:

10. Ajax

So far, we've explored the creation of a simple home page with a form. At the same time, we've seen the validations and support for alert messages.

Next, let's explore the Apache Tapestry's built-in support for Ajax.

First, we'll inject the instance of the AjaxResponseRenderer and Block component in the Home class. Then, we'll create a method onCallAjax for processing the Ajax call:

public class Home { // .... @Inject private AjaxResponseRenderer ajaxResponseRenderer; @Inject private Block ajaxBlock; @Log void onCallAjax() { ajaxResponseRenderer.addRender("ajaxZone", ajaxBlock); } }

Also, we need to make a few changes in our Home.tml.

First, we'll add the eventLink to invoke the onCallAjax method. Then, we'll add a zone element with id ajaxZone to render the Ajax response.

Last, we need to have a block component that will be injected in the Home class and rendered as Ajax response:

Call Ajax


Rendered through Ajax

The current time is: ${currentTime}

Let's take a look at the updated home page:

Then, we can click the Call Ajax button and see the ajaxResponseRenderer in action:

11. Logging

To enable the built-in logging feature, the instance of the Logger is required to be injected. Then, we can use it to log at any level like TRACE, DEBUG, and INFO.

Alors, apportons les modifications requises dans la classe Home :

public class Home { // ... @Inject private Logger logger; void onCallAjax() { logger.info("Ajax call"); ajaxResponseRenderer.addRender("ajaxZone", ajaxBlock); } }

Maintenant, lorsque nous cliquons sur le bouton Appeler Ajax, l' enregistreur se connecte au niveau INFO:

[INFO] pages.Home Ajax call 

12. Conclusion

Dans cet article, nous avons exploré le framework Web Apache Tapestry.

Pour commencer, nous avons créé une application Web de démarrage rapide et ajouté une page d' accueil utilisant les fonctionnalités de base d'Apache Tapestry, telles que les composants , les pages et les modèles .

Ensuite, nous avons examiné quelques annotations pratiques fournies par Apache Tapestry pour configurer une propriété et une injection de composant / page.

Enfin, nous avons exploré la prise en charge intégrée d'Ajax et de la journalisation fournie par le framework.

Comme d'habitude, toutes les implémentations de code sont disponibles sur sur GitHub.