[Android 기초] 16. Room (데이터베이스)

 

 

 

 

 

안드로이드에서의 영구(비휘발성) 데이터 저장법

1. SharedPreference
2. 데이터베이스
3. 파일

 

 

---

 

1) Room 개요

방  |  Jetpack  |  Android Developers

• SQLite를 쉽게 사용할 수 있는 데이터베이스 객체 매핑 라이브러리
• 쉽게 Query를 사용할 수 있는 API를 제공
• Query를 컴파일 시간에 검증함
• Query결과를 LiveData로하여 데이터베이스가 변경될 때 마다 쉽게 UI를 변경할 수 있음
• SQLite 보다 Room을 사용할 것을 권장함

 

 

 

2) Room 주요 3요소

• @Database
  - 클래스를 데이터베이스로 지정하는 annotation, RoomDatabase를 상속 받은 클래스여야 함
  - Room.databaseBuilder를 이용하여 인스턴스를 생성함
• @Entity
  - 클래스를 테이블 스키마로 지정하는 annotation
• @Dao
  - 클래스를 DAO(Data Access Object)로 지정하는 annotation
  - 기본적인 insert, delete, update SQL은 자동으로 만들어주며, 복잡한 SQL은 직접 만들 수 있음

 

 

 

3) gradle 파일 설정

plugins {
		..
    kotlin("kapt")
}
..

dependencies {

    ..
    val room_version = "2.6.1" // 최신 버전 안드로이드 검색해서 들어가기
    implementation("androidx.room:room-runtime:$room_version")
    annotationProcessor("androidx.room:room-compiler:$room_version")
    kapt("androidx.room:room-compiler:$room_version") // To use Kotlin annotation processing tool (kapt)
    
    
    // To use Kotlin Symbol Processing (KSP)
    ksp("androidx.room:room-compiler:$room_version")

    // optional - Kotlin Extensions and Coroutines support for Room
    implementation("androidx.room:room-ktx:$room_version")

    // optional - RxJava2 support for Room
    implementation("androidx.room:room-rxjava2:$room_version")

    // optional - RxJava3 support for Room
    implementation("androidx.room:room-rxjava3:$room_version")

    // optional - Guava support for Room, including Optional and ListenableFuture
    implementation("androidx.room:room-guava:$room_version")

    // optional - Test helpers
    testImplementation("androidx.room:room-testing:$room_version")

    // optional - Paging 3 Integration
    implementation("androidx.room:room-paging:$room_version")
}

• Room은 안드로이드 아키텍처에 포함되어 있음
• 사용하기 위해 build.gradle 파일의 dependencies에 아래 내용을 추가해야 함
      - Androidx 사용하는 경우를 가정함, Android Studio와 SDK는 최신 버전으로 사용
      - 'kotlin-kapt' 플러그인 추가
      - dependencies 추가

 

 

 

 4) Entity 생성

CREATE TABLE student_table (student_id INTEGER PRIMARY KEY, name TEXT NOT NULL); 의 경우

@Entity(tableName = "student_table")    // 테이블 이름을 student_table로 지정함
data class Student (
    @PrimaryKey @ColumnInfo(name = "student_id") val id: Int,
    val name: String
)

• Entity는 테이블 스키마 정의
  (모든 데이터베이스는 테이블을 가지고 있고, 각 테이블들은 어떤 컬럼들을 가지고 있을지 정의하는 것이 스키마)
• @Entity data class Student

 

 

 

5) DAO 생성

@Query("SELECT * from table") fun getAllData() : List<Data>

• DAO는 interface나 abstract class로 정의되어야 함
• Annotation에 SQL 쿼리를 정의하고 그 쿼리를 위한 메소드를 선언
• 가능한 annotation으로 @Insert, @Update, @Delete, @Query가 있음
• @Insert, @Update, @Delete는 SQL 쿼리를 작성하지 않아도 컴파일러가 자동으로 생성함
      - @Insert나 @Update는 key가 중복되는 경우 처리를 위해 onConflict를 지정할 수 있음
          - OnConflictStrategy.ABORT: key 충돌시 종료
          - OnConflictStrategy.IGNORE: key 충돌 무시
          - OnConflictStrategy.REPLACE: key 충돌시 새로운 데이터로 변경
      - @Update나 @Delete는 primary key에 해당되는 튜플을 찾아서 변경/삭제 함

 

@Query("SELECT * from table") fun getAllData() : LiveData<List<Data>>

• @Query로 리턴되는 데이터의 타입을 LiveData<>로 하면,
  나중에 이 데이터가 업데이트될 때 Observer를 통해 할 수 있음

 

@Query("SELECT * FROM student_table WHERE name = :sname")
suspend fun getStudentByName(sname: String): List<Student>

• @Query에 SQL을 정의할 때 메소드의 인자를 사용할 수 있음 (예: 인자 sname을 SQL에서 :sname으로 사용)

 

@Dao
interface MyDAO {
    @Insert(onConflict = OnConflictStrategy.REPLACE)  // INSERT, key 충돌이 나면 새 데이터로 교체
    suspend fun insertStudent(student: Student)

    @Query("SELECT * FROM student_table")
    fun getAllStudents(): LiveData<List<Student>>        // LiveData<> 사용

    @Query("SELECT * FROM student_table WHERE name = :sname")   
    suspend fun getStudentByName(sname: String): List<Student>

    @Delete
    suspend fun deleteStudent(student: Student); // primary key is used to find the student

    // ...
}

• fun 앞에 suspend는 Kotlin coroutine을 사용하는 것
  나중에 이 메소드를 부를 때는 runBlocking {} 내에서 호출해야 함
• LiveData는 비동기적으로 동작하기 때문에 coroutine으로 할 필요가 없음
• @Query("SELECT * from table") fun getAllData() : LiveData<List<Data>>
  @Query("SELECT * FROM student_table WHERE name = :sname")
  suspend fun getStudentByName(sname: String): List<Student>
• 인자 sname을 SQL에서 :sname으로 사용

 

 

 

6) Database 생성

@Database(entities = [Student::class, ClassInfo::class, Enrollment::class, Teacher::class], version = 1)
abstract class MyDatabase : RoomDatabase() {
    abstract fun getMyDao() : MyDAO

    companion object {
        private var INSTANCE: MyDatabase? = null
        private val MIGRATION_1_2 = object : Migration(1, 2) {
            override fun migrate(database: SupportSQLiteDatabase) { 생략 }
        }

        private val MIGRATION_2_3 = object : Migration(2, 3) {
            override fun migrate(database: SupportSQLiteDatabase) { 생략 }
        }
        fun getDatabase(context: Context) : MyDatabase {
            if (INSTANCE == null) {
                INSTANCE = Room.databaseBuilder(
                    context, MyDatabase::class.java, "school_database")
                    .addMigrations(MIGRATION_1_2, MIGRATION_2_3)
                    .build()
            }
            return INSTANCE as MyDatabase
        }
    }
}

• RoomDatabase를 상속하여 자신의 Room 클래스를 만들어야 함
• 포함되는 Entity들과 데이터베이스 버전(version)을 @Database annotation에 지정함
      - version이 기존에 저장되어 있는 데이터베이스보다 높으면, 데이터베이스를 open할 때 migration을 수행하게 됨
      - Migration 수행 방법은 RoomDatabase 객체의 addMigration() 메소드를 통해 알려줌
• DAO를 가져올 수 있는 getter 메소드를 만듬
      - 실제 메소드 정의는 자동으로 생성됨
• Room 클래스의 인스턴스는 하나만 있으면 되므로 Singleton 패턴을 사용
• Room 클래스의 객체 생성은 Room.databaseBuilder()를 이용함

 

 

 

7) Migration

Room.databaseBuilder(...).addMigrations(MIGRATION_1_2, MIGRATION_2_3)

private val MIGRATION_1_2 = object : Migration(1, 2) {   // version 1 -> 2
    override fun migrate(database: SupportSQLiteDatabase) {
        database.execSQL("ALTER TABLE student_table ADD COLUMN last_update INTEGER")
    }
}

private val MIGRATION_2_3 = object : Migration(2, 3) {   // version 2 -> 3
    override fun migrate(database: SupportSQLiteDatabase) {
        database.execSQL("ALTER TABLE class_table ADD COLUMN last_update INTEGER")
    }
}

• 앞에서 MyRoomDatabase객체 생성 후 addMigrations() 메소드를 호출하여 Migration 방법을 지정했음
• 여러개의 Migration 지정 가능

 

 

 

8) UI와 연결

myDao = MyDatabase.getDatabase(this).getMyDao()
runBlocking { // (주의) UI를 블록할 수 있는 DAO 메소드를 UI 스레드에서 바로 호출하면 안됨
    myDao.insertStudent(Student(1, "james"))  // suspend 지정되어 있음
}
val allStudents = myDao.getAllStudents() // LiveData는 Observer를 통해 비동기적으로 데이터를 가져옴

• 안드로이드 아키텍처에 따라 Repository와 ViewModel을 사용하길 권장하지만
      - 참고: https://codelabs.developers.google.com/codelabs/android-room-with-a-view-kotlin/
      - 여기에서는 Room과 LiveData 사용만 다룸
• RoomDatabase객체에서 DAO 객체를 받아오고, 이 DAO객체의 메소드를 호출하여 데이터베이스를 접근함

 

 

 

9) UI와 연결 - LiveData

 

LiveData?

• 안드로이드 아키텍처 컴포넌트의 일부로, 관찰 가능한 데이터 홀더 클래스
• 이를 통해 UI 컴포넌트(예: 액티비티, 프래그먼트)는 데이터의 변경 사항을 관찰하고 이에 반응
• 데이터가 변경될 때마다 LiveData는 관찰자에게 알림을 보냄

 

LiveData의 핵심 특징

• 1. 수명주기 인식
  - LiveData는 안드로이드의 수명주기를 인식
  - 즉, 액티비티나 프래그먼트의 수명주기 상태에 따라 알림을 자동으로 관리
  - 이로 인해 메모리 누수 및 액티비티가 종료된 상태에서 발생할 수 있는 크래시를 방지
• 2. UI와 데이터 상태의 일관성 유지
  - LiveData를 사용하면 UI가 데이터와 일관되게 유지
  - 데이터가 변경될 때 UI가 자동으로 갱신되기 때문에, 사용자에게 최신의 정보를 제공
• 3. 중앙 집중적인 데이터 관리
  - LiveData는 뷰모델(ViewModel)과 함께 사용되어 앱의 데이터를 중앙에서 관리할 수 있게 함
  - 이는 데이터 관리를 더욱 효율적으로 만들어 줌
• 4. 데이터 변경에 따른 자동 업데이트
  - LiveData의 관찰자는 오직 활성 수명주기 상태(active lifecycle state)의 컴포넌트에만 알림을 보냄
  - 이는 데이터가 변경될 때 활성 상태의 UI만 업데이트되어, 불필요한 리소스 사용을 줄여줌

 

val allStudents = myDao.getAllStudents()
allStudents.observe(this) {   // Observer::onChanged() 는 SAM 이기 때문에 lambda로 대체
    val str = StringBuilder().apply {
            for ((id, name) in it) {
                append(id)
                append("-")
                append(name)
                append("\n")
            }
        }.toString()
    binding.textStudentList.text = str
}

• LiveData<> 타입으로 리턴되는 DAO 메소드 경우
      - observe() 메소드를 이용하여 Observer를 지정
      - 데이터가 변경될 때마다 자동으로 Observer의 onChanged()가 호출됨
• LiveData<>를 리턴하는 DAO 메소드는 Observer를 통해 비동기적으로 데이터를 받기 때문에, UI 스레드에서 직접 호출해도 문제 없음

 

 

10) Room Database의 주요 어노테이션(Annotations)

• @Database
      - 데이터베이스 클래스를 정의할 때 사용함
      - 데이터베이스에 포함될 엔티티와 버전을 명시함
• @Entity
      - 데이터베이스 내의 테이블을 정의할 때 사용함
      - 클래스 이름이 테이블 이름으로 사용되며, 필드는 컬럼으로 매핑됨
• @PrimaryKey
      - 엔티티의 기본 키(primary key)를 정의함
      - 유니크한 값이어야 하며, 데이터베이스 내에서 각 엔티티를 구분하는 데 사용됨
• @ColumnInfo
      - 테이블의 컬럼 정보를 세부적으로 정의할 때 사용함
      - 컬럼의 이름, 타입, 인덱스 등을 설정할 수 있음
• @Dao
      - 데이터 접근 객체(Data Access Object)를 정의할 때 사용함
      - 데이터베이스의 CRUD(Create, Read, Update, Delete) 연산을 위한 메소드를 포함함
• @Insert
      - 데이터를 삽입하는 메소드에 사용함
      - 해당 메소드는 엔티티를 인자로 받아 데이터베이스에 추가함
• @Query
      - 복잡한 SQL 쿼리를 실행하는 메소드에 사용함
      - 메소드에 주어진 SQL 쿼리를 실행하여 결과를 반환함
• @Update
      - 데이터를 업데이트하는 메소드에 사용함
      - 인자로 받은 엔티티의 데이터로 기존 레코드를 갱신함
• @Delete
      - 데이터를 삭제하는 메소드에 사용함
      - 인자로 받은 엔티티를 데이터베이스에서 제거함
• @Transaction
      - 메소드가 하나의 트랜잭션으로 실행되어야 함을 나타냄
      - 여러 연산을 하나의 작업으로 묶어 실행할 때 사용함
• @ForeignKey
      - 엔티티 간의 외래 키 관계를 정의할 때 사용함
      - 참조 무결성을 유지하는 데 도움을 줌
• @Index
      - 특정 컬럼에 인덱스를 생성할 때 사용함
      - 쿼리 성능을 향상시키는 데 유용함

 

 

11) Room 예제

 

build.gradle(:app)

plugins {
    alias(libs.plugins.androidApplication)
    alias(libs.plugins.jetbrainsKotlinAndroid)
    kotlin("kapt")
}

android {
    namespace = "com.limheejin.test"
    compileSdk = 34

    defaultConfig {
        applicationId = "com.limheejin.test"
        minSdk = 26
        targetSdk = 34
        versionCode = 1
        versionName = "1.0"

        testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
    }

    buildTypes {
        release {
            isMinifyEnabled = false
            proguardFiles(
                getDefaultProguardFile("proguard-android-optimize.txt"),
                "proguard-rules.pro"
            )
        }
    }
    compileOptions {
        sourceCompatibility = JavaVersion.VERSION_1_8
        targetCompatibility = JavaVersion.VERSION_1_8
    }
    kotlinOptions {
        jvmTarget = "1.8"
    }

    buildFeatures {
        viewBinding = true
    }
}

dependencies {
    implementation(libs.androidx.core.ktx)
    implementation(libs.androidx.appcompat)
    implementation(libs.material)
    implementation(libs.androidx.activity)
    implementation(libs.androidx.constraintlayout)
    testImplementation(libs.junit)
    androidTestImplementation(libs.androidx.junit)
    androidTestImplementation(libs.androidx.espresso.core)

    val room_version = "2.6.1"
    implementation("androidx.room:room-runtime:$room_version")
    annotationProcessor("androidx.room:room-compiler:$room_version")
    kapt("androidx.room:room-compiler:$room_version")
    implementation("androidx.room:room-ktx:$room_version")
    testImplementation("androidx.room:room-testing:$room_version")
}

 

 

activity_main.xml

<?xml version="1.0" encoding="utf-8"?>
<androidx.constraintlayout.widget.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:padding="5dp"
    tools:context=".MainActivity">

    <EditText
        android:id="@+id/edit_student_id"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:ems="10"
        android:hint="ID"
        android:inputType="number"
        app:layout_constraintEnd_toStartOf="@+id/query_student"
        app:layout_constraintHorizontal_bias="0.5"
        app:layout_constraintHorizontal_chainStyle="spread_inside"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintTop_toTopOf="parent" />

    <EditText
        android:id="@+id/edit_student_name"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:ems="10"
        android:hint="student name"
        android:inputType="textPersonName"
        app:layout_constraintEnd_toStartOf="@+id/add_student"
        app:layout_constraintHorizontal_bias="0.5"
        app:layout_constraintHorizontal_chainStyle="spread_inside"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintTop_toBottomOf="@+id/edit_student_id" />

    <Button
        android:id="@+id/add_student"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Add Student"
        app:layout_constraintEnd_toEndOf="parent"
        app:layout_constraintHorizontal_bias="0.5"
        app:layout_constraintStart_toEndOf="@+id/edit_student_name"
        app:layout_constraintTop_toBottomOf="@+id/query_student" />

    <Button
        android:id="@+id/query_student"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Query Student"
        app:layout_constraintEnd_toEndOf="parent"
        app:layout_constraintHorizontal_bias="0.5"
        app:layout_constraintStart_toEndOf="@+id/edit_student_id"
        app:layout_constraintTop_toTopOf="parent" />

    <TextView
        android:id="@+id/textView"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_marginTop="16dp"
        android:text="Result of Query Student"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintTop_toBottomOf="@+id/edit_student_name" />

    <TextView
        android:id="@+id/textView2"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_marginTop="24dp"
        android:text="Student List"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintTop_toBottomOf="@+id/text_query_student" />

    <TextView
        android:id="@+id/text_query_student"
        android:layout_width="0dp"
        android:layout_height="100sp"
        app:layout_constraintEnd_toEndOf="parent"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintTop_toBottomOf="@+id/textView" />

    <TextView
        android:id="@+id/text_student_list"
        android:layout_width="0dp"
        android:layout_height="0dp"
        android:layout_marginBottom="8dp"
        app:layout_constraintBottom_toBottomOf="parent"
        app:layout_constraintEnd_toEndOf="parent"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintTop_toBottomOf="@+id/textView2" />

</androidx.constraintlayout.widget.ConstraintLayout>

 

MyEntity

package com.limheejin.test

import androidx.room.ColumnInfo
import androidx.room.Entity
import androidx.room.PrimaryKey

@Entity(tableName = "student_table")
data class Student(
    @PrimaryKey @ColumnInfo(name = "student_id") val id: Int,
    val name: String
)

 

MyDatabase.kt

package com.limheejin.test

import android.content.Context
import androidx.room.Database
import androidx.room.Room
import androidx.room.RoomDatabase
import androidx.room.migration.Migration
import androidx.sqlite.db.SupportSQLiteDatabase

@Database(entities = [Student::class], exportSchema = false, version = 1)
abstract class MyDatabase : RoomDatabase() {
    abstract fun getMyDao(): MyDAO

    companion object {
        private var INSTANCE: MyDatabase? = null
        private val MIGRATION_1_2 = object : Migration(1, 2) {
            override fun migrate(db: SupportSQLiteDatabase) {
            }
        }

        private val MIGRATION_2_3 = object : Migration(2, 3) {
            override fun migrate(db: SupportSQLiteDatabase) {
                db.execSQL("ALTER TABLE student_table ADD COLUMN last_update INTEGER")
            }
        }

        fun getDatabase(context: Context): MyDatabase {
            if (INSTANCE == null) {
                INSTANCE = Room.databaseBuilder(
                    context, MyDatabase::class.java, "school_database"
                )
                    .addMigrations(MIGRATION_1_2, MIGRATION_2_3)
                    .build()
                // for in-memory database
                /*INSTANCE = Room.inMemoryDatabaseBuilder(
                    context, MyDatabase::class.java
                ).build()*/
            }
            return INSTANCE as MyDatabase
        }
    }
}

 

MyDao

package com.limheejin.test

import androidx.lifecycle.LiveData
import androidx.room.Dao
import androidx.room.Delete
import androidx.room.Insert
import androidx.room.OnConflictStrategy
import androidx.room.Query

@Dao
interface MyDAO {
    @Insert(onConflict = OnConflictStrategy.REPLACE) // INSERT, key 충돌이 나면 새 데이터로 교체
    suspend fun insertStudent(student: Student) // suspend는 코루틴을 사용하는 것 (라이브데이터의 경우 필요 없음)

    @Query("SELECT * FROM student_table")
    fun getAllStudents(): LiveData<List<Student>> // LiveData<> 사용

    @Query("SELECT * FROM student_table WHERE name = :sname") // 메소드 인자를 SQL문에서 :를 붙여 사용
    suspend fun getStudentByName(sname: String): List<Student>

    @Delete
    suspend fun deleteStudent(student: Student);

}

 

MainActivity.kt

package com.limheejin.test

import android.os.Bundle
import android.widget.Toast
import androidx.activity.enableEdgeToEdge
import androidx.appcompat.app.AppCompatActivity
import androidx.core.view.ViewCompat
import androidx.core.view.WindowInsetsCompat
import com.limheejin.test.databinding.ActivityMainBinding
import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.launch
import kotlinx.coroutines.withContext

class MainActivity : AppCompatActivity() {
    private val binding by lazy { ActivityMainBinding.inflate(layoutInflater) }
    lateinit var myDao: MyDAO

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(binding.root)

        myDao = MyDatabase.getDatabase(this).getMyDao()

        val allStudents = myDao.getAllStudents()
        allStudents.observe(this) {
            val str = StringBuilder().apply {
                for ((id, name) in it) {
                    append(id)
                    append("-")
                    append(name)
                    append("\n")
                }
            }.toString()
            binding.textStudentList.text = str
        }

        binding.addStudent.setOnClickListener {
            val id = binding.editStudentId.text.toString().toInt()
            val name = binding.editStudentName.text.toString()
            if (id > 0 && name.isNotEmpty()) {
                CoroutineScope(Dispatchers.IO).launch {
                    myDao.insertStudent(Student(id, name))
                }
            }
            binding.editStudentId.text = null
            binding.editStudentName.text = null
        }

        binding.queryStudent.setOnClickListener {
            val name = binding.editStudentName.text.toString()
            CoroutineScope(Dispatchers.IO).launch {
                val results = myDao.getStudentByName(name)
                if (results.isNotEmpty()) {
                    val str = StringBuilder().apply {
                        results.forEach { student ->
                            append(student.id)
                            append("-")
                            append(student.name)
                        }
                    }
                    withContext(Dispatchers.Main) {
                        binding.textQueryStudent.text = str
                    }
                } else {
                    withContext(Dispatchers.Main) {
                        binding.textQueryStudent.text = ""
                    }
                }
            }
        }
    }
}

 

 

 

App Insepection에서 저장한 Room 데이터 확인 가능