Introduzione ad Apache Tapestry

1. Panoramica

Oggigiorno, dai social network alle banche, dalla sanità ai servizi governativi, tutte le attività sono disponibili online. Pertanto, fanno molto affidamento sulle applicazioni web.

Un'applicazione Web consente agli utenti di utilizzare / usufruire dei servizi online forniti da un'azienda. Allo stesso tempo, funge da interfaccia per il software di backend.

In questo tutorial introduttivo, esploreremo il framework web Apache Tapestry e creeremo una semplice applicazione web utilizzando le funzionalità di base che fornisce.

2. Apache Tapestry

Apache Tapestry è un framework basato su componenti per la creazione di applicazioni web scalabili.

Segue il paradigma della convenzione sulla configurazione e utilizza annotazioni e convenzioni di denominazione per le configurazioni.

Tutti i componenti sono semplici POJO. Allo stesso tempo, vengono sviluppati da zero e non hanno dipendenze da altre librerie.

Insieme al supporto Ajax, Tapestry ha anche ottime capacità di segnalazione delle eccezioni. Fornisce anche un'ampia libreria di componenti comuni incorporati.

Tra le altre grandi caratteristiche, una di spicco è il ricaricamento a caldo del codice. Pertanto, utilizzando questa funzione, possiamo vedere i cambiamenti istantaneamente nell'ambiente di sviluppo.

3. Configurazione

Apache Tapestry richiede un semplice set di strumenti per creare un'applicazione web:

  • Java 1.6 o successivo
  • Strumento di costruzione (Maven o Gradle)
  • IDE (Eclipse o IntelliJ)
  • Application Server (Tomcat o Jetty)

In questo tutorial, useremo la combinazione di Java 8, Maven, Eclipse e Jetty Server.

Per configurare l'ultimo progetto Apache Tapestry, useremo l'archetipo Maven e seguiremo le istruzioni fornite dalla documentazione ufficiale:

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

Oppure, se abbiamo un progetto esistente, possiamo semplicemente aggiungere la dipendenza Maven arazzo-core al pom.xml :

 org.apache.tapestry tapestry-core 5.4.5 

Una volta che siamo pronti con la configurazione, possiamo avviare l'applicazione apache-tapestry con il seguente comando Maven:

$ mvn jetty:run

Per impostazione predefinita, l'app sarà accessibile su localhost: 8080 / apache-tapestry :

4. Struttura del progetto

Esploriamo il layout del progetto creato da Apache Tapestry:

Possiamo vedere una struttura di progetto simile a Maven, insieme ad alcuni pacchetti basati su convenzioni.

Le classi Java sono inserite in src / main / java e classificate come componenti , pagine e servizi.

Allo stesso modo, src / main / resources contengono i nostri modelli (simili ai file HTML) - questi hanno l' estensione .tml .

Per ogni classe Java posta sotto componenti e directory di pagine , dovrebbe essere creato un file modello con lo stesso nome.

La directory src / main / webapp contiene risorse come immagini, fogli di stile e file JavaScript. Allo stesso modo, i file di test vengono inseriti in src / test .

Infine, src / site conterrà i file di documentazione.

Per un'idea migliore, diamo un'occhiata alla struttura del progetto aperta in Eclipse IDE:

5. Annotazioni

Parliamo di alcune utili annotazioni fornite da Apache Tapestry per l'uso quotidiano. In futuro, utilizzeremo queste annotazioni nelle nostre implementazioni.

5.1. @Iniettare

L' annotazione @Inject è disponibile nel pacchetto org.apache.tapestry5.ioc.annotations e fornisce un modo semplice per iniettare dipendenze nelle classi Java.

Questa annotazione è molto utile per iniettare un asset, un blocco, una risorsa e un servizio.

5.2. @InjectPage

Disponibile nel pacchetto org.apache.tapestry5.annotations , l' annotazione @InjectPage ci consente di inserire una pagina in un altro componente. Inoltre, la pagina inserita è sempre una proprietà di sola lettura.

5.3. @InjectComponent

Allo stesso modo, l' annotazione @InjectComponent ci consente di iniettare un componente definito nel modello.

5.4. @Log

L' annotazione @Log è disponibile nel pacchetto org.apache.tapestry5.annotations ed è utile per abilitare la registrazione a livello di DEBUG su qualsiasi metodo. Registra l'entrata e l'uscita dal metodo, insieme ai valori dei parametri.

5.5. @Proprietà

Available in the org.apache.tapestry5.annotations package, the @Property annotation marks a field as a property. At the same time, it automatically creates getters and setters for the property.

5.6. @Parameter

Similarly, the @Parameter annotation denotes that a field is a component parameter.

6. Page

So, we're all set to explore the basic features of the framework. Let's create a new Home page in our app.

First, we'll define a Java class Home in the pages directory in src/main/java:

public class Home { }

6.1. Template

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.

Quindi, apportiamo le modifiche richieste nella classe Home :

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

Ora, quando facciamo clic sul pulsante Chiama Ajax, il logger accederà a livello INFO:

[INFO] pages.Home Ajax call 

12. Conclusione

In questo articolo, abbiamo esplorato il framework web Apache Tapestry.

Per cominciare, abbiamo creato un'applicazione web di avvio rapido e aggiunto una home page utilizzando le funzionalità di base di Apache Tapestry, come componenti , pagine e modelli .

Quindi, abbiamo esaminato alcune utili annotazioni fornite da Apache Tapestry per configurare una proprietà e un'iniezione di componente / pagina.

Infine, abbiamo esplorato l'Ajax integrato e il supporto per la registrazione fornito dal framework.

Come al solito, tutte le implementazioni del codice sono disponibili su GitHub.