Einführung in Apache Tapestry

1. Übersicht

Heutzutage sind alle Aktivitäten online verfügbar, von sozialen Netzwerken über Bankgeschäfte, Gesundheitswesen bis hin zu staatlichen Dienstleistungen. Daher sind sie stark auf Webanwendungen angewiesen.

Mit einer Webanwendung können Benutzer die von einem Unternehmen bereitgestellten Onlinedienste nutzen / genießen. Gleichzeitig fungiert es als Schnittstelle zur Backend-Software.

In diesem Einführungs-Tutorial werden wir das Apache Tapestry-Webframework untersuchen und eine einfache Webanwendung mit den darin enthaltenen Grundfunktionen erstellen.

2. Apache Tapisserie

Apache Tapestry ist ein komponentenbasiertes Framework zum Erstellen skalierbarer Webanwendungen.

Es folgt dem Paradigma der Konvention über Konfiguration und verwendet Anmerkungen und Namenskonventionen für Konfigurationen.

Alle Komponenten sind einfache POJOs. Gleichzeitig werden sie von Grund auf neu entwickelt und sind nicht von anderen Bibliotheken abhängig.

Neben der Ajax-Unterstützung bietet Tapestry auch hervorragende Funktionen für die Berichterstellung von Ausnahmen. Es bietet auch eine umfangreiche Bibliothek integrierter gemeinsamer Komponenten.

Eine herausragende Funktion ist unter anderem das Hot-Reload des Codes. Daher können wir mit dieser Funktion die Änderungen sofort in der Entwicklungsumgebung sehen.

3. Setup

Apache Tapestry erfordert eine Reihe einfacher Tools zum Erstellen einer Webanwendung:

  • Java 1.6 oder höher
  • Build Tool (Maven oder Gradle)
  • IDE (Eclipse oder IntelliJ)
  • Anwendungsserver (Tomcat oder Jetty)

In diesem Tutorial verwenden wir die Kombination aus Java 8, Maven, Eclipse und Jetty Server.

Um das neueste Apache Tapestry-Projekt einzurichten, verwenden wir den Archetyp Maven und befolgen die Anweisungen in der offiziellen Dokumentation:

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

Wenn wir bereits ein Projekt haben, können wir der pom.xml einfach die Maven-Abhängigkeit des Gobelin-Kerns hinzufügen :

 org.apache.tapestry tapestry-core 5.4.5 

Sobald wir mit dem Setup fertig sind, können wir den Apache-Tapisserie der Anwendung mit dem folgenden Maven-Befehl starten :

$ mvn jetty:run

Standardmäßig ist die App unter localhost zugänglich : 8080 / apache-tapestry :

4. Projektstruktur

Lassen Sie uns das von Apache Tapestry erstellte Projektlayout untersuchen:

Wir können eine Maven-ähnliche Projektstruktur sehen, zusammen mit einigen Paketen, die auf Konventionen basieren.

Die Java-Klassen werden in src / main / java abgelegt und als Komponenten , Seiten und Dienste kategorisiert .

Ebenso enthält src / main / resources unsere Vorlagen (ähnlich wie HTML-Dateien) - diese haben die Erweiterung .tml .

Für jede Java - Klasse platziert unter Komponenten und Seiten - Verzeichnissen, sollte eine Vorlagendatei mit dem gleichen Namen erstellt werden.

Das Verzeichnis src / main / webapp enthält Ressourcen wie Bilder, Stylesheets und JavaScript-Dateien. Ebenso werden Testdateien in src / test abgelegt .

Zuletzt enthält src / site die Dokumentationsdateien.

Schauen wir uns zur besseren Vorstellung die in Eclipse IDE geöffnete Projektstruktur an:

5. Anmerkungen

Lassen Sie uns einige nützliche Anmerkungen diskutieren, die von Apache Tapestry für den täglichen Gebrauch bereitgestellt werden. In Zukunft werden wir diese Anmerkungen in unseren Implementierungen verwenden.

5.1. @Injizieren

Die Annotation @Inject ist im Paket org.apache.tapestry5.ioc.annotations verfügbar und bietet eine einfache Möglichkeit, Abhängigkeiten in Java-Klassen einzufügen .

Diese Anmerkung ist sehr praktisch, um ein Asset, einen Block, eine Ressource und einen Service einzufügen.

5.2. @InjectPage

Die Annotation @InjectPage ist im Paket org.apache.tapestry5.annotations verfügbar und ermöglicht es uns, eine Seite in eine andere Komponente einzufügen . Außerdem ist die injizierte Seite immer schreibgeschützt.

5.3. @InjectComponent

In ähnlicher Weise können wir mit der Annotation @InjectComponent eine in der Vorlage definierte Komponente einfügen .

5.4. @Log

Die @Log Anmerkung ist im org.apache.tapestry5.annotations Paket und ist praktisch , um die Debug - Level - Protokollierung auf einem beliebigen Verfahren zu ermöglichen. Es protokolliert den Ein- und Ausgang von Methoden sowie Parameterwerte.

5.5. @Eigentum

Die Annotation @Property ist im Paket org.apache.tapestry5.annotations verfügbar und markiert ein Feld als Eigenschaft. Gleichzeitig werden automatisch Getter und Setter für die Eigenschaft erstellt.

5.6. @Parameter

In ähnlicher Weise gibt die Annotation @Parameter an, dass ein Feld ein Komponentenparameter ist.

6. Seite

Wir sind also alle bereit, die grundlegenden Funktionen des Frameworks zu untersuchen. Lassen Sie sich eine neue erstellen Startseite Seite in unserer App.

Zunächst werden wir eine Java - Klasse definieren Start in den Seiten - Verzeichnis in src / main / java :

public class Home { }

6.1. Vorlage

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.

Nehmen wir also die erforderlichen Änderungen in der Home- Klasse vor:

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

Wenn wir nun auf die Schaltfläche Ajax aufrufen klicken, protokolliert der Logger auf INFO-Ebene:

[INFO] pages.Home Ajax call 

12. Schlussfolgerung

In diesem Artikel haben wir das Apache Tapestry-Webframework untersucht.

Zunächst haben wir eine Schnellstart-Webanwendung erstellt und eine Startseite hinzugefügt, die die grundlegenden Funktionen von Apache Tapestry wie Komponenten , Seiten und Vorlagen verwendet .

Anschließend haben wir einige nützliche Anmerkungen von Apache Tapestry untersucht, um eine Eigenschaft und eine Komponenten- / Seiteninjektion zu konfigurieren.

Zuletzt haben wir uns mit der integrierten Ajax- und Protokollierungsunterstützung des Frameworks befasst.

Wie üblich sind alle Code-Implementierungen über GitHub verfügbar.