когда нужно передавать ответственность дальше?

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

Что такое паттерн проектирования Chain of Responsibility?

Вы когда-нибудь задумывались о том, как работает система обработки заявок в крупной компании? Или как ваш любимый онлайн-магазин обрабатывает заказы? Скорее всего, там задействован паттерн проектирования под названием Chain of Responsibility (Цепочка обязанностей). Звучит сложновато, да? Но поверьте, это не так уж и страшно!

В этой статье мы разберем этот паттерн на пальцах, посмотрим примеры кода на разных языках программирования и поймем, когда его стоит применять. Готовы? Тогда поехали!


Что вообще такое Chain of Responsibility?

Представьте себе цепочку людей, каждый из которых отвечает за определенный этап проверки документа. Первый проверяет наличие подписи, второй – правильность заполнения данных, третий – соответствие требованиям безопасности и так далее. Если кто-то обнаруживает ошибку, он ее фиксирует и передает документ следующему в цепочке. И только если все этапы пройдены успешно, документ считается одобренным.

Вот это и есть суть паттерна Chain of Responsibility: передача запроса по цепочке обработчиков (handlers), пока один из них не обработает его. Каждый обработчик может либо выполнить свою часть работы, либо передать запрос дальше.

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


Зачем он нужен? Преимущества паттерна

  • Разделение ответственности: Каждый обработчик выполняет только одну задачу, что делает код более понятным и легким в отладке.
  • Гибкость: Легко добавлять новые обработчики или изменять порядок их выполнения без изменения существующего кода. Представьте, что вам нужно добавить проверку кредитной истории – просто создаете новый обработчик и вставляете его в цепочку!
  • Уменьшение связности: Обработчики не знают друг о друге, они взаимодействуют только через общий интерфейс. Это упрощает тестирование и повторное использование кода.

А вы знали? Этот паттерн часто используется для реализации конвейеров обработки данных или валидации пользовательского ввода.


Реализация на практике: Swift

Давайте посмотрим, как это выглядит в коде. Начнем со Swift:

protocol Handler {
    var nextHandler: Handler? { get set }
    func handle(request: String) -> String?
}

class SignatureHandler: Handler {
    var nextHandler: Handler?

    func handle(request: String) -> String? {
        if request.contains("Подпись") {
            print("SignatureHandler processed the request.")
            return nextHandler?.handle(request: request)
        } else {
            print("SignatureHandler cannot process this request.")
            return nil
        }
    }
}

// ... другие обработчики (DataHandler, SecurityHandler и т.д.)

let signatureHandler = SignatureHandler()
// ... настройка цепочки обработчиков

В этом примере Handler – это протокол, определяющий общий интерфейс для всех обработчиков. Каждый конкретный обработчик (SignatureHandler, DataHandler и т.д.) реализует этот интерфейс и отвечает за свою часть работы. Обратите внимание на свойство nextHandler: оно указывает на следующий обработчик в цепочке.


Java: немного более формально

В Java реализация паттерна Chain of Responsibility выглядит похожим образом, но с использованием классов и интерфейсов:

interface Handler {
    void setNext(Handler handler);
    String handleRequest(String request);
}

class SignatureHandler implements Handler {
    private Handler nextHandler;

    @Override
    public void setNext(Handler handler) {
        this.nextHandler = handler;
    }

    @Override
    public String handleRequest(String request) {
        if (request.contains("Подпись")) {
            System.out.println("SignatureHandler processed the request.");
            return nextHandler != null ? nextHandler.handleRequest(request) : "Request approved!";
        } else {
            System.out.println("SignatureHandler cannot process this request.");
            return null;
        }
    }
}

// ... другие обработчики (DataHandler, SecurityHandler и т.д.)

Здесь мы видим более явное использование интерфейсов и классов для определения структуры паттерна.


JavaScript: динамичность и гибкость

JavaScript позволяет реализовать Chain of Responsibility еще более гибко благодаря своей динамической природе:

class Handler {
  constructor() {
    this.nextHandler = null;
  }

  setNext(handler) {
    this.nextHandler = handler;
    return handler; // Для удобного построения цепочки
  }

  handleRequest(request) {
    if (this.canHandle(request)) {
      console.log(`${this.constructor.name} processed the request.`);
      return this.nextHandler ? this.nextHandler.handleRequest(request) : "Request approved!";
    } else {
      console.log(`${this.constructor.name} cannot process this request.`);
      return null;
    }
  }

  canHandle(request) {} // Метод, который нужно переопределить в каждом обработчике
}

// ... другие обработчики (SignatureHandler, DataHandler и т.д.)

В JavaScript мы можем использовать цепочки прототипов или просто объекты для реализации паттерна.


Python: лаконичность и читаемость

Python позволяет реализовать Chain of Responsibility очень элегантно благодаря своей лаконичности:

class Handler:
    def __init__(self):
        self.next_handler = None

    def set_next(self, handler):
        self.next_handler = handler
        return handler

    def handle_request(self, request):
        if self.can_handle(request):
            print(f"{self.__class__.__name__} processed the request.")
            if self.next_handler:
                return self.next_handler.handle_request(request)
            else:
                return "Request approved!"
        else:
            print(f"{self.__class__.__name__} cannot process this request.")
            return None

    def can_handle(self, request):
        raise NotImplementedError

# ... другие обработчики (SignatureHandler, DataHandler и т.д.)

В Python мы используем абстрактные классы и методы для определения структуры паттерна.


Когда стоит использовать Chain of Responsibility?

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

Честно говоря, этот паттерн не всегда является лучшим решением. Если у вас всего несколько простых этапов обработки запроса, то проще реализовать их в одном классе. Но если задача сложная и требует гибкости, то Chain of Responsibility может стать настоящим спасением!


Заключение: передавайте ответственность с умом!

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


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

Nikulux в Telegram

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

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