Что такое паттерн Builder?

🛠️ Паттерн Builder: концепция и применение

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

🤔 Зачем нужен Builder?

Основная проблема, которую решает Builder — управление созданием объектов с большим количеством параметров. Рассмотрим типичные ситуации без Builder:

Проблема "телескопического конструктора"

class User {
    let name: String
    let age: Int?
    let email: String?
    let phone: String?
    let address: String?
    
    // Плохой подход: множественные конструкторы
    init(name: String) {
        self.name = name
        self.age = nil
        self.email = nil
        self.phone = nil
        self.address = nil
    }
    
    init(name: String, age: Int) {
        self.name = name
        self.age = age
        self.email = nil
        self.phone = nil
        self.address = nil
    }
    
    init(name: String, age: Int, email: String) {
        self.name = name
        self.age = age
        self.email = email
        self.phone = nil
        self.address = nil
    }
    // ... и так далее для всех комбинаций
}

Проблема инициализации с множеством опциональных параметров

let user = User(name: "Иван", age: 30, email: nil, phone: nil, address: nil)
// Какие параметры передаются? Непонятно без документации

✅ Решение через Builder

Builder предлагает элегантное решение этих проблем:

class User {
    let name: String
    let age: Int?
    let email: String?
    let phone: String?
    let address: String?
    
    private init(builder: Builder) {
        self.name = builder.name
        self.age = builder.age
        self.email = builder.email
        self.phone = builder.phone
        self.address = builder.address
    }
    
    // Вложенный класс Builder
    class Builder {
        let name: String  // Обязательный параметр
        var age: Int? = nil
        var email: String? = nil
        var phone: String? = nil
        var address: String? = nil
        
        init(name: String) {
            self.name = name
        }
        
        func setAge(_ age: Int) -> Builder {
            self.age = age
            return self
        }
        
        func setEmail(_ email: String) -> Builder {
            self.email = email
            return self
        }
        
        func setPhone(_ phone: String) -> Builder {
            self.phone = phone
            return self
        }
        
        func setAddress(_ address: String) -> Builder {
            self.address = address
            return self
        }
        
        func build() -> User {
            return User(builder: self)
        }
    }
}

// Использование
let user = User.Builder(name: "Иван")
    .setAge(30)
    .setEmail("ivan@example.com")
    .setPhone("+79991234567")
    .build()

🎯 Ключевые преимущества Builder

1. Гибкость создания объектов — можно создавать объекты с разными комбинациями параметров
2. Читаемость кода — цепочка методов (method chaining) делает код самодокументируемым
3. Неизменяемость объектов — после создания объект нельзя изменить
4. Валидация параметров — можно проверять корректность данных перед созданием объекта
5. Пошаговое конструирование — сложные объекты собираются постепенно

📱 Практический пример в iOS разработке

В iOS Builder особенно полезен при работе с:

• UI компонентами (кастомные алерты, ячейки таблиц)
• Сетевыми запросами (построение параметров запроса)
• Навигацией (подготовка экранов с разными параметрами)

Пример построителя для кастомного алерта:

class AlertBuilder {
    private var title: String?
    private var message: String?
    private var actions: [UIAlertAction] = []
    private var preferredStyle: UIAlertController.Style = .alert
    
    func setTitle(_ title: String) -> AlertBuilder {
        self.title = title
        return self
    }
    
    func setMessage(_ message: String) -> AlertBuilder {
        self.message = message
        return self
    }
    
    func addAction(title: String, style: UIAlertAction.Style, handler: ((UIAlertAction) -> Void)?) -> AlertBuilder {
        let action = UIAlertAction(title: title, style: style, handler: handler)
        actions.append(action)
        return self
    }
    
    func setStyle(_ style: UIAlertController.Style) -> AlertBuilder {
        self.preferredStyle = style
        return self
    }
    
    func build() -> UIAlertController {
        let alert = UIAlertController(
            title: title,
            message: message,
            preferredStyle: preferredStyle
        )
        
        for action in actions {
            alert.addAction(action)
        }
        
        return alert
    }
}

// Использование
let alert = AlertBuilder()
    .setTitle("Внимание")
    .setMessage("Вы уверены, что хотите удалить запись?")
    .addAction(title: "Отмена", style: .cancel, handler: nil)
    .addAction(title: "Удалить", style: .destructive) { _ in
        // Обработка удаления
    }
    .build()

present(alert, animated: true)

⚖️ Когда использовать Builder?

Используйте Builder, когда:

• Объект имеет много параметров (более 4-5)
• Некоторые параметры являются опциональными
• Требуется создание неизменяемых объектов
• Нужна валидация параметров перед созданием объекта
• Процесс создания объекта сложный и многоступенчатый

Не используйте Builder, когда:

• Объект имеет мало параметров (2-3)
• Все параметры обязательные
• Процесс создания объекта простой

🔄 Альтернативы и сравнение

1. Factory Method — подходит для создания семейств связанных объектов
2. Abstract Factory — создает группы связанных объектов
3. Простая инициализация — достаточно для простых случаев

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

🏆 Заключение

Паттерн Builder — это мощный инструмент в арсенале iOS-разработчика, который значительно улучшает читаемость и поддерживаемость кода при работе со сложными объектами. Он особенно полезен в iOS-разработке благодаря своей совместимости с Fluent Interface (цепочки методов) и возможности создания неизменяемых моделей, что соответствует принципам функционального программирования и делает код более безопасным и предсказуемым.