Mediator Method – Python Design Pattern

Mediator Method is a Behavioral Design Pattern which allows us to reduce the unordered dependencies between the objects. In a mediator environment, objects take the help of mediator objects to communicate with each other. It reduces coupling by reducing the dependencies between communicating objects. The mediator works as a router between objects and it can have it’s own logic to provide a way of communication.

Design Components:

  • Mediator: It defines the interface for communication between colleague objects.
  • Concrete Mediator: It implements the mediator interface and coordinates communication between colleague objects.
  • Colleague: It defines the interface for communication with other colleagues
  • Concrete Colleague: It implements the colleague interface and communicates with other colleagues through its mediator.

Problem Without using Mediator Method

Imagine you are going to take admission in one of the elite courses offered by GeeksforGeeks such as DSA, SDE and STL. Initially, there are very few students who are approaching to join these courses. Initially, the developer can create separate objects and classes for the connection between the students and the courses but as the courses become famous among students it becomes hard for developers to handle such a huge number of sub-classes and there objects.

Problem-Mediator-Method

Problem-Mediator-Method

Solution using Mediator Method

Now let us understand how a pro developer will handle such a situation using the Mediator design pattern. We can create a separate mediator class named as Course and a User Class using which we can create different objects of Course class. In the main method, we will create a separate object for each student and inside the User class, we will create the object for Course class which helps in preventing the unordered code.

Solution-Mediator-method

Solution-mediator-method

filter_none

edit
close

play_arrow

link
brightness_4
code

class Course(object):
    """Mediator class."""
  
    def displayCourse(self, user, course_name):
        print("[{}'s course ]: {}".format(user, course_name))
  
  
class User(object):
    '''A class whose instances want to interact with each other.'''
  
    def __init__(self, name):
        self.name = name
        self.course = Course()
  
    def sendCourse(self, course_name):
        self.course.displayCourse(self, course_name)
  
    def __str__(self):
        return self.name
  
"""main method"""
  
if __name__ == "__main__":
  
    mayank = User('Mayank')   # user object
    lakshya = User('Lakshya') # user object
    krishna = User('Krishna') # user object
  
    mayank.sendCourse("Data Structures and Algorithms")
    lakshya.sendCourse("Software Development Engineer")
    krishna.sendCourse("Standard Template Library")

chevron_right


UML Diagram

Following is the UML Diagram for Mediator Method:

Mediator-method-UML-Diagram

Mediator-method-UML-Diagram

Advantages

  • Single Responsibility Principle: Extracting the communications between the various components is possible under Mediator Method into a single place which is easier to maintain.
  • Opne/Closed Principle: It’s easy to introduce new mediators without disturbing the existing client code.
  • Allows Inheritance: We can resue the individual components of the mediators as it follows the Inheritance
  • Few Sub-Classes: Mediator limits the Sub-Classing as a mediator localizes the behavior that otherwise would be disturbed among the several objects.

Disadvantages

  • Centralization: It completely centralizes the control because the mediator pattern trades complexity of interaction for complexity in the mediator.
  • God Object: A Mediator can be converted into a God Object (an object that knows too much or does too much).
  • Increased Complexity: The structure of the mediator object may become too much complex if we put too much logic inside it.

Applicability

  • Reduce the number of sub-classes: When you have realized that you have created a lot of unnecessary sub-classes, then it is preferred to use the Mediator method to avoid these unncessary sub-classes.
  • Air Traffic Controller: Air traffic controller is a great example of mediator pattern where the airport control room works as a mediator for communication between different flights.

Further Read – Mediator Method in Java




My Personal Notes arrow_drop_up

Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.


Article Tags :

1


Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.