KotlinでRoomを活用するためのデータベース操作ベストプラクティス

KotlinでAndroidアプリ開発を行う際、効率的なデータベース操作は不可欠です。Googleが提供するRoomライブラリは、SQLiteを簡単かつ安全に扱える抽象化レイヤーであり、煩雑なデータベース処理を大幅に効率化します。Roomを使うことで、コンパイル時のクエリ検証、LiveDataやFlowによるリアルタイムデータ更新、シンプルなDAO（データアクセスオブジェクト）の作成が可能になります。

本記事では、KotlinにおけるRoomを使ったデータベース操作のベストプラクティスについて詳しく解説します。Roomのセットアップ方法から、エンティティ設計、効率的なクエリの記述、変更監視、テストの方法まで、実践的な内容をステップごとに説明します。これにより、安定したデータベース機能を備えたAndroidアプリを効率的に開発するスキルが身につきます。

Roomデータベースとは？

RoomはGoogleが提供するAndroid向けのデータベースライブラリで、SQLiteをより簡単かつ安全に扱うための抽象化レイヤーです。Roomを利用することで、SQLクエリの記述やデータベース操作がシンプルになり、コードの可読性と保守性が向上します。

Roomの特徴

コンパイル時のSQLクエリ検証
クエリ文が正しく記述されているかをコンパイル時に検証し、エラーを早期に発見できます。
アノテーションによるシンプルな構成
エンティティ、DAO、データベースのクラスをアノテーションで簡単に定義できます。
LiveDataやFlowとの連携
データベースの変更をリアルタイムにUIに反映することが可能です。
RxJavaやCoroutinesのサポート
非同期処理やリアクティブプログラミングと組み合わせてデータ操作を効率化できます。

Roomの主な構成要素

エンティティ（Entity）：テーブルに対応するデータクラス。
DAO（Data Access Object）：データベース操作を定義するインターフェース。
データベースクラス：データベースのインスタンスを生成し、DAOにアクセスするためのクラス。

Roomを導入することで、従来のSQLite操作に比べて効率的かつエラーの少ないデータベース管理が可能になります。

Roomのセットアップ方法

KotlinでRoomを利用するには、プロジェクトへの依存関係の追加や必要なクラスの準備が必要です。以下の手順でRoomのセットアップを行いましょう。

1. 依存関係の追加

build.gradle.ktsファイルにRoomの依存関係を追加します。

dependencies {
    val roomVersion = "2.6.1"

    implementation("androidx.room:room-runtime:$roomVersion")
    kapt("androidx.room:room-compiler:$roomVersion")
    implementation("androidx.room:room-ktx:$roomVersion")
}

注：kaptはKotlinのアノテーション処理用です。Kotlinプロジェクトでは必須です。

2. Kotlin Kaptプラグインの適用

build.gradle.ktsのpluginsブロックにKaptを追加します。

plugins {
    kotlin("kapt")
}

3. エンティティクラスの作成

データベースのテーブルを表すエンティティクラスを作成します。

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

@Entity(tableName = "users")
data class User(
    @PrimaryKey val id: Int,
    val name: String,
    val email: String
)

4. DAOの作成

データアクセスオブジェクト（DAO）を作成し、データ操作のメソッドを定義します。

import androidx.room.Dao
import androidx.room.Insert
import androidx.room.Query

@Dao
interface UserDao {
    @Insert
    suspend fun insert(user: User)

    @Query("SELECT * FROM users WHERE id = :id")
    suspend fun getUserById(id: Int): User?
}

5. データベースクラスの作成

データベースクラスを作成し、エンティティとDAOを紐づけます。

import androidx.room.Database
import androidx.room.RoomDatabase

@Database(entities = [User::class], version = 1)
abstract class AppDatabase : RoomDatabase() {
    abstract fun userDao(): UserDao
}

6. データベースインスタンスの取得

アプリケーションクラスやSingletonでデータベースインスタンスを作成します。

import android.content.Context
import androidx.room.Room

object DatabaseProvider {
    private var INSTANCE: AppDatabase? = null

    fun getDatabase(context: Context): AppDatabase {
        return INSTANCE ?: synchronized(this) {
            val instance = Room.databaseBuilder(
                context.applicationContext,
                AppDatabase::class.java,
                "app_database"
            ).build()
            INSTANCE = instance
            instance
        }
    }
}

Roomのセットアップが完了しました。これでKotlinアプリ内でデータベース操作ができる準備が整いました。

DAO（データアクセスオブジェクト）の作成

DAO（Data Access Object）は、Roomでデータベース操作を行うためのインターフェースです。SQLクエリをメソッドに関連付け、データの挿入、更新、削除、検索などの操作を定義します。RoomはDAOを通してSQLiteクエリを実行します。

DAOの基本構成

DAOはインターフェースまたは抽象クラスとして定義し、アノテーションを用いてクエリを指定します。主なアノテーションには以下のものがあります。

@Insert：データを挿入
@Update：データを更新
@Delete：データを削除
@Query：カスタムSQLクエリの実行

シンプルなDAOの作成例

エンティティ User に対するデータ操作を定義するDAOの例です。

import androidx.room.*

@Dao
interface UserDao {

    // データの挿入
    @Insert
    suspend fun insertUser(user: User)

    // データの更新
    @Update
    suspend fun updateUser(user: User)

    // データの削除
    @Delete
    suspend fun deleteUser(user: User)

    // IDによるユーザー取得
    @Query("SELECT * FROM users WHERE id = :id")
    suspend fun getUserById(id: Int): User?

    // すべてのユーザーを取得
    @Query("SELECT * FROM users")
    suspend fun getAllUsers(): List<User>
}

クエリの記述におけるポイント

パラメータの指定
:id のように、パラメータをSQLクエリ内で指定し、メソッド引数と関連付けます。
戻り値の型

単一のデータ：User?
リスト：List<User>
LiveDataやFlowを使用したリアルタイム取得も可能です。

LiveDataやFlowの活用

データの変更をリアルタイムで監視するには、LiveDataやFlowを戻り値に指定します。

@Query("SELECT * FROM users")
fun getAllUsersLiveData(): LiveData<List<User>>

@Query("SELECT * FROM users")
fun getAllUsersFlow(): Flow<List<User>>

複雑なクエリの例

複数条件でデータを取得するクエリも簡単に定義できます。

@Query("SELECT * FROM users WHERE name LIKE :name AND email LIKE :email")
suspend fun findUsersByNameAndEmail(name: String, email: String): List<User>

DAOのベストプラクティス

シンプルで責務が明確なメソッドを定義する。
非同期処理には suspend キーワードや Flow を活用する。
クエリの検証はRoomがコンパイル時に行うため、エラーを早期に発見できる。

DAOを適切に設計することで、データベース操作が効率的かつ安全になります。

エンティティの設計

エンティティ（Entity）は、Roomでデータベースのテーブルに対応するデータクラスです。エンティティを設計することで、データベース内のデータ構造を定義し、Roomが自動的にSQLテーブルを作成します。

エンティティの基本構成

エンティティクラスには、@Entityアノテーションを使用し、フィールドには適切なアノテーションを付けます。

@Entity：クラスをテーブルとして定義
@PrimaryKey：主キーを指定
@ColumnInfo：カラム名や属性を指定（省略可能）
@Ignore：データベースに含めないフィールドを指定

シンプルなエンティティの例

ユーザー情報を格納するUserエンティティの例です。

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

@Entity(tableName = "users")
data class User(
    @PrimaryKey(autoGenerate = true) val id: Int,
    @ColumnInfo(name = "user_name") val name: String,
    @ColumnInfo(name = "email") val email: String,
    val age: Int
)

各アノテーションの解説

@PrimaryKey(autoGenerate = true)
主キーとして設定し、自動的にIDを生成します。
@ColumnInfo(name = “user_name”)
データベースのカラム名を指定します。変数名と異なる名前を付けたい場合に使用します。
省略可能なフィールド
ageのように、特別な指定がない場合は、変数名がそのままカラム名になります。

エンティティの高度な設計

Roomでは、複数のエンティティ間でリレーション（関連付け）を構築できます。

@Entity(tableName = "posts")
data class Post(
    @PrimaryKey(autoGenerate = true) val postId: Int,
    val userId: Int, // UserエンティティのIDと関連付け
    val content: String
)

データ型と注意点

Roomは一般的なデータ型をサポートしていますが、サポートされていない型を扱う場合は型変換が必要です。

サポートされる型：Int, String, Boolean, Double, Float, Long, ByteArray
型変換（Type Converter）を使ってカスタム型をサポートできます。

import androidx.room.TypeConverter
import java.util.Date

class Converters {
    @TypeConverter
    fun fromTimestamp(value: Long?): Date? {
        return value?.let { Date(it) }
    }

    @TypeConverter
    fun dateToTimestamp(date: Date?): Long? {
        return date?.time
    }
}

データベースクラスに型変換を登録します。

@Database(entities = [User::class, Post::class], version = 1)
@TypeConverters(Converters::class)
abstract class AppDatabase : RoomDatabase() {
    abstract fun userDao(): UserDao
    abstract fun postDao(): PostDao
}

エンティティ設計のベストプラクティス

正規化を意識する：データの重複を避け、効率的な設計を行う。
主キーの自動生成を活用する：一意性を保ちやすくする。
カラム名を明確にする：わかりやすいカラム名を指定することで保守性を向上させる。
型変換を活用する：Dateやリストなど、サポート外の型にはType Converterを適用する。

エンティティを適切に設計することで、Roomを用いたデータベース操作が効率的かつシンプルになります。

クエリの記述と最適化

Roomを使用する際、効率的なクエリの記述はデータベースパフォーマンスに大きな影響を与えます。Roomでは、SQLクエリを@Queryアノテーションを使用して記述し、コンパイル時に検証されるため、安全性が高まります。

基本的なクエリの記述

以下は、基本的なCRUD操作を行うクエリの例です。

import androidx.room.*

@Dao
interface UserDao {

    // すべてのユーザーを取得する
    @Query("SELECT * FROM users")
    suspend fun getAllUsers(): List<User>

    // IDに基づいて特定のユーザーを取得する
    @Query("SELECT * FROM users WHERE id = :userId")
    suspend fun getUserById(userId: Int): User?

    // 名前でユーザーを検索する
    @Query("SELECT * FROM users WHERE name LIKE :name")
    suspend fun getUsersByName(name: String): List<User>

    // ユーザー数をカウントする
    @Query("SELECT COUNT(*) FROM users")
    suspend fun getUserCount(): Int
}

クエリ最適化のポイント

データベースのパフォーマンスを向上させるために、以下の最適化ポイントを考慮しましょう。

1. 必要なカラムのみを取得する

すべてのカラムを取得するのではなく、必要なカラムだけを取得することでクエリの効率が向上します。

@Query("SELECT name, email FROM users")
suspend fun getUserNamesAndEmails(): List<UserSummary>

data class UserSummary(
    val name: String,
    val email: String
)

2. インデックスを活用する

検索やソートが頻繁に行われるカラムにインデックスを設定すると、クエリのパフォーマンスが向上します。

@Entity(tableName = "users", indices = [Index(value = ["email"], unique = true)])
data class User(
    @PrimaryKey(autoGenerate = true) val id: Int,
    val name: String,
    val email: String
)

3. LIMITとOFFSETの使用

大量のデータを取得する際には、LIMITとOFFSETを使用してデータの読み込みを制限しましょう。

@Query("SELECT * FROM users LIMIT :limit OFFSET :offset")
suspend fun getUsersWithPagination(limit: Int, offset: Int): List<User>

4. トランザクションの利用

複数の操作を一括で実行する場合、トランザクションを使用するとデータ整合性が保たれます。

@Transaction
suspend fun insertAndDeleteUser(newUser: User, userToDelete: User) {
    insertUser(newUser)
    deleteUser(userToDelete)
}

非同期クエリの活用

Roomは、suspend関数やFlowをサポートしており、非同期でデータベース操作を実行できます。

@Query("SELECT * FROM users")
fun getAllUsersFlow(): Flow<List<User>>

複雑なクエリの例

複数条件の検索や結合クエリもRoomで簡単に記述できます。

@Query("""
    SELECT * FROM users 
    WHERE age > :minAge AND email LIKE :emailDomain
    ORDER BY name ASC
""")
suspend fun getUsersByAgeAndEmailDomain(minAge: Int, emailDomain: String): List<User>

クエリのベストプラクティス

カラムの選択を最小限にする：必要なデータだけを取得する。
インデックスを適切に設定する：検索が速くなる。
トランザクションを使う：複数操作を安全に実行する。
非同期処理を活用する：UIスレッドのブロックを避ける。

効率的なクエリの記述と最適化を行うことで、Roomを用いたデータベース操作のパフォーマンスと信頼性が向上します。

LiveDataとFlowの活用

Roomデータベースと組み合わせることで、LiveDataやFlowを使用してリアルタイムにデータの変更を監視し、UIに反映することができます。これにより、データが変更されるたびにUIが自動的に更新されるため、効率的なデータ操作が可能です。

LiveDataとは？

LiveDataは、Androidアプリでよく使われるライフサイクル対応のデータホルダーです。データの変更を監視し、ライフサイクルに合わせてUIを更新するため、メモリリークを防ぐことができます。

LiveDataの使用例

1. DAOでLiveDataを戻り値として使用する：

@Dao
interface UserDao {
    @Query("SELECT * FROM users")
    fun getAllUsersLiveData(): LiveData<List<User>>
}

2. ViewModelでLiveDataを取得する：

class UserViewModel(private val userDao: UserDao) : ViewModel() {
    val allUsers: LiveData<List<User>> = userDao.getAllUsersLiveData()
}

3. UIでLiveDataを監視し、RecyclerViewを更新する：

userViewModel.allUsers.observe(viewLifecycleOwner) { users ->
    adapter.submitList(users)
}

Flowとは？

Flowは、Kotlin Coroutinesで提供される非同期データストリームです。LiveDataと似ていますが、Flowはバックグラウンドスレッドで動作し、より柔軟な操作が可能です。

Flowの使用例

1. DAOでFlowを戻り値として使用する：

@Dao
interface UserDao {
    @Query("SELECT * FROM users")
    fun getAllUsersFlow(): Flow<List<User>>
}

2. ViewModelでFlowを取得し、StateFlowに変換する：

class UserViewModel(private val userDao: UserDao) : ViewModel() {
    val allUsers: StateFlow<List<User>> = userDao.getAllUsersFlow()
        .stateIn(viewModelScope, SharingStarted.WhileSubscribed(), emptyList())
}

3. UIでFlowを収集して表示する：

lifecycleScope.launch {
    userViewModel.allUsers.collect { users ->
        adapter.submitList(users)
    }
}

LiveDataとFlowの比較

特性	LiveData	Flow
ライフサイクル対応	対応	非対応（`lifecycleScope`が必要）
スレッド	メインスレッド	バックグラウンドスレッド
非同期処理	不可	可能
リアルタイムデータ	可能	可能
コレクション操作	非対応	高度な操作が可能

ベストプラクティス

UIのライフサイクルに連動する場合は、LiveDataを使用する。
バックグラウンド処理や複雑なデータ操作が必要な場合は、Flowを使用する。
StateFlowやSharedFlowを活用すると、Flowの状態管理やデータ共有が効率的になる。
UIスレッドで重い処理を避けるために、FlowのflowOn(Dispatchers.IO)を活用する。

LiveDataとFlowを効果的に使い分けることで、Roomと連携したリアルタイムデータ管理がスムーズになり、ユーザー体験を向上させることができます。

変更監視とトランザクション処理

Roomデータベースでは、データ変更の監視やトランザクション処理を活用することで、データの一貫性と整合性を保つことができます。適切に変更を監視し、トランザクションを管理することで、効率的で信頼性の高いデータベース操作が可能になります。

変更監視の仕組み

RoomはLiveDataやFlowを使用してデータベースの変更を監視し、リアルタイムでUIに反映します。

LiveDataでの変更監視

LiveDataを使うと、データが変更されるたびにUIが自動的に更新されます。

DAOでLiveDataを返すメソッド：

@Dao
interface UserDao {
    @Query("SELECT * FROM users")
    fun getAllUsersLiveData(): LiveData<List<User>>
}

ViewModelとUIでの監視：

class UserViewModel(private val userDao: UserDao) : ViewModel() {
    val allUsers: LiveData<List<User>> = userDao.getAllUsersLiveData()
}

userViewModel.allUsers.observe(viewLifecycleOwner) { users ->
    adapter.submitList(users)
}

Flowでの変更監視

Flowを使うと、非同期処理やバックグラウンドスレッドでの変更監視が可能です。

DAOでFlowを返すメソッド：

@Dao
interface UserDao {
    @Query("SELECT * FROM users")
    fun getAllUsersFlow(): Flow<List<User>>
}

ViewModelとUIでの監視：

class UserViewModel(private val userDao: UserDao) : ViewModel() {
    val allUsers: Flow<List<User>> = userDao.getAllUsersFlow()
}

lifecycleScope.launch {
    userViewModel.allUsers.collect { users ->
        adapter.submitList(users)
    }
}

トランザクション処理の活用

トランザクションは、複数のデータベース操作を一括して安全に実行するための仕組みです。操作がすべて成功した場合にのみコミットされ、エラーが発生した場合はロールバックされます。

トランザクションの定義

@TransactionアノテーションをDAOのメソッドに付けることで、トランザクション処理が可能です。

例：ユーザーの挿入と削除を一括で行うトランザクション処理

@Dao
interface UserDao {
    @Insert
    suspend fun insertUser(user: User)

    @Delete
    suspend fun deleteUser(user: User)

    @Transaction
    suspend fun replaceUser(oldUser: User, newUser: User) {
        deleteUser(oldUser)
        insertUser(newUser)
    }
}

トランザクションを使う理由

一貫性の保証：すべての操作が成功した場合にのみデータが変更される。
エラー処理：途中でエラーが発生した場合、自動的にロールバックされる。
データの整合性：複数の変更を一度に適用するため、データの整合性が保たれる。

複数テーブルにまたがる操作

トランザクションを使用して、複数のテーブルに対して一括で変更を加えることができます。

例：ユーザーとその投稿を同時に削除

@Dao
interface UserDao {
    @Delete
    suspend fun deleteUser(user: User)
}

@Dao
interface PostDao {
    @Query("DELETE FROM posts WHERE userId = :userId")
    suspend fun deletePostsByUserId(userId: Int)
}

@Transaction
suspend fun deleteUserAndPosts(user: User, userDao: UserDao, postDao: PostDao) {
    postDao.deletePostsByUserId(user.id)
    userDao.deleteUser(user)
}

ベストプラクティス

一括操作にはトランザクションを使用する：データの整合性を確保するため。
変更監視にはLiveDataまたはFlowを活用する：リアルタイムでUIを更新。
エラーハンドリングを適切に行う：トランザクション内で例外が発生した場合に備える。

変更監視とトランザクション処理を効果的に活用することで、Roomを使ったデータベース操作が安全で効率的になります。

テストとデバッグのベストプラクティス

Roomデータベースを使用する際、適切なテストとデバッグを行うことで、バグを早期に発見し、信頼性の高いアプリを構築できます。ここでは、Roomのテスト方法とデバッグのベストプラクティスを紹介します。

Unitテストのセットアップ

Roomのテストは、JUnitやAndroidX Testライブラリを使用して行います。テスト用のデータベースは、inMemoryDatabaseBuilderを使用してメモリ上に作成することで、ディスクへの永続化を防ぎます。

依存関係の追加（build.gradle.kts）：

dependencies {
    testImplementation("junit:junit:4.13.2")
    androidTestImplementation("androidx.test.ext:junit:1.1.5")
    androidTestImplementation("androidx.test.espresso:espresso-core:3.5.1")
    androidTestImplementation("androidx.room:room-testing:2.6.1")
}

Roomデータベースのテスト例

1. テスト用データベースの作成：

import androidx.room.Room
import androidx.test.core.app.ApplicationProvider
import org.junit.After
import org.junit.Before
import org.junit.Test

class UserDaoTest {

    private lateinit var db: AppDatabase
    private lateinit var userDao: UserDao

    @Before
    fun setUp() {
        db = Room.inMemoryDatabaseBuilder(
            ApplicationProvider.getApplicationContext(),
            AppDatabase::class.java
        ).build()
        userDao = db.userDao()
    }

    @After
    fun tearDown() {
        db.close()
    }
}

2. CRUD操作のテスト：

@Test
fun insertAndRetrieveUser() = runBlocking {
    val user = User(id = 1, name = "John Doe", email = "john@example.com", age = 30)
    userDao.insertUser(user)

    val retrievedUser = userDao.getUserById(1)
    assertEquals("John Doe", retrievedUser?.name)
}

LiveDataのテスト

LiveDataをテストするには、getOrAwaitValueという拡張関数を作成すると便利です。

fun <T> LiveData<T>.getOrAwaitValue(): T {
    var data: T? = null
    val latch = CountDownLatch(1)
    val observer = Observer<T> {
        data = it
        latch.countDown()
    }
    this.observeForever(observer)
    latch.await()
    return data as T
}

LiveDataのテスト例：

@Test
fun getAllUsersLiveData() = runBlocking {
    val user = User(id = 1, name = "Jane Doe", email = "jane@example.com", age = 25)
    userDao.insertUser(user)

    val users = userDao.getAllUsersLiveData().getOrAwaitValue()
    assertEquals(1, users.size)
    assertEquals("Jane Doe", users[0].name)
}

デバッグのベストプラクティス

1. SQLクエリのログを有効にする

RoomのSQLクエリをログに出力することで、クエリの実行状況やエラーを確認できます。

ログの有効化：

val db = Room.databaseBuilder(context, AppDatabase::class.java, "app_database")
    .setQueryCallback(RoomDatabase.QueryCallback { sql, args ->
        Log.d("RoomQuery", "SQL: $sql Args: $args")
    }, Executors.newSingleThreadExecutor())
    .build()

2. データベースインスペクタの活用

Android StudioのDatabase Inspectorを使用すると、アプリのデータベースの中身をリアルタイムで確認し、クエリの実行結果を調査できます。

使い方：

Android Studioのメニューから View → Tool Windows → App Inspection を選択。
Database Inspector タブを開き、アプリのデータベースを確認。

3. エラーメッセージの確認

Roomで発生するエラーのスタックトレースを確認し、クエリの文法エラーやデータ型の不一致を特定します。

4. テストを定期的に実行する

CI/CDパイプラインにUnitテストを組み込んで、変更ごとにテストを自動で実行し、リグレッションを防ぎましょう。

ベストプラクティスのまとめ

inMemoryデータベースを使用してテストを高速化。
LiveDataやFlowのテストに拡張関数を活用。
SQLクエリのログ出力を有効化し、デバッグを効率化。
Database Inspectorでデータベースの状態を可視化。
定期的にテストを実行し、品質を維持。

テストとデバッグを適切に行うことで、Roomデータベースの信頼性とパフォーマンスを向上させることができます。

まとめ

本記事では、KotlinにおけるRoomを利用したデータベース操作のベストプラクティスについて解説しました。Roomの概要からセットアップ方法、DAOの作成、エンティティ設計、効率的なクエリの記述、LiveDataやFlowを活用した変更監視、トランザクション処理、そしてテストとデバッグの手法まで、実践的な内容を網羅しました。

Roomを適切に活用することで、SQLiteをより安全かつ効率的に操作でき、データの整合性を保ちながらリアルタイムにUIへ反映することが可能です。これにより、Kotlinを使ったAndroidアプリ開発の質が向上し、メンテナンス性やパフォーマンスも高まります。

ベストプラクティスを習得し、Roomを使ったデータベース操作をマスターすることで、より堅牢で効率的なアプリケーションを開発できるでしょう。

KotlinでRoomを活用するためのデータベース操作ベストプラクティス

Roomデータベースとは？

Roomの特徴

Roomの主な構成要素

Roomのセットアップ方法

1. 依存関係の追加

2. Kotlin Kaptプラグインの適用

3. エンティティクラスの作成

4. DAOの作成

5. データベースクラスの作成

6. データベースインスタンスの取得

DAO（データアクセスオブジェクト）の作成

DAOの基本構成

シンプルなDAOの作成例

クエリの記述におけるポイント

LiveDataやFlowの活用

複雑なクエリの例

DAOのベストプラクティス

エンティティの設計

エンティティの基本構成

シンプルなエンティティの例

各アノテーションの解説

エンティティの高度な設計

データ型と注意点

エンティティ設計のベストプラクティス

クエリの記述と最適化

基本的なクエリの記述

クエリ最適化のポイント

1. 必要なカラムのみを取得する

2. インデックスを活用する

3. LIMITとOFFSETの使用

4. トランザクションの利用

非同期クエリの活用

複雑なクエリの例

クエリのベストプラクティス

LiveDataとFlowの活用

LiveDataとは？

LiveDataの使用例

Flowとは？

Flowの使用例

LiveDataとFlowの比較

ベストプラクティス

変更監視とトランザクション処理

変更監視の仕組み

LiveDataでの変更監視

Flowでの変更監視

トランザクション処理の活用

トランザクションの定義

トランザクションを使う理由

複数テーブルにまたがる操作

ベストプラクティス

テストとデバッグのベストプラクティス

Unitテストのセットアップ

Roomデータベースのテスト例

LiveDataのテスト

デバッグのベストプラクティス

1. SQLクエリのログを有効にする

2. データベースインスペクタの活用

3. エラーメッセージの確認

4. テストを定期的に実行する

ベストプラクティスのまとめ

まとめ

コメント

コメントする コメントをキャンセル

コメントするコメントをキャンセル