Posts mit dem Label Strukturmuster werden angezeigt. Alle Posts anzeigen
Posts mit dem Label Strukturmuster werden angezeigt. Alle Posts anzeigen

22. Januar 2013

Entwurfsmuster: Proxy

Der Begriff eines Proxys bedeutet so viel wie "Stellvertreter", was dem Prinzip des gleichnamigen Strukturmusters entspricht. Ein Proxy fungiert dabei als ein Platzhalter für ein anderes Objekt und leitet Zugriffe auf dieses weiter. Dies führt dazu, dass das originale Objekt hinter dem Proxy-Objekt versteckt wird. Dessen Aufgabe ist es nicht, neue Eigenschaften oder Funktionalitäten hinzuzufügen, sondern den Zugriff auf das Original für den Benutzer zu erleichtern. Der Proxy stellt also eine Art intelligenten "Zeiger" dar, der je nach Bedarf angepasst werden kann.

Umgesetzt wird ein solcher Proxy, indem er die selbe Schnittstelle implementiert, wie das Objekt, als dessen Platzhalter er fungiert. Für die Delegation der Methodenaufrufe, die an den Proxy erfolgen, verfügt dieser über eine Referenz auf das Original. Das unter stehende Klassendiagram verdeutlicht diesen Zusammenhang:

Zusammenspiel der Klassen des Proxy-Entwurfsmusters

Vorteile:
  • Ein Proxy kann Aspekte implementieren, die über die Verantwortlichkeit der Originals hinaus gehen. Dazu gehören technische Aspekte wie z.B. Caching, Sicherheitsabfragen, Pooling oder Logging. 
Nachteile:
  • Für jede Methode des Originals muss der Proxy eine Methode mit der selben Signatur anbieten, was zu Redundanz führen kann, falls keine zusätzliche Funktion vom Proxy umgesetzt wird. 

21. Januar 2013

Entwurfsmuster: Adapter

Das Entwurfsmuster "Adapter", dient, wie der Name bereits andeutet, dazu, eine Schnittstelle einer anderen, inkompatiblen Schnittstelle anzupassen. Damit können Klassen zusammenarbeiten, die sonst aufgrund ihrer Schnittstellen nicht dazu in der Lage wären. 

Häufig wird man zu der Verwendung eines Adapters geradezu gezwungen, wenn man mit vorgegebenen Klassen, etwa die eines Frameworks, arbeiten muss, deren Schnittstelle aber nicht der benötigten entspricht. Andererseits kann man den Ansatz auch vorrauschauend nutzen, um etwa Klassen mit erhöhter Wiederverwendbarkeit zu erstellen, die im Folgenden mit beliebigen anderen Klassen zusammenarbeiten können. Auch denkbar wäre die Verwendung eines Adapters wenn verschiedene Implementierungen, die sich jedoch nur schwierig unter einer gemeinsamen Schnittstelle zusammenfassen lassen, genutzt werden sollen.

Bei einem Adapter handelt sich um ein Strukturmuster, das in zwei verschiedenen Varianten existiert: Einer klassenbasierten, die auf Mehrfachvererbung basiert, sowie einer objektorientierten, die auf Delegation setzt. Beide Varianten und ihre Besonderheiten sollen im Folgenden erläutert werden.

Klassenbasierter Adapter:

Da die Umsetzung eines klassenbasierten Adapters auf Mehrfachvererbung basiert, was von vielen Programmiersprachen, wie z.B. Java nicht unterstützt wird, kann er nur unter solchen Sprachen, die Merhfachvererbung anbieten, sinnvoll genutzt werden. 

Das folgende Klassendiagramm zeigt die Realisierung eines solchen Adapters, indem er sowohl von der Ziel-Schnittstelle, als auch von der bereits vorhandenen abgeleitet wird:

Das Klassendiagram eines klassenbasierten Adapters

Neben der Einschränkung, dass ein solcher Adapter nur in Programmiersprachen eingesetzt werden kann, die Mehrfachvererbung unterstützen, existiert noch der weitere Nachteil, dass, anders als bei dem objektorientierten Adapter, der im Folgenden noch vorgestellt werden wird, Unterklassen des anzupassenden Dienstes nicht automatisch von dem Adapter abgedeckt werden. Dieser Nachteil kann allerdings auch als Vorteil gewertet werden, da der Adapter genau einer einzigen Zielklasse angepasst ist und nur deren Verhalten überschreiben kann.

Objektorientierter Adapter:

Für alle Programmiersprachen, die keine Mehrfachvererbung anbieten, kommt nur diese Variante des Adapters in Frage. Dabei besitzt der Adapter, anstatt von der anzupassenden Klasse zu erben, eine Referenz auf diese. Das folgende Klassendiagramm verdeutlicht den Unterschied zu dem klassenbasierten Adapter:

Das Klassendiagramm eines objektorientierten Adapters

Die Referenz auf die anzupassende Klasse wird dabei in der Regel beim Konstruktoraufruf an den Adapter übergeben. Der folgende Beispielcode, soll das verdeutlichen:
 public interface Ziel {  
   
   void operation();  
   
 }  
   
 public class Adapter implements Ziel {  
   
   private Dienst dienst;  
   
   public Adapter(Dienst dienst) {  
     this.dienst = dienst;  
   }  
   
   @Override  
   public void operation() {  
     dienst.action();  
   }  
   
 }  
Neben dem offensichtlichen Vorteil, dass diese Adapter-Variante in jeder beliebigen Programmiersprache seinen Einsatz finden kann, kann auch die Eigenschaft, dass an den Adapter auch Unterklassen des anzupassenden Dienstes übergeben werden können, von Vorteil sein.

Generell bieten alle Adapter den Vorteil, dass der dahinterliegende Dienst und auch sie selbst zur Laufzeit ausgetauscht werden können, was Varianten verschiedener Implementierungen erlaubt. Nachteiligt wirkt sich aus, dass Adapter sehr komplex werden können, falls die zu adaptierende Schnittstelle dementsprechend groß ist, oder die Zielschnittstelle technisch stark von der bestehenden Schnittstelle abweicht.

20. Januar 2013

Entwurfsmuster: Fliegengewicht

Bei dem zweiten Entwurfsmuster, das in dieser Serie vorgestellt werden soll, handelt es sich um das "Fliegengewicht" (eng. Flyweight-Pattern). Es ist ein sogenanntes Strukturmuster und wird in der Softwareentwicklung verwendet, wenn eine große Anzahl von Objekten verwaltet werdern soll, die sich variable Informationen teilen. Das unten stehende Klassendiagramm zeigt die Beziehung zwischen den, für das Entwurfsmuster notwendigen, Klassen.

UML-Klassendiagramm des Entwurfsmusters "Fliegengewicht" (Klicken zum Vergrößern)

Das Interface "Flyweight" definiert dabei die Schnittstelle für die einzelnen Objekte, die ausgelagerte Zustände empfangen sollen. Diese Schnittstelle wird von konkreten Klassen implementiert, die bei Bedarf außerdem noch einen internen Zustand besitzen können und definiert Methoden, die mit einem ausgelagerten Zustand, der als Parameter übergeben wird, arbeiten. Die Klasse "FlyweightFactory" erzeugt und verwaltet Fliegengewichte. Dazu übergibt der Client, der den ausgelagerten Zustand verwaltet, einen Schlüssel an die Klasse. Für jeden Schlüssel wird lediglich ein einziges Fliegengewicht instanziiert und zurückgegeben.

Vorteile:
  • Die Anzahl der benötigten Objektinstanzen, und damit auch der Speicherbedarf, kann drastisch reduziert werden. Bei Persitierung der Objektstruktur kann außerdem der benötigte Speicherplatz und die Übertragungszeit reduziert werden.
  •  Oftmals werden die betreffenden Klassen schlanker, da Informationen ausgelagert wurden.
Nachteile:
  • Die Komplexität der Implementierung wird teils stark erhöht und bei jeder späteren Ergänzung muss bedacht werden, dass der ausgelagerte Zustand nicht um Daten ergänzt werden darf, die kontextabhängig sind.
  • Der Einsatz von Flyweight-Instanzen (beispielsweise als Hash-Wert) kann unerwartete Folgen haben, da diese in der Regel mehrfach referenziert sind.
  •  Die Laufzeitkosten steigen an, da der ausgelagerte Zustand bei jedem Zugriff erst zusammengestellt werden muss.
Da die Nachteile dieses Entwurfsmusters bei falscher Anwendung gravierend sein können, sollte im Vornhinein genau überlegt werden, ob sich der Einsatz lohnt. Dies ist nur der Fall, wenn eine ausreichend große Anzahl an Objektinstanzen benötigt wird und die Kosten für deren Speicherung so groß werden, dass die Speicheinsparung spürbar wird. Außerdem sollte darauf geachtet werden, dass die internen und ausgelagerten Zustände so verteilt werden können, dass nur wenige Fliegengewicht-Implementierungen benötigt werden.

Entwurfsmuster: Fassade

Die folgenden Posts sollen eine Serie bilden, in der etablierte Entwurfsmuster (engl. Design-Patterns), die sich für den alltäglichen Einsatz in der Softwareentwicklung bewährt haben, vorgestellt werden sollen. Entwurfsmuster sind Lösungsmodelle für immer wiederkehrende Probleme beim Entwurf objektorientierter Software und bieten Lösungsansätze, die meist durch die Beschreibung von Klassen und Interfaces, sowie deren Funktion und Beziehung zueinander, beschrieben werden.

Den Anfang dieser Reihe von Posts soll die sogenannte "Fassade", ein relativ simples Entwurfsmuster bilden. Die Fassade (engl. Facade-Pattern) ist ein Entwurfsmuster aus dem Bereich der Softwareentwicklung, das zu der Kategorie der Strukturmuster gehört und dessen Ziel es ist, eine Vielzahl verschiedener Schnittstellen eines Subsystems über eine einzige, einheitliche und oftmals vereinfachte Schnittstelle, verfügbar zu machen.

Dazu wird eine Schnittstelle definiert, die nur ausgewählte, von den Clients benötigte, Methoden anbietet. Aufrufe dieser Methoden werden intern an die jeweils zuständigen Klassen des Subsystems delegiert. Das folgende UML-Diagram verdeutlicht das Prinzip des Fassade-Patterns und zeigt beispielhaft wie die Delegation an die einzelnen Komponenten des Subsystems aussehen könnte.

Das Fassade-Pattern als UML-Klassendiagramm


Vorteile:
  • Die Fassade entkoppelt die einzelnen Klassen des Subsystems von den Clients, die sie verwenden. Dadurch können die Implementierungen und Schnittstellen der Subsystem-Klassen geändert werden, ohne die Clients anpassen zu müssen.
  • Die Verwendung des Subsystems wird erleichtert, weil dessen Komplexität durch die Fassade versteckt.
Nachteile:
  • Wenn Clients die Fassade umgehen und das Subsystem direkt ansprechen, wird das komplette Entwurfsmuster ausgehebelt. Normalerweise ist diese Möglichkeit technisch jedoch nicht zu verhindern. 
  • Wenn sich Schnittstellen innerhalb des Subsystems ändern, so muss jedes Mal die Fassade angepasst werden.
Fassaden können außerdem nach Bedarf weitere Verantwortlichkeiten wie Zugangskontrolle, Transaktionsmanagement oder Session-Handling übernehmen und die Clients von dem Subsystem, durch die Verwendung asynchroner Kommunikationsmechanismen, entkoppeln.