Что такое порождающие паттерны проектирования?

Порождающие паттерны проектирования

Порождающие паттерны (Creational Patterns) — это категория паттернов проектирования, которые управляют процессом создания объектов. Они скрывают логику создания объектов, делая систему независимой от того, как создаются, из чего состоят и как представляются объекты.

Цель порождающих паттернов

• Упростить создание сложных объектов
• Сделать создание объектов гибким и масштабируемым
• Скрыть детали реализации от клиента
• Повысить переиспользуемость кода

Основные порождающие паттерны

1. Singleton (Одиночка)

Гарантирует, что класс имеет только один экземпляр и предоставляет глобальную точку доступа.

class Singleton:
    _instance = None
    
    def __new__(cls):
        if cls._instance is None:
            cls._instance = super().__new__(cls)
        return cls._instance

db1 = Singleton()
db2 = Singleton()
print(db1 is db2)  # True

2. Factory Method (Фабрика)

Определяет интерфейс для создания объектов, позволяя подклассам решать, какой класс инстанцировать.

from abc import ABC, abstractmethod

class Transport(ABC):
    @abstractmethod
    def deliver(self):
        pass

class Truck(Transport):
    def deliver(self):
        return "Доставка грузовиком"

class Ship(Transport):
    def deliver(self):
        return "Доставка кораблем"

class Logistics(ABC):
    @abstractmethod
    def create_transport(self):
        pass
    
    def plan_delivery(self):
        transport = self.create_transport()
        return transport.deliver()

class RoadLogistics(Logistics):
    def create_transport(self):
        return Truck()

class SeaLogistics(Logistics):
    def create_transport(self):
        return Ship()

logistics = RoadLogistics()
print(logistics.plan_delivery())  # Доставка грузовиком

3. Abstract Factory (Абстрактная фабрика)

Обеспечивает интерфейс для создания семейств взаимосвязанных объектов.

from abc import ABC, abstractmethod

class Button(ABC):
    @abstractmethod
    def click(self):
        pass

class Input(ABC):
    @abstractmethod
    def focus(self):
        pass

class WindowsButton(Button):
    def click(self):
        return "Windows кнопка нажата"

class WindowsInput(Input):
    def focus(self):
        return "Windows input в фокусе"

class MacButton(Button):
    def click(self):
        return "Mac кнопка нажата"

class MacInput(Input):
    def focus(self):
        return "Mac input в фокусе"

class UIFactory(ABC):
    @abstractmethod
    def create_button(self):
        pass
    
    @abstractmethod
    def create_input(self):
        pass

class WindowsUIFactory(UIFactory):
    def create_button(self):
        return WindowsButton()
    
    def create_input(self):
        return WindowsInput()

class MacUIFactory(UIFactory):
    def create_button(self):
        return MacButton()
    
    def create_input(self):
        return MacInput()

factory = WindowsUIFactory()
button = factory.create_button()
print(button.click())  # Windows кнопка нажата

4. Builder (Строитель)

Отделяет конструирование сложного объекта от его представления, позволяя пошагово создавать объект.

class House:
    def __init__(self):
        self.foundation = None
        self.walls = None
        self.roof = None
        self.windows = None

class HouseBuilder:
    def __init__(self):
        self.house = House()
    
    def build_foundation(self):
        self.house.foundation = "Бетонный фундамент"
        return self
    
    def build_walls(self):
        self.house.walls = "Кирпичные стены"
        return self
    
    def build_roof(self):
        self.house.roof = "Черепичная крыша"
        return self
    
    def build_windows(self):
        self.house.windows = "Деревянные окна"
        return self
    
    def build(self):
        return self.house

house = (HouseBuilder()
    .build_foundation()
    .build_walls()
    .build_roof()
    .build_windows()
    .build())

5. Prototype (Прототип)

Осуществляет создание объекта через клонирование существующего объекта вместо создания с нуля.

import copy

class Document:
    def __init__(self, title, content):
        self.title = title
        self.content = content
    
    def clone(self):
        return copy.deepcopy(self)

original = Document("Письмо", "Содержание...")
clone = original.clone()
clone.title = "Копия письма"

print(original.title)  # Письмо
print(clone.title)     # Копия письма

Сравнение паттернов

Практический пример: Database Connection

class DatabaseConnection:
    _instance = None
    
    def __new__(cls):
        if cls._instance is None:
            cls._instance = super().__new__(cls)
            cls._instance._initialize()
        return cls._instance
    
    def _initialize(self):
        self.connection = None
        print("Инициализация подключения")
    
    def connect(self):
        print("Подключение к БД")

db1 = DatabaseConnection()
db2 = DatabaseConnection()
print(db1 is db2)  # True

Преимущества порождающих паттернов

• Гибкость при добавлении новых типов объектов
• Инкапсуляция логики создания
• Упрощение кода клиента
• Возможность централизованно управлять созданием

Резюме

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