Что такое Singleton и когда его использовать?

Что такое Singleton?

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

В Swift Singleton обычно реализуется через static let свойство, что обеспечивает потокобезопасность и ленивую инициализацию благодаря гарантиям языка:

final class NetworkManager {
    static let shared = NetworkManager()
    
    private init() {
        // Приватный инициализатор предотвращает создание новых экземпляров
    }
    
    func fetchData() {
        // Реализация сетевого запроса
    }
}

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

Ключевые характеристики реализации:

• final class — предотвращает наследование
• static let shared — статическое константное свойство для хранения экземпляра
• private init() — приватный инициализатор блокирует создание через NetworkManager()

Когда использовать Singleton?

Обоснованные случаи применения

1. Менеджеры ресурсов и системных сервисов

   • NetworkManager — централизованное управление сетевыми запросами, кэширование, обработка токенов
   • LocationManager — работа с геолокацией, чтобы избежать конфликтов при одновременном доступе
   • AudioSession в AVFoundation — управление аудиосессией должно быть единым

2. Кэширование данных

   • ImageCache — единое хранилище для кэширования изображений в памяти
   • UserDefaultsManager — обёртка над UserDefaults для централизованного доступа к настройкам

3. Логгеры и системы аналитики

   • AnalyticsService — сбор и отправка аналитики из разных частей приложения
   • Logger — единая система логирования с конфигурируемым уровнем детализации

4. Координаторы навигации и состояний

   • Router — централизованное управление навигацией в сложных приложениях
   • AppStateManager — управление глобальным состоянием приложения (авторизация, темы и т.д.)

Пример правильного использования

final class ImageCache {
    static let shared = ImageCache()
    private let cache = NSCache<NSString, UIImage>()
    
    private init() {}
    
    func image(for key: String) -> UIImage? {
        return cache.object(forKey: key as NSString)
    }
    
    func insert(_ image: UIImage, for key: String) {
        cache.setObject(image, forKey: key as NSString)
    }
}

// Использование в разных модулях
ImageCache.shared.insert(avatarImage, for: "user_123")
let cachedImage = ImageCache.shared.image(for: "user_123")

Когда НЕ стоит использовать Singleton?

Проблемы и альтернативы

1. Скрытые зависимости и тестируемость

   // Проблема: скрытая зависимость
   class UserService {
       func getUser() {
           NetworkManager.shared.fetchUser() // Прямая зависимость
       }
   }
   
   // Решение: Dependency Injection
   class UserService {
       private let networkManager: NetworkProtocol
       
       init(networkManager: NetworkProtocol = NetworkManager.shared) {
           self.networkManager = networkManager // Внедрение зависимости
       }
   }
   

2. Состояние глобального объекта

   • Singleton хранит состояние между вызовами, что может приводить к неочевидным сайд-эффектам
   • Затрудняет понимание потока данных в приложении

3. Нарушение принципа единственной ответственности

   • Singleton часто превращается в "God Object", накапливая несвязанную функциональность

Лучшие альтернативы

1. Dependency Injection через параметры инициализатора
2. Service Locator — явная регистрация и разрешение зависимостей
3. Environment Objects в SwiftUI — для передачи зависимостей по иерархии view
4. Фабрики и протоколы для создания объектов с нужными зависимостями

Вывод

Используйте Singleton осознанно и только когда это действительно необходимо — для управления уникальными системными ресурсами или глобальными точками координации. В большинстве случаев предпочтительнее использовать внедрение зависимостей, которое делает код более гибким, тестируемым и поддерживаемым. Помните, что Singleton — это не способ избежать передачи параметров, а инструмент для решения конкретных архитектурных задач.