... die meisten Websites weisen darauf hin, dass der Mediator "Funktionalität hinzufügt" ...
Die Fassade zeigt die vorhandene Funktionalität nur aus einer anderen Perspektive.
Der Mediator "fügt" Funktionen hinzu, da er verschiedene vorhandene Funktionen kombiniert, um eine neue zu erstellen.
Nehmen Sie das folgende Beispiel:
Sie haben ein Protokollierungssystem. Von diesem Protokollierungssystem aus können Sie entweder in einer Datei, in einem Socket oder in einer Datenbank protokollieren.
Mit dem Fassadenentwurfsmuster würden Sie alle Beziehungen vor vorhandenen Funktionen hinter einer einzigen "Schnittstelle" "verbergen", die die Fassade freigibt.
Kundencode:
Logger logger = new Logger();
logger.initLogger("someLogger");
logger.debug("message");
Die Implementierung kann die Interaktion vieler Objekte beinhalten. Aber am Ende ist die Funktionalität bereits vorhanden. Wahrscheinlich ist die "Debug" -Methode wie folgt implementiert:
Implementierung:
class Logger {
private LoggerImpl internalLogger;
private LoggerManager manager;
public void initLogger( String loggerName ) {
this.internalLogger = manager.getLogger( loggerName );
}
public void debug( String message ) {
this.internalLogger.debug( message );
}
}
Die Funktionalität ist bereits vorhanden. Die Fassade verbirgt es nur. In diesem hypothetischen Fall übernimmt der LoggerManager die Erstellung des richtigen Loggers, und der LoggerImpl ist ein paketprivates Objekt mit der Methode "debug". Auf diese Weise fügt die Fassade keine Funktionen hinzu, sondern delegiert sie nur an einige vorhandene Objekte.
Andererseits fügt der Mediator neue Funktionen hinzu, indem er verschiedene Objekte kombiniert.
Gleicher Client-Code:
Logger logger = new Logger();
logger.initLogger("someLogger");
logger.debug("message");
Implementierung:
class Logger {
private java.io.PrintStream out;
private java.net.Socket client;
private java.sql.Connection dbConnection;
private String loggerName;
public void initLogger( String loggerName ) {
this.loggerName = loggerName;
if ( loggerName == "someLogger" ) {
out = new PrintStream( new File("app.log"));
} else if ( loggerName == "serverLog" ) {
client = new Socket("127.0.0.1", 1234 );
} else if( loggerName == "dblog") {
dbConnection = Class.forName()... .
}
}
public void debug( String message ) {
if ( loggerName == "someLogger" ) {
out.println( message );
} else if ( loggerName == "serverLog" ) {
ObjectOutputStrewam oos =
new ObjectOutputStrewam( client.getOutputStream());
oos.writeObject( message );
} else if( loggerName == "dblog") {
Pstmt pstmt = dbConnection.prepareStatment( LOG_SQL );
pstmt.setParameter(1, message );
pstmt.executeUpdate();
dbConnection.commit();
}
}
}
In diesem Code ist der Mediator derjenige, der die Geschäftslogik enthält, um einen geeigneten "Kanal" zum Protokollieren zu erstellen und das Protokoll auch in diesem Kanal zu erstellen. Der Mediator "erstellt" die Funktionalität.
Natürlich gibt es bessere Möglichkeiten, dies mithilfe von Polymorphismus zu implementieren, aber hier geht es darum zu zeigen, wie der Mediator neue Funktionen "hinzufügt", indem er vorhandene Funktionen kombiniert (in meinem Beispiel hat es nicht sehr leid getan), aber stellen Sie sich den Mediator vor, lesen Sie Aus der Datenbank erstellt der Remote-Host, auf dem protokolliert werden soll, einen Client und schreibt schließlich die Protokollnachricht in diesen Client-Druckstrom. Auf diese Weise würde der Mediator zwischen den verschiedenen Objekten "vermitteln".
Schließlich ist die Fassade ein Strukturmuster, dh sie beschreibt die Zusammensetzung der Objekte, während der Mediator ein Verhalten ist, dh die Art und Weise, wie die Objekte interagieren.
Ich hoffe das hilft.