5 сентября 2017 г.

Hello CoreData!

Сегодня будем рассматривать ненавистный мне framework от Apple под страшным названием CoreData. Это решения от Apple для работы с SQLite (реляционная база данных). CoreData может сохранять объекты Swift в SQLite, а также выполнять обратную операцию.

Введение

Лично мне больше нравится Realm, так как там мало что нужно делать, чтобы framework заработал — просто устанавливаете и начинаете создавать то, что хотите, плюс на официальном сайте есть прекрасная документация по всем фичам. Но когда вы просматриваете вакансии других компаний (я лично — никогда! А есть другие компании? ;) ) часто попадаете на требования CoreData, и если вы не имеете опыта работы с этим framework, то вас легко могут «завалить» уже в начале интервью, так и не узнав, какие красивые кнопочки вы умеете делать :)

Почему я не любил это framework? Потому что он достаточно тяжелый для понимания новичками, и в нем легко запутаться и допустить ошибки, а чем больше кода у вас написано, тем больше вероятность, что где-то вы ошиблись.

Начиная с ios 10, Apple многое сделали для упрощения работы с CoreData. Например, представили объект NSPersistentContainer, который берет на себя работу по созданию NSManagedObjectModel, NSPersistentStoreCoordinator и NSManagedObjectContext. Теперь для начала работы достаточно инициализировать объект persistentContainer = NSPersistentContainer(name: "MyModel"). В самом начале статья задумывалась как обзор сторонних решений для работы с CoreData, но так как Apple переделали framework, многие из этих решений находились или в процессе переделки или, того хуже, написаны на Objective-C. Так что мы рассмотрим три примера. В первом пройдемся по NSFetchedResultsController и NSPersistentContainer; во втором, начнем писать свой класс для упрощения работы, а в последнем примере улучшим класс путем добавления generics.

Пример 1

Проект доступен для изучения и называется MagicalRecord_project (изначально хотел использовать именно этот framework). Рассмотрим файл Model.xcdatamodeld:

Для атрибута avatar (тип которого Binary Data) выставлено в опциях Allows External Storage.

Переходим в контроллер:

fileprivate let persistentContainer: NSPersistentContainer = NSPersistentContainer(name: "Model")
 
    fileprivate lazy var fetchedResultsController: NSFetchedResultsController<Person> = {
        let fetchRequest = NSFetchRequest<Person>()
        fetchRequest.entity = Person.entity()
        fetchRequest.sortDescriptors = [NSSortDescriptor(key: "name", ascending: true)]
        let frc = NSFetchedResultsController(fetchRequest: fetchRequest,
                                             managedObjectContext: self.persistentContainer.viewContext,
                                             sectionNameKeyPath: "name",
                                             cacheName: nil)
        frc.delegate = self
        return frc
    }()

Тут мы создаем объекты persistentContainer и fetchedResultsController, который будет отвечать за наполнение данными. Также создадим метод, который будет помогать создавать объекты:

func createPersonObject(name: String, about: String, image: UIImage) {
        let person = NSEntityDescription.insertNewObject(forEntityName: "Person", into: persistentContainer.viewContext) as! Person
        person.name = name
        person.about = about
        person.avatar = UIImageJPEGRepresentation(image, 1.0) as NSData?
    }

Смотрим, как это все выглядит в viewDidLoad:

override func viewDidLoad() {
        super.viewDidLoad()
 
        tableView.delegate = self
        tableView.dataSource = self
 
        //create data
        createPersonObject(name: "Name A", about: "some inform...", image: UIImage(named: "01")!)
        createPersonObject(name: "Name B", about: "some inform...", image: UIImage(named: "02")!)
 
        perform(#selector(insertAfterDelay), with: nil, afterDelay: 2.0)
 
        //fetch data in controller
        do {
            try fetchedResultsController.performFetch()
        } catch {
            print(error)
        }
    }

Вот эта строка perform(#selector(insertAfterDelay), with: nil, afterDelay: 2.0) добавляет третий объект к контексту и NSFetchedResultsController обновляет tableView (об этом чуть позже).

fetchedResultsController.performFetch() передает данные с CoreData в контроллер.

Запускаем приложение.

В начале видим два добавленных объекта, спустя две секунды — три. Создаем extension для ViewController:

extension ViewController: UITableViewDelegate, UITableViewDataSource {
    func tableView(_ tableView: UITableView, canEditRowAt indexPath: IndexPath) -> Bool {
        return false
    }
 
    func numberOfSections(in tableView: UITableView) -> Int {
        return fetchedResultsController.sections?.count ?? 0
    }
 
    func tableView(_ tableView: UITableView, numberOfRowsInSection section: Int) -> Int {
        return fetchedResultsController.sections?[section].numberOfObjects ?? 0
    }
 
    func tableView(_ tableView: UITableView, cellForRowAt indexPath: IndexPath) -> UITableViewCell {
        let cell = tableView.dequeueReusableCell(withIdentifier: "Cell") as! Cell
 
        guard let sections = fetchedResultsController.sections else {
            fatalError("Sections missing")
        }
 
        let section = sections[indexPath.section]
        guard let itemsInSection = section.objects as? [Person] else {
            fatalError("Items missing")
        }
 
        let person = itemsInSection[indexPath.row]
 
        cell.aboutLbl.text = person.about
        cell.nameLbl.text = person.name
        cell.avatarImView.image = UIImage(data: person.avatar! as Data)
 
        return cell
    }
}

Так как вместо массива dataSource мы имеем fetchedResultsController, то используем его для получения всех необходимых данных. В переменной fileprivate lazy var fetchedResultsController мы объявили себя делегатом NSFetchedResultsController. Реализуем необходимые методы:

extension ViewController: NSFetchedResultsControllerDelegate {
    func controllerWillChangeContent(_ controller: NSFetchedResultsController<NSFetchRequestResult>) {
        tableView.beginUpdates()
    }
 
    func controllerDidChangeContent(_ controller: NSFetchedResultsController<NSFetchRequestResult>) {
        tableView.endUpdates()
    }
 
    func controller(_ controller: NSFetchedResultsController<NSFetchRequestResult>, didChange anObject: Any, at indexPath: IndexPath?, for type: NSFetchedResultsChangeType, newIndexPath: IndexPath?) {
 
        switch type {
        case .insert: tableView.insertRows(at: [newIndexPath!], with: .automatic)
        case .delete: tableView.deleteRows(at: [indexPath!], with: .automatic)
        case .update: tableView.reloadRows(at: [indexPath!], with: .automatic)
        case .move: tableView.moveRow(at: indexPath!, to: newIndexPath!)
        }
    }
 
    func controller(_ controller: NSFetchedResultsController<NSFetchRequestResult>, didChange sectionInfo: NSFetchedResultsSectionInfo, atSectionIndex sectionIndex: Int, for type: NSFetchedResultsChangeType) {
 
        switch type {
        case .insert: tableView.insertSections(IndexSet(integer: sectionIndex), with: .automatic)
        case .delete: tableView.deleteSections(IndexSet(integer: sectionIndex), with: .automatic)
        case .move, .update: tableView.reloadSections(IndexSet(integer: sectionIndex), with: .automatic)
        }
    }
}

Теперь, когда что-то меняется (добавляем, обновляем или удаляем какой-то элемент), NSFetchedResultsController знает об этом и может сделать необходимые коррекции в UITableView. Подобный механизм реализован и в Realm:

let token = realm.addNotificationBlock { notification, realm in
    viewController.updateUI()
}
 
token = results.addNotificationBlock { [weak self] (changes: RealmCollectionChange) in
      guard let tableView = self?.tableView else { return }
      switch changes {
      case .initial:
        // Results are now populated and can be accessed without blocking the UI
        tableView.reloadData()
        break
      case .update(_, let deletions, let insertions, let modifications):
        // Query results have changed, so apply them to the UITableView
        tableView.beginUpdates()
        tableView.insertRows(at: insertions.map({ IndexPath(row: $0, section: 0) }),
                           with: .automatic)
        tableView.deleteRows(at: deletions.map({ IndexPath(row: $0, section: 0)}),
                           with: .automatic)
        tableView.reloadRows(at: modifications.map({ IndexPath(row: $0, section: 0) }), 
                           with: .automatic)
        tableView.endUpdates()
        break
      case .error(let error):
        // An error occurred while opening the Realm file on the background worker thread
        fatalError("\(error)")
        break
      }
    }
  }

К нашему примеру это не относится, но как видите, механизмы обновления UITableView похожи.

Пример 2

В этом примере будем создавать StoreManager. Откройте проект StoreManager_project. StoreManager создан с использованием патерна Singleton (одна копия на протяжении жизни программы):

fileprivate override init(){}
    static let sharedInstance = StoreManager()
    override func copy() -> Any {
        fatalError("You are not allowed to use copy method on singleton!")
    }
 
fileprivate lazy var fetchRequest: NSFetchRequest<Car> = {
        let request = NSFetchRequest<Car>()
        request.entity = Car.entity()
        request.sortDescriptors = [NSSortDescriptor(key: "name", ascending: true)]
        return request
    }()
 
    fileprivate lazy var persistentContainer: NSPersistentContainer = {
        let container = NSPersistentContainer(name: "Model")
        container.loadPersistentStores(completionHandler: { (storeDescription, error) in
            if let error = error as NSError? {
                fatalError("Unresolved error \(error), \(error.userInfo)")
            }
        })
        return container
    }()

NSPersistentContainer имеет два свойства, точнее свойство и метод: viewContext и newBackgroundContext. Первый ассоциирован с main queue, второй — privateQueueConcurrencyType. Когда мы пишем что-то в newBackgroundContext, он отсылает нотификацию для объекта viewContext на мердж содержимого. Поэтому выходит, что нам уже не нужно самим подписываться на эту нотификацию. Из документации по viewContext:

This context is configured to be generational and to automatically consume save notifications from other contexts.

По newBackgroundContext:

…is set to consume NSManagedObjectContextDidSave broadcasts automatically.

Я добавил несколько методов, которые мы будем модифицировать в третьем примере:

func saveMainContext () {
        let context = persistentContainer.viewContext
        if context.hasChanges {
            do {
                try context.save()
            } catch {
                let nserror = error as NSError
                fatalError("Unresolved error \(nserror), \(nserror.userInfo)")
            }
        }
    }
 
    func clearMainStorage() {
        var cars: [Car]?
        do {
            cars = try persistentContainer.viewContext.fetch(fetchRequest)
        } catch {
            print("Storage reading error!")
        }
        if let cars = cars {
            for item in cars {
                persistentContainer.viewContext.delete(item)
            }
        }
    }
 
    func addACar(name: String, hasRoof: Bool, numberOfWheels: Int) {
        //add data to background context
        let context = persistentContainer.newBackgroundContext()
        let car = NSEntityDescription.insertNewObject(forEntityName: "Car", into: context) as! Car
        car.name = name
        car.numberOfWheels = Int16(numberOfWheels)
        car.hasRoof = hasRoof
        do {
            try context.save()
        } catch {
            print(error)
        }
    }
 
    func showMainStorage() {
        var cars: [Car]?
        do {
            cars = try persistentContainer.viewContext.fetch(fetchRequest)
        } catch {
            print("Storage reading error!")
        }
        print("CARS: \(cars?.map { $0.name! })")
    }
 
viewDidLoad из ViewController:
 
StoreManager.sharedInstance.clearMainStorage()
 
        StoreManager.sharedInstance.addACar(name: "BMW", hasRoof: true, numberOfWheels: 4)
        StoreManager.sharedInstance.addACar(name: "Zapor", hasRoof: false, numberOfWheels: 3)
        StoreManager.sharedInstance.addACar(name: "Fiat", hasRoof: true, numberOfWheels: 5)
        StoreManager.sharedInstance.addACar(name: "F1", hasRoof: false, numberOfWheels: 4)
 
        perform(#selector(insertAnotherCar), with: nil, afterDelay: 2.0)
        StoreManager.sharedInstance.showMainStorage()

Сначала чистим хранилище, потом добавляем модели авто. Дальше идет метод, который добавит третье авто, после двух секунд (никогда не используйте performSelector: afterDelay: — это плохая практика). И два метода showMainStorage(), которые показывают, как изменилась база данных. Для примера можете раскоментировать следующие куски кода:

NotificationCenter.default.addObserver(self, selector: #selector(storageHasChanged(note:)), name: NSNotification.Name.NSManagedObjectContextObjectsDidChange, object: nil)
 
deinit {
        NotificationCenter.default.removeObserver(self)
    }
 
//MARK: Actions
    func storageHasChanged(note: NSNotification) {
        let inserted = note.userInfo?["inserted"]
        let deleted = note.userInfo?["deleted"]
        let updated = note.userInfo?["updated"]
 
        if let insertedSet = inserted as? Set<Car>, insertedSet.count > 0 {
            print("INSERTED")
            print(insertedSet.map { $0.name })
        }
        if let deletedSet = deleted as? Set<Car>, deletedSet.count > 0 {
            print("DELETED")
            print(deletedSet.map { $0.name })
        }
        if let updatedSet = updated as? Set<Car>, updatedSet.count > 0 {
            print("UPDATED")
            print(updatedSet.map { $0.name })
        }
    }

Можете поэкспериментировать с нотификацией на изменение базы данных. Мой результат:

[Optional("Zapor")]
INSERTED
[Optional("Fiat")]
INSERTED
[Optional("F1")]
DELETED
[Optional("Zapor"), Optional("F1"), Optional("Fiat"), Optional("BMW"), Optional("Fiat"), Optional("BMW"), Optional("Alfa Romeo"), Optional("Alfa Romeo"), Optional("BMW"), Optional("Fiat"), Optional("BMW"), Optional("F1"), Optional("F1"), Optional("Alfa Romeo"), Optional("F1"), Optional("Fiat"), Optional("Alfa Romeo"), Optional("Zapor"), Optional("Zapor"), Optional("Zapor")]
CARS: Optional(["BMW", "F1", "Fiat", "Zapor"])
INSERTED
[Optional("Alfa Romeo")]
CARS: Optional(["Alfa Romeo", "BMW", "F1", "Fiat", “Zapor"])

Пример 3

В этом примере я хотел продемонстрировать работу с JSON. Конечно, в реальном проекте я бы использовал что-то для мапинга, возможно SwiftyJSON для простоты. Но для небольшого урока, как в этот, я задал JSON строкой и потом его распарсил:

et json = "{\"cars\":[{\"name\":\"ZaZ\"},{\"name\":\"Lada\"},{\"name\":\"Lexus\"}]}"
        let dict = try! JSONSerialization.jsonObject(with: json.data(using: .utf8)!, options: JSONSerialization.ReadingOptions.allowFragments) as! [String:Any]

Смотрим на файл StoreManager:

//to make sure we have only one copy
    lazy var backgroundContext: NSManagedObjectContext = {
        return self.persistentContainer.newBackgroundContext()
    }()
 
    fileprivate lazy var persistentContainer: NSPersistentContainer = {
        let container = NSPersistentContainer(name: "Model")
        container.loadPersistentStores(completionHandler: { (storeDescription, error) in
            if let error = error as NSError? {
                fatalError("Unresolved error \(error), \(error.userInfo)")
            }
        })
        return container
    }()
 
    func saveContext(type: ContextType) {
        let context = type == .main ? persistentContainer.viewContext : backgroundContext
        if context.hasChanges {
            do {
                try context.save()
            } catch {
                let nserror = error as NSError
                fatalError("Unresolved error \(nserror), \(nserror.userInfo)")
            }
        }
    }
 
    func getMainContextObjects<T: NSManagedObject>(entity: T.Type) -> [NSManagedObject]? {
        return persistentContainer.viewContext.fetchAll(entity: entity, fetchConfiguration: nil)
    }
 
    func clearStorage<T: NSManagedObject>(type: ContextType, entity: T.Type) {
        let context = type == .main ? persistentContainer.viewContext : backgroundContext
        let objects = context.fetchAll(entity: entity, fetchConfiguration: nil)
        if let objects = objects {
            for item in objects {
                context.delete(item)
            }
        }
    }
 
    func showStorage<T: NSManagedObject>(type: ContextType, entity: T.Type) {
        let context = type == .main ? persistentContainer.viewContext : backgroundContext
        let objects = context.fetchAll(entity: entity, fetchConfiguration: nil)
        print("OBJECTS: \(objects)")
        print("COUNT: \(objects?.count)")
    }

Здесь я храню backgroundContext как переменную, чтобы всегда был только один backgroundContext, который в дальнейшем я могу сохранять методом saveContext(type:). Остальные методы должны быть понятны. Так как у нас есть enum...

enum ContextType {
    case main
    case background
}

...мы всегда знаем, с каким контекстом работаем. Вернемся в ViewController. Обратите внимание, как я создаю объекты:

for item in dict["cars"] as! [Any] {
            let car = StoreManager.sharedInstance.backgroundContext.insert(entity: Car.self)
            car.name = (item as? [String:Any])?["name"] as! String?
        }

Но в стандартном контексте метода insert(entity:) нет! Дело в том, что я написал extensions, которые работают с generics-данными:

//MARK: CoreData extensions
extension NSManagedObject {
    class var entityName : String {
        let components = NSStringFromClass(self)
        return components
    }
 
    class func fetchRequestObj() -> NSFetchRequest<NSFetchRequestResult> {
        let request = NSFetchRequest<NSFetchRequestResult>(entityName: self.entityName)
        return request
    }
 
    class func fetchRequestWithKey(key: String, ascending: Bool = true) -> NSFetchRequest<NSFetchRequestResult> {
        let request = fetchRequestObj()
        request.sortDescriptors = [NSSortDescriptor(key: key, ascending: ascending)]
        return request
    }
}
 
extension NSManagedObjectContext {
    func insert<T: NSManagedObject>(entity: T.Type) -> T {
        let entityName = entity.entityName
        return NSEntityDescription.insertNewObject(forEntityName: entityName, into: self) as! T
    }
 
    func fetchAll<T: NSManagedObject>(entity: T.Type, fetchConfiguration: ((NSFetchRequest<NSManagedObject>) -> Void)?) -> [NSManagedObject]? {
        let dataFetchRequest = NSFetchRequest<NSManagedObject>(entityName: entity.entityName)
 
        fetchConfiguration?(dataFetchRequest)
        var result = [NSManagedObject]()
        do {
            result = try self.fetch(dataFetchRequest)
        } catch {
            print("Failed to fetch feed data, critical error: \(error)")
        }
        return result
    }
}

Поэтому можно добавлять сущность в контекст, используя его тип и слово self (Car.self). Также добавлен метод fetchAll, работающий с generics. Его используем в методах StoreManager. Теперь наш менеджер готов к работе. Надеюсь испытать и улучшить его при первой необходимости