I've been researching the difference between these two patterns.
I understand that facade encapsulates access to a sub system and mediator encapsulates the interactions between components.
I understand that sub system components are not aware of the facade, where as components are obviously aware of the mediator.
I'm currently using a facade for encapsulating the method of retrieving configuration information, e.g. App.Config, user setting stored in SQL, Assembly info, etc, and a mediator for navigation between different windows forms.
However, most sites point out that the mediator “adds functionality”. What do they mean by this? How does mediator add functionality?
I'm using mediator to add log file functionality.
It works like this:
The facade only exposes the existing functionality from a different perspective.
The mediator "adds" functionality because it combines different existing functionality to create a new one.
Take the following example:
You have a logging system. From that logging system you can either log to a file, to a socket, or to a database.
Using the facade design pattern you would "hide" all the relationships from existing functionality behind a single "interface" the one that the facade exposes.
Client code:
The implementation may involve the interaction of many objects. But at the end, the functionality already exists. Probably the "debug" method is implemented as follows:
Implementation:
The functionality already exist. The facade only hides it. In this hypothetical case, the LoggerManager handles the creation of the correct logger, and the LoggerImpl is a package private object that has the "debug" method. This way the Facade is not adding functionality it is just delegating to some existing objects.
In the other hand the mediator add the new functionality by combining different objects.
Same Client code:
Implementation:
In this code, the mediator is the one that contains the business logic to create the appropriate "channel" to log and also to make the log into that channel. The mediator is "creating" the functionality.
Of course, there are better ways to implement this using polymorphism, but the point here is to show how the mediator "adds" new functionality by combining existing functionality ( in my sample didn't show very much sorry ) but imagine the mediator, read from the database the remote host where to log, then creates a client and finally write to that client print stream the log message. This way the mediator would be "mediating" between the different objects.
Finally, the facade is an structural pattern, that is it describes the composition of the objects, while the mediator is an behavioral, that is , it describes the way the objects interact.
I hope this helps.
I thought the distinction was directional: facade is a one-way communication between client and facade; mediator can be a two-way conversation, with messages flowing back and forth between the client and mediator.
Take a simple analogy:
Facade: like a parking lot, when call
mab be a simple chain works:
Mediator: like traffic light.
There are interactions between light and car,
and cars are controlled by it's state.
I though maybe this is the mediator “adds functionality”
And about the definition:
Facade's Type: Structural
Mediator's Type: Behavioral
facade more concerned about the components were contained in the unified interface,
and mediator concern how a set of objects interact.
Both impose some kind of policy on another group of objects. Facade imposes the policy from above, and Mediator imposes the policy from below. The use of Facade is visible and constraining, while the use of Mediator is invisible and enabling.
The Facade pattern is used when you want to provide a simple and specific interface to a group of objects that has a complex and general interface.
The Mediator pattern also imposes policy. However, whereas Facade imposed its policy in a visible and constraining way, Mediator imposes its policies in a hidden and unconstrained way.
Agile Software Development, Principles, Patterns, and Practices Robert C. Martin.
From the "Design Patterns" book, the KEY of the Mediator pattern is described as follows: "It (a mediator) acts as a HUB of communication for widgets (i.e., 'a' group of interdependent objects)."
In other words, a mediator object is the sole superobject that knows all other objects in a group of collaborating objects and how they should interact with each other. All other objects should interact with the mediator object, instead of each other.
In contrast, a facade is a "unified interface" for a set of interfaces in a subsystem - for use by consumers of the subsystem - not among the components of the subsystem.