Как сделать композицию в init?

Композиция в инициализаторах Swift

Композиция в инициализаторах — это подход к построению объектов, при котором зависимые объекты создаются и настраиваются внутри инициализатора основного объекта, а не передаются извне. Это реализация принципа композиции объектов (object composition) на уровне инициализации.

Основные подходы к композиции в init

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

class NetworkManager {
    private let session: URLSession
    private let decoder: JSONDecoder
    
    init() {
        // Композиция через создание зависимостей внутри init
        self.session = URLSession(configuration: .default)
        self.decoder = JSONDecoder()
        decoder.keyDecodingStrategy = .convertFromSnakeCase
        decoder.dateDecodingStrategy = .iso8601
    }
}

В этом подходе зависимости создаются непосредственно в теле инициализатора. Это самый простой способ, но он имеет недостаток — жесткую связь (tight coupling) и сложность тестирования.

2. Композиция с параметрами по умолчанию

class DataService {
    private let cache: Cache
    private let serializer: Serializer
    
    // Параметры по умолчанию позволяют переопределять зависимости при необходимости
    init(cache: Cache = MemoryCache(), 
         serializer: Serializer = JSONSerializer()) {
        self.cache = cache
        self.serializer = serializer
    }
}

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

3. Фабричные методы внутри init

class ViewModel {
    private let apiClient: APIClient
    private let formatter: DateFormatter
    
    init(baseURL: URL) {
        // Использование фабричных методов для создания зависимостей
        self.apiClient = APIClientFactory.makeClient(for: baseURL)
        self.formatter = FormatterFactory.makeDateFormatter()
        
        // Дополнительная настройка
        configureFormatter()
    }
    
    private func configureFormatter() {
        formatter.dateStyle = .medium
        formatter.timeStyle = .short
    }
}

Практический пример композиции

Рассмотрим пример сервиса для работы с пользователями:

class UserService {
    private let networkService: NetworkService
    private let storage: UserStorage
    private let validator: UserValidator
    
    init() {
        // Создаем и компонуем все зависимости
        self.networkService = NetworkService(
            baseURL: Constants.baseURL,
            timeout: 30
        )
        
        self.storage = CoreDataStorage(
            modelName: "UserModel",
            persistentContainer: NSPersistentContainer(name: "UserModel")
        )
        
        self.validator = UserValidator(
            minAge: 18,
            maxUsernameLength: 20,
            allowedDomains: ["example.com"]
        )
        
        // Настраиваем взаимосвязи
        setupDependencies()
    }
    
    private func setupDependencies() {
        networkService.delegate = self
        storage.setupCompletionHandler { [weak self] in
            self?.handleStorageReady()
        }
    }
}

Преимущества подхода композиции в init

• Инкапсуляция создания — логика создания зависимостей скрыта внутри класса
• Гарантированная инициализация — все зависимости создаются к моменту завершения init
• Упрощение публичного интерфейса — клиентскому коду не нужно знать о внутренних зависимостях
• Контроль жизненного цикла — управление временем жизни зависимых объектов

Недостатки и ограничения

1. Сложность тестирования — моки и стабы сложно подставлять
2. Жесткая связность — изменения в зависимостях требуют изменений в основном классе
3. Нарушение Single Responsibility Principle — класс отвечает и за свою основную задачу, и за создание зависимостей

Альтернативные подходы

Для решения проблем тестирования и гибкости часто используют:

// Dependency Injection через инициализатор
class UserManager {
    private let apiService: APIServiceProtocol
    private let cache: CacheProtocol
    
    init(apiService: APIServiceProtocol, cache: CacheProtocol) {
        self.apiService = apiService
        self.cache = cache
    }
}

// Использование в продакшене
let userManager = UserManager(
    apiService: ProductionAPIService(),
    cache: DiskCache()
)

// Использование в тестах
let testUserManager = UserManager(
    apiService: MockAPIService(),
    cache: InMemoryCache()
)

Рекомендации по использованию

1. Используйте композицию в init для простых, стабильных зависимостей, которые редко меняются
2. Применяйте Dependency Injection для зависимостей, которые могут меняться или требуют мокинга в тестах
3. Комбинируйте подходы — часть зависимостей создавайте внутри, часть принимайте через параметры
4. Для сложных объектов рассмотрите использование Factory или Builder паттернов

Композиция в инициализаторах — мощный инструмент, который следует использовать осознанно, учитывая требования к тестируемости, гибкости и поддерживаемости кода. В современных iOS-приложениях часто встречается гибридный подход, где часть зависимостей создается внутри init, а часть инжектируется извне.