Step-by-Step-Anleitung zur eigenen Anwendung

Tutorial: Mobile Apps mit Vaadin TouchKit

Olaf Lange, Marko Grönroos, Matti Tahvonen, Oliver Damm

Mit Vaadin lassen sich moderne Internetanwendungen entwickeln. Wir gehen in diesem Tutorial einen Schritt weiter und zeigen, wie einfach die Entwicklung mobiler Anwendungen mit dem Vaadin TouchKit ist.

Erinnern Sie sich, vor wenigen Jahren entstand der Trend, Desktopanwendungen immer mehr ins Web auszulagern? Der Browser wurde dank JavaScript, GWT und anderen Frameworks zur Allzweckwaffe. Mobile Applikationen werden bis heute jedoch überwiegend native realisiert. Die Entwicklung für iOS- und Android-Geräte unterscheidet sich dabei deutlich: Angefangen von der Programmiersprache bis hin zur Bereitstellung über einen Store. Folglich werden mobile Applikationen mindestens zweifach entwickelt, wenn man zumindest die beiden größten Vertreter der Branche adressieren will.

Heute ist HTML5 in aller Munde und die Frage steht im Raum, ob die Entwicklung mobiler Applikationen eine ähnliche Wende wie im Desktopbereich erleben wird. Der HTML5-Standard wird von vielen Smartphones und Tablets unterstützt und es lassen sich Anwendungen entwickeln, die der alten Java-Grundidee „write once, run anyware“ sehr nahe kommen. Mit dem Vaadin TouchKit wird genau dieser Weg bestritten: In „Pure Java“ werden auf einfachem Wege Applikationen entwickelt, die universell als HTML5-Anwendungen auf iPhone, iPad, Android-Smartphones und vielen anderen Geräte aufrufbar sind. Das Ergebnis überzeugt: Praktisch ist kein Unterschied zu einer nativen App erkennbar (Abb. 1).

Abb. 1: Die Demo-App „Vornitologist“

Die Demo-App

Dieses zweiteilige Tutorial demonstriert anhand der Anwendung Vornitologist, wie einfach die Entwicklung einer mobilen Anwendung mit dem Vaadin TouchKit ist. Die Demoapplikation wurde von der finnische Firma Vaadin entwickelt und unterstützt das Beobachten von Vögeln, ein sehr verbreitetes Hobby in Finnland. Mit der Anwendung können Benutzer ihre Beobachtungen protokollieren und Daten untereinander austauschen. Auch wenn dieses Beispiel in keinem Businesskontext steht, so enthält es doch viele Eigenschaften, die auch bei einer Geschäftsanwendung vorzufinden sind. Die Anwendung ist für Smartphones, wie z. B. das iPhone, optimiert. Sie kann aber genauso gut auf einem Tablet oder sogar mit einem Browser auf einem Desktopsystem verwendet werden.

Wir empfehlen, den Quellcode des Projekts [1] in Ihre IDE zu importieren, um einen weiterführenden Einblick in den Aufbau der Anwendung zu erhalten. Nach Abschluss des ersten Teils werden Sie so weit eingearbeitet sein, dass Sie mit der Entwicklung einer eigenen mobilen Anwendung starten können. Im zweiten Teil werden wir weiterführende Features wie Geolokalisierung und die Unterstützung eines Offline-Modus vorstellen.

Tutorial-Aufbau
Teil 1
– Einführung in Vaadin TouchKit
– Aufsetzen eines Vaadin-TouchKit-Projektes
– Deployment der Anwendung
– Integration in die Oberflächen des Endgeräts
– Entwicklung der Top-Level-Navigation
– Vorstellung einiger für Touchgeräte optimierter Komponenten
Teil 2
– Entwicklung einer Navigation für eine hierarchische Datenstruktur
– Verwendung von Geolokalisierung
– Erstellen einer Offline-Variante der Anwendung
– Optimierung der Anwendung für niedrige Bandbreite bzw. hohe Latenz

Was ist Vaadin?
Vaadin ist ein Java-Framework für die Entwicklung von hochqualitativen Rich Internet Applications (RIA). Anwendungen fürs Web werden mit Vaadin vergleichbar zu einer Java-Desktopanwendung entwickelt. D. h. die Entwickler benötigen keine Kenntnisse der eigentlichen Webtechnologien HTML oder JavaScript. Der Kern des Frameworks besteht aus einer Java-Bibliothek, die ähnlich wie in der Programmierung mit Swing oder SWT genutzt werden kann. Vaadin übernimmt durch das servergetriebene Programmiermodel die Koordination der Benutzerinteraktionen und die AJAX-Kommunikation zwischen Browser und Server. Entwickler, die das Framework einsetzen, können sich somit auf die Applikationslogik konzentrieren. Das Vaadin TouchKit ist ein Add-on für mobile Endgeräte und basiert auf dem Vaadin-Framework.

Aufsetzen des Vaadin-TouchKit-Projektes

Wir verwenden Maven, um das Projekt in Eclipse aufzusetzen. Sie können aber alternativ ein normales Java-Projekt erstellen. Wir empfehlen folgende Plug-ins:

Wir verwenden in diesem Tutorial die Version 1.0.200 des m2e Plug-ins. Die neuere Version 1.1.0 unterstützt zum Zeitpunkt des Schreibens dieses Artikels noch nicht den Connector m2e-subeclipse, der notwendig ist, damit wir ein Maven-Projekt über Subversion importieren können. Die ältere Version des Plug-ins kann bei der Installation ausgewählt werden. Nach der Installation der Plug-ins in Eclipse muss der m2e Connector für SVN konfiguriert werden. Hierfür wählen Sie in den Eclipse-Einstellungen unter Maven | Discovery | Open Catalog in der Liste den Connector m2e-subversive aus (Abb. 2). Anschließend führen Sie folgende Schritte aus:

Abb. 2: Einrichtung des „m2e-subeclipse“ Connetor unter Eclipse

  1. Wählen Sie aus dem Eclipse-Menü File | Import…
  2. Wählen Sie im folgenden Dialog Maven | Check out Maven Project from SCM aus und klicken Sie danach auf Next
  3. Wählen unter SCM URL svn aus und geben Sie den URL http://dev.vaadin.com/svn/demo/vornitologist ein
  4. Klicken Sie auf Finish

 Der Import kann einige Zeit in Anspruch nehmen, da diverse Maven-Abhängigkeiten geladen werden. Nachdem das Projekt fertig importiert wurde, lohnt sich ein erster Blick in die Projektstruktur (Abb. 3). Für den Einstieg sind die Dateien web.xml und VornitologistApplication.java interessant (Listing 1 und 2). Wenn Sie das Projekt nicht importieren möchten, stehen die Sourcen alternativ auch online über den Vornitologist-Codebrowser [1] zur Verfügung.

Abb. 3: Projektstruktur der importierten Demoapplikation Vornitologist

<servlet> 
<servlet-name>Vornitologist</servlet-name>
    <servlet-class>com.vaadin.addon.touchkit.server.TouchKitApplicationServlet</servlet-class>
<init-param> 
  <description>Vaadin application class to start</description> 
  <param-name>application</param-name> 
  <param-value>com.vornitologist.VornitologistApplication</param-value> 
</init-param> 
<init-param>
  <description>Application widgetset</description> 
  <param-name>widgetset</param-name> 
  <param-value> com.vornitologist.widgetset.VornitologistWidgetset</param-value> 
</init-param>
<init-param>
  <description>Vaadin fallback application class to start</description>
  <param-name>fallbackApplication</param-name>
  <param-value>com.vornitologist.VornitologistFallbackApplication</param-value>
</init-param>
<init-param>
  <description>Application widgetset</description>
  <param-name>fallbackWidgetset</param-name>
  <param-value>com.vaadin.terminal.gwt.DefaultWidgetSet</param-value>
</init-param> 
  </servlet>
  public class VornitologistApplication extends TouchKitApplication {

public static SystemMessages getSystemMessages() {
      return customizedSystemMessages;
}

    static CustomizedSystemMessages customizedSystemMessages = new CustomizedSystemMessages();

static {     
  customizedSystemMessages.setSessionExpiredNotificationEnabled(false); 
}

private TouchKitWindow mainWindow; 

public VornitologistWindow(){
      addApplicationIcon(VornitologistApplication.get().getURL()
                + "VAADIN/themes/vornitologist/icon.png");
      setStartupImage(VornitologistApplication.get().getURL()
                + "VAADIN/themes/vornitologist/startup.png");
      setWebAppCapable(true);
      setPersistentSessionCookie(true);
}

@Override 
public void init() {     
  configureMainWindow();      
      setTheme("vornitologist"); 
  setUser("Eräjorma"); 
}

public void configureMainWindow() {     
  mainWindow = new VornitologistWindow();
  setTheme(mainWindow); 
}

  }

Mit einem leeren Vaadin-TouchKit-Projekt starten
Wenn Sie mit einem leeren Projekt starten möchten, können Sie das Projekt als Vaadin-Anwendung erzeugen oder einen für das TouchKit bereitgestellten Maven Archetype verwenden. Wenn Sie sich für das letztere Vorgehen entscheiden, werden die grundlegenden Konfigurationsschritte automatisch durchgeführt, gehen Sie wie folgt vor:

1. Wählen Sie im Eclipse-Menü File | New | Project… aus
2. Wählen Sie im folgenden Dialog Maven | Maven Project aus und klicken Sie auf Next
3. Auf der nächsten Seite des Dialogs drücken Sie wieder auf Next
4. Geben Sie vaadin in das Feld Filter ein und drücken Sie die Eingabetaste
5. Wählen Sie vaadin-archetype-touchkit aus und klicken Sie auf Next
6. Geben Sie im Feld Group Id z. B. com.example ein
7. Geben Sie im Feld Artifact Id z. B. mytouchkitapp ein
8. Klicken Sie auf Finish

Wenn Sie das Projekt als normales Vaadin-Projekt erzeugen, sind einige manuelle Anpassungen in der web.xml (Listing 1) nötig. Eine Vaadin-TouchKit-Anwendung muss ein spezielles Servlet verwenden. Dieses ersetzt die Klasse ApplicationServlet, die in einer Standard-Vaadin-Anwendung verwendet wird. Der Maven Archetype trägt dieses Servlet automatisch in die web.xml ein. Da das Vaadin TouchKit auch clientseitige Erweiterung beinhaltet, muss ein projektspezifisches Widget Set definiert sein. Das ist im Grunde ein GWT-Modul und definiert alle clientseitigen Implementierungen der verwendeten Komponenten und Erweiterungen.
Die Klasse Application stellt den Einstiegspunkt in eine Standard-Vaadin-Anwendung dar. Anwendungen, die das TouchKit verwenden, müssen hingegen von der Klasse TouchKitApplication ableiten. In unserem Beispiel ist dies durch die Klasse VornitologistApplication realisiert. Die Initialisierung wird in der Methode init() durchgeführt. Dies ist auch bei einer normalen Vaadin-Anwendung der Fall. Bei einer TouchKit-Anwendung ist es allerdings wichtig, dass als Hauptfenster ein Exemplar der Klasse TouchKitWindow an der Anwendung gesetzt wird (Listing 2).
Das TouchKit erlaubt es, sowohl ein alternatives Widget Set als auch eine alternative Klasse für die Applikation anzugeben. Diese Angaben werden verwendet, wenn die Anwendung in einem nicht unterstützten Browser ausgeführt wird. Dieses Fallback-Feature werden wir im zweiten Teil des Tutorials näher erläutern.

Deployment der Anwendung

Eine Vaadin-Anwendung muss in einem Servlet-Container ausgeführt werden. Wir verwenden für unser Tutorial den Jetty-Webserver. Um die Anwendung aus Eclipse heraus zu deployen, muss zunächst ein Server eingerichtet werden. Durch das Eclipse Plug-in Maven Integration for WTP [4] werden Maven-Projekte in Eclipse als Webanwendung erkannt und können in einem in Eclipse eingerichteten Server deployt werden. Sollten Sie das Vaadin-Projekt zuerst importiert haben und erst danach das Plug-in installiert haben, müssen Sie einmalig über das Kontextmenü des Projektes Maven | Update Projekt Configuration… ausführen.

Um einen Server einzurichten, öffnen Sie zunächst die View Servers. Wählen Sie dazu im Menü Window den Eintrag Show View | Others… aus. Es öffnet sich ein Dialog. Wählen sie dort unter Server die View Servers aus.

In der View Servers können Sie nun über das Kontextmenü (New | Server) einen neuen Server einrichten. Es öffnet sich ein Dialog, in dem ein Server-Adapter ausgewählt werden muss (Abb. 4). Sollte kein Adapter für Jetty angeboten werden, klicken Sie den Link Download additional server adapters an. Es öffnet sich ein weiterer Dialog. Warten Sie bis alle verfügbaren Adapter geladen wurden und wählen Sie den Adapter Jetty Generic Server Adaptor aus. Klicken Sie auf Next und befolgen Sie die weiteren Installationsanweisungen.

Abb. 4: Jetty-Server in Eclipse einrichten

Nach der Auswahl des Server-Adapters klicken Sie auf Next. Auf der folgenden Seite des Dialogs müssen Sie nun das Installationsverzeichnis von Jetty angeben. Jetty kann als Zip von der Homepage [5] geladen werden. Wählen Sie in Eclipse das entsprechende Verzeichnis aus. Im View Servers erscheint jetzt ein Eintrag für den Jetty-Server. Sie können anschließend das Projekt Vornitologist auf diesen Eintrag per Drag and Drop ziehen. Jetty wird automatisch gestartet und die Anwendung wird deployt (Abb. 5).

Damit die Anwendung lauffähig ist, muss einmal das Widget Set kompiliert werden. Führen Sie dazu das Maven Goal gwt:compile auf dem Projekt aus. In Eclipse können Sie dazu Run as | Maven Build… aus dem Kontextmenü des Projekts verwenden. Die Anwendung wird danach automatisch neu deployt.

Abb. 5: Jetty-Server mit deployter Vornitologist-Anwendung

Über den URL http://localhost:8080/Vornitologist/ können Sie mit einem Webkit-basierten Browser (Chrome oder Safari) die Anwendung testen. Sollte die IP Ihres Entwicklungsrechners von Ihrem Smartphone oder Tablet erreichbar sein, so können Sie die Anwendung auch über diese Geräte ausprobieren.

Integration in die Oberfläche des Endgeräts

Das TouchKit ermöglicht es, eine Vaadin-Anwendung tiefer in die Benutzeroberfläche von iOS- bzw. Android-Geräten zu integrieren. Folgende Features werden unterstützt:

  • Setzen eines Icons, das auf dem Home Screen des Geräts angezeigt wird
  • Setzen eines Icons, das beim Start der Anwendung angezeigt wird (nur iOS)
  • Versetzen der Anwendung in einen Vollbildmodus, wodurch die Adresszeile des Browser ausgeblendet wird (nur iOS)
  • Verwendung von persistenten Session Cookies, um den Zustand der Anwendung über das Schließen und Öffnen hinweg zu erhalten
  • Unterdrückung der Meldung über den Ablauf einer Session (stattdessen erfolgt ein Neuladen der Seite)
  final class VornitologistWindow extends TouchKitWindow {

    public VornitologistWindow() {
      addApplicationIcon(VornitologistApplication.get().getURL()
                + "VAADIN/themes/vornitologist/icon.png");
      setStartupImage(VornitologistApplication.get().getURL()
                + "VAADIN/themes/vornitologist/startup.png");
      setWebAppCapable(true);
      setPersistentSessionCookie(true);

      addURIHandler(WikiImageProxy.get());
    }

  }

Listing 3 zeigt, wie die meisten dieser Features in der Klasse VornitologistWindow verwendet werden. Bei einer normalen Vaadin-Anwendung wird der Anwender informiert, wenn die HTTP-Session abgelaufen ist. Dieses Verhalten ist für Webseiten auf mobilen Geräten unerwünscht, da der Anwender erwartet, dass die Seite automatisch neugeladen wird, wenn er nach einer längeren Pause wieder in den Browser wechselt. Listing 2 zeigt, wie dieses Verhalten in einer TouchKit-Anwendung über die System Messages festgelegt wird.

Zugriff auf Session-bezogene Daten

Das TouchKit bringt eine Implementierung des ThreadLocal-Entwurfsmusters mit, um den Zugriff auf Session-bezogene Daten (z. B. Lokalisierung) zu erleichtern. Zwar stehen allen Vaadin-Komponenten die Methoden getApplication(), getWindow() und getLocale() zur Verfügung, sie können allerdings erst dann verwenden werden, wenn die entsprechende Komponente attacht ist, also der Komponentenhierarchie des Hauptfensters hinzugefügt wurde. Vor allem bei der Erzeugung einer Komponente ist im Konstruktor dieser Zustand aber noch nicht erreicht. Statische Variablen können ebenfalls nicht verwendet werden, da diese Session-übergreifend sind. Abhilfe schafft die statische Methode get() der Klasse TouchKitApplication, über sie kann auf ein Thread-lokales Exemplar der Anwendungen zugegriffen werden. Diese Methode kann überall verwendet werden, wie z. B. im Konstruktor der Klasse MainTabsheet (Listing 4). Das ThreadLocal-Entwurfsmuster ist detailliert im Book of Vaadin [6] beschrieben.

  public class MainTabsheet extends TabBarView {

private MapView mapView;
private LastestObservations latestObservations;
private ClassificationHierarchy classificationHierarchy; 
    
    public MainTabsheet() {
  ResourceBundle tr = Translations.get(VornitologistApplication.get().getLocale());

  classificationHierarchy = new ClassificationHierarchy();
  Tab addTab = addTab(classificationHierarchy);
  addTab.setIcon(new ThemeResource("linegraphics/bird.png"));
  addTab.setCaption(tr.getString("Aves"));
  
  latestObservations = new LatestObservations();
  addTab = addTab(latestObservations);
  addTab.setIcon(new ThemeResource("linegraphics/binocular.png"));
  addTab.setCaption(tr.getString("Observations"));
  
  mapView = new MapView();
  addTab = addTab(mapView);
  addTab.setIcon(new ThemeResource("linegraphics/world.png"));
  addTab.setCaption(tr.getString("Map"));
  
      SettingsView settings = new SettingsView();
  addTab = addTab(settings);
  addTab.setIcon(new ThemeResource("linegraphics/tools.png"));
  addTab.setCaption(tr.getString("Settings"));

  setSelectedTab(settings);
}

  }

Die Hauptnavigation

Nachdem der Server die Browsereigenschaften des Mobilgeräts erhalten hat, wird die Oberfläche der Anwendung initialisiert. Sobald die Eigenschaften verfügbar sind, wird die Methode onBrowserDetailsReady() der Klasse TouchKitApplication aufgerufen. Zu den Eigenschaften gehört unter anderem die Bildschirmauflösung des Geräts. Diese Information kann genutzt werden, um angepasste Oberflächen auf unterschiedlichen Geräten (z. B. Smartphone oder Tablet) bereitzustellen. In unserer Anwendung verwenden wir lediglich eine Oberfläche. Ein Beispiel für eine Anwendung mit angepassten Oberflächen ist die Anwendung Mobile Mail [7]. In der Methode onBrowserDetailsReady() wird der Inhalt des Hauptfensters festgelegt. Wir verwenden die Klasse MainTabsheet, über welche die Navigation zwischen den Hauptansichten unserer Anwendung realisiert wird. MainTabsheet erbt von der TouchKit-Klasse TabBarView. Diese Komponente stellt am unteren Rand des Bildschirms eine Tab-Bar bereit. Diese dient zur Navigation zwischen den vier Hautpansichten der Anwendung:

  • ClassificationHierarchy
  • LatestObservations
  • MapView
  • SettingsView

 Der Konstruktor von MainTabsheet erzeugt alle vier Ansichten sofort. Alternativ können die Ansichten auch beim ersten Zugriff erzeugt werden. Dies ist besonders bei komplexen Ansichten sinnvoll, da dadurch die Ladezeit beim ersten Zugriff auf eine Anwendung reduziert werden kann.

TouchKit-Komponenten

TouchKit-Anwendungen werden fast genauso entwickelt wie eine Standard-Vaadin-Anwendung. Die meisten Vaadin-Komponenten sind bereits geeignet, um auf Geräten mit Touch-Oberfläche eingesetzt zu werden. TouchKit bringt zusätzlich eine Reihe von Komponenten mit, die für Touch-Oberflächen besonders gut geeignet sind. Weiterhin existiert ein eigenes Theme (CSS), um die Standard-Vaadin-Komponenten für die Touch-Bedienung zu optimieren. Als Beispiel können Sie sich die Tabelle in der Ansicht Latest Obervations anschauen. Die Höhe der Zeilen ist vergrößert, damit der Benutzer eine Zeile leichter mit dem Finger auswählen kann. Die Klasse SettingsView aus dem Package com.vornitologist.ui stellt die Einstiegsansicht der Anwendung bereit. Hier kann der Benutzer einige Einstellungen wie z. B. Name und Alter festlegen (Abb. 6).

Abb. 6: Ansicht „Einstellungen“ der Demo-App

In Listing 5 sehen wir, wie in der Klasse SettingsView verschiedene Komponenten des TouchKits verwendet werden: VerticalComponentGroup, NumberField, EmailField und Switch. Sie werden feststellen, dass in unserem Fall für die meisten dieser Komponenten keine Anwendungslogik hinterlegt ist. Die Komponenten werden lediglich verwendet, um deren Benutzeroberfläche zu zeigen.

  public class SettingsView extends NavigationView {

    @Override
public void attach() {
  super.attach();
  buildView();
}

private void buildView() {
  componentGroup = new VerticalComponentGroup();
  componentGroup.setCaption("Settings");

      EmailField email = new EmailField("Email");
  email.setWidth("100%");
  email.setValue("ornithologist@example.com");
  componentGroup.addComponent(email);

  NumberField age = new NumberField("Age");
  age.setWidth("100%");
  componentGroup.addComponent(age);

      Switch switch1 = new Switch("Use my location");
  switch1.setValue(true);
  componentGroup.addComponent(switch1);
}

}

Die Ansicht wird nicht im Konstruktor sondern in der Methode attach() initialisiert. Dadurch findet die Initialisierung erst dann statt, wenn die Ansicht dem Komponentenbaum der Anwendung hinzugefügt wird. Diese späte Initialisierung bringt einige Vorteile mit sich. Zum Beispiel, dass der Arbeitsspeicher erst dann reserviert wird, wenn es wirklich nötig ist. Als Layout für die Ansicht wird die Klasse CSSLayout verwendet. Die Größe und die Position von Komponenten in diesem Layout können von einem Browser sehr schnell berechnet werden. Dies ist besonders auf Mobilgeräten wichtig. Weiterhin kann es leicht über CSS angepasst werden. Die Ansicht für die Einstellungen benutzt die Komponente VerticalComponentGroup. Dies ist eine Layoutkomponente, die Komponenten in einer Box zusammenfasst und über der Box eine Überschrift darstellt. Die Komponenten werden vertikal angeordnet und durch Linien getrennt. Für die horizontale Anordnung kann die Komponente HorizontalComponentGroup verwendet werden.

Ausblick

Im zweiten Teil des Tutorials werden wir Ihnen anhand der weiteren Hauptansichten der Anwendungen zeigen, wie eine Navigation für hierarchische Datenstrukturen mit dem Vaadin TouchKit umgesetzt wird. Außerdem werden wir darstellen, wie Sie den aktuellen Standort des Benutzers ermitteln. Ein weiteres Thema sind alternative Oberflächen, die dargestellt werden, wenn ein Browser nicht unterstützt wird bzw. der Browser keine Verbindung zum Server hat. Abschließend werden wir auf die Optimierung der Anwendung für Datenverbindungen mit geringer Bandbreite bzw. hoher Latenz eingehen.

Geschrieben von
Olaf Lange
Olaf Lange
  Olaf Lange ist Geschäftsführer der Java-Einheit der akquinet in Hamburg. Er berät Kunden bei der Auswahl von UI- und JEE-Technologien. Die offizielle Partnerschaft mit Vaadin empfindet er als großen Gewinn für sein Unternehmen.
Marko Grönroos
Marko Grönroos
Marko Grönroos ist Experte der finnischen Firma Vaadin. Er Kernentwickler von Vaadin und Autor des erstklassigen Vaadin-Handbuchs „Book of Vaadin“.
Matti Tahvonen
Matti Tahvonen
Matti Tahvonen ist kein Unbekannter bei Vaadin: Seit den Anfängen der JavaScript-Programmierung bis in die GWT-Ära hinein hat er das Framework mit­ und weiterentwickelt. Er ist mit einer ganzen Reihe offizieller und inoffizieller Add­ons in der Vaadin Directory vertreten. Heute verbringt er einen Großteil seiner Zeit damit, über die neuesten Technologien und deren Zusammenspiel mit Vaadin zu informieren. Dabei bringt er sein Expertenwissen auch in die Vaadin GmbH ein und stellt sicher, dass auch die deutschsprachigen Kunden bestens über den Einsatz von Vaadin, Java EE, Spring und das Thema User Interfaces informiert sind.
Oliver Damm
Oliver Damm
  Oliver Damm ist Berater und Softwarearchitekt bei der akquinet in Hamburg. Er ist spezialisiert auf Java- und JEE-Technologien. Seit 2010 beschäftigt er sich intensiv mit der Entwicklung von Webanwendungen unter Einsatz von Vaadin.
Kommentare

Schreibe einen Kommentar

Deine E-Mail-Adresse wird nicht veröffentlicht.