Czytaj książkę: «Абстрактная фабрика. Паттерн GoF на Python, C++23, Rust и Java»

Czcionka:

Глава 1. Реализация на Python

Об этой книге

Эта книга посвящена одному паттерну проектирования — Абстрактная фабрика (Abstract Factory). Он относится к каталогу «Банды четырёх» (Gang of Four, GoF). Здесь паттерн разобран сразу в четырёх реализациях: на Python, C++23, Rust и Java. Каждая реализация — отдельная глава: сначала задача и общая схема, затем код, модификации, гибридные варианты и самостоятельные работы.

Основы каждого языка здесь не повторяются: они собраны в книгах серий по соответствующему языку. Разделы каждой главы нумеруются заново, поэтому ссылка «раздел 1.2» указывает на раздел той же главы, где она сделана.

1.1. Зачем нужна абстрактная фабрика

Приложение с графическим интерфейсом работает в светлой и тёмной теме. В каждой теме свои кнопки, поля ввода и флажки. Если код окна сам создаёт LightButton и DarkCheckbox, рано или поздно получится смесь: светлая кнопка рядом с тёмным флажком. А добавление третьей темы потребует найти каждое место, где создаётся элемент.

Абстрактная фабрика собирает создание всех элементов одной темы в одном объекте. Клиентский код получает фабрику и просит у неё «кнопку» и «флажок», не зная, какие именно классы вернутся. Подменить тему — значит подменить одну фабрику, а совместимость элементов гарантирована: одна фабрика создаёт только элементы своего семейства.

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

1.2. Участники и схема


AbstractFactory (WidgetFactory) — интерфейс с методом создания для каждого вида продукта.

ConcreteFactory — реализация для одного семейства.

AbstractProduct (Button, Checkbox) — интерфейсы продуктов.

ConcreteProduct — конкретные классы.

Client — код, который работает только с интерфейсами и получает фабрику снаружи.

В Python интерфейсы можно описать абстрактными базовыми классами (abc.ABC) — тогда фабрика без нужного метода не создастся — или протоколами (typing.Protocol) — тогда подходит любой объект с нужными методами. А поскольку классы в Python сами являются объектами, фабрикой может быть даже словарь классов.

1.3. Когда применять и какие последствия

Паттерн уместен, когда система работает с несколькими семействами связанных продуктов, выбор семейства делается в одном месте (при запуске, по настройке, в тестах), а клиентский код не должен зависеть от конкретных классов.

Плюсы: семейство меняется подменой одной фабрики, совместимость продуктов обеспечена конструкцией. Минус: добавить новый вид продукта трудно — нужно расширить интерфейс фабрики и все реализации. Добавить новое семейство легко.

1.4. Классическая реализация: светлая и тёмная темы

Файл 01_classic.py :



Листинг 1.1 — Классическая реализация: светлая и тёмная темы




Листинг 1.1 (продолжение) — Классическая реализация: светлая и тёмная темы




Листинг 1.1 (продолжение) — Классическая реализация: светлая и тёмная темы

Разбор. build_dialog получает любую фабрику и вызывает два метода — ей не важно, какие классы стоят за ними. Выбор семейства сделан ровно в одном месте. Чтобы добавить третью тему, достаточно двух продуктов и одной фабрики.

Абстрактные базовые классы дают проверку, которой нет при утиной типизации: класс BrokenFactory забыл метод checkbox, и Python отказывается создать его экземпляр. Ошибка появляется при создании фабрики, а не в момент, когда пользователь откроет диалог с флажком.

Конструкция if __name__ == «__main__»: выполняет демонстрацию только при запуске файла как программы; при импорте модуля она не сработает.

1.5. Протоколы: интерфейс без наследования

Наследоваться от ABC не всегда удобно — например, если продукты приходят из чужой библиотеки. typing.Protocol описывает интерфейс структурно: подходит любой класс с нужными методами. А декоратор runtime_checkable позволяет проверять это и во время выполнения.

Файл 02_protocol.py :




Листинг 1.2 — Протоколы: интерфейс без наследования




Листинг 1.2 (продолжение) — Протоколы: интерфейс без наследования

Разбор. RetroFactory и MinimalFactory нигде не говорят, что реализуют WidgetFactory, — у них просто есть методы button и label. Это утиная типизация, оформленная явно: редактор и анализатор типов (mypy, pyright) проверят, что объект, передаваемый в confirm, подходит под протокол. isinstance с протоколом, помеченным runtime_checkable, проверяет только наличие методов, но не их сигнатуры, поэтому NotAFactory без label отсеивается, а вот метод с неверными аргументами прошёл бы.

1.6. Фабрика как данные: словарь классов

В Python классы — объекты, поэтому семейство можно описать без отдельного класса фабрики: словарь «вид продукта → класс».

Файл 03_registry.py :



Листинг 1.3 — Фабрика как данные: словарь классов




Листинг 1.3 (продолжение) — Фабрика как данные: словарь классов

Разбор. Фабрика — словарь функций создания. Новое семейство — новая запись в THEMES, новый вид продукта — новый ключ во всех записях. Такой подход короче классов и удобен, когда семейства задаются конфигурацией. Недостаток — нет проверки, что у каждой темы есть все ключи; в больших системах лучше классы с ABC.

raise… from None скрывает исходную ошибку KeyError из трассировки: пользователю важна причина на языке задачи, а не детали словаря.

1.7. Модификации паттерна

Фабрика с параметрами семейства и dataclass

Фабрика может хранить параметры семейства — цвета, размеры, локаль — и применять их ко всем продуктам. @dataclass(frozen=True) делает её неизменяемой и хешируемой.

Файл 04_configured.py :




Листинг 1.4 — Модификации паттерна




Листинг 1.4 (продолжение) — Модификации паттерна

Разбор. Одна и та же логика создания продуктов работает для любой темы — темы отличаются только данными. frozen=True запрещает менять тему после создания и генерирует __hash__, поэтому две темы с одинаковыми полями считаются одной в множестве. field(default_factory=list) создаёт новый список для каждого Toolbar — изменяемое значение по умолчанию в виде items: list = [] было бы общим для всех экземпляров.

1.8. Гибриды и конкурентность

Фабрика соединений для пула потоков

Фабрику часто создают один раз и раздают рабочим потокам. Если она хранит изменяемое состояние — например, счётчик созданных соединений, — его нужно защитить блокировкой: операция += 1 в Python не атомарна.

Файл 05_threads.py :




Листинг 1.5 — Гибриды и конкурентность




Листинг 1.5 (продолжение) — Гибриды и конкурентность

Разбор. ThreadPoolExecutor запускает 200 задач на восьми потоках, и все они обращаются к одной фабрике. Увеличение счётчика и чтение его нового значения выполняются под with self._lock, поэтому номера не повторяются. Без блокировки два потока могли бы прочитать одно и то же значение _created до записи, и номера совпали бы, — GIL не защищает от этого, потому что += 1 состоит из нескольких операций байт-кода.

pool.map возвращает результаты в порядке задач, независимо от того, в каком порядке потоки их выполнили.

Асинхронная фабрика клиентов

В асинхронном коде создание продукта само может быть асинхронным — например, установка соединения. Фабрика тогда предоставляет async-методы.

Файл 06_async.py :



Листинг 1.6 — Гибриды и конкурентность




Листинг 1.6 (продолжение) — Гибриды и конкурентность

Разбор. Семейство здесь — «клиенты всех сервисов в одном окружении». Боевая фабрика создаёт настоящие клиенты, тестовая — заглушки, а load_dashboard не знает разницы. asyncio.gather создаёт оба клиента параллельно и затем параллельно выполняет оба запроса; порядок результатов совпадает с порядком аргументов.

1.9. Самостоятельные работы

Работа 1. Кросс-платформенные диалоги

Задание. Напишите фабрику для Windows и macOS. Семейство: заголовок окна и ряд кнопок. На Windows кнопка подтверждения слева от отмены, на macOS — справа. Клиентская функция должна собрать диалог «Удалить файл?» и не знать о платформе.

Полное решение — файл 07_platforms.py :




Листинг 1.7 — Самостоятельные работы

Разбор. Порядок кнопок — деталь платформы, и она не протекает в клиентский код: confirm_delete передаёт тексты, а размещение решает продукт конкретного семейства.

Работа 2. Подмена семейства в тестах

Задание. Сервис уведомлений использует семейство «отправитель письма + отправитель SMS». Сделайте боевую фабрику и тестовую, которая записывает сообщения в журнал. Проверьте сервис тестовой фабрикой.

Полное решение — файл 08_test_factory.py :




Листинг 1.8 — Самостоятельные работы




Листинг 1.8 (продолжение) — Самостоятельные работы

Разбор. Оба тестовых отправителя получают один и тот же список log — в Python это обычная ссылка на объект, и запись из любого отправителя видна в фабрике и в тесте. Сервис notify_shipped вообще не объявляет тип фабрики: ему достаточно методов email() и sms().

1.10. Типичные ошибки

Фабрика без семейства. Если у фабрики один метод создания, это не абстрактная фабрика, а фабричный метод или просто функция.

Проверка конкретного класса продукта. Если клиенту приходится писать isinstance(button, DarkButton), абстракция протекла: нужная операция должна быть в интерфейсе продукта.

Изменяемое значение по умолчанию. items: list = [] в классе или функции создаёт один список на всех. Используйте field(default_factory=list) или None с созданием внутри.

Состояние фабрики без блокировки. Если фабрику разделяют потоки, любые изменения её атрибутов нужно защищать.

1.11. Вопросы для самопроверки

Чем абстрактная фабрика отличается от фабричного метода?

Что даёт абстрактный базовый класс по сравнению с утиной типизацией?

Чем Protocol отличается от ABC и что проверяет isinstance с протоколом?

Как описать семейство без классов фабрик?

Зачем frozen=True у фабрики-темы?

Почему счётчик в PgFactory защищён блокировкой, хотя в CPython есть GIL?

Что легче добавить в абстрактную фабрику — новое семейство или новый вид продукта?

Почему field(default_factory=list), а не = []?

1.12. Ответы

Фабричный метод создаёт один вид продукта; абстрактная фабрика объединяет создание нескольких связанных продуктов одного семейства.

Класс без реализации абстрактного метода нельзя создать — ошибка обнаруживается сразу, а не при первом вызове метода.

Protocol описывает интерфейс структурно, без наследования. isinstance с протоколом runtime_checkable проверяет только наличие методов, не их сигнатуры.

Словарём «вид продукта → класс или функция создания», потому что классы и функции — объекты.

Тема становится неизменяемой и хешируемой; её нельзя случайно испортить после создания, и её можно класть в множества и ключи словарей.

+= 1 — несколько операций байт-кода; поток может прерваться между чтением и записью. GIL не делает составные операции атомарными.

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

Значение по умолчанию вычисляется один раз при определении класса, и список оказался бы общим для всех экземпляров.

Глава 2. Реализация на C++23

1.1. Зачем нужны паттерны проектирования

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

Идея описывать повторяемые решения получила известность благодаря работам архитектора Кристофера Александера. К программированию подход применили, в частности, Эрих Гамма, Ричард Хелм, Ральф Джонсон и Джон Влиссидес — авторы книги Design Patterns: Elements of Reusable Object-Oriented Software. Их часто называют Gang of Four, или GoF. Каталог содержит 23 паттерна: пять порождающих, семь структурных и одиннадцать поведенческих.

Слово «паттерн» не означает, что решение всегда лучше простого кода. Если программа создает один известный класс и не ожидает расширений, обычного конструктора может быть достаточно. Дополнительные интерфейсы и классы оправданы тогда, когда решают реальную проблему изменяемости, тестирования или управления ресурсом.

1.2. Основы объектно-ориентированного подхода

Абстракция выделяет важные для клиента операции и скрывает детали, которые клиенту не нужны. Например, клиенту перевозки достаточно операции deliver(): ему не обязательно знать внутреннее устройство грузовика.

Инкапсуляция защищает состояние и правила его изменения. Закрытый конструктор и проверяющая фабричная функция могут не допустить появления объекта с неверными параметрами.

Наследование позволяет описать отношение между типами и переопределить виртуальные операции. Использовать его следует там, где производный класс действительно выполняет контракт базового типа.

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

Композиция — хранение одного объекта внутри другого — также является важным инструментом. Её стоит рассматривать наряду с наследованием: она часто позволяет менять части поведения без построения глубокой иерархии.

1.3. Принципы SOLID

S — единственная ответственность. У модуля должна быть согласованная причина для изменения. Создание транспортного объекта и бизнес-правила доставки могут изменяться по разным причинам.

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

L — подстановка Барбары Лисков. Производный объект должен выполнять обязательства базового типа: клиент, работающий с Transport, не должен получать нарушающий его ожидания продукт.

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

D — инверсия зависимостей. Высокоуровневый алгоритм зависит от абстракции продукта; конкретную реализацию предоставляет подходящий создатель.

Паттерн сам по себе не гарантирует соблюдения SOLID. Например, если каждый новый транспорт требует изменить большой switch, расширение всё ещё может затрагивать существующий код.

1.4. Порождающие паттерны и средства C++23

Порождающие паттерны управляют созданием объектов. Помимо Фабричного метода, к группе GoF относятся Абстрактная фабрика, Строитель, Прототип и Одиночка. Они решают разные задачи: один изменяет способ создания отдельного продукта, другой создает совместимое семейство, третий управляет пошаговой сборкой, а четвёртый копирует готовый образец.

В C++ проектирование создания тесно связано с владением ресурсами. Идиома RAII связывает ресурс со временем жизни объекта: при выходе из области видимости вызывается деструктор. std::unique_ptr<T> выражает единоличное владение; std::shared_ptr<T> — разделяемое владение, когда оно действительно требуется. std::weak_ptr<T> наблюдает за объектом, не продлевая его жизнь.

std::make_unique<T>(…) создаёт объект и сразу помещает его в unique_ptr. Фабрика может также возвращать объект по значению, std::optional, std::expected или другой тип результата. Выбор зависит от контракта, а не от имени паттерна. В примерах C++23 применяются концепты, std::expected, std::move_only_function, корутины и другие средства там, где они помогают задаче.

Если базовый класс используется для удаления производного объекта через базовый указатель, его деструктор должен быть виртуальным. Поэтому в полиморфных интерфейсах этой главы обычно указан virtual ~Type() = default.

1.5. Проблема: жесткая привязка к конкретному продукту

Представим сервис доставки. В первой версии он всегда создаёт грузовик. Если внутри общего алгоритма написано Truck truck;, алгоритм зависит от конкретного типа. Добавление морской доставки заставляет менять алгоритм или добавлять ветвления. Когда разновидностей и правил становится больше, код создания распространяется по проекту.

Фабричный метод выделяет место создания. Общий алгоритм работает с интерфейсом продукта Transport, а конкретный создатель решает, какой именно объект создать. При этом сам алгоритм подготовки доставки может оставаться в базовом классе.

Важна именно связь создатель + его фабричный метод + использующий продукт алгоритм. Любая функция с именем create не становится автоматически реализацией GoF Factory Method. Статическая фабрика и простая фабрика — полезные родственные приёмы, но ниже они рассматриваются отдельно.

1.6. Участники и архитектура

Product — общий интерфейс создаваемых объектов; в примере это Transport.

ConcreteProduct — конкретные реализации продукта: Truck и Ship.

Creator — базовый создатель Logistics; в нём находятся общий алгоритм и фабричный метод.

ConcreteCreator — конкретный создатель (RoadLogistics или SeaLogistics), который переопределяет фабричный метод.

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

UML-диаграмма классов:


1.7. Когда применять и какие есть последствия

Применяйте Фабричный метод, когда общий алгоритм должен работать с разными продуктами, а выбор конкретного класса естественно относится к разновидности создателя. Он полезен во фреймворке, где основная последовательность действий уже написана, но пользователь должен подменить шаг создания.

Преимущества: выделяется точка изменения; бизнес-алгоритм зависит от интерфейса продукта; продукты легче подменять в тестах; конкретный создатель может контролировать способ получения продукта.

Недостатки: возрастает число классов; иерархии создателей и продуктов могут разрастаться; выбор создателя всё равно необходимо выполнить на границе системы; виртуальные вызовы и динамическое выделение памяти имеют стоимость, которую следует оценивать в контексте конкретной программы.

Отличие от Абстрактной фабрики: последняя обычно создаёт согласованное семейство разных продуктов, например кнопку и флажок одной темы. Связь с Шаблонным методом: общий алгоритм создателя может задавать скелет работы и вызывать виртуальный фабричный шаг. Не следует путать паттерн Template Method с шаблонами языка template.

1.8. Классическая реализация: транспортная логистика

Ниже приведён полный файл logistics.cpp. plan_delivery() содержит общий алгоритм, а create_transport() является изменяемым шагом. Обе реализации возвращают std::unique_ptr<Transport>: это один и тот же тип возвращаемого значения, содержащий указатель на разные производные объекты.



Листинг 2.1 — Классическая реализация: транспортная логистика




Листинг 2.1 (продолжение) — Классическая реализация: транспортная логистика

Как работает программа. Transport задаёт интерфейс и виртуальный деструктор. Truck и Ship реализуют deliver(). В Logistics::plan_delivery() локальная переменная transport владеет продуктом; после вызова deliver() объект освобождается автоматически. Проверка!transport обнаруживает нарушение контракта конкретной фабрики.

create_transport() объявлен protected, потому что это точка расширения для наследников, а не обязательная операция клиента. = 0 делает метод чисто виртуальным. RoadLogistics и SeaLogistics используют override, чтобы компилятор проверил корректность переопределения. В main() выбираются создатели, а затем вызывается общий алгоритм.

Сборка и запуск в Ubuntu / WSL2:




Вывод:




Пример работает в одном потоке. Возвращаемые продукты имеют ограниченное время жизни внутри plan_delivery(). Если в приложении продукт должен жить дольше, нужно изменить контракт и явно передать владение клиенту.

1.9. Одиннадцать разновидностей и связанных приёмов

Названия ниже сохранены в соответствии с оглавлением. Они не все являются самостоятельными разновидностями GoF Factory Method: часть описывает другие фабричные приёмы или комбинации паттернов. Для каждой темы полный работающий пример и практическое задание приведены в разделе 1.10.

1. Static Factory Method / Named Constructor — именованный конструктор

Статическая функция с говорящим именем обозначает способ получения объекта: from_cartesian и from_polar яснее, чем два конструктора с одинаковыми типами аргументов. Конструктор можно закрыть и допустить создание только после проверки. Ошибку удобно выразить через std::expected, а успех — вернуть по значению.

Именованная функция может возвращать разные объекты или использовать кэш, но переопределяемого метода создателя в ней может не быть. Это самостоятельный фабричный приём, а не обязательная реализация GoF. Полная программа и разбор — в работе 2.

2. Simple Factory / Concrete Factory — простая фабрика

Вместо того чтобы повторять switch в каждом клиенте, помещают его в один класс или функцию. Фабрика получает enum class и возвращает реализацию общего интерфейса. Клиент не должен включать все конкретные реализации, если фабрика вынесена в отдельный модуль.

Преимущество — ясная централизация. При добавлении типа обычно необходимо изменить саму фабрику; это не делает решение ошибочным, если набор типов меняется редко. В работе 3 фабрика создает консольный или файловый журнал.

3. Parameterized Factory Method — параметризованный метод

Метод получает идентификатор или конфигурацию и выбирает результат. Например, строка circle обозначает один тип фигуры, rectangle — другой. На неизвестный идентификатор нужно реагировать явно: вернуть ошибку, исключение или другой предусмотренный контрактом результат.

Параметризация может использоваться и с виртуальным фабричным методом, и в простой фабрике. Именно наличие переопределяемого шага создателя определяет связь с GoF. Работа 4 показывает строковый выбор и std::expected.

4. Classic GoF Polymorphic Creator — классический полиморфный создатель

Базовый Creator определяет общий алгоритм и виртуальный фабричный метод, а наследники создают конкретные продукты. В примере логистики plan_delivery() не зависит от Truck и Ship, а соответствующие создатели возвращают их через std::unique_ptr<Transport>.

Типы умных указателей сами по себе не поддерживают ковариантность виртуальных возвращаемых типов. Поэтому переопределения в примере объявляют одинаковый возвращаемый тип std::unique_ptr<Transport>; преобразование из unique_ptr<Truck> происходит при возврате. Работа 5 закрепляет конструкцию.

5. Creator with Default Implementation — реализация по умолчанию

Базовый создатель может реализовать фабричный метод сам и возвращать обычный продукт. Наследнику нужно переопределять его только тогда, когда поведение по умолчанию не подходит. Так устроен DocumentEditor из работы 6: обычный редактор создаёт текстовый документ, специализированный — HTML-документ.

Следует документировать, какой продукт предоставляется по умолчанию и выполняет ли он контракт клиента. Изменение поведения по умолчанию способно повлиять на существующих наследников.

6. Template Factory Method / NVI — общий алгоритм и виртуальный шаг

Публичная невиртуальная операция управляет порядком действий: проверкой входа, журналированием, вызовом виртуальной фабрики и обработкой ответа. Скрытый виртуальный шаг отвечает только за создание. Это сочетание Template Method, Factory Method и идиомы Non-Virtual Interface.

Невиртуальный публичный метод нельзя переопределить как виртуальный шаг, поэтому единый алгоритм остаётся под контролем базового класса. Работа 7 строит ответ обработчика и журналирует запрос. Если создать продукт не удалось, промышленный код должен определить политику ошибок.

7. Registry / Map-Based Factory — фабрика с реестром

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

std::move_only_function в C++23 допускает хранение вызываемых объектов, которые нельзя копировать. Необходимо определить правила дублирующихся ключей, неизвестных имён, пустых функций и многопоточной регистрации. В работе 8 реестр намеренно используется одним потоком и возвращает ошибку на неизвестный ключ.

Darmowy fragment się skończył.

Ograniczenie wiekowe:
0+
Data wydania na Litres:
18 listopada 2026
Data napisania:
2026
Objętość:
150 str. 151 ilustracji
Właściciel praw:
Автор
Format pobierania: