Mediator-Entwurfsmuster
Mediator-Entwurfsmuster
Das Mediator-Entwurfsmuster ist ein Verhaltensmuster aus der Softwareentwicklung. Es dient dazu, die Kommunikation zwischen Objekten zu zentralisieren, indem ein Vermittlerobjekt (Mediator) die Interaktionen koordiniert. Dadurch werden direkte Abhängigkeiten zwischen den beteiligten Objekten reduziert und das System bleibt übersichtlicher, entkoppelter und leichter wartbar.
Ziel
Das Mediator-Muster soll:
- Abhängigkeiten zwischen Klassen reduzieren
- Komplexität der Kommunikation vereinfachen
- Änderungen lokal halten, ohne viele Klassen anpassen zu müssen
- Code lesbarer und modularer gestalten
Problemstellung
Ohne Mediator kommunizieren Objekte oft direkt miteinander. In Systemen mit vielen Objekten führt dies zu:
- komplexen Abhängigkeiten,
- schwerer Wartbarkeit,
- hoher Kopplung.
Das Mediator-Muster löst dies, indem alle Kommunikation über eine zentrale Instanz läuft.
Grundidee
Statt dass Objekte sich gegenseitig direkt aufrufen, informieren sie den Mediator. Dieser entscheidet dann, welches Objekt darauf reagieren soll.
Prinzipielle Darstellung
Vorher (hohe Kopplung):
Objekt A <--> Objekt B <--> Objekt C
Nachher (mit Mediator):
Objekt A --> Mediator <-- Objekt B
^
|
Objekt C
Kernbestandteile
| Komponente | Beschreibung |
|---|---|
| Mediator | Vermittelt und koordiniert die Kommunikation zwischen Objekten. |
| ConcreteMediator | Konkrete Implementierung der Vermittlungslogik. |
| Colleague | Objekt, das mit anderen kommunizieren möchte, jedoch nur den Mediator kontaktiert. |
| ConcreteColleague | Konkrete Klassen, die Nachrichten über den Mediator senden. |
Beispiel in C++
#include <iostream>
#include <string>
class Mediator;
class Colleague {
protected:
Mediator* mediator;
public:
Colleague(Mediator* m) : mediator(m) {}
virtual void receive(const std::string& msg) = 0;
void send(const std::string& msg);
};
class Mediator {
public:
virtual void distribute(Colleague* sender, const std::string& msg) = 0;
};
void Colleague::send(const std::string& msg) {
mediator->distribute(this, msg);
}
class ConcreteColleagueA : public Colleague {
public:
using Colleague::Colleague;
void receive(const std::string& msg) override {
std::cout << "A empfängt: " << msg << std::endl;
}
};
class ConcreteColleagueB : public Colleague {
public:
using Colleague::Colleague;
void receive(const std::string& msg) override {
std::cout << "B empfängt: " << msg << std::endl;
}
};
class ConcreteMediator : public Mediator {
private:
Colleague* a;
Colleague* b;
public:
ConcreteMediator(Colleague* a, Colleague* b) : a(a), b(b) {}
void distribute(Colleague* sender, const std::string& msg) override {
if (sender == a) b->receive(msg);
else a->receive(msg);
}
};
int main() {
ConcreteColleagueA a(nullptr);
ConcreteColleagueB b(nullptr);
ConcreteMediator m(&a, &b);
a = ConcreteColleagueA(&m);
b = ConcreteColleagueB(&m);
a.send("Hallo von A!");
b.send("Hallo von B!");
}
Vorteile
- Verringerte Kopplung zwischen Objekten
- Zentrale Steuerung des Kommunikationsverhaltens
- Leichtere Erweiterbarkeit, da Änderungen nur im Mediator erfolgen
- Übersichtliche Struktur bei vielen interagierenden Komponenten
Nachteile
- Mediator kann komplex werden, wenn viele Regeln zentralisiert sind
- Gefahr eines „God Object“, das zu viel Logik übernimmt
- Verteilung der Verantwortlichkeiten muss klar definiert werden
Einsatzgebiete
Das Mediator-Muster wird eingesetzt, wenn:
- viele Objekte miteinander interagieren,
- die Kommunikationslogik häufig geändert wird,
- eine klare Trennung von Logik und Kommunikationsregeln erforderlich ist.
Typische Anwendungsfälle:
- GUI-Systeme (z. B. Dialog- und UI-Steuerung)
- Chat- oder Messaging-Systeme
- Event-Handling in komplexen Softwarekomponenten
- Microservice-Orchestrierung
Zusammenfassung
Das Mediator-Entwurfsmuster zentralisiert die Kommunikation zwischen Objekten, reduziert Kopplung und verbessert die Wartbarkeit komplexer Systeme. Es ist besonders geeignet für Anwendungen mit vielen interagierenden Komponenten, muss jedoch sorgfältig gestaltet werden, um eine Überlastung des Mediators zu vermeiden.
Siehe auch
- Observer-Entwurfsmuster
- Strategy-Entwurfsmuster
- Command-Entwurfsmuster
- Entwurfsmuster in der Softwareentwicklung