Zwei-Schicht++-Architektur
Wie kann man aus einer vorhandenen Zwei-Schicht-Anwendung eine Drei-Schicht-Anwendung machen, ohne den Code komplett neu zu schreiben? Der nachfolgende Artikel gibt die Erfahrungen bei der Migration einer RCP-Applikation wieder. Das vorgestellte Konzept ist aber auch für neue Applikationen interessant.
Bei einem Kunden existiert ein über mehrere Jahre entwickeltes System. Es handelt sich um einen auf der Eclipse Rich Client Platform (RCP) basierenden Rich-Client für die Anwender (nachfolgend GUI-Client genannt) und einen RCP-basierten Batch-Client. Der Batch-Client dient u. a. zur Verarbeitung von Schnittstellendateien. Beide Clients sind als Zwei-Schicht-Anwendung implementiert, verwenden eine gemeinsame Codebasis und greifen per JPA auf dieselbe Datenbank zu. Als JPA-Implementierung wird Hibernate verwendet. Zum Editieren von Daten im GUI-Client werden diese in einem RCP-Editor geöffnet, bearbeitet und anschließend durch einen Klick auf den Speichern-Button gespeichert. Hierbei verwenden wir das EntityManager-per-Conversation-Pattern (Kasten: „Gültigkeitsbereich des EntityManagers“), wobei eine Konversation vom Öffnen bis zum Schließen des Editors dauert. Beim Öffnen des Editors wird eine Transaktion gestartet, und beim Speichern wird ein Commit ausgeführt, wobei alle Änderungen an den Entities automatisch gespeichert werden. Da der EntityManager während der gesamten Lebensdauer des Editors geöffnet bleibt, können Daten bei Bedarf per Lazy Loading nachgeladen werden.
Aus Sicherheitsgründen (u. a. Datenbankverbindungsdaten im GUI-Client abgelegt) und durch Änderungen an der Infrastruktur (Verschieben der Datenbank in eine Sicherheitszone, sodass diese vom GUI-Client nicht mehr direkt erreichbar ist) ist der Betrieb des zweischichtigen GUI-Clients zukünftig nicht mehr möglich. Daher soll die Anwendung (GUI-Client) auf eine Drei-Schicht-Architektur migriert werden, wobei einige Vorgaben einzuhalten sind:
-
Die Anwender sollen weiterhin mit dem vertrauten GUI-Client arbeiten
-
Aus Kostengründen soll möglichst viel vom vorhandenen Code übernommen werden
-
GUI- und Batch-Client verwenden weiterhin eine gemeinsame Codebasis
-
Der Batch-Client soll möglichst weiterhin als Zwei-Schicht-Applikation direkt auf die Datenbank zugreifen
Nachfolgend wird zunächst ein Konzept vorgestellt, das das Betreiben einer Applikation im Zwei- oder Drei-Schicht-Modus ermöglicht. Anschließend wird auf die konkrete Migration der Anwendung eingegangen.
Gültigkeitsbereich des EntityManagers
EntityManager per Conversation
-
EntityManager wird nach einer Transaktion nicht geschlossen, sondern über einen längeren Zeitraum offen gehalten
-
Entities werden aktiv verwaltet, d. h., beim Commit werden alle Änderungen automatisch gespeichert
-
Lazy Loading ist möglich
EntityManager per Request (with detached Entities)
-
EntityManager wird am Ende jeder Transaktion geschlossen
-
Beim Schließen des EntityManagers wechseln die Entities in den Zustand „Detached“
-
Kein Lazy Loading für detached Entities
Command-Pattern
Das Konzept zum wahlweisen Betrieb einer Applikation im Zwei- oder Drei-Schicht-Modus basiert auf einem modifizierten Command-Pattern. Ein Command ist in diesem Fall eine Aktion, die der Client innerhalb einer Transaktion ausführen kann. Normalerweise wird ein Command remote auf einem Applikationsserver ausgeführt. Es ist aber auch möglich, Commands lokal in der Client-JVM auszuführen. Ein Command kann Parameter und einen Rückgabewert haben. Per Konvention hat ein Command in unserem Fall genau einen Konstruktor, der die für die Ausführung erforderlichen Daten als Parameter enthält und mittels der @Command-Annotation gekennzeichnet wird. Die Ausführung eines Commands erfolgt durch Aufruf der execute()-Methode. Falls das Command kein Ergebnis liefert, wird als Rückgabewert java.lang.Void angegeben, und die execute()-Methode liefert in diesem Fall null zurück. Alle Commands leiten von der Klasse ACommand ab und erhalten so Zugriff auf den EntityManager (Listing 1). Ein Beispiel für ein einfaches Command ist das Laden aller Personen mit einem bestimmten Namen (Listing 2). Commands können aber auch beliebig komplexe Anwendungslogik beinhalten.
Listing 1
public abstract class ACommand<R> {
private EntityManager m_entityManager;
public final EntityManager getEntityManager() {
return m_entityManager;
}
public final void setEntityManager(EntityManager entityManager) {
m_entityManager = entityManager;
}
/**
* Execute the command
* @return the result
* @throws CommandException if command execution fails
*/
public abstract R execute() throws CommandException;
}Listing 2
@Command
public class FindPersonsByNameCommand...
