Как реализуешь кеширование изображения?

Подход к кешированию изображений в iOS

Для эффективного кеширования изображений в iOS приложениях я использую многоуровневую стратегию, комбинируя кэш в памяти (memory cache), кэш на диске (disk cache) и сетевые запросы. Вот моя реализация:

1. Многоуровневая архитектура кэширования

import UIKit

class ImageCacheManager {
    // Статический экземпляр для Singleton
    static let shared = ImageCacheManager()
    
    // Кэш в памяти (NSCache)
    private let memoryCache = NSCache<NSString, UIImage>()
    
    // Кэш на диске (FileManager)
    private let fileManager = FileManager.default
    private lazy var diskCacheDirectory: URL = {
        let paths = FileManager.default.urls(for: .cachesDirectory, in: .userDomainMask)
        let cacheDirectory = paths[0].appendingPathComponent("ImageCache")
        
        // Создаем директорию при необходимости
        if !fileManager.fileExists(atPath: cacheDirectory.path) {
            try? fileManager.createDirectory(at: cacheDirectory, 
                                           withIntermediateDirectories: true)
        }
        return cacheDirectory
    }()
    
    // Очередь для операций с диском
    private let diskQueue = DispatchQueue(label: "com.app.imagecache.disk", 
                                        qos: .utility)
    
    private init() {
        // Настраиваем кэш в памяти
        memoryCache.countLimit = 100 // Максимум 100 изображений
        memoryCache.totalCostLimit = 50 * 1024 * 1024 // 50 MB лимит
    }
}

2. Ключевые компоненты реализации

#### Кэш в памяти (Memory Cache)

• Использую NSCache как thread-safe контейнер
• Автоматически очищает старые объекты при нехватке памяти
• Быстрый доступ (O(1) в идеальном случае)

#### Кэш на диске (Disk Cache)

• Сохраняю декодированные изображения в формате PNG/JPEG
• Использую хэширование URL для именования файлов
• Реализую LRU (Least Recently Used) политику очистки

extension ImageCacheManager {
    // Генерация ключа для кэширования
    private func cacheKey(for url: URL) -> String {
        return url.absoluteString.data(using: .utf8)?.base64EncodedString() ?? ""
    }
    
    // Сохранение в памяти
    func saveToMemoryCache(_ image: UIImage, for key: String) {
        let cost = image.size.height * image.size.width * 4 // Примерный расчет cost
        memoryCache.setObject(image, forKey: key as NSString, cost: Int(cost))
    }
    
    // Сохранение на диск
    func saveToDiskCache(_ image: UIImage, for key: String) {
        diskQueue.async {
            let fileURL = self.diskCacheDirectory.appendingPathComponent(key)
            
            // Конвертируем UIImage в Data
            guard let data = image.pngData() else { return }
            
            // Атомарная запись на диск
            do {
                try data.write(to: fileURL, options: .atomic)
            } catch {
                print("Ошибка сохранения на диск: \(error)")
            }
        }
    }
}

3. Алгоритм загрузки изображений

Реализую следующий порядок при запросе изображения:

1. Проверка кэша в памяти - мгновенный доступ
2. Проверка кэша на диске - асинхронная загрузка
3. Сетевой запрос - с последующим кэшированием
4. Fallback изображение - если все варианты неудачны

extension ImageCacheManager {
    func loadImage(from url: URL, completion: @escaping (UIImage?) -> Void) {
        let key = cacheKey(for: url)
        
        // 1. Проверяем кэш в памяти
        if let cachedImage = memoryCache.object(forKey: key as NSString) {
            DispatchQueue.main.async {
                completion(cachedImage)
            }
            return
        }
        
        // 2. Проверяем кэш на диске
        diskQueue.async {
            let fileURL = self.diskCacheDirectory.appendingPathComponent(key)
            
            if self.fileManager.fileExists(atPath: fileURL.path),
               let diskImage = UIImage(contentsOfFile: fileURL.path) {
                
                // Сохраняем в память для будущих запросов
                self.saveToMemoryCache(diskImage, for: key)
                
                DispatchQueue.main.async {
                    completion(diskImage)
                }
                return
            }
            
            // 3. Загружаем из сети
            self.downloadImage(from: url, key: key, completion: completion)
        }
    }
    
    private func downloadImage(from url: URL, key: String, 
                             completion: @escaping (UIImage?) -> Void) {
        URLSession.shared.dataTask(with: url) { [weak self] data, response, error in
            guard let self = self,
                  let data = data,
                  let image = UIImage(data: data),
                  error == nil else {
                DispatchQueue.main.async {
                    completion(nil) // 4. Fallback или nil
                }
                return
            }
            
            // Кэшируем в обоих хранилищах
            self.saveToMemoryCache(image, for: key)
            self.saveToDiskCache(image, for: key)
            
            DispatchQueue.main.async {
                completion(image)
            }
        }.resume()
    }
}

4. Оптимизации и продвинутые техники

#### Управление памятью

• Реагирование на UIApplication.didReceiveMemoryWarningNotification
• Автоматическая очистка NSCache при memory warnings
• Фоновое удаление старых файлов с диска

#### Производительность

• Асинхронные операции для избежания блокировки UI
• Использование DispatchQueue с правильными QoS
• Кэширование декодированных изображений (не Data)

#### Дополнительные возможности

• Поддержка WebP и других форматов через SDWebImage или Kingfisher
• Prefetching изображений для коллекций
• Политики TTL (Time-To-Live) для устаревания кэша
• Инвалидация кэша при изменении URL параметров

5. Готовые решения vs Кастомная реализация

Для production приложений часто использую Kingfisher или SDWebImage, которые предоставляют:

• Автоматическое управление памятью и диском
• Анимации перехода
• Поддержку GIF и progressive JPEG
• Расширенную обработку ошибок
• Интеграцию с UIKit и SwiftUI

Однако понимание внутренней реализации критично для:

• Отладки сложных проблем с памятью
• Оптимизации под специфичные use cases
• Создания специализированных решений для уникальных требований приложения

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