import org.slf4j.Logger;
@Inject
private Logger logger;

A little bit more complicated is the usage in a Tapestry-Service. Here an @Inject Annotation will fail, so you would have to get an instance for your logger from another source. One possibility would be to use a build-method in your Module class. But then, you would have to distribute such method for each service which should use a logger.

Tapestry helps you here and can contribute the needed Logger instance if you insert a constructor method to your service:

import org.slf4j.Logger;

private final Logger logger;

public MyServiceImpl(final Logger _logger){
    this.logger = _logger;
    this.logger.debug("Successfully initialized MyServiceImpl);
}

Your Service will now be initialized with a working instance of the Logger-class.

Tapestry 5: Die Entwicklung von Webanwendungen mit Leichtigkeit!

Mitte letzten Jahres hatte ich angefangen, mich mit dem Web-Framework Tapestry zu beschäftigen und war sehr schnell davon begeistert. Für mich als Programmierer, der mit HTML und PHP recht wenig am Hut hat, ist der Einstieg sehr einfach gewesen.

Zu dem Zeitpunkt gab es leider noch kein empfehlenswertes Buch und auch keine ausreichende Dokumentation zum Framework. Deswegen musste ich mir viele Informationen aus allerlei Quellen (Mailing-Listen, Foren, …) zusammensuchen. Das Problem hat sich Ende letzten Jahres aber zum Glück geändert, denn zu dem Zeitpunkt ist das oben genannte Buch erschienen.

In dem Buch erklärt Igor Drobiazko, der selbst ein aktiver Entwickler des Frameworks ist, fast alle Funktionen, die das Tapestry bietet. Besonders spannend fand ich das letzte Kapitel, in dem auf sehr tief gehende Möglichkeiten, dass Framework anzupassen, eingegangen wird.

Amazon-Link zum Buch

Falls einer der Blog-Leser sich für das Buch interessiert, würde ich mich sehr über sein Feedback dazu freuen!

Ich hatte mir noch ein gebrauchtes Exemplar eines anderen Buchs über Tapestry bei ebay gekauft, davon war ich aber leider sehr enttäuscht, da es nur um die Grundfunktionen ging und für fortgeschrittene Entwickler uninteressant war.

Googles doesn’t offer you a relational database but their own database-system called BigTable which you can’t access with the usual Hibernate-Mapping. And one more thing: Google doesn’t call it a database but a datastore

In this example I’d like to show you, how to save, get, update and delete an object.

How to access the datastore

There are several possibilities to access the datastore from your code. You can read about it in the API-Document. I want to focus on using JDO to connect and save data in a datastore.We will use the Datanucleus Access Platform which offers us a framework for data management.

First of it all, we’ll need to import the required libraries in our maven project. Most of them are available in the official repositories or distributed with the GAE SDK:

• datanucleus-appengine 1.0.5
• datanucleus-core 1.1.6
• datanucleus-jpa 1.1.5
• maven-datanucleus-plugin 1.1.4
• jdo2-api 2.3-ec

If we’d use Hibernate with Tapestry, we would just inject the Hibernate-Service/Session into your DAO. With JDO we need to define a Singleton which represents the PersistanceManager for ourdatastore.

PersistanceManagerFactory.java

Making a class persistence-ready

We want to save and edit an USER in our datastore, therefore we’ll implement a class called User.java in our entities-package.

User.java

As you can see, I added some annotations which tell Datanucleus, that we want to save our class persistent. By using annotation you spare defining your classes in XML-Files.

If you want to implement inheritance in your data, you need to define your base-class with the following annotation:

@PersistenceCapable
@Inheritance(strategy = InheritanceStrategy.SUBCLASS_TABLE)
public abstract class EntityWithLongID {

The DAO

We want to follow the design pattern of DAOs which allows us, to inject a DAO in our page and then use the CRUD (Create, Receive, Update and Delete) methods (and more if we want).

UserDAO.java

In our implementation of the interface, we make use of our PersistanceManagerFactory:

UserDAOImpl.java

As you can see, there’s a little problem with the update method.

The PersistenceManager doesn’t offer any possibility to just send a update of a User. You have to load the user, you want want to edit, then edit it and save it in the same transaction. Due to this fact, if we want to edit a user on our website, we would need to open the transaction if the page is requested. Then the transaction needs to be kept open till the submit button is pressed and the edited user can be saved.  To prevent this, we need to load the user we want to edit in our update method again. Afterwards we copy every field from the edited user to the newly loaded user and then commit the action.

We could do this with a simple use of the getter/setter methods but then we would need to edit our DAO if we add/remove a field to our User-Class. For that reason we  use our old friend: reflection

The other methods should be rather clear…

To bind the DAO to the fitting Implementation, we add this line to our AppModule.java bind-Method:

binder.bind(UserDAO.class, DummyUserDAOImpl.class);

Configuring JDO and adding enhancement for our classes

There are only to steps left to save data in our datastore:

We need to to configure Datanucleus/JDO, which happens through a little file, we put in the META-INF Folder (in Netbeans: Other Sources/META-INF):

jdoconfig.xml

Now, we only have to tell Maven to enhance our class-Files in the build-process. To do so, we modify our pom.xml and add this code in the build / plugins section:

<plugin>
      <groupId>org.datanucleus</groupId>
      <artifactId>maven-datanucleus-plugin</artifactId>
      <version>1.1.4</version>
      <configuration>
            <log4jConfiguration>${basedir}/log4j.properties</log4jConfiguration>
            <mappingIncludes>**/entities/*.class, **/entities/account/*.class</mappingIncludes>
            <verbose>true</verbose>
            <enhancerName>ASM</enhancerName>
            <api>JDO</api>
      </configuration>
      <executions>
            <execution>
                 <phase>process-classes</phase>
                 <goals>
                     <goal>enhance</goal>
                     <goal>enhance-check</goal>
                </goals>
           </execution>
      </executions>
</plugin>

Now we just build our project and the everything should work…

One problem I faced, resulted from google’s JRE Class whitelist, which lists all classes, you can use in your application. The current stable release of Tapestry uses a blacklisted XML Parser.

Therefore you have two possibilities:

• Replace the XML-Parser
• or just use Tapestry 5.2

I decided to update my downloaded Tapestry Libs to 5.2.

Create a project

First we have to create a new Tapestry-app with Maven. I used the integrated support of Netbeans to achieve this. In apache’s maven repository you can find a quickstart-app for Tapestry 5.2, which is ideal for testing purpose.

Now you only have to add a appengine-web.xml file and that’s it…

Leider gibt es in der aktuellen Tapestry Version 5.1.0.5 noch einige Bugs, die den Einsatz verhindern. Theoretisch sollte aber die Version 5.2, welche aktuell noch im Entwicklungsstadium ist, jedoch laufen.

Das Vorgehen, um eine Tapestry Anwendung in die GAE zu laden ist wie bereits beschrieben recht einfach.

Erstellen des Projektes

Am einfachsten generiert man eine Tapestry-Anwendung mittels Maven. Ich nutze hierzu die in Netbeans integrierte Unterstützung. Im Repository gibt es eine Quickstart-Anwendung für Tapestry 5.2, welche für die Testzwecke ideal ist.

Nach dem erzeugen der Anwendung legt man nun wieder eine appengine-web.xml Datei an und schon kann man die Anwendung hochladen.

Leider hat das überhaupt nichts gebracht, deswegen habe ich mich auf die Suche, nach einer anderen Lösung gemacht.

Zum Glück bin ich nicht allein

Hier wurde die Lösung für das ganze Problem gepostet und was soll ich sagen: es läuft

Danke an den Autor, hat mir viel Zeit gespart!

Der Fehler den Glassfish nach dem Deployment gebracht hat:

java.lang.RuntimeException: Exception constructing service 'TemplateParser':
Error invoking constructor...

- In das Verzeichnis /domains/domain1/lib/ext/ die woodstox*.jar und stax2*.jar aus der Tapestry Anwendung kopieren

- In der Glassfish AdminOberfläche in Configuration/System Properties folgendes hinzufügen:

javax.xml.stream.XMLEventFactory        com.ctc.wstx.stax.WstxEventFactory
javax.xml.stream.XMLInputFactory        com.ctc.wstx.stax.WstxInputFactory
javax.xml.stream.XMLOutputFactory     com.ctc.wstx.stax.WstxOutputFactory
- Glassfish neustarten

Eins weiß ich aber sicher: Es macht Spass