[Kotlin][Android] 안드로이드 Room의 사용방법에 대해서

안녕하세요 👋

오늘은 안드로이드 Room의 사용법에 대해서 포스팅해보려 합니다.

---

Room이란?

스마트폰 내장 DB에 데이터를 저장하기 위해 사용하는 라이브러리로

ORM(Object Relational Mapping)라이브러리입니다.

Room은 DB 데이터를 Java 또는 코틀린 객체로 매핑해주며,

SQLite를 내부적으로 사용함으로써 DB를 구조적으로 분리하고

데이터 접근의 편의성을 높여주어 유지보수를 편리하게 해 줍니다.

---

Room의 구조에 대해서

room의 구조는 크게 

Database , DAO , Entity로 나눌 수 있습니다.

아래는 Room의 구조이며 각각에 대해 설명하도록 하겠습니다.

Room의 구조

 

Entity(엔티티)

DB 내의 Table로 class의 변수들이 칼럼(column)이 되어 Table이 생성됩니다.

Annotation	설명	사용법
@Entity	Table 이름을 선언합니다.	@Entity(tableName = StudentEntry.TABLE_NAME)
@PrimaryKey	해당 property를 primaryKey로 지정합니다.
@ColumnInfo	Table 내 column 을 변수와 매칭 시켜줍니다.

 

DAO(Data Access Object)

데이터베이스에 접근하여 수행할 작업을 메소드 형태로 정의하는 class입니다.(SQL 쿼리도 지정 가능)

 

Annotation	설명
@Insert	Entity를 set하는 함수 또는 메소드를 정의합니다. @Entity로 정의된 class만 인자로 받거나, 그 class의 collection 또는 array 만 인자로 받을 수 있습니다.
@Update	Entity를 update하는 함수 또는 메소드를 정의합니다.
@Delete	Entity를 delete하는 함수 또는 메소드를 정의합니다.
@Query	선언된 query를 통해 DB를 조회한 결과를 보여주는 함수 또는 메소드를 정의합니다.

 

DataBase

 데이터베이스의 전체적인 소유자 역할을 하는 추상 클래스로

RoomDB에서 DAO를 가져와서 객체를 통해 데이터를 CRUD 처리합니다.

 

속성	설명
entities	Database에 어떤 Entitiy가 있는지 명시
version	Database의 version을 나타낸다 (scheme이 바뀔때 함께 바꾸어 주어야한다.)
scheme	Room의 Schema 구조를 폴더로 Export 할 수 있는지에 대한 여부를 설정

---

이제는 예제를 통해 사용법을 알아보도록 하겠습니다. 🤔

먼저, 전반적인 RoomDB 설정부터 관련 class들을 만들겠습니다.

1. gradle을 설정해줍니다.

plugins {
    id 'com.android.application'
    id 'org.jetbrains.kotlin.android'
    id 'kotlin-kapt' // kapt를 사용하기 위해 필수 추가
}

android{
   ... 생략
    buildFeatures {
            viewBinding true
            dataBinding true
    }
}
dependencies {

    implementation 'androidx.core:core-ktx:1.9.0'
    implementation 'androidx.appcompat:appcompat:1.5.1'
    implementation 'com.google.android.material:material:1.7.0'
    implementation 'androidx.constraintlayout:constraintlayout:2.1.4'
    testImplementation 'junit:junit:4.13.2'
    androidTestImplementation 'androidx.test.ext:junit:1.1.4'
    androidTestImplementation 'androidx.test.espresso:espresso-core:3.5.0'

    //Room
    implementation 'androidx.room:room-runtime:2.4.3'
    implementation "androidx.room:room-ktx:2.4.3"
    kapt 'androidx.room:room-compiler:2.4.3'

    // Coroutine
    implementation "org.jetbrains.kotlinx:kotlinx-coroutines-android:1.6.4"
    implementation "org.jetbrains.kotlinx:kotlinx-coroutines-core:1.6.1"

}

필자는 해당 예제에서 Coroutine과 DataBinding을 사용하기 때문에 해당 부분도 함께 추가해주었습니다. 😎

 

2. Entity를 생성해줍니다.

@Entity(tableName = "user_tbl")
data class UserEntity(
    @PrimaryKey(autoGenerate = true)
    val userId: Int?,
    var userName: String,
    var userAge: Int
    )

 

3. DB를 컨트롤할 DAO interface를 만들어 줍니다.

@Dao
interface UserDao {
    @Insert // 새로운 User 생성
    suspend fun insertUser(user : UserEntity)

    @Query("SELECT * FROM user_tbl") // 모든 User 가져오기
    suspend fun getAllUser() : MutableList<User>

    @Delete // 선택한 User 삭제하기
    suspend fun deleteUser(user : UserEntity)

    @Update // 선택한 User 업데이트 하기
    suspend fun updateUser(user : UserEntity)

}

 

/**
* User정보를 가져올때 사용할 data class
**/

data class User (
    val userId : Int ,
    var userName : String ,
    var userAge : Int
) : Serializable

 

4. Application class를 생성하여 Application Context를 가져올 수 있도록 합니다.

class MainApplication : Application() {
    companion object{
        private lateinit var appInstance : MainApplication
        fun getInstance() = appInstance
    }

    override fun onCreate() {
        super.onCreate()
        appInstance = this
    }
}

 

5. RoomDB를 생성해줍니다.

@Database(entities = [UserEntity::class] , version = 1 , exportSchema = false)
abstract class UserDatabase : RoomDatabase() {
    abstract fun userDAO() : UserDao
    companion object{
        private lateinit var instance : UserDatabase
        internal fun getInstance() : UserDatabase {
            if(!::instance.isInitialized){
                synchronized(UserDatabase::class.java){
                    instance = Room.databaseBuilder(
                        MainApplication.getInstance() , 
                        // Application Context를 참조하여 앱과 생명주기를 같게 해줍니다.
                        // 즉, 해당 앱이 죽으면 instance도 사라짐
                        UserDatabase::class.java ,
                        "user.db" ,
                    ).build()
                }
            }
            return instance
        }
    }
}

 

✔️ Database를 생성하는 일은 굉장히 많은 IO가 발생하는 일이므로 싱글턴 패턴을 통해 단 한 번만 생성하도록 합니다.

---

이번에는 MVVM패턴을 통해 Room을 사용하는 전반적인 코드에 대해 

설명드리겠습니다.

---

1. MainActivity( 입력창 )

<?xml version="1.0" encoding="utf-8"?>
<layout>
    <data>
        <variable
            name="activityMainViewModel"
            type="com.lee.viewmodel.ActivityMainViewModel" />
    </data>
    <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"
        tools:context=".MainActivity">

        <LinearLayout
            android:id="@+id/userNameLayout"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:orientation="vertical"
            android:layout_marginTop="10dp"
            app:layout_constraintTop_toTopOf="parent"
            >
            <TextView
                android:layout_width="wrap_content"
                android:layout_height="wrap_content"
                android:text="이름"
                android:textSize="20sp"
                android:layout_marginStart="10dp"
                />
            <EditText
                android:id="@+id/userNameEditText"
                android:layout_width="match_parent"
                android:layout_height="50dp"
                android:layout_margin="20dp"
                android:background="@drawable/border_textview"
                android:text="@={activityMainViewModel.userName}"
                android:paddingStart="10dp"
                android:paddingEnd="0dp"
                />
        </LinearLayout>

        <LinearLayout
            android:id="@+id/userAgeLayout"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:orientation="vertical"
            android:layout_marginTop="10dp"
            app:layout_constraintTop_toBottomOf="@id/userNameLayout"
            >
            <TextView
                android:layout_width="wrap_content"
                android:layout_height="wrap_content"
                android:text="나이"
                android:textSize="20sp"
                android:layout_marginStart="10dp"
                />
            <EditText
                android:id="@+id/userAgeEditText"
                android:layout_width="match_parent"
                android:layout_height="50dp"
                android:layout_margin="20dp"
                android:background="@drawable/border_textview"
                android:text="@={activityMainViewModel.userAge}"
                android:inputType="number"
                android:paddingStart="10dp"
                android:paddingEnd="0dp"
                />
        </LinearLayout>

        <Button
            android:id="@+id/confirmButton"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:text="저장하기"
            app:layout_constraintBottom_toBottomOf="parent"
            app:layout_constraintLeft_toLeftOf="parent"
            app:layout_constraintRight_toRightOf="parent"
            android:layout_margin="10dp"
            android:onClick="@{() -> activityMainViewModel.insertUser()}"
            />

        <Button
            android:id="@+id/listButton"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            app:layout_constraintBottom_toTopOf="@id/confirmButton"
            app:layout_constraintLeft_toLeftOf="parent"
            app:layout_constraintRight_toRightOf="parent"
            android:text="목록으로"
            />

    </androidx.constraintlayout.widget.ConstraintLayout>
</layout>

class MainActivity : AppCompatActivity() {
    private lateinit var binding : ActivityMainBinding
    private lateinit var mViewModel : ActivityMainViewModel

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        binding = DataBindingUtil.setContentView(this , R.layout.activity_main)
        mViewModel = ViewModelProvider(this@MainActivity , MainViewModelFactory(MainRepository.getInstance()))[ActivityMainViewModel::class.java]
        binding.activityMainViewModel = mViewModel
        addListeners()
        observeData()
    }

    private fun addListeners() { // 리스너 추가
        with(binding){
            listButton.setOnClickListener {
                with(Intent(this@MainActivity , ListActivity::class.java)){
                    startActivity(this)
                }
            }
        }
    }

    private fun observeData() { // LiveData 관찰 함수
        with(mViewModel){
            message.observe(this@MainActivity){
                Toast.makeText(MainApplication.getInstance() , it , Toast.LENGTH_SHORT).show()
            }
        }
    }
}

 

1-1. MainActivity( 입력창 )의 ViewModel

class ActivityMainViewModel(private val repository: MainRepository) : ViewModel() {
    val userName = MutableLiveData<String>("")
    val userAge = MutableLiveData<String>("")
    val message = MutableLiveData<String>()

    fun insertUser(){ // Repository를 통해 userDAO의 insertUser를 호출한다.
        CoroutineScope(Dispatchers.IO).launch {
            val user = UserEntity(null , userName.value!! , userAge.value!!.toInt())
            repository.insertUser(user)
            CoroutineScope(Dispatchers.Main).launch {
                message.value = "정상적으로 등록되었습니다."
            }
        }
    }

    fun updateUser(user : UserEntity){ // Repository를 통해 userDAO의 updateUser를 호출한다.
        CoroutineScope(Dispatchers.IO).launch {
            with(user){
                val updateUser = UserEntity(userId , userName , userAge)
                repository.updateUser(updateUser)
                CoroutineScope(Dispatchers.Main).launch{
                    message.value = "정상적으로 업데이트 되었습니다."
                }
            }
        }
    }
}

위 ViewModel은 MainActivity와 UpdateActivity에서 함께 사용할 ViewModel입니다.

 

1-2.  ViewModel Factory 

class MainViewModelFactory(private val repository: MainRepository) : ViewModelProvider.Factory {
    override fun <T : ViewModel> create(modelClass: Class<T>): T {
        return if(modelClass.isAssignableFrom(ActivityMainViewModel::class.java)){
            ActivityMainViewModel(repository) as T
        }else if(modelClass.isAssignableFrom(ActivityListViewModel::class.java)){
           ActivityListViewModel(repository) as T
        } else {
            throw java.lang.IllegalArgumentException("해당 ViewModel을 찾을수 없습니다!")
        }
    }
}

1-3.  Repository class

class MainRepository {
    private val userDao = UserDatabase.getInstance().userDAO()
    companion object{ // Repository는 싱글턴 패턴으로 instance를 가져올것이다.
        private lateinit var instance : MainRepository
        fun getInstance() : MainRepository {
            if(!::instance.isInitialized){
                instance = MainRepository()
            }
            return instance
        }
    }

    suspend fun insertUser(user : UserEntity) = userDao.insertUser(user)

    suspend fun deleteUser(user : UserEntity) = userDao.deleteUser(user)

    suspend fun updateUser(user : UserEntity) = userDao.updateUser(user)

    suspend fun getAllUser() = userDao.getAllUser()
}

---

2.  ListActivity(User 목록 조회 페이지)

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

    <TextView
        android:id="@+id/headerTitle"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        app:layout_constraintTop_toTopOf="parent"
        android:gravity="center"
        android:text="유저목록"
        android:textSize="30sp"
        android:padding="5dp"
        />

    <androidx.recyclerview.widget.RecyclerView
        android:id="@+id/userListRecyclerView"
        android:layout_width="match_parent"
        android:layout_height="0dp"
        app:layout_constraintTop_toBottomOf="@id/headerTitle"
        app:layout_constraintBottom_toBottomOf="parent"
        app:layout_constraintLeft_toLeftOf="parent"
        app:layout_constraintRight_toRightOf="parent"
        tools:listitem="@layout/user_list_item"
        />

</androidx.constraintlayout.widget.ConstraintLayout>

private const val TAG = "ListActivity"
const val EXTRA_SELECTED_USER = "selected_user" // 선택된 User 객체를 Intent에 보낼때 사용하는 key

class ListActivity : AppCompatActivity() {
    private lateinit var binding : ActivityListBinding
    private lateinit var mRecyclerViewAdapter: UserListRecyclerViewAdapter
    private lateinit var mViewModel : ActivityListViewModel

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        binding = ActivityListBinding.inflate(layoutInflater).also {
            setContentView(it.root)
        }
        mViewModel = ViewModelProvider(this@ListActivity , MainViewModelFactory(MainRepository.getInstance()))[ActivityListViewModel::class.java]
        observeData()
        initRecyclerView()
    }

    override fun onResume() {
        super.onResume()
        mViewModel.getAllUser()
    }

    /**
    * RecyclerView 초기화
    **/
    private fun initRecyclerView() {
        mRecyclerViewAdapter = UserListRecyclerViewAdapter()
        mRecyclerViewAdapter.setOnMenuItemClickListener(PopupMenuClickListener())
        mRecyclerViewAdapter.setOnItemClickListener(UserItemClickListener())
        with(binding.userListRecyclerView){
            layoutManager = LinearLayoutManager(this@ListActivity)
            adapter = mRecyclerViewAdapter
        }
    }

    @SuppressLint("NotifyDataSetChanged")
    private fun observeData() {
        with(mViewModel){
            userList.observe(this@ListActivity){
                mRecyclerViewAdapter.setList(it)
                mRecyclerViewAdapter.notifyDataSetChanged()
            }
            message.observe(this@ListActivity){
                Toast.makeText(MainApplication.getInstance() , it , Toast.LENGTH_SHORT).show()
            }
        }
    }
	/**
    * PopupMenu 선택시 발생하는 Listener
    **/
    private inner class PopupMenuClickListener() : OnMenuItemClickListener{
        override fun onMenuItemClick(menuItem: MenuItem?): Boolean {
            when(menuItem?.itemId){
                R.id.delete -> {
                    Log.d(TAG, "onMenuItemClick: click delete")
                    val deleteUser : UserEntity
                    with(mRecyclerViewAdapter.getSelectedUser()){
                        deleteUser = UserEntity(userId , userName , userAge)
                    }
                    mViewModel.deleteSelectedUser(deleteUser)
                }
            }
            return true
        }
    }

    /**
    * RecyclerView Item 선택시 발생하는 Listener
    **/
    private inner class UserItemClickListener : UserListRecyclerViewAdapter.OnItemClickListener{
        override fun onItemClick(view: View, data: User, position: Int) {
            with(Intent(this@ListActivity , UpdateActivity::class.java)){
                putExtra(EXTRA_SELECTED_USER , data)
                startActivity(this)
            }
        }
    }
}

2-1.  ListActivity의 ViewModel

class ActivityListViewModel(private val repository: MainRepository) : ViewModel() {
    val userList = MutableLiveData<MutableList<User>>()
    val message = MutableLiveData<String>()

    fun getAllUser(){ // 모든 User 정보 가져오기
        CoroutineScope(Dispatchers.IO).launch {
            val list = repository.getAllUser()
            CoroutineScope(Dispatchers.Main).launch {
                userList.value = list
            }
        }
    }

    fun deleteSelectedUser(user : UserEntity){ // 선택된 User 삭제하기
        CoroutineScope(Dispatchers.IO).launch {
            repository.deleteUser(user)
            getAllUser()
            CoroutineScope(Dispatchers.Main).launch{
                message.value = "정상적으로 삭제 되었습니다."
            }
        }
    }
}

 

2-2.  RecyclerView를 사용하기 위한 Adapter class

class UserListRecyclerViewAdapter : RecyclerView.Adapter<UserListRecyclerViewAdapter.UserListRecyclerViewHolder>() {
    private var userList = mutableListOf<User>()
    private var mOnMenuItemClickListener : OnMenuItemClickListener? = null
    private var mOnItemClickListener : OnItemClickListener? = null
    private lateinit var mSelectedData : User
    
    /**
    * ItemClickListener를 사용하기 위해 Interface를 선언
    **/
    interface OnItemClickListener { 
        fun onItemClick(view : View, data : User , position: Int)
    }


    override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): UserListRecyclerViewHolder {
        val binding = UserListItemBinding.inflate(LayoutInflater.from(parent.context) , parent , false)
        return UserListRecyclerViewHolder(binding)
    }

    override fun onBindViewHolder(holder: UserListRecyclerViewHolder, position: Int) {
        holder.bind(userList[position])
    }

    override fun getItemCount() = userList.size

    fun setList(list : MutableList<User>){
        userList = list
    }
    
     /**
    * Menu Item 선택시 호출 될 Listener를 setting
    **/
    fun setOnMenuItemClickListener(listener: OnMenuItemClickListener){
        mOnMenuItemClickListener = listener
    }

	/**
    * RecyclierViewItem이 선택시에 호출 될 Listener를 setting
    **/
    fun setOnItemClickListener(listener: OnItemClickListener){
        mOnItemClickListener = listener
    }

    fun getSelectedUser() = mSelectedData // 선택된 Data를 ListActivityd에서 사용하기 위한 함수

    inner class UserListRecyclerViewHolder(private val binding : UserListItemBinding) : RecyclerView.ViewHolder(binding.root){
        fun bind(data : User) {
            with(binding){
                userNameTextView.text = data.userName
                userAgeTextViuew.text = data.userAge.toString()
            }
            val position = adapterPosition
            if(position != RecyclerView.NO_POSITION){
                mSelectedData = data
                itemView.setOnLongClickListener { // Long Click시에 PopupMenu를 생성
                    val popupMenu = PopupMenu(binding.root.context , it)
                    popupMenu.menuInflater.inflate(R.menu.list_menu , popupMenu.menu)
                    popupMenu.setOnMenuItemClickListener(mOnMenuItemClickListener)
                    popupMenu.show()
                    true
                }

                itemView.setOnClickListener { // 설정한 ItemClickListener를 호출
                    mOnItemClickListener?.onItemClick(it , data , position)
                }
            }
        }
    }
}

2-3.  PopupMenu에 사용할 XML 정의

<?xml version="1.0" encoding="utf-8"?>
<menu xmlns:android="http://schemas.android.com/apk/res/android">
    <item android:id="@+id/delete" android:title="삭제하기"/>
</menu>

---

3.  RecyclerView 아이템 선택 시 나타나는 UpdateActivity

class UpdateActivity : AppCompatActivity() {
    private lateinit var binding : ActivityUpdateBinding
    private lateinit var mViewModel : ActivityMainViewModel
    private var mUserInfo : User? = null

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        binding = DataBindingUtil.setContentView(this , R.layout.activity_update)
        mViewModel = ViewModelProvider(this , MainViewModelFactory(MainRepository.getInstance()))[ActivityMainViewModel::class.java]
        init()
        addListener()
        observeData()
        binding.updateActivityViewModel = mViewModel
    }
    
    /**
    * ListActivity로 부터 전달받은 User 객체를 통해 EditText의 값을 setting한다.
    **/
    private fun init() { 
        mUserInfo = intent?.extras?.getSerializable(EXTRA_SELECTED_USER) as User
        with(mViewModel){
            userName.value = mUserInfo!!.userName
            userAge.value = mUserInfo!!.userAge.toString()
        }
    }

 	
    private fun addListener() {
        /**
        * 입력된 정보에 따라 User를 update하도록 하는 동작
        **/
        binding.updateButton.setOnClickListener {
            val user = UserEntity(mUserInfo?.userId , mViewModel.userName.value!! , mViewModel.userAge.value!!.toInt())
            mViewModel.updateUser(user)
        }
    }

    private fun observeData() {
        with(mViewModel){
            message.observe(this@UpdateActivity){
                Toast.makeText(MainApplication.getInstance() , it , Toast.LENGTH_SHORT).show()
            }
        }
    }
}

✔️ 위에서 언급했듯 해당 Activity는 ActivityMain의 ViewModel을 함께 쓰도록 합니다.

 

마지막으로 전반적인 실행화면을 끝으로 포스팅을 마치도록 하겠습니다.

오늘도 즐코하세요 :)

 

시연화면