Паттерн: Цепочка обязанностей (Chain of responsobility)

1️⃣ Как кратко ответить

"Паттерн 'Цепочка обязанностей' позволяет передавать запросы по цепочке обработчиков, где каждый обработчик решает, обрабатывать запрос или передать его дальше. Это способствует гибкости и расширяемости системы, так как обработчики могут быть добавлены или изменены без изменения клиентского кода."

2️⃣ Подробное объяснение темы

Что такое паттерн "Цепочка обязанностей"?

Паттерн "Цепочка обязанностей" (Chain of Responsibility) — это поведенческий паттерн проектирования, который позволяет передавать запросы по цепочке потенциальных обработчиков, пока один из них не обработает запрос. Это помогает избежать жесткой привязки отправителя запроса к его получателю, позволяя нескольким объектам обработать запрос.

Зачем это нужно?

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

Где применяется?

• Логирование: Разные уровни логирования (информация, предупреждения, ошибки) могут обрабатываться разными обработчиками.
• Обработка событий в GUI: Разные элементы интерфейса могут обрабатывать события, такие как нажатия клавиш или клики мыши.
• Валидация данных: Разные этапы валидации могут быть выполнены разными обработчиками.

Как это работает?

Паттерн "Цепочка обязанностей" состоит из следующих компонентов:

1. Обработчик (Handler): Интерфейс или абстрактный класс, определяющий метод для обработки запроса и ссылку на следующий обработчик в цепочке.
2. Конкретные обработчики (Concrete Handlers): Реализуют метод обработки запроса. Каждый обработчик решает, может ли он обработать запрос, или передает его следующему обработчику.
3. Клиент (Client): Инициирует запрос, который передается по цепочке обработчиков.

Пример на Python

class Handler:
    def __init__(self, successor=None):
        self.successor = successor
​
    def handle_request(self, request):
        raise NotImplementedError("This method should be overridden by subclasses")
​
class ConcreteHandler1(Handler):
    def handle_request(self, request):
        if request == "Task1":
            print("ConcreteHandler1 handled the request")
        elif self.successor:
            self.successor.handle_request(request)
​
class ConcreteHandler2(Handler):
    def handle_request(self, request):
        if request == "Task2":
            print("ConcreteHandler2 handled the request")
        elif self.successor:
            self.successor.handle_request(request)
​
# Создаем цепочку обработчиков
handler1 = ConcreteHandler1()
handler2 = ConcreteHandler2(handler1)
​
# Клиент отправляет запрос
handler2.handle_request("Task1")  # Output: ConcreteHandler1 handled the request
handler2.handle_request("Task2")  # Output: ConcreteHandler2 handled the request

Аналогия

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

Преимущества

• Гибкость: Легко добавлять новые обработчики или изменять порядок существующих.
• Ослабление связи: Отправитель запроса не знает, какой обработчик его обработает.

Недостатки

• Отладка: Может быть сложнее отлаживать, так как запросы проходят через множество обработчиков.
• Потенциальная неэффективность: Если цепочка слишком длинная, это может привести к снижению производительности.