CoreData简介

1.iOS开发中实现数据持久化存储的一种重要手段

2.提供了对象-关系映射的功能，能降对象使用数据库或者XML等方式存储

3.如果使用CoreData将数据存储在数据库中，不使用sql语句来操作数据

什么是CoreData

这个框架是基于关系型数据结构而设计的。它本身不是数据库，而是基于某种存储实体（一般是sqlite）的一个上层的抽象.我们的精力不在如何设计数据库和操作数据库上，而是把精力放到了数据结构上。

CoreData涉及到的几个类

1.NSManagedObjectModel:用来加载CoreData数据模型文件，所有的数据模型可以全部加载在此对象中

2.NSManafedObjectContext:用于操作数据模型，并监测数据模型的变化

3.NSPersistentStoreCoordinator:数据持久化存储协调器，负责调度上层和底层对数据的操作

4.NSManagedObject：具体的数据模型对象

5.NSentityDescription：模型描述类，能够实例化得到具体的数据模型对象

6.NSFetchRequest：数据查询请求类

7.NSPredicate：通过谓词设置查询条件的类

CoreData的使用

一、使用前的准备工作

    1.获取momd文件的路径，后缀名一定是momd
    let path = NSBundle.mainBundle().pathForResource("Person", ofType: "momd")
    2.获取被管理对象模型
    let models = NSManagedObjectModel(contentsOfURL: NSURL(fileURLWithPath: path!))
    3.创建一个持久化存储协调器，可以将coreData模型和数据库关联起来
    let coordinator = NSPersistentStoreCoordinator(managedObjectModel: models!)
    4.需要关联的数据库路径
    let str = NSHomeDirectory() as NSString
    let dbPath = str.stringByAppendingPathComponent("/Documents/coreData.sqlite")
    5.关联数据库路径
    do {
        try coordinator.addPersistentStoreWithType(NSSQLiteStoreType, configuration: nil, URL: NSURL(fileURLWithPath: dbPath), options: nil)
    } catch let error {
        print("关联数据库失败:\(error)")
    }
    6.创建上下文
    context = NSManagedObjectContext(concurrencyType: NSManagedObjectContextConcurrencyType.MainQueueConcurrencyType)
    7.将数据协调器设置给上下文
    context?.persistentStoreCoordinator = coordinator

二、增删改查使用

1.增

    let model = NSEntityDescription.insertNewObjectForEntityForName("Student", inManagedObjectContext: context!) as! Student

往上下文中插入数据并进行属性赋值，然后保存数据，并往当前控制器的数组中追加数据，刷新UI

2.删

    let model = self.dataArray[currentRow]
    context?.deleteObject(model)

找到需要删除的对象并进行删除操作，然后保存数据，移除当前控制器数组中的元素，刷新UI

3.改

    let model = dataArray[currentRow]

找到需要修改的对象并修改对象的属性值，然后保存数据，刷新界面

4.查

    let request = NSFetchRequest(entityName: "Student")
    let predicate = NSPredicate(format: "userName like %@", "*" + userNameTextField.text! + "*")
    request.predicate = predicate
    dataArray = try context?.executeFetchRequest(request) as! [Student]

创建查询请求，设置查询条件，然后给查询请求设置查询条件，最后开始查询并刷新界面

使用步骤：

方法一：完全自己写，创建工程时不勾选Use Core Data

创建工程之后
１.

创建文件.png

1.2建表.png

1.3关联.png

成功之后会自动生成相关文件

实现

import UIKit
import CoreData //实现CoreData数据库必须添加系统框架

class ViewController: UIViewController {
    
    @IBOutlet weak var ageTextLabel: UITextField!
    
    @IBOutlet weak var nameTextLabel: UITextField!

    
    //上下文
    var context:NSManagedObjectContext!
    
    var tableView:UITableView!
    
    //数据数组
    var dataArray = [Dog]()
    
    //当前对应的row，主要用于记录和删除哪一行
    //最好设置为-1，因为row是从0开始的
    var currentRow = -1
    
    override func viewDidLoad() {
        super.viewDidLoad()
        
        self.creatUI()
        self.prepareForCoreData()
    }
    
    
    
    func creatUI(){
        self.tableView = UITableView(frame: CGRectMake(0,150,self.view.frame.size.width,self.view.frame.size.height), style: .Plain)
        tableView.delegate = self
        tableView.dataSource = self
        self.view.addSubview(tableView)
    }
    
    //使用前准备工作
    func prepareForCoreData(){
        //1.获取momd文件路径,后缀必须是momd
        let path = NSBundle.mainBundle().pathForResource("AnimalModel", ofType: "momd")
        //2.获取被管理的对象模型
        let models = NSManagedObjectModel(contentsOfURL: NSURL(fileURLWithPath: path!))
        //3.创建一个持久化的存储协调器，起到桥梁作用，将CoreData数据库和模型关联起来
        let coordinator = NSPersistentStoreCoordinator(managedObjectModel: models!)
        //4.设置数据库路径
        let str = NSHomeDirectory() as NSString
        //拼接路径
        let dbPath = str.stringByAppendingPathComponent("/Documents/dog.sqlite")
        //5.将数据库路径和存储协调器关联
        do{
            try coordinator.addPersistentStoreWithType(NSSQLiteStoreType, configuration: nil, URL: NSURL(fileURLWithPath: dbPath), options: nil)
        }catch let error{
            print("关联失败\(error)")
        }
        //6.创建上下文——是实现增删改查的核心类
        context = NSManagedObjectContext(concurrencyType: NSManagedObjectContextConcurrencyType.MainQueueConcurrencyType)
        //7.将存储协调器赋值给上下文
        context.persistentStoreCoordinator = coordinator
        
        //刚进入时查询数据库全部数据
        let request = NSFetchRequest(entityName: "Dog")
        do{
            self.dataArray = try context.executeFetchRequest(request) as! [Dog]
            self.tableView.reloadData()
        }catch{
            
        }
    }
    
   //增
    @IBAction func addAction(sender: UIButton) {
        
        //校验
         if self.nameTextLabel.text == "" || self.ageTextLabel.text == ""{
            return
        }
        //插入数据
        let model = NSEntityDescription.insertNewObjectForEntityForName("Dog", inManagedObjectContext: context) as! Dog
        model.name = self.nameTextLabel.text
        model.age = Int(self.ageTextLabel.text!)
        
        //同步数据
        do {
            try context.save()
            //想当前控制器的数组追加数据
            self.dataArray.append(model)
            //刷新
            self.tableView.reloadData()
        }catch let error{
            print("插入失败\(error)")
        }
    }
    
    //删
    @IBAction func deleteAction(sender: UIButton) {
        if currentRow < 0{
            return
        }
        let model = self.dataArray[currentRow]
        context.deleteObject(model)
        
        //同步
        do {
            try context.save()
            self.dataArray.removeAtIndex(currentRow)
            self.tableView.reloadData()
        }catch let error{
            print("删除失败\(error)")
        }
        //重置current
        currentRow = -1
    }
    //改
    @IBAction func updateAction(sender: UIButton) {
        //校验
        if self.nameTextLabel.text == "" || self.ageTextLabel.text == ""{
            return
        }
        
        //获取需要更改的数据
        let model = self.dataArray[currentRow]
        model.name = self.nameTextLabel.text
        model.age = Int(self.ageTextLabel.text!)
        
        //同步
        do {
            try context.save()
            
            self.tableView.reloadData()
        }catch let error{
            print("更新失败\(error)")
        }
    }
    //查
    @IBAction func deqAction(sender: UIButton) {
        
        //创建查询请求
        let request = NSFetchRequest(entityName: "Dog")
        //查询条件(谓词或者正则表达式)
        //name是模型中的一个属性，必须和模型中的保持一致
        let predicate = NSPredicate(format: "name like %@", "*" + self.nameTextLabel.text! + "*")
        //将谓词设置给查询请求
        request.predicate = predicate
        
        //开始查询
        do {
            self.dataArray = try self.context.executeFetchRequest(request) as! [Dog]
            self.tableView.reloadData()
        }catch let error{
            print("查询失败\(error)")
        }
        
    }
}


extension ViewController:UITableViewDelegate,UITableViewDataSource{
    
    func tableView(tableView: UITableView, numberOfRowsInSection section: Int) -> Int {
        return self.dataArray.count
    }
    
    func tableView(tableView: UITableView, cellForRowAtIndexPath indexPath: NSIndexPath) -> UITableViewCell {
        var cell = tableView.dequeueReusableCellWithIdentifier("cell")
        if cell == nil{
            cell = UITableViewCell(style: .Subtitle, reuseIdentifier: "cell")
            
        }
        let model = self.dataArray[indexPath.row]
        cell?.textLabel?.text = model.name
        cell?.detailTextLabel?.text = String(model.age)
        if model.age != nil{
            cell?.detailTextLabel?.text = String(model.age!)
        }
        return cell!
    }
    
    //选中的时候确认currentRow
    func tableView(tableView: UITableView, didSelectRowAtIndexPath indexPath: NSIndexPath) {
        self.currentRow = indexPath.row
    }
}

效果.png

方式二：创建工程时勾选Use Core Data

demo2勾选方式创建.png

这种方式会自动生成一个文件，所有的代码会在Appdelegate里面自动生成，实现增删改查，只需要获取AppDelegate里面的上下文（var contexte = AppDelegate().managedObjectContext）

Appdelegate自动生成的文件

// MARK: - Core Data stack

    lazy var applicationDocumentsDirectory: NSURL = {
        // The directory the application uses to store the Core Data store file. This code uses a directory named "com.zhaoguojin.CoreDataDemo2" in the application's documents Application Support directory.
        let urls = NSFileManager.defaultManager().URLsForDirectory(.DocumentDirectory, inDomains: .UserDomainMask)
        return urls[urls.count-1]
    }()

    lazy var managedObjectModel: NSManagedObjectModel = {
        // The managed object model for the application. This property is not optional. It is a fatal error for the application not to be able to find and load its model.
        let modelURL = NSBundle.mainBundle().URLForResource("CoreDataDemo2", withExtension: "momd")!
        return NSManagedObjectModel(contentsOfURL: modelURL)!
    }()

    lazy var persistentStoreCoordinator: NSPersistentStoreCoordinator = {
        // The persistent store coordinator for the application. This implementation creates and returns a coordinator, having added the store for the application to it. This property is optional since there are legitimate error conditions that could cause the creation of the store to fail.
        // Create the coordinator and store
        let coordinator = NSPersistentStoreCoordinator(managedObjectModel: self.managedObjectModel)
        let url = self.applicationDocumentsDirectory.URLByAppendingPathComponent("SingleViewCoreData.sqlite")
        var failureReason = "There was an error creating or loading the application's saved data."
        do {
            try coordinator.addPersistentStoreWithType(NSSQLiteStoreType, configuration: nil, URL: url, options: nil)
        } catch {
            // Report any error we got.
            var dict = [String: AnyObject]()
            dict[NSLocalizedDescriptionKey] = "Failed to initialize the application's saved data"
            dict[NSLocalizedFailureReasonErrorKey] = failureReason

            dict[NSUnderlyingErrorKey] = error as NSError
            let wrappedError = NSError(domain: "YOUR_ERROR_DOMAIN", code: 9999, userInfo: dict)
            // Replace this with code to handle the error appropriately.
            // abort() causes the application to generate a crash log and terminate. You should not use this function in a shipping application, although it may be useful during development.
            NSLog("Unresolved error \(wrappedError), \(wrappedError.userInfo)")
            abort()
        }
        
        return coordinator
    }()

    lazy var managedObjectContext: NSManagedObjectContext = {
        // Returns the managed object context for the application (which is already bound to the persistent store coordinator for the application.) This property is optional since there are legitimate error conditions that could cause the creation of the context to fail.
        let coordinator = self.persistentStoreCoordinator
        var managedObjectContext = NSManagedObjectContext(concurrencyType: .MainQueueConcurrencyType)
        managedObjectContext.persistentStoreCoordinator = coordinator
        return managedObjectContext
    }()

    // MARK: - Core Data Saving support

    func saveContext () {
        if managedObjectContext.hasChanges {
            do {
                try managedObjectContext.save()
            } catch {
                // Replace this implementation with code to handle the error appropriately.
                // abort() causes the application to generate a crash log and terminate. You should not use this function in a shipping application, although it may be useful during development.
                let nserror = error as NSError
                NSLog("Unresolved error \(nserror), \(nserror.userInfo)")
                abort()
            }
        }
    }

方式三，使用第三方库MagicalRecord

MagicalPanda是基于CoreData的一个第三方库。MagicalRecord 致力于更快捷和容易的使用CoreData。MagicalRecord 致力于使CoreData的代码更简洁，更简单的获取数据，并且使用最优化的操作，它提供了方便的方法，包含了CoreData使用的查询更新等的公用模板，降低了CoreData的使用门槛

使用时要自己创建文件和表，关联

使用第三方库需要初始化.png

• Appdelegate

实现

import UIKit

class ViewController: UIViewController {

    @IBOutlet weak var nameTextField: UITextField!
    
    @IBOutlet weak var ageTextField: UITextField!
    
    override func viewDidLoad() {
        super.viewDidLoad()
        
    }
    
    //增
    @IBAction func insertAction(sender: UIButton) {
        
        //将数据库和模型关联
        let model = Dog.MR_createEntity()
        //进行属性赋值
        model.name = self.nameTextField.text
        model.age = Int(self.ageTextField.text!)
        //同步数据
        NSManagedObjectContext.MR_defaultContext().MR_saveToPersistentStoreAndWait()
    }
    //删
    @IBAction func deleteAction(sender: UIButton) {
        
        //指明需要删除的数据
        let models = Dog.MR_findByAttribute("name", withValue: self.nameTextField.text)
        //循环遍历查找的结果并且删除相应的数据
        for model in models{
            model.MR_deleteEntity()
        }
        //同步数据库
        NSManagedObjectContext.MR_defaultContext().MR_saveToPersistentStoreAndWait()
    }
    //改
    @IBAction func updateAction(sender: UIButton) {
        
        //获取需要更改的数据
        let model = Dog.MR_findFirst()
        //重新进行属性赋值
        model.name = "二狗子"
        model.age = 18
        //同步数据库
        NSManagedObjectContext.MR_defaultContext().MR_saveToPersistentStoreAndWait()
    }
    //查
    @IBAction func fetchAction(sender: UIButton) {
        //查询全部数据
        let models = Dog.MR_findAll()
        for model in models{
            let dog = model as! Dog
            print("狗名\(dog.name)~~~狗龄\(dog.age)")
        }
    }

}