A simple implementation based on the Java-Class LinkedHashMap can be found here:

LRUCache.java

Usage:

LRUCache<String, String> myCache = new LRUCache<String, String>(10);

If you need to access the cache with multiple threads, you can use the static Collections.synchronizedMap method:

Collections.synchronizedMap(new LRUCache<String, String>(CACHE_SIZE));

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.

Java provides several build-in algorithms for symmetric-key cryptography (AES, DES …). To use those algorithms, you have to generate a secret-key and initialize a cipher for decryption and one for encryption with it.Those ciphers can now be used to crypt your data.

To simplify this task, I created a small library which provides the needed methods to decrypt and encrypt a String. There are several static methods to automatically initialize a crypter for a certain algorithm such as AES.

How to encrypt and decrypt a String:

Crypter myCrypter = Crypter.getAES_Crypter();
String encrypted = myCrypter.encrypt("my secret text");
String decrypted = myCrypter.decrypt(encrypted);

Download:

Library

Source

A big thank you goes out to the author of the used Base64-Coder: http://www.source-code.biz/

Bei unserem Projekt handelt es sich einerseits um eine Tapestry 5 Anwendung. Diese lässt sich auf jedem beliebigen Server mit installiertem Maven über den Befehl

mvn jetty:run

starten.

Auf der anderen Seite haben wir dann noch eine einfache Java-Anwendung, die eine Verbindung über einen Socket aufbaut.

Als Einführung ins Thema Maven haben wir uns das folgende Buch gekauft:
Maven: A Developer’s Notebook (Developer’s Notebooks)

Zwar behandelt es eine etwas ältere Maven Version, es ist aber gut für die Grundlagen geeignet.

It’s quite simple to use:

final CoordinateTool ct = new CoordinateTool();
final Coordinate coord = ct.getCoordinateForAddress(YOUR_ADDRESS);

Another feature is the possibility to load a route from A to B. You have the possibility to get this route as String or to save it to a File.

final CoordinateTool ct = new CoordinateTool();
final String route = ct.getRouteForAddresses(YOUR_ADDRESS, YOUR_DESTINATION);
ct.saveRouteForAddresses(YOUR_ADDRESS, YOUR_DESTINATION, FILENAME);

If you need the distance between two addresses or coordinates, you can use this “getDistanceBetween” method.

Download:

Library

Source.

Für den einfachen Einstieg habe ich dann mal nach einem Buch gesucht und folgendes gefunden:

Das Google Web Toolkit: Ajax-Applikationen mit Java

Die Bewertungen bei Amazon waren schon mal soweit ok und haben sich nun auch bestätigt. Der Autor erklärt in einem recht kleinem Rahmen die Grundlagen des Toolkits und was man damit so erreichen kann. Einziger Nachteil: es wird die Version 1.X behandelt. In der aktuellen 2.X Version sind einige Änderungen hinzugekommen, für einen Einstieg ist das Buch aber trotzdem gut geeignet.

Ein weiterer Pluspunkt ist der für ein Fachbuch doch sehr faire Preis

Amazon-Link

Normally a developer would implement some methods to create those dummy objects with random data. If you have many classes, this might become a quick time-consuming task. A good solution would be a library, which creates those objects automatically.

For this sake, I started the DummyCreator project. It is planned to provide a static method which returns a random Object of whatever class is needed. In the process of object-creation, the DummyCreator will rely on the usual JavaBean specifications of  setter methods. Those methods are defined by their name (starts with “set”), their parameter (just one) and that they are always void methods.

Object-creation will start by finding a suitable constructor and then set all available attributes of the object automatically. This will done by using the reflection API with all of it’s magic.

A first version of the DummyCreator and the source can be found on the Google-Code homepage: http://code.google.com/p/dummycreator/

There is also a short introduction available which describes the first steps to use DummyCreator in your project. You can integrate the jar-File in the development and later deploy without it.

It currently works quite well, there are only some issues with classes which have lists as attribute. Those will be created but empty.

SDK herunterladen und installieren

Zuerst benötigt man natürlich das Android SDK. Dieses findet man samt einiger Anleitungen dazu auf dieser Seite. Nach dem herunterladen entpackt man das gesamte SDK in einen beliebigen Ordner und führt die zugehörige Setup Datei aus.

Mittels dieses Setups werden alle benötigten Pakete zu beliebigen API-Versionen heruntergeladen und installiert. Normalerweise sollte die neueste Version reichen, aber natürlich kann jede gewählt werden.

Nachdem das Setup erfolgreich abgeschlossen wurde, muss man noch ein Gerät (Device) hinzufügen. Dies geschieht auch über das Setup im Punkt Virtual Devices. Die Einstellungen für das Gerät sind beliebig zu wählen und sollten dem Zielgerät entsprechen (Ausstattung, Auflösung etc).

Netbeans Plugin installieren

Nachdem der Rechner nun quasi bereit ist, eine Android Anwendung zu starten, wird noch ein Plugin für Netbeans benötigt: nbandroid. Die zur Zeit gültige Webseite des zugehörigen Projektes findet sich hier. In den zugehörigen Installationsanweisungen findet sich auch der Link, welcher das Plugin in Netbeans Update-Center integriert. Dieses findet man unter Tools => Plugins. Zum hinzufügen klickt man nun auf Settings => Add und fügt folgenden Link als Quelle hinzu: http://kenai.com/downloads/nbandroid/updates.xml

Im Anschluss findet sich unter den verfügbaren Plugins das Android Plugin, welches auch installiert werden muss.

Android Plattform einrichten

Um nun noch die passende Plattform für Netbeans einzurichten, startet man den zugehörigen Manager über Tools => Java Platforms => Add. Hier wählt man nun die Google Android Open Handheld Platform. Als Ordner wird das vorher entpackte und installierte SDK, die Version der Plattform entsprechend den Anforderungen gewählt.

Projekt erstellen

Wenn nun alle Punkte erfolgreich abgearbeitet wurden, kann man über File => New Project => Android ein neues Android Projekt anlegen. Sobald man im Projekt dann auf Run klickt (oder F6 drückt) startet der Emulator mit dem gewünschten Projekt.

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…