Какие знаешь порождающие паттерны?

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

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

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

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

Обеспечивает существование только одного экземпляра класса и глобальную точку доступа к нему. Широко используется в iOS для менеджеров, логгеров, кэшей.

final class NetworkManager {
    static let shared = NetworkManager()
    private init() {}
    
    func fetchData() { /* ... */ }
}

// Использование
NetworkManager.shared.fetchData()

Применение в iOS: UserDefaults.standard, FileManager.default, URLSession.shared. Важно: в Swift final и приватный конструктор предотвращают случайное создание дополнительных экземпляров.

2. Factory Method (Фабричный метод)

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

protocol Vehicle {
    func drive()
}

class Car: Vehicle {
    func drive() { print("Driving a car") }
}

class Bike: Vehicle {
    func drive() { print("Riding a bike") }
}

class VehicleFactory {
    func createVehicle(type: String) -> Vehicle? {
        switch type {
        case "car": return Car()
        case "bike": return Bike()
        default: return nil
        }
    }
}

// Использование
let factory = VehicleFactory()
let vehicle = factory.createVehicle(type: "car")
vehicle?.drive()

Применение в iOS: UIKit использует фабричный метод в инициализации UIViewController через storyboards (метод instantiateViewController).

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

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

protocol Button {
    func render()
}

protocol Checkbox {
    func toggle()
}

// Конкретные продукты
class iOSButton: Button {
    func render() { print("Render iOS-style button") }
}

class iOSCheckbox: Checkbox {
    func toggle() { print("Toggle iOS-style checkbox") }
}

// Абстрактная фабрика
protocol GUIFactory {
    func createButton() -> Button
    func createCheckbox() -> Checkbox
}

class iOSFactory: GUIFactory {
    func createButton() -> Button { return iOSButton() }
    func createCheckbox() -> Checkbox { return iOSCheckbox() }
}

// Клиентский код
let factory: GUIFactory = iOSFactory()
let button = factory.createButton()
button.render()

Применение в iOS: Создание различных UI-компонентов в зависимости от платформы (iOS/macOS) или версии ОС.

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

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

class Pizza {
    var size: String = ""
    var cheese: Bool = false
    var pepperoni: Bool = false
    
    init(builder: PizzaBuilder) {
        self.size = builder.size
        self.cheese = builder.cheese
        self.pepperoni = builder.pepperoni
    }
}

class PizzaBuilder {
    var size: String = "Medium"
    var cheese: Bool = false
    var pepperoni: Bool = false
    
    func setSize(_ size: String) -> Self {
        self.size = size
        return self
    }
    
    func addCheese() -> Self {
        self.cheese = true
        return self
    }
    
    func addPepperoni() -> Self {
        self.pepperoni = true
        return self
    }
    
    func build() -> Pizza {
        return Pizza(builder: self)
    }
}

// Использование
let pizza = PizzaBuilder()
    .setSize("Large")
    .addCheese()
    .addPepperoni()
    .build()

Применение в iOS: Построение сложных URLRequest, конфигурация UIAlertController, создание NSAttributedString.

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

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

protocol Prototype: AnyObject, NSCopying {
    func clone() -> Self
}

class Person: Prototype {
    var name: String
    var age: Int
    
    init(name: String, age: Int) {
        self.name = name
        self.age = age
    }
    
    func copy(with zone: NSZone? = nil) -> Any {
        let copy = Person(name: name, age: age)
        return copy
    }
    
    func clone() -> Self {
        return copy() as! Self
    }
}

// Использование
let original = Person(name: "John", age: 30)
let cloned = original.clone()
cloned.name = "Jane"

Применение в iOS: Клонирование объектов, особенно когда создание через конструктор дорого или требует сложной инициализации.

Ключевые преимущества порождающих паттернов в iOS

• Управление зависимостями: Инкапсуляция логики создания объектов уменьшает связанность между компонентами.
• Гибкость конфигурации: Легко менять типы создаваемых объектов без изменения клиентского кода.
• Упрощение тестирования: Возможность подмены реальных объектов mock-объектами в unit-тестах.
• Повторное использование: Стандартизированные подходы к созданию объектов across the codebase.
• Контроль над процессом: Тонкая настройка инициализации сложных объектов.

Выбор паттерна для конкретной задачи

• Используйте Singleton для глобальных менеджеров и shared-ресурсов.
• Выбирайте Factory Method при необходимости делегировать создание объектов подклассам.
• Применяйте Abstract Factory для создания семейств связанных объектов.
• Используйте Builder для пошагового конструирования сложных объектов.
• Выбирайте Prototype когда клонирование дешевле, чем создание с нуля.

В современной iOS-разработке эти паттерны часто комбинируются и адаптируются под конкретные нужды проекта, особенно с учетом возможностей Swift (value types, protocol-oriented programming) и архитектурных подходов (VIPER, Clean Architecture).