Entwurfsmuster (Softwareentwicklung) - Versionsgeschichte

PhilKa: /* Entwurfsmuster in der Softwareentwicklung */

2025-11-04T12:15:25Z

Entwurfsmuster in der Softwareentwicklung

← Nächstältere Version		Version vom 4. November 2025, 14:15 Uhr
Zeile 1:		Zeile 1:
	= Entwurfsmuster in der Softwareentwicklung =		= Entwurfsmuster in der Softwareentwicklung =

	'''Entwurfsmuster''' (engl. Design Patterns) sind wiederverwendbare Lösungsansätze für häufig auftretende Probleme in der Softwareentwicklung. Sie beschreiben bewährte Strukturen und Interaktionen von Klassen und Objekten, ohne eine konkrete Implementierung vorzugeben.		'''Entwurfsmuster''' (engl. ''Design Patterns'') sind wiederverwendbare Lösungsansätze für häufig auftretende Probleme in der Softwareentwicklung. Sie beschreiben bewährte Strukturen und Interaktionen von Klassen und Objekten, ohne eine konkrete Implementierung vorzugeben.

	== Ziel ==		== Ziel ==
	Das Ziel von Entwurfsmustern ist es, Software:		Das Ziel von Entwurfsmustern ist es, Software:
	* verständlicher,		* '''verständlicher''',
	* wartbarer,		* '''wartbarer''',
	* erweiterbarer		* '''erweiterbarer'''
	und wiederverwendbarer zu machen.		und '''wiederverwendbarer''' zu machen.

	Sie fördern eine saubere Architektur, klare Verantwortlichkeiten und vermeiden redundanten Code.		Sie fördern eine saubere Architektur, klare Verantwortlichkeiten und vermeiden redundanten Code.
Zeile 14:		Zeile 14:
	== Ursprung ==		== Ursprung ==
	Das Konzept der Entwurfsmuster wurde durch die sogenannte „Gang of Four“ (GoF) geprägt:		Das Konzept der Entwurfsmuster wurde durch die sogenannte „Gang of Four“ (GoF) geprägt:
	Erich Gamma, Richard Helm, Ralph Johnson und John Vlissides veröffentlichten 1994 das Buch „Design Patterns: Elements of Reusable Object-Oriented Software“, das 23 grundlegende Muster definiert.		Erich Gamma, Richard Helm, Ralph Johnson und John Vlissides veröffentlichten 1994 das Buch ''„Design Patterns: Elements of Reusable Object-Oriented Software“'', das 23 grundlegende Muster definiert.

	== Klassifikation ==		== Klassifikation ==
Zeile 51:		Zeile 51:

	== Vorteile ==		== Vorteile ==
	* Förderung von Modularität und Wiederverwendbarkeit		* Förderung von '''Modularität''' und '''Wiederverwendbarkeit'''
	* Erleichtert Kommunikation durch standardisierte Begriffe		* Erleichtert '''Kommunikation''' durch standardisierte Begriffe
	* Erhöht Flexibilität und Erweiterbarkeit		* Erhöht '''Flexibilität''' und '''Erweiterbarkeit'''
	* Verbessert Wartbarkeit und Testbarkeit		* Verbessert '''Wartbarkeit''' und '''Testbarkeit'''

	== Nachteile ==		== Nachteile ==
	* Erhöhter Abstraktionsgrad und damit höhere Komplexität		* Erhöhter '''Abstraktionsgrad''' und damit höhere '''Komplexität'''
	* Gefahr von Überengineering, wenn Muster unnötig eingesetzt werden		* Gefahr von '''Überengineering''', wenn Muster unnötig eingesetzt werden
	* Kann Leistungseinbußen verursachen (z. B. durch zusätzliche Objektschichten)		* Kann '''Leistungseinbußen''' verursachen (z. B. durch zusätzliche Objektschichten)

	== Beispiel: Singleton-Muster in Java ==		== Beispiel: Singleton-Muster in Java ==
Zeile 112:		Zeile 112:
	== Anwendung in modernen Architekturen ==		== Anwendung in modernen Architekturen ==
	Entwurfsmuster werden auch in modernen Softwarearchitekturen eingesetzt:		Entwurfsmuster werden auch in modernen Softwarearchitekturen eingesetzt:
	* MVC, MVP, MVVM – zur Trennung von Darstellung und Logik		* '''MVC, MVP, MVVM''' – zur Trennung von Darstellung und Logik
	* Dependency Injection (DI) – zur Entkopplung von Komponenten		* '''Dependency Injection (DI)''' – zur Entkopplung von Komponenten
	* Event Sourcing und CQRS – in verteilten Systemen und Microservices		* '''Event Sourcing''' und '''CQRS''' – in verteilten Systemen und Microservices
	* Repository Pattern – in Datenzugriffsschichten		* '''Repository Pattern''' – in Datenzugriffsschichten

	== Zusammenhang mit Softwarearchitektur ==		== Zusammenhang mit Softwarearchitektur ==
Zeile 122:		Zeile 122:

	== Bekannte Erweiterungen ==		== Bekannte Erweiterungen ==
	* Enterprise Patterns (z. B. in der Java EE-Welt: Service Locator, DAO, Session Facade)		* '''Enterprise Patterns''' (z. B. in der Java EE-Welt: Service Locator, DAO, Session Facade)
	* Concurrency Patterns (z. B. Producer-Consumer, Thread Pool, Reactor Pattern)		* '''Concurrency Patterns''' (z. B. Producer-Consumer, Thread Pool, Reactor Pattern)
	* Functional Patterns (z. B. Monaden, Funktoren in funktionalen Sprachen)		* '''Functional Patterns''' (z. B. Monaden, Funktoren in funktionalen Sprachen)

	== Werkzeuge und Frameworks ==		== Werkzeuge und Frameworks ==
	Viele Frameworks implementieren Entwurfsmuster intern:		Viele Frameworks implementieren Entwurfsmuster intern:
	* Spring Framework (Java): Dependency Injection, Proxy, Singleton		* '''Spring Framework (Java):''' Dependency Injection, Proxy, Singleton
	* Angular (JavaScript): Observer, Dependency Injection		* '''Angular (JavaScript):''' Observer, Dependency Injection
	* .NET Framework: Factory, Strategy, Decorator		* '''.NET Framework:''' Factory, Strategy, Decorator

	== Siehe auch ==		== Siehe auch ==

PhilKa: Die Seite wurde neu angelegt: „= Entwurfsmuster in der Softwareentwicklung = '''Entwurfsmuster''' (engl. Design Patterns) sind wiederverwendbare Lösungsansätze für häufig auftretende Probleme in der Softwareentwicklung. Sie beschreiben bewährte Strukturen und Interaktionen von Klassen und Objekten, ohne eine konkrete Implementierung vorzugeben. == Ziel == Das Ziel von Entwurfsmustern ist es, Software: * verständlicher, * wartbarer, * erweiterbarer und **wied…“

2025-11-04T12:14:17Z

Die Seite wurde neu angelegt: „= Entwurfsmuster in der Softwareentwicklung = '''Entwurfsmuster''' (engl. *Design Patterns*) sind wiederverwendbare Lösungsansätze für häufig auftretende Probleme in der Softwareentwicklung. Sie beschreiben bewährte Strukturen und Interaktionen von Klassen und Objekten, ohne eine konkrete Implementierung vorzugeben. == Ziel == Das Ziel von Entwurfsmustern ist es, Software: * **verständlicher**, * **wartbarer**, * **erweiterbarer** und **wied…“

Neue Seite

= Entwurfsmuster in der Softwareentwicklung =

'''Entwurfsmuster''' (engl. *Design Patterns*) sind wiederverwendbare Lösungsansätze für häufig auftretende Probleme in der Softwareentwicklung. Sie beschreiben bewährte Strukturen und Interaktionen von Klassen und Objekten, ohne eine konkrete Implementierung vorzugeben.

== Ziel ==
Das Ziel von Entwurfsmustern ist es, Software:
* **verständlicher**,
* **wartbarer**,
* **erweiterbarer**
und **wiederverwendbarer** zu machen.

Sie fördern eine saubere Architektur, klare Verantwortlichkeiten und vermeiden redundanten Code.

== Ursprung ==
Das Konzept der Entwurfsmuster wurde durch die sogenannte „Gang of Four“ (GoF) geprägt:
*Erich Gamma, Richard Helm, Ralph Johnson und John Vlissides* veröffentlichten 1994 das Buch *„Design Patterns: Elements of Reusable Object-Oriented Software“*, das 23 grundlegende Muster definiert.

== Klassifikation ==
Die GoF-Entwurfsmuster werden in drei Hauptkategorien eingeteilt:

=== 1. Erzeugungsmuster (Creational Patterns) ===
Diese Muster befassen sich mit der Erzeugung von Objekten und trennen die Objektinstanziierung von der Nutzung.
* '''Singleton''': Stellt sicher, dass es nur eine Instanz einer Klasse gibt.
* '''Factory Method''': Delegiert die Objekterzeugung an Unterklassen.
* '''Abstract Factory''': Erzeugt Familien verwandter Objekte, ohne deren konkrete Klassen anzugeben.
* '''Builder''': Trennt die Konstruktion komplexer Objekte von ihrer Darstellung.
* '''Prototype''': Erstellt neue Objekte durch Kopieren eines vorhandenen Prototyps.

=== 2. Strukturmuster (Structural Patterns) ===
Diese Muster beschreiben, wie Klassen und Objekte zu größeren Strukturen zusammengesetzt werden.
* '''Adapter''': Passt inkompatible Schnittstellen aneinander an.
* '''Bridge''': Trennt Abstraktion und Implementierung, sodass beide unabhängig voneinander variieren können.
* '''Composite''': Ermöglicht die einheitliche Behandlung einzelner Objekte und Objektgruppen.
* '''Decorator''': Fügt Objekten dynamisch zusätzliche Funktionalität hinzu.
* '''Facade''': Bietet eine vereinfachte Schnittstelle zu einem komplexen Subsystem.
* '''Flyweight''': Spart Speicher, indem häufig wiederkehrende Objekte geteilt werden.
* '''Proxy''': Stellt ein Stellvertreterobjekt für ein anderes Objekt bereit.

=== 3. Verhaltensmuster (Behavioral Patterns) ===
Diese Muster befassen sich mit der Kommunikation und Zusammenarbeit zwischen Objekten.
* '''Chain of Responsibility''': Leitet Anfragen entlang einer Kette von Objekten weiter.
* '''Command''': Kapselt Befehle als Objekte.
* '''Iterator''': Ermöglicht den sequenziellen Zugriff auf Elemente einer Sammlung.
* '''Mediator''': Kapselt die Interaktion mehrerer Objekte in einem Vermittlerobjekt.
* '''Memento''': Erlaubt das Speichern und Wiederherstellen von Objektzuständen.
* '''Observer''': Benachrichtigt abhängige Objekte automatisch bei Zustandsänderungen.
* '''State''': Kapselt Zustandsabhängiges Verhalten in separate Klassen.
* '''Strategy''': Definiert austauschbare Algorithmen über gemeinsame Schnittstellen.
* '''Template Method''': Definiert ein Grundgerüst eines Algorithmus, dessen Schritte Unterklassen spezifizieren können.
* '''Visitor''': Trennt Operationen von den Objekten, auf denen sie ausgeführt werden.

== Vorteile ==
* Förderung von **Modularität** und **Wiederverwendbarkeit**
* Erleichtert **Kommunikation** durch standardisierte Begriffe
* Erhöht **Flexibilität** und **Erweiterbarkeit**
* Verbessert **Wartbarkeit** und **Testbarkeit**

== Nachteile ==
* Erhöhter **Abstraktionsgrad** und damit höhere **Komplexität**
* Gefahr von **Überengineering**, wenn Muster unnötig eingesetzt werden
* Kann **Leistungseinbußen** verursachen (z. B. durch zusätzliche Objektschichten)

== Beispiel: Singleton-Muster in Java ==
<syntaxhighlight lang="java">
public class Singleton {
private static Singleton instance;

private Singleton() {
// privater Konstruktor verhindert externe Instanziierung
}

public static Singleton getInstance() {
if (instance == null) {
instance = new Singleton();
}
return instance;
}

public void printMessage() {
System.out.println("Singleton-Instanz aktiv");
}
}
</syntaxhighlight>

== Beispiel: Observer-Muster in Python ==
<syntaxhighlight lang="python">
class Subject:
def __init__(self):
self._observers = []

def attach(self, observer):
self._observers.append(observer)

def notify(self, message):
for obs in self._observers:
obs.update(message)

class Observer:
def update(self, message):
print(f"Observer erhielt Nachricht: {message}")

subject = Subject()
o1 = Observer()
o2 = Observer()

subject.attach(o1)
subject.attach(o2)

subject.notify("Zustandsänderung erfolgt!")
</syntaxhighlight>

== Anwendung in modernen Architekturen ==
Entwurfsmuster werden auch in modernen Softwarearchitekturen eingesetzt:
* **MVC, MVP, MVVM** – zur Trennung von Darstellung und Logik
* **Dependency Injection (DI)** – zur Entkopplung von Komponenten
* **Event Sourcing** und **CQRS** – in verteilten Systemen und Microservices
* **Repository Pattern** – in Datenzugriffsschichten

== Zusammenhang mit Softwarearchitektur ==
Entwurfsmuster sind Bausteine für größere Architekturkonzepte.
Während Architekturmuster (z. B. [[Microservices-Architektur]], [[Client-Server-Architektur]]) die Gesamtstruktur einer Anwendung beschreiben, lösen Entwurfsmuster Probleme auf Klassen- oder Objektebene.

== Bekannte Erweiterungen ==
* **Enterprise Patterns** (z. B. in der Java EE-Welt: Service Locator, DAO, Session Facade)
* **Concurrency Patterns** (z. B. Producer-Consumer, Thread Pool, Reactor Pattern)
* **Functional Patterns** (z. B. Monaden, Funktoren in funktionalen Sprachen)

== Werkzeuge und Frameworks ==
Viele Frameworks implementieren Entwurfsmuster intern:
* **Spring Framework (Java):** Dependency Injection, Proxy, Singleton
* **Angular (JavaScript):** Observer, Dependency Injection
* **.NET Framework:** Factory, Strategy, Decorator

== Siehe auch ==
* [[Softwarearchitektur]]
* [[MVC]]
* [[MVP]]
* [[MVVM]]
* [[Dependency Injection]]
* [[Microservices-Architektur]]

== Literatur ==
* Gamma, Helm, Johnson, Vlissides: ''Design Patterns – Elements of Reusable Object-Oriented Software'', Addison-Wesley, 1994.
* Buschmann et al.: ''Pattern-Oriented Software Architecture'', Wiley, 1996.
* Freeman, Freeman: ''Head First Design Patterns'', O’Reilly, 2004.

== Weblinks ==
* [https://en.wikipedia.org/wiki/Software_design_pattern Wikipedia: Software Design Pattern]
* [https://refactoring.guru/design-patterns Refactoring.Guru – Design Patterns Übersicht]
* [https://sourcemaking.com/design_patterns SourceMaking Design Patterns]