Как сделать код дружнее и понятнее (и зачем это вообще нужно?)

Перечень паттернов можно найти здесь.

Что такое паттерн проектирования Mediator?

Вы когда-нибудь сталкивались с ситуацией, когда ваш код превращается в запутанный клубок зависимостей? Когда изменение одной части системы приводит к каскаду правок в других местах? Если да, то вам пора познакомиться с паттерном проектирования Mediator. Звучит страшно? Да ладно! Сейчас разберемся, что это такое и как он может спасти ваш проект от хаоса.


Что за зверь такой – Mediator?

Представьте себе диспетчера аэропорта. Он не занимается непосредственно посадкой пассажиров или взлетом самолетов. Его задача – координировать работу всех служб: службы безопасности, наземного обслуживания, пилотов и т.д. Он обеспечивает связь между ними, чтобы все работало слаженно.

Паттерн Mediator делает примерно то же самое в вашем коде. Он выступает посредником между разными объектами, уменьшая их прямые зависимости друг от друга. Вместо того, чтобы объекты напрямую общались, они взаимодействуют через Mediator. Это как если бы каждый самолет обращался к диспетчеру с просьбой связаться с нужной службой – гораздо проще и организованнее, чем пытаться договориться всем самостоятельно!


Зачем нам это нужно? (Или где этот паттерн реально пригодится)

Прямая зависимость между объектами – это не всегда плохо. Но когда их становится много, код превращается в “спагетти”. Изменение одного объекта может сломать другие, тестирование становится кошмаром, а поддержка и отладка – настоящей головной болью.

Mediator помогает решить эти проблемы:

  • Уменьшает связность: Объекты меньше знают друг о друге, что упрощает их изменение и повторное использование.
  • Централизует логику взаимодействия: Вся координация работы объектов находится в одном месте – Mediator. Это облегчает понимание и отладку кода.
  • Упрощает тестирование: Можно тестировать отдельные объекты независимо друг от друга, а затем проверить взаимодействие через Mediator.

Как это работает? (Погружаемся в детали)

Основная идея заключается в том, чтобы выделить класс Mediator, который будет отвечать за управление взаимодействием между другими классами – коллегами (Colleagues). Коллеги не общаются напрямую друг с другом, а отправляют сообщения Mediator. Mediator, в свою очередь, перенаправляет эти сообщения нужным объектам.

Давайте посмотрим на примере кода, как это выглядит на разных языках программирования:

Swift

protocol ChatMediator {
    func sendMessage(message: String, from colleague: Colleague)
}

class ConcreteChatMediator: ChatMediator {
    private var colleagues = [String: Colleague]()

    func addColleague(_ colleague: Colleague) {
        colleagues[colleague.name] = colleague
    }

    func sendMessage(message: String, from colleague: Colleague) {
        for (name, otherColleague) in colleagues where name != colleague.name {
            otherColleague.receiveMessage(message: message, from: colleague.name)
        }
    }
}

class Colleague {
    let name: String
    var mediator: ChatMediator?

    init(name: String, mediator: ChatMediator?) {
        self.name = name
        self.mediator = mediator
    }

    func sendMessage(message: String) {
        if let mediator = mediator {
            mediator.sendMessage(message: message, from: self)
        }
    }

    func receiveMessage(message: String, from senderName: String) {
        print("\(name) received message '\(message)' from \(senderName)")
    }
}

// Пример использования
let mediator = ConcreteChatMediator()
let alice = Colleague(name: "Alice", mediator: mediator)
let bob = Colleague(name: "Bob", mediator: mediator)
let charlie = Colleague(name: "Charlie", mediator: mediator)

mediator.addColleague(alice)
mediator.addColleague(bob)
mediator.addColleague(charlie)

alice.sendMessage(message: "Hello everyone!")

В этом примере ChatMediator координирует общение между коллегами (Alice, Bob, Charlie). Обратите внимание, что коллеги не знают друг о друге – они просто отправляют сообщения через Mediator.

Java

interface ChatMediator {
    void sendMessage(String message, Colleague colleague);
}

class ConcreteChatMediator implements ChatMediator {
    private Map<String, Colleague> colleagues = new HashMap<>();

    public void addColleague(Colleague colleague) {
        colleagues.put(colleague.getName(), colleague);
    }

    @Override
    public void sendMessage(String message, Colleague colleague) {
        for (Map.Entry<String, Colleague> entry : colleagues.entrySet()) {
            if (!entry.getKey().equals(colleague.getName())) {
                entry.getValue().receiveMessage(message, colleague.getName());
            }
        }
    }
}

class Colleague {
    private String name;
    private ChatMediator mediator;

    public Colleague(String name, ChatMediator mediator) {
        this.name = name;
        this.mediator = mediator;
    }

    public String getName() {
        return name;
    }

    public void sendMessage(String message) {
        mediator.sendMessage(message, this);
    }

    public void receiveMessage(String message, String senderName) {
        System.out.println(name + " received message '" + message + "' from " + senderName);
    }
}

// Пример использования
ChatMediator mediator = new ConcreteChatMediator();
Colleague alice = new Colleague("Alice", mediator);
Colleague bob = new Colleague("Bob", mediator);
Colleague charlie = new Colleague("Charlie", mediator);

mediator.addColleague(alice);
mediator.addColleague(bob);
mediator.addColleague(charlie);

alice.sendMessage("Hello everyone!");

Здесь логика аналогична Swift, но реализована на Java. Обратите внимание на использование интерфейса ChatMediator для определения контракта взаимодействия.

JavaScript

class ChatMediator {
    constructor() {
        this.colleagues = {};
    }

    addColleague(colleague) {
        this.colleagues[colleague.name] = colleague;
    }

    sendMessage(message, from) {
        for (const name in this.colleagues) {
            if (name !== from.name) {
                this.colleagues[name].receiveMessage(message, from.name);
            }
        }
    }
}

class Colleague {
    constructor(name, mediator) {
        this.name = name;
        this.mediator = mediator;
    }

    sendMessage(message) {
        this.mediator.sendMessage(message, this);
    }

    receiveMessage(message, from) {
        console.log(`${this.name} received message '${message}' from ${from}`);
    }
}

// Пример использования
const mediator = new ChatMediator();
const alice = new Colleague("Alice", mediator);
const bob = new Colleague("Bob", mediator);
const charlie = new Colleague("Charlie", mediator);

mediator.addColleague(alice);
mediator.addColleague(bob);
mediator.addColleague(charlie);

alice.sendMessage("Hello everyone!");

В JavaScript код выглядит немного проще, но суть остается той же – Mediator координирует общение между коллегами.

Python

class ChatMediator:
    def __init__(self):
        self.colleagues = {}

    def add_colleague(self, colleague):
        self.colleagues[colleague.name] = colleague

    def send_message(self, message, from_colleague):
        for name, colleague in self.colleagues.items():
            if name != from_colleague.name:
                colleague.receive_message(message, from_colleague.name)


class Colleague:
    def __init__(self, name, mediator):
        self.name = name
        self.mediator = mediator

    def send_message(self, message):
        self.mediator.send_message(message, self)

    def receive_message(self, message, from_name):
        print(f"{self.name} received message '{message}' from {from_name}")


# Пример использования
mediator = ChatMediator()
alice = Colleague("Alice", mediator)
bob = Colleague("Bob", mediator)
charlie = Colleague("Charlie", mediator)

mediator.add_colleague(alice)
mediator.add_colleague(bob)
mediator.add_colleague(charlie)

alice.send_message("Hello everyone!")

В Python код также следует той же логике, что и в других языках. Обратите внимание на использование словаря self.colleagues для хранения коллег.


Когда стоит задуматься о Mediator? (И когда лучше обойтись без него)

Mediator – это мощный инструмент, но он не является серебряной пулей. Вот несколько ситуаций, когда его применение может быть оправдано:

  • Сложная логика взаимодействия: Если объекты взаимодействуют сложным образом и их зависимости трудно отслеживать.
  • Желание уменьшить связность: Если вы хотите сделать код более гибким и устойчивым к изменениям.
  • Необходимость централизованного управления: Если вам нужно контролировать все взаимодействие между объектами в одном месте.

Но если у вас небольшая система с простыми взаимодействиями, то Mediator может быть излишним усложнением. В этом случае лучше обойтись без него и использовать более простые подходы.


В заключение (И что дальше?)

Паттерн Mediator – это отличный способ сделать ваш код дружнее, понятнее и проще в поддержке. Он помогает уменьшить связность между объектами, централизовать логику взаимодействия и упростить тестирование. Попробуйте применить его в своем следующем проекте, и вы увидите, как он может спасти вас от хаоса!

А знаете что? Существуют и другие паттерны проектирования, которые могут помочь вам создавать еще более качественный код. Не бойтесь экспериментировать и изучать новые подходы – это ключ к успеху в программировании!


Будет интересно

Nikulux в Telegram

Статьи, архивы материалов, скоро ещё и мемы

(= Подписаться =)