[iOS] CoreData 개념 및 활용예제

네이버 부스트캠프 프로젝트를 진행했을 때, 공부했던 CoreData입니다.

친절한 설명을 해주는 블로그를 찾지 못해, 혼자 정리해보았습니다. 도움이 되었으면 좋겠습니다!

 

GitHub - boostcampwm-2024/iOS06-molio: 나만의 뮤직 포트폴리오, 몰리오 🎶

 

 

1. CoreData란?

어플리케이션의 데이터 모델을 관리하고
저장하는 것을 도와주는 iOS의 객체 그래프 관리 프레임 워크
SQLite 데이터 베이스의 효율성 + 객체 지향 프로그래밍의 장점
→ 복잡한 구조를 쉽게 관리하게 해줌.

 

Core Data는 애플이 제공하는 프레임워크로, 앱의 영구 데이터를 관리하고 객체 그래프를 관리하는 데 사용됩니다. 이를 통해 데이터를 저장하고, 조회하고, 업데이트하고, 삭제할 수 있습니다. Core Data는 관계형 데이터베이스(SQLite) 기반이지만, 데이터베이스 직접 관리보다는 객체-관계 매핑(ORM) 방식을 제공합니다.

 

Core Data의 주요 역할

1. 데이터 영구 저장: Core Data는 앱 데이터를 영구 저장소에 저장하여 앱이 종료되어도 유지되도록 합니다.
2. 데이터 관리: Core Data는 데이터를 추가, 조회, 수정, 삭제할 수 있는 다양한 기능을 제공합니다.
3. 객체 관리: Core Data는 데이터베이스와는 다르게 객체로 데이터를 다룰 수 있습니다. 즉, 데이터베이스의 행(row) 대신 객체(object)를 조작하는 방식으로 데이터를 관리합니다.

2. Core Data의 주요 개념과 기능

Core Data의 주요 개념 정리

1. NSManagedObjectModel (데이터 모델)
   • Core Data에서 앱의 데이터 구조를 정의하는 부분입니다.
   • 이 모델에는 앱에서 사용할 엔티티(Entity)와 각 엔티티의 속성(Attribute), 엔티티 간의 관계(Relationship)가 정의됩니다.
2. NSPersistentContainer (데이터 저장소 설정 및 관리)
   • Core Data를 쉽게 설정하고 관리할 수 있도록 해주는 도구입니다.
   • Core Data가 데이터를 저장할 저장소(Persistent Store)를 설정하고 초기화하는 역할을 합니다.
3. NSManagedObjectContext (작업 영역)
   • Core Data에서 데이터 작업을 수행하는 공간입니다. 데이터를 추가, 수정, 삭제할 때 모두 이 작업 공간에서 이루어집니다.
   • 변경사항은 일시적으로 이 공간에 저장되며, save() 메서드를 호출하면 영구 저장소에 반영됩니다.
4. NSManagedObject (데이터 객체)
   • Core Data에서 데이터를 관리하는 객체입니다.
   • 데이터베이스의 행(row)에 해당하며, 데이터를 코드에서 다루기 위한 객체 형식으로 제공합니다.
5. NSFetchRequest (데이터 요청)
   • Core Data에 저장된 데이터를 가져오기 위해 사용하는 요청 객체입니다.
   • 특정 조건으로 데이터를 검색하거나 필터링할 수 있습니다.
6. Persistent Store (영구 저장소)
   • Core Data가 데이터를 실제로 저장하는 공간으로, 다양한 저장 방식이 있습니다.
   • 앱의 필요에 따라 SQLite, Binary, In-Memory 등의 형식을 선택할 수 있습니다.

Persistent Store의 주요 유형

1. SQLite:
   • 가장 일반적인 데이터 저장 방식입니다.
   • 대용량 데이터를 관리할 때 성능이 우수합니다.
2. Binary Store:
   • 데이터를 이진 형식으로 저장하며, 작은 용량의 데이터를 다룰 때 적합합니다.
3. In-Memory Store:
   • 데이터를 메모리에만 저장하며, 앱이 종료되면 데이터가 사라집니다. 영구 저장이 필요 없는 임시 데이터를 다룰 때 유용합니다.

Core Data 사용 예시

import CoreData

// Persistent Container 설정
let container = NSPersistentContainer(name: "MyAppModel")
container.loadPersistentStores { (storeDescription, error) in
    if let error = error {
        print("Persistent Store 로드 실패: \\\\(error)")
    }
}

// 데이터 저장 예시
let context = container.viewContext
let entity = NSEntityDescription.entity(forEntityName: "Person", in: context)!
let newPerson = NSManagedObject(entity: entity, insertInto: context)
newPerson.setValue("John", forKey: "name")
try? context.save()

핵심 요약

개념 설명

NSManagedObjectModel	데이터 모델. 데이터 구조와 관계를 정의함.
NSPersistentContainer	Core Data 스택을 관리하고 영구 저장소를 설정함.
NSManagedObjectContext	작업 영역. 데이터를 추가, 수정, 삭제하는 곳.
NSManagedObject	데이터를 관리하는 객체. 속성과 관계를 코드로 다룸.
NSFetchRequest	데이터 요청 객체. 데이터를 검색하고 필터링할 수 있음.
Persistent Store	영구 저장소. SQLite, Binary, In-Memory 등이 있음.

3. Entity 정의하기

1. Core Data의 엔티티(Entity)

• 엔티티는 Core Data 모델에서 데이터 객체의 유형을 정의합니다.
• 각 엔티티는 속성(Attributes)과 관계(Relationships)를 가집니다.
• 엔티티 인스턴스는 앱에서 데이터를 저장하고 관리할 수 있는 객체가 됩니다.

2. 엔티티 속성(Attributes)

엔티티 속성은 객체의 상태를 나타내는 데이터 필드로, 일반적인 데이터베이스의 컬럼에 해당합니다.

속성 유형 (Attribute Types)

Core Data는 다양한 속성 유형을 지원하며, 이를 통해 필요한 데이터 형식을 정의할 수 있습니다.

1. 기본 데이터 타입
   • String: 문자열 데이터
   • Integer: 정수형 데이터 (Int16, Int32, Int64)
   • Double, Float: 실수형 데이터
   • Boolean: 논리형 데이터 (true, false)
   • Date: 날짜 및 시간 데이터
   • Binary Data: 이미지와 같은 이진 데이터 (Data 타입)
2. Transformable (변환 가능한 타입)
   • 사용자 정의 객체나 배열과 같은 복잡한 타입을 저장하기 위해 사용됩니다.
   • Swift의 Codable을 이용해 커스텀 객체를 Data로 인코딩하여 저장한 뒤, 필요 시 디코딩해 사용합니다.
   • 예: [String] 배열이나 사용자 정의 타입 등을 저장할 때 사용.
   • Transformable 속성을 사용하여 복잡한 데이터 타입을 저장하거나, URL을 String으로 변환하여 저장하는 등의 방식을 통해 Core Data의 한계를 극복할 수 있습니다.
3. UUID, URI:
   • UUID: 고유 식별자(UUID)를 저장하는 데 사용됩니다.
   • URI: 파일이나 리소스의 경로를 나타내기 위해 사용됩니다.
4. 기타 커스텀 타입
   • URL: Core Data는 URL을 직접 지원하지 않으므로, URL은 String으로 저장하고, 필요할 때 URL로 변환합니다.

속성 옵션

• 기본값 (Default Value): 속성의 기본값을 지정할 수 있습니다.
• 필수 여부 (Optional): 필수 필드 여부를 설정할 수 있으며, 필수가 아닌 속성은 nil 값을 가질 수 있습니다.
• 유일성 (Unique): 속성 값이 유일해야 하는지 여부를 설정합니다.

 

3. 엔티티 관계(Relationships)

관계는 Core Data에서 엔티티 간의 연결을 정의합니다. 관계 설정에 따라 데이터 간 연동 및 참조가 가능합니다.

관계 유형

1. 1:1 관계 (One-to-One):
   • 하나의 엔티티 인스턴스가 다른 하나의 엔티티 인스턴스와 연결되는 경우입니다.
   • 예: 사용자가 하나의 프로필만 가지는 상황.
2. 1:N 관계 (One-to-Many):
   • 하나의 엔티티 인스턴스가 여러 엔티티 인스턴스와 연결되는 경우입니다.
   • 예: 작가가 여러 권의 책을 쓰는 경우. 작가 엔티티는 책 엔티티와 1:N 관계가 됩니다.
3. N:M 관계 (Many-to-Many):
   • 여러 엔티티 인스턴스가 서로 여러 엔티티 인스턴스와 연결되는 경우입니다.
   • 예: 여러 학생이 여러 강의를 수강할 수 있는 상황. 학생과 강의 간의 관계는 N:M 관계가 됩니다.

관계 속성 옵션

1. Destination (대상):
   • 관계에서 연결되는 엔티티를 의미합니다.
   • 예: Playlist 엔티티의 songs 관계는 Song 엔티티를 대상으로 합니다.
2. Inverse Relationship (역관계):
   • 양방향 관계를 설정하여, 하나의 관계 변경이 연결된 엔티티에도 영향을 주도록 만듭니다.
   • 예: Playlist 엔티티의 songs 관계와 Song 엔티티의 playlists 관계가 서로를 역관계로 설정합니다.
3. To-One vs. To-Many:
   • To-One: 단일 엔티티 인스턴스와의 관계 (하나의 값만 가짐).
   • To-Many: 여러 엔티티 인스턴스와의 관계 (여러 값을 가짐).
4. Ordered (정렬된 관계):
   • 관계가 NSOrderedSet 타입으로 설정되어 순서가 유지됩니다.
   • 순서가 중요한 경우, 예를 들어 플레이리스트 내 곡 순서가 중요한 경우 사용됩니다.
5. Delete Rule (삭제 규칙):
   • 관계 엔티티가 삭제될 때, 연결된 엔티티에 미치는 영향을 설정합니다.
   • Cascade: 부모가 삭제되면 모든 자식 엔티티도 삭제.
   • Nullify: 부모가 삭제되면 자식 엔티티의 관계 참조만 끊음.
   • Deny: 자식이 남아 있는 경우 부모를 삭제할 수 없음.
   • No Action: 아무런 작업도 수행하지 않음.

 

4. Core Data 모델 파일에서 엔티티 설정하기

1. 모델 파일 생성:
   • Xcode에서 Core Data 모델 파일을 생성하여, 앱의 데이터 구조를 설정합니다.
2. 엔티티 생성:
   • 모델 파일에서 필요한 엔티티를 추가하고, 엔티티마다 속성 및 관계를 정의합니다.
3. 속성 및 관계 설정:
   • 각 엔티티에 속성 및 관계를 추가하고, 관계에 따라 역관계(Inverse)와 삭제 규칙(Delete Rule)을 설정합니다.

 

5. 예시: Playlist와 Song 엔티티 모델링

• Playlist: 다수의 곡을 포함하는 플레이리스트 엔티티.
  • name: String
  • createdAt: Date
  • songs: Song 엔티티와의 다대다 관계 (Ordered 관계 사용)

6. Core Data 엔티티 코드 예시

import CoreData

// Playlist 엔티티
@objc(Playlist)
class Playlist: NSManagedObject {
    @NSManaged public var name: String
    @NSManaged public var createdAt: Date
    @NSManaged public var songs: NSOrderedSet  // Ordered 관계 설정
}

4. CoreData 예제

1단계: Core Data 스택 설정하기

Core Data 스택은 Core Data를 사용하기 위한 기본적인 설정입니다. 이를 통해 데이터를 저장하고 관리하는 작업을 할 수 있는 환경을 만듭니다.

1. 프로젝트에 Core Data를 추가했다면 NSPersistentContainer 인스턴스를 만들고 앱의 데이터베이스 이름을 지정합니다.

import CoreData

let persistentContainer: NSPersistentContainer = {
    // 모델 이름을 입력해 주세요 (예: "MyAppModel")
    let container = NSPersistentContainer(name: "MyAppModel")

    // 영구 저장소 로드
    container.loadPersistentStores { (storeDescription, error) in
        if let error = error {
            fatalError("Persistent Store 로드 실패: \\\\(error)")
        }
    }
    return container
}()

// 작업 공간(Context)을 가져옵니다.
let context = persistentContainer.viewContext

 

 

2단계: 데이터 모델(Entity) 생성하기

Core Data에서 데이터를 저장할 구조를 정의하는 엔티티(Entity)를 생성합니다. 예를 들어 Person 엔티티를 만들고 name과 age 속성을 추가할 수 있습니다.

1. Xcode의 Data Model 파일을 엽니다.
2. 엔티티(Entity)를 추가하고, 이름을 Person으로 설정합니다.
3. Person 엔티티에 name (String)과 age (Integer 16) 속성을 추가합니다.

이렇게 설정하면 Person 엔티티는 Core Data에서 관리되는 하나의 데이터 유형이 됩니다.

 

3단계: 데이터 추가(Create)

데이터를 추가하려면 NSManagedObject를 사용하여 새로운 엔티티 인스턴스를 만들고, 속성 값을 설정한 후 context.save()를 호출해 저장합니다.

func addPerson(name: String, age: Int16) {
    // `Person` 엔티티를 위한 `NSManagedObject` 생성
    let entity = NSEntityDescription.entity(forEntityName: "Person", in: context)!
    let newPerson = NSManagedObject(entity: entity, insertInto: context)

    // 속성 값 설정
    newPerson.setValue(name, forKey: "name")
    newPerson.setValue(age, forKey: "age")

    // 저장
    do {
        try context.save()
        print("Person 추가 성공")
    } catch {
        print("Person 추가 실패: \\\\(error)")
    }
}

 

4단계: 데이터 조회(Read)

저장된 데이터를 가져오려면 NSFetchRequest를 사용하여 특정 조건으로 데이터를 검색합니다.

func fetchPersons() -> [NSManagedObject]? {
    // 요청 설정
    let fetchRequest = NSFetchRequest<NSManagedObject>(entityName: "Person")

    do {
        let persons = try context.fetch(fetchRequest)
        return persons
    } catch {
        print("데이터 조회 실패: \\\\(error)")
        return nil
    }
}

이 코드는 Person 엔티티에 저장된 모든 데이터를 가져오는 예제입니다.

---

5단계: 데이터 수정(Update)

조회된 데이터를 수정하려면 속성 값을 변경한 후, context.save()를 호출해 변경 사항을 영구 저장합니다.

func updatePerson(name: String, newAge: Int16) {
    let fetchRequest = NSFetchRequest<NSManagedObject>(entityName: "Person")
    fetchRequest.predicate = NSPredicate(format: "name == %@", name)

    do {
        let persons = try context.fetch(fetchRequest)

        // 첫 번째 결과의 나이 수정
        if let personToUpdate = persons.first {
            personToUpdate.setValue(newAge, forKey: "age")

            // 변경 사항 저장
            try context.save()
            print("Person 수정 성공")
        } else {
            print("해당 이름의 Person이 없습니다.")
        }
    } catch {
        print("데이터 수정 실패: \\\\(error)")
    }
}

 

 

6단계: 데이터 삭제(Delete)

데이터를 삭제하려면 조회 후 context.delete()를 호출하여 삭제한 다음 context.save()로 반영합니다.

func deletePerson(name: String) {
    let fetchRequest = NSFetchRequest<NSManagedObject>(entityName: "Person")
    fetchRequest.predicate = NSPredicate(format: "name == %@", name)

    do {
        let persons = try context.fetch(fetchRequest)

        // 첫 번째 결과 삭제
        if let personToDelete = persons.first {
            context.delete(personToDelete)

            // 변경 사항 저장
            try context.save()
            print("Person 삭제 성공")
        } else {
            print("해당 이름의 Person이 없습니다.")
        }
    } catch {
        print("데이터 삭제 실패: \\\\(error)")
    }
}

 

 

전체 요약

• 1단계: Core Data 스택을 초기화하고, NSPersistentContainer와 context를 설정합니다.
• 2단계: Xcode의 데이터 모델 파일에서 엔티티와 속성을 정의합니다.
• 3단계: NSManagedObject 인스턴스를 생성하여 데이터를 추가하고, context.save()로 저장합니다.
• 4단계: NSFetchRequest를 사용해 데이터를 조회합니다.
• 5단계: 조회된 데이터의 속성 값을 수정하고, context.save()로 저장합니다.
• 6단계: 조회된 데이터를 context.delete()로 삭제하고, context.save()로 반영합니다.

 

 

 

참고 자료

 

Core Data | Apple Developer Documentation

 

 

 

CoreData(1) - 기본 개념 및 아키텍처

 

 

Core Data Programming Guide: Creating and Saving Managed Objects