Как сделать агрегацию в init?

Агрегация в Swift Initializer

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

Основные подходы к агрегации в init

1. Прямая инициализация зависимостей

Самый простой способ — передача зависимостей через параметры инициализатора:

class NetworkService {
    let baseURL: URL
    let session: URLSession
    
    init(baseURL: URL, session: URLSession = .shared) {
        self.baseURL = baseURL
        self.session = session
        // Дополнительная агрегация конфигураций
    }
}

// Использование
let service = NetworkService(
    baseURL: URL(string: "https://api.example.com")!,
    session: URLSession(configuration: .ephemeral)
)

2. Агрегация через Configuration Object

Паттерн Configuration Object помогает избежать "распухания" инициализатора:

struct APIConfiguration {
    let baseURL: URL
    let timeout: TimeInterval
    let retryCount: Int
    let cachePolicy: URLCache.StoragePolicy
}

class APIClient {
    let configuration: APIConfiguration
    let networkService: NetworkService
    
    init(configuration: APIConfiguration) {
        self.configuration = configuration
        // Агрегация сервисов на основе конфигурации
        self.networkService = NetworkService(
            baseURL: configuration.baseURL,
            timeout: configuration.timeout
        )
    }
}

3. Builder Pattern для сложной агрегации

Для объектов со множеством зависимостей и опциональных параметров:

class UserProfileBuilder {
    var userId: String = ""
    var preferences: [String: Any] = [:]
    var services: [ProfileService] = []
    
    func build() -> UserProfile {
        // Валидация и агрегация всех компонентов
        return UserProfile(
            userId: userId,
            preferences: preferences,
            services: services
        )
    }
}

class UserProfile {
    let userId: String
    let preferences: [String: Any]
    let services: [ProfileService]
    
    init(userId: String, preferences: [String: Any], services: [ProfileService]) {
        self.userId = userId
        self.preferences = preferences
        self.services = services
        // Дополнительная агрегация и валидация
        self.validateAndAggregate()
    }
    
    private func validateAndAggregate() {
        // Логика агрегации
    }
}

4. Агрегация с Dependency Injection Container

Для сложных приложений с множеством зависимостей:

protocol ServiceContainer {
    func resolve<T>() -> T?
}

class AppCoordinator {
    let services: ServiceContainer
    let userManager: UserManager
    let analytics: AnalyticsService
    
    init(serviceContainer: ServiceContainer) {
        self.services = serviceContainer
        // Агрегация зависимостей из контейнера
        guard let userManager: UserManager = serviceContainer.resolve(),
              let analytics: AnalyticsService = serviceContainer.resolve() else {
            fatalError("Dependencies not registered")
        }
        
        self.userManager = userManager
        self.analytics = analytics
        self.setupAggregatedServices()
    }
    
    private func setupAggregatedServices() {
        // Настройка взаимодействия между агрегированными сервисами
        userManager.delegate = analytics
    }
}

Ключевые принципы агрегации в init

Принцип единственной ответственности

Каждый инициализатор должен отвечать только за агрегацию своих непосредственных зависимостей:

class DataProcessor {
    let parser: DataParser
    let validator: DataValidator
    let formatter: DataFormatter
    
    // Плохо: слишком много логики в init
    // Хорошо: только агрегация зависимостей
    init(parser: DataParser, validator: DataValidator, formatter: DataFormatter) {
        self.parser = parser
        self.validator = validator
        self.formatter = formatter
        // Минимальная логика инициализации
    }
}

Lazy Aggregation для опциональных зависимостей

Использование lazy properties для отложенной агрегации:

class CacheManager {
    let configuration: CacheConfig
    lazy var memoryCache: MemoryCache = {
        return MemoryCache(configuration: configuration.memoryConfig)
    }()
    lazy var diskCache: DiskCache = {
        return DiskCache(configuration: configuration.diskConfig)
    }()
    
    init(configuration: CacheConfig) {
        self.configuration = configuration
        // Агрегация происходит лениво при первом обращении
    }
}

Фабричные методы для сложной агрегации

class ViewModelFactory {
    static func makeViewModel(for type: ViewModelType) -> BaseViewModel {
        switch type {
        case .user:
            let api = UserAPIService()
            let cache = UserCache()
            let validator = UserValidator()
            return UserViewModel(api: api, cache: cache, validator: validator)
        case .settings:
            // Другая агрегация зависимостей
            return SettingsViewModel()
        }
    }
}

Лучшие практики

1. Избегайте side effects в init — инициализатор должен только агрегировать зависимости и устанавливать начальные состояния
2. Используйте dependency injection для тестируемости и гибкости
3. Выносите сложную логику агрегации в фабрики или билдеры
4. Документируйте обязательные зависимости через неопциональные свойства
5. Проводите валидацию агрегированных данных на раннем этапе

class PaymentProcessor {
    let paymentGateway: PaymentGateway
    let currencyConverter: CurrencyConverter
    let receiptGenerator: ReceiptGenerator
    
    init(paymentGateway: PaymentGateway, 
         currencyConverter: CurrencyConverter, 
         receiptGenerator: ReceiptGenerator) {
        
        // Валидация агрегированных зависимостей
        guard paymentGateway.isAvailable else {
            fatalError("Payment gateway unavailable")
        }
        
        self.paymentGateway = paymentGateway
        self.currencyConverter = currencyConverter
        self.receiptGenerator = receiptGenerator
        
        // Настройка взаимодействия между агрегированными компонентами
        self.setupDependencies()
    }
    
    private func setupDependencies() {
        currencyConverter.delegate = paymentGateway
        paymentGateway.receiptHandler = receiptGenerator
    }
}

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