Mediator Design Pattern example

How components are interacting with each other ?

In an airport, there are multiple airplanes that need to communicate and coordinate their movements to avoid collisions and ensure safe takeoffs and landings. Without a centralized system, direct communication between airplanes could lead to chaos and increased risk.

What can be the challenges while implementing this system?

Air Traffic Complexity: Direct communication between airplanes might result in complex and error-prone coordination, especially when dealing with multiple aircraft in the same airspace.
Collision Risks: Without a centralized control mechanism, the risk of collisions between airplanes during takeoffs, landings, or mid-flight maneuvers increases.

How Mediator Pattern help to solve above challenges?

The Mediator pattern helps in managing the complex communication and coordination between airplanes and air traffic controllers, ensuring a safer and more organized aviation system. The centralized control provided by the mediator simplifies interactions, reduces the risk of errors, and promotes a scalable and maintainable solution in the aviation domain.

Centralized Control: The air traffic control tower acts as a mediator, facilitating communication between airplanes. This ensures that all airplanes are aware of each other’s positions and intentions.
Collision Avoidance: The mediator (air traffic control tower) manages the flow of airplanes, preventing collisions by providing clear instructions and coordinating their movements.

Below is the code of above problem statement using Command Pattern:

1. Colleague Interface(Airplane)

Java

// Colleague Interface
public interface Airplane {
    void requestTakeoff();
    void requestLanding();
    void notifyAirTrafficControl(String message);
}

2. ConcreteColleague Class(CommercialAirplane)

Java

// Concrete Colleague
public class CommercialAirplane implements Airplane {
    private AirTrafficControlTower mediator;
 
    public CommercialAirplane(AirTrafficControlTower mediator) {
        this.mediator = mediator;
    }
 
    @Override
    public void requestTakeoff() {
        mediator.requestTakeoff(this);
    }
 
    @Override
    public void requestLanding() {
        mediator.requestLanding(this);
    }
 
    @Override
    public void notifyAirTrafficControl(String message) {
        System.out.println("Commercial Airplane: " + message);
    }
}

3. Mediator Interface(AirTrafficControlTower)

Java

// Mediator Interface
public interface AirTrafficControlTower {
    void requestTakeoff(Airplane airplane);
    void requestLanding(Airplane airplane);
}

4. ConcreteMediator Class(AirportControlTower)

Java

// Concrete Mediator
public class AirportControlTower implements AirTrafficControlTower {
    @Override
    public void requestTakeoff(Airplane airplane) {
        // Logic for coordinating takeoff
        airplane.notifyAirTrafficControl("Requesting takeoff clearance.");
    }
 
    @Override
    public void requestLanding(Airplane airplane) {
        // Logic for coordinating landing
        airplane.notifyAirTrafficControl("Requesting landing clearance.");
    }
}

Complete code for the above example

Below is the complete code for the above example:

Java

// Colleague Interface
interface Airplane {
    void requestTakeoff();
    void requestLanding();
    void notifyAirTrafficControl(String message);
}
 
// Concrete Colleague
class CommercialAirplane implements Airplane {
    private AirTrafficControlTower mediator;
 
    public CommercialAirplane(AirTrafficControlTower mediator) {
        this.mediator = mediator;
    }
 
    @Override
    public void requestTakeoff() {
        mediator.requestTakeoff(this);
    }
 
    @Override
    public void requestLanding() {
        mediator.requestLanding(this);
    }
 
    @Override
    public void notifyAirTrafficControl(String message) {
        System.out.println("Commercial Airplane: " + message);
    }
}
 
// Mediator Interface
interface AirTrafficControlTower {
    void requestTakeoff(Airplane airplane);
    void requestLanding(Airplane airplane);
}
 
// Concrete Mediator
class AirportControlTower implements AirTrafficControlTower {
    @Override
    public void requestTakeoff(Airplane airplane) {
        // Logic for coordinating takeoff
        airplane.notifyAirTrafficControl("Requesting takeoff clearance.");
    }
 
    @Override
    public void requestLanding(Airplane airplane) {
        // Logic for coordinating landing
        airplane.notifyAirTrafficControl("Requesting landing clearance.");
    }
}
 
// Main class
public class MediatorAirplaneExample {
    public static void main(String[] args) {
        // Instantiate the Mediator (Airport Control Tower)
        AirTrafficControlTower controlTower = new AirportControlTower();
 
        // Instantiate Concrete Colleagues (Commercial Airplanes)
        Airplane airplane1 = new CommercialAirplane(controlTower);
        Airplane airplane2 = new CommercialAirplane(controlTower);
 
        // Set up the association between Concrete Colleagues and the Mediator
        airplane1.requestTakeoff();
        airplane2.requestLanding();
 
        // Output:
        // Commercial Airplane: Requesting takeoff clearance.
        // Commercial Airplane: Requesting landing clearance.
    }
}

Output

Commercial Airplane: Requesting takeoff clearance.
Commercial Airplane: Requesting landing clearance.

Mediator design pattern

The Mediator design pattern is a behavioral pattern that defines an object, the mediator, to centralize communication between various components or objects in a system. This promotes loose coupling by preventing direct interactions between components, instead of having them communicate through the mediator, facilitating better maintainability and flexibility in the system architecture.

Important Topics for the Mediator Design Pattern

What is the Mediator Design Pattern?
Real-Life Analogy of the Mediator Design Pattern
Components of the Mediator Design Pattern
How components are interacting with each other?
Mediator Design Pattern example
When to use the Mediator Design Pattern
When not to use the Mediator Design Pattern

Tags:

#Design Pattern #System Design

How components are interacting with each other ?

When to use the Mediator Design Pattern

Mediator Design Pattern example

What can be the challenges while implementing this system?

How Mediator Pattern help to solve above challenges?

Below is the code of above problem statement using Command Pattern:

1. Colleague Interface(Airplane)

Java

2. ConcreteColleague Class(CommercialAirplane)

Java

3. Mediator Interface(AirTrafficControlTower)

Java

4. ConcreteMediator Class(AirportControlTower)

Java

Complete code for the above example

Java

Output

Mediator design pattern

Similar Reads