Practical Applications and Examples of the Mediator Pattern

14.2.1 Practical Applications and Examples of the Mediator Pattern

The Mediator Pattern is a behavioral design pattern that facilitates communication between different components, often called colleagues, by introducing a mediator object. This pattern is particularly useful in scenarios involving complex interactions between multiple objects, such as in user interface dialogs where widgets like buttons and text fields need to interact seamlessly.

User Interface Dialog Example

Imagine a user interface dialog for a registration form containing several widgets: a text field for the username, a text field for the password, a submit button, and a cancel button. In a traditional setup, each widget might directly interact with others, leading to a tightly coupled system where changes to one widget necessitate changes to others. The Mediator Pattern helps avoid this by centralizing communication through a mediator object.

How the Mediator Handles Events

In our registration form example, the mediator manages the interaction logic. When a user enters a username, the mediator can enable the submit button only if both username and password fields are filled. Similarly, if the cancel button is clicked, the mediator can clear all fields and reset the form.

Here’s how it works:

1. Widget Communication: Each widget communicates its changes to the mediator. For instance, when the username text field is updated, it notifies the mediator.
2. Mediator Logic: The mediator contains the logic to determine the appropriate actions based on the changes. It checks whether to enable the submit button or perform other actions.
3. Updating Widgets: The mediator then informs other widgets of the necessary updates. This decouples the widgets, as they do not need to know about each other’s existence.

Implementing the Mediator Pattern

To implement the Mediator Pattern, we need to define a Mediator interface, a Concrete Mediator class, and Colleague classes for each widget.

Mediator Interface

The Mediator interface defines the methods for communication between colleagues.

interface Mediator {
    void widgetChanged(Colleague colleague);
}

Concrete Mediator Class

The Concrete Mediator implements the Mediator interface and contains the logic for coordinating widget interactions.

class RegistrationFormMediator implements Mediator {
    private UsernameField usernameField;
    private PasswordField passwordField;
    private SubmitButton submitButton;
    private CancelButton cancelButton;

    public RegistrationFormMediator(UsernameField usernameField, PasswordField passwordField,
                                    SubmitButton submitButton, CancelButton cancelButton) {
        this.usernameField = usernameField;
        this.passwordField = passwordField;
        this.submitButton = submitButton;
        this.cancelButton = cancelButton;
    }

    @Override
    public void widgetChanged(Colleague colleague) {
        if (colleague == usernameField || colleague == passwordField) {
            updateSubmitButton();
        } else if (colleague == cancelButton) {
            clearFields();
        }
    }

    private void updateSubmitButton() {
        boolean enable = !usernameField.getText().isEmpty() && !passwordField.getText().isEmpty();
        submitButton.setEnabled(enable);
    }

    private void clearFields() {
        usernameField.setText("");
        passwordField.setText("");
        submitButton.setEnabled(false);
    }
}

Colleague Classes

Each widget is represented by a Colleague class that interacts with the mediator.

abstract class Colleague {
    protected Mediator mediator;

    public Colleague(Mediator mediator) {
        this.mediator = mediator;
    }

    public void changed() {
        mediator.widgetChanged(this);
    }
}

class UsernameField extends Colleague {
    private String text = "";

    public UsernameField(Mediator mediator) {
        super(mediator);
    }

    public void setText(String text) {
        this.text = text;
        changed();
    }

    public String getText() {
        return text;
    }
}

class PasswordField extends Colleague {
    private String text = "";

    public PasswordField(Mediator mediator) {
        super(mediator);
    }

    public void setText(String text) {
        this.text = text;
        changed();
    }

    public String getText() {
        return text;
    }
}

class SubmitButton extends Colleague {
    private boolean enabled = false;

    public SubmitButton(Mediator mediator) {
        super(mediator);
    }

    public void setEnabled(boolean enabled) {
        this.enabled = enabled;
    }

    public boolean isEnabled() {
        return enabled;
    }
}

class CancelButton extends Colleague {
    public CancelButton(Mediator mediator) {
        super(mediator);
    }

    public void click() {
        changed();
    }
}

Best Practices for Using the Mediator Pattern

• Clear and Well-Organized Logic: Keep the mediator’s logic simple and well-organized to prevent it from becoming a bottleneck in the system.
• Decoupling Colleagues: Ensure that colleagues do not directly interact with each other, maintaining a clear separation of concerns.
• Extending the Mediator: When adding new colleagues, update the mediator to handle new interactions. Consider using inheritance or composition to manage complexity.
• Testing Interactions: Thoroughly test the interactions between colleagues to ensure the mediator coordinates them correctly.
• Documenting Coordination Logic: Document the mediator’s logic for maintainability and ease of understanding by other developers.

Challenges and Strategies

One potential challenge with the Mediator Pattern is the risk of the mediator becoming overly complex as more colleagues are added. To address this, consider decomposing the mediator into smaller, more manageable components or using multiple mediators for different parts of the system.

Conclusion

The Mediator Pattern provides a robust solution for managing complex interactions in software systems, particularly in user interfaces. By centralizing communication through a mediator, it decouples components and simplifies maintenance. However, it requires careful design and testing to ensure the mediator remains efficient and manageable.

Quiz Time!