Schichtenarchitektur II
In diesem Beitrag geht’s weiter mit der Schichtenarchitektur und den unteren beiden Schichten, nämlich der GUI- und der Datenhaltungsschicht.
Inhaltsübersicht
Die GUI-Schicht
Machen wir gleich weiter mit der zweiten, grafisch ansprechendsten Schicht.
Die GUI-Schicht ist die einzige Schicht, von der wir während des Programmablaufs nachher etwas zu sehen bekommen. Dabei ist wichtig, dass sie direkt über der Fachkonzeptschicht liegt. Daraus folgt, dass GUI-Klassen zwar Zugriff auf Fachkonzeptklassen haben, diese aber nicht auf GUI-Klassen.
Der Vorteil dabei ist, dass du dein GUI nachher verändern kannst, ohne die Implementierung deiner Fachkonzeptklassen ändern zu müssen. Es hat aber auch zur Folge, dass du dein GUI nach jeder Änderung der fachlichen Daten aktualisieren musst. Zum Glück gibt es dafür Automatismen, derer du dich bedienen kannst. Einer davon wäre das Polling, bei dem du in regelmäßigen Abständen nach Änderungen in den fachlichen Daten fragst.
Observer- und Observable-Objekt
Wir wollen dir hier aber eine andere Möglichkeit zeigen. Mittels des Beobachtermusters kannst du nämlich bei Änderungen in der Fachkonzeptschicht, die GUI-Schicht benachrichtigen lassen. Dazu brauchst du ein Observer-Objekt vom Typ einer deiner GUI-Klassen und ein Observable-Objekt der Fachkonzeptklasse, die du überwachen möchtest.
Die beobachtete Klasse machst du zur Unterklasse von java.util.Observable. Das sorgt dafür, dass sie eine Liste besitzt, auf der sie alle hinzugefügten Observer führt – also eine Art von Abonnenten-Liste für alle Status-Updates.
Nun fügst du das gewünschte Observer-Objekt der Liste der Abonnenten hinzu. Von diesem Moment an erhält es jeden Newsletter und jedes Update, bis du es mit dem deleteObserver() Befehl wieder abmeldest.
Um deinen Newsletter zu versenden, musst du nur die Methoden setChanged() und notifyObservers() aufrufen. Daraufhin wird bei allen Observern die update() Methode gestartet, die, ähnlich wie die Ereignisbehandlung beim GUI festlegt, was diese Objekte bei einem Update tun sollen. Manche überfliegen vielleicht den Newsletter nur, während andere deine empfohlenen Veranstaltungen sofort besuchen. Wieder andere notieren sich alle darin erwähnten Informationen.
Damit sie das allerdings tun können, musst du deren Klasse noch die Schnittstelle java.util.Observer implementieren lassen. Diese Schnittstelle stellt ihnen nämlich erst die Prototypen für die update-Methode zur Verfügung, die mit folgenden Parametern ausgeführt werden kann:
Zum einen gibt es das geänderte Objekt o und zum anderen optionale Zusatzinformationen, die aber auch einfach leer gelassen werden können.
Die Datenhaltungsschicht
Kommen wir nun zur dritten und damit letzten Schicht: Der Datenhaltungsschicht. Zur Laufzeit des Programms werden Daten im Arbeitsspeicher abgelegt. Dies hat allerdings zur Folge, dass du nach Beendigung deines Programmes alle deine Daten verlierst.
Um das zu vermeiden, gibt es die sogenannte persistente Datenspeicherung, die Daten dauerhaft speichert. Dazu kann man viele verschiedene Methoden, wie z.B. Objektserialisierung, Textdateien, XML-Dateien oder eben Datenbanken verwenden. Der Code für diese Speicher- und Lade-Operationen wird in der Datenhaltungsschicht gekapselt. Um das umzusetzen, brauchst du einen sogenannten Wurzelcontainer. Er ist allen Datencontainern bekannt. Wichtig ist hier, dass genau eine Datenhaltungsklasse an ihn angebunden wird.
Diese Klasse enthält wichtige Operationen für den Container: Die load – Methode zum Laden aller Datenbankobjekte, die save-Methode zum Speichern ebenjener Objekte, die add- und die delete-Methode zum hinzufügen bzw. entfernen einzelner Datenobjekte und die modify-Methode zur Bearbeitung vorhandener Datenobjekte.
Super, jetzt kennst du alle drei Schichten der Schichtenarchitektur und kannst dich mit einem besseren Verständnis und einigen neuen Tools wieder an die Arbeit machen.