Android Kotlin Fundamentals 06.1: Создание базы данных Room

Эта кодовая лаборатория является частью курса Android Kotlin Fundamentals. Вы получите максимальную отдачу от этого курса, если будете последовательно работать с лабораториями кода. Все кодовые лаборатории курса перечислены на целевой странице кодовых лабораторий Android Kotlin Fundamentals .

Введение

В большинстве приложений есть данные, которые необходимо сохранить даже после того, как пользователь закроет приложение. Например, приложение может хранить плейлист, инвентарь игровых предметов, записи о расходах и доходах, каталог созвездий или данные о сне с течением времени. Обычно вы используете базу данных для хранения постоянных данных.

Room — это библиотека баз данных, входящая в состав Android Jetpack . Room берет на себя многие хлопоты по установке и настройке базы данных и позволяет вашему приложению взаимодействовать с базой данных с помощью обычных вызовов функций. Под капотом Room — это слой абстракции поверх базы данных SQLite. Терминология Room и синтаксис запросов для более сложных запросов соответствуют модели SQLite.

На изображении ниже показано, как база данных Room соответствует общей архитектуре, рекомендованной в этом курсе.

Что вы уже должны знать

Вы должны быть знакомы с:

  • Создание базового пользовательского интерфейса (UI) для приложения Android
  • Использование действий, фрагментов и представлений.
  • Навигация между фрагментами и использование Safe Args (плагин Gradle) для передачи данных между фрагментами.
  • Модели просмотра, фабрики моделей просмотра, а LiveData и его наблюдатели. Эти темы архитектурных компонентов рассматриваются в предыдущей кодовой лаборатории этого курса.
  • Базовое понимание баз данных SQL и языка SQLite. См. SQLite Primer для краткого обзора или переподготовки.

Что вы узнаете

  • Как создать базу данных Room и взаимодействовать с ней для сохранения данных.
  • Как создать класс данных, определяющий таблицу в базе данных.
  • Как использовать объект доступа к данным (DAO) для сопоставления функций Kotlin с SQL-запросами.
  • Как проверить, работает ли ваша база данных.

Что ты будешь делать

  • Создайте базу данных Room с интерфейсом для данных о ночном сне.
  • Протестируйте базу данных с помощью предоставленных тестов.

В этой кодовой лаборатории вы создаете часть базы данных приложения, которое отслеживает качество сна. Приложение использует базу данных для хранения данных о сне с течением времени.

Приложение имеет два экрана, представленных фрагментами, как показано на рисунке ниже.

На первом экране, показанном слева, есть кнопки для запуска и остановки отслеживания. На экране отображаются все данные о сне пользователя. Кнопка « Очистить » безвозвратно удаляет все данные, которые приложение собрало для пользователя.

Второй экран, показанный справа, предназначен для выбора оценки качества сна. В приложении рейтинг представлен в числовом виде. В целях разработки приложение показывает как значки лиц, так и их числовые эквиваленты.

Поток пользователя выглядит следующим образом:

  • Пользователь открывает приложение и видит экран отслеживания сна.
  • Пользователь нажимает кнопку « Пуск ». Это записывает время начала и отображает его. Кнопка « Пуск » отключена, а кнопка « Стоп » включена.
  • Пользователь нажимает кнопку « Стоп ». Это записывает время окончания и открывает экран качества сна.
  • Пользователь выбирает значок качества сна. Экран закроется, и на экране отслеживания отобразится время окончания сна и качество сна. Кнопка « Стоп » отключена, а кнопка « Пуск » включена. Приложение готово к другой ночи.
  • Кнопка « Очистить » активна всякий раз, когда в базе данных есть данные. Когда пользователь нажимает кнопку « Очистить », все его данные безвозвратно стираются — нет вопроса «Вы уверены?» сообщение.

Это приложение использует упрощенную архитектуру, как показано ниже в контексте полной архитектуры. Приложение использует только следующие компоненты:

  • Контроллер пользовательского интерфейса
  • Посмотреть модель и LiveData
  • База данных номеров

Шаг 1. Загрузите и запустите стартовое приложение.

  1. Загрузите приложение TrackMySleepQuality-Starter с GitHub.
  2. Создайте и запустите приложение. Приложение показывает пользовательский интерфейс для фрагмента SleepTrackerFragment , но не содержит данных. Кнопки не реагируют на нажатия.

Шаг 2. Проверьте стартовое приложение

  1. Взгляните на файлы Gradle:
  • Файл проекта Gradle
     В файле build.gradle уровня проекта обратите внимание на переменные, указывающие версии библиотек. Версии, используемые в начальном приложении, хорошо работают вместе и хорошо работают с этим приложением. К тому времени, когда вы закончите эту лабораторную работу, Android Studio может предложить вам обновить некоторые версии. Вам решать, хотите ли вы обновить или остаться с версиями, которые есть в приложении. Если вы столкнулись со «странными» ошибками компиляции, попробуйте использовать комбинацию версий библиотеки, которую использует окончательное приложение-решение .
  • Файл модуля Gradle. Обратите внимание на предоставленные зависимости для всех библиотек Android Jetpack, включая Room , и зависимости для сопрограмм.
  1. Взгляните на пакеты и пользовательский интерфейс. Приложение структурировано по функциональности. Пакет содержит файлы-заполнители, в которые вы будете добавлять код на протяжении всей серии лабораторных работ.
  • Пакет database для всего кода , относящегося к базе данных Room .
  • Пакеты sleepquality и sleeptracker содержат фрагмент, модель представления и фабрику моделей представления для каждого экрана.
  1. Взгляните на файл Util.kt , который содержит функции, помогающие отображать данные о качестве сна. Некоторый код закомментирован, потому что он ссылается на модель представления, которую вы создадите позже.
  2. Взгляните на папку androidTest ( SleepDatabaseTest.kt ). Вы будете использовать этот тест, чтобы убедиться, что база данных работает должным образом.

В Android данные представлены в классах данных, а доступ к данным и их изменение осуществляется с помощью вызовов функций. Однако в мире баз данных вам нужны сущности и запросы .

  • Сущность представляет объект или понятие и его свойства для хранения в базе данных. Класс сущностей определяет таблицу, и каждый экземпляр этого класса представляет строку в таблице. Каждое свойство определяет столбец. В вашем приложении объект будет хранить информацию о ночи сна.
  • Запрос — это запрос данных или информации из таблицы базы данных или комбинации таблиц или запрос на выполнение действия над данными. Общие запросы предназначены для получения, вставки и обновления сущностей. Например, вы можете запросить все зарегистрированные ночи сна, отсортированные по времени начала.

Room выполняет за вас всю тяжелую работу по переходу от классов данных Kotlin к сущностям, которые можно хранить в таблицах SQLite, и от объявлений функций к SQL-запросам.

Вы должны определить каждую сущность как аннотированный класс данных, а взаимодействия — как аннотированный интерфейс, объект доступа к данным (DAO) . Room использует эти аннотированные классы для создания таблиц в базе данных и запросов, которые воздействуют на базу данных.

Шаг 1. Создайте сущность SleepNight

В этой задаче вы определяете одну ночь сна как аннотированный класс данных.

Для одной ночи сна вам необходимо записать время начала, время окончания и оценку качества.

И вам нужен идентификатор, чтобы однозначно идентифицировать ночь.

  1. В пакете database найдите и откройте файл SleepNight.kt .
  2. Создайте класс данных SleepNight с параметрами для идентификатора, времени начала (в миллисекундах), времени окончания (в миллисекундах) и числовой оценки качества сна.
  • Вы должны инициализировать sleepQuality , поэтому установите для него значение -1 , указывающее, что данные о качестве не собирались.
  • Вы также должны инициализировать время окончания. Установите его на время начала, чтобы указать, что время окончания еще не записано.
data class SleepNight(
       var nightId: Long = 0L,
       val startTimeMilli: Long = System.currentTimeMillis(),
       var endTimeMilli: Long = startTimeMilli,
       var sleepQuality: Int = -1
)
  1. Перед объявлением класса аннотируйте класс данных с помощью @Entity . Назовите таблицу daily_sleep_quality_table . Аргумент для tableName является необязательным, но рекомендуется. Вы можете посмотреть другие аргументы в документации.

    При появлении запроса импортируйте Entity и все остальные аннотации из библиотеки androidx .
@Entity(tableName = "daily_sleep_quality_table")
data class SleepNight(...)
  1. Чтобы определить nightId как первичный ключ, аннотируйте свойство nightId с помощью @PrimaryKey . Установите для параметра autoGenerate значение true , чтобы Room генерировал идентификатор для каждого объекта. Это гарантирует, что идентификатор для каждой ночи уникален.
@PrimaryKey(autoGenerate = true)
var nightId: Long = 0L,...
  1. Аннотируйте оставшиеся свойства с помощью @ColumnInfo . Настройте имена свойств, используя параметры, как показано ниже.
import androidx.room.ColumnInfo
import androidx.room.Entity
import androidx.room.PrimaryKey

@Entity(tableName = "daily_sleep_quality_table")
data class SleepNight(
       @PrimaryKey(autoGenerate = true)
       var nightId: Long = 0L,

       @ColumnInfo(name = "start_time_milli")
       val startTimeMilli: Long = System.currentTimeMillis(),

       @ColumnInfo(name = "end_time_milli")
       var endTimeMilli: Long = startTimeMilli,

       @ColumnInfo(name = "quality_rating")
       var sleepQuality: Int = -1
)
  1. Создайте и запустите свой код, чтобы убедиться, что в нем нет ошибок.

В этой задаче вы определяете объект доступа к данным (DAO). В Android DAO предоставляет удобные методы для вставки, удаления и обновления базы данных.

Когда вы используете базу данных Room , вы запрашиваете базу данных, определяя и вызывая функции Kotlin в своем коде. Эти функции Kotlin сопоставляются с SQL-запросами. Вы определяете эти сопоставления в DAO с помощью аннотаций, а Room создает необходимый код.

Думайте о DAO как об определении пользовательского интерфейса для доступа к вашей базе данных.

Для общих операций с базой данных библиотека Room предоставляет удобные аннотации, такие как @Insert , @Delete и @Update . Для всего остального есть аннотация @Query . Вы можете написать любой запрос, поддерживаемый SQLite.

В качестве дополнительного бонуса, когда вы создаете свои запросы в Android Studio, компилятор проверяет ваши SQL-запросы на наличие синтаксических ошибок.

Для базы данных трекера сна о ночах сна вам необходимо сделать следующее:

  • Вставьте новые ночи.
  • Обновите существующую ночь, чтобы обновить время окончания и рейтинг качества.
  • Получите конкретную ночь на основе ее ключа.
  • Получите все ночи , чтобы вы могли их отображать.
  • Получите самую последнюю ночь.
  • Удалить все записи в базе данных.

Шаг 1. Создайте DAO SleepDatabase

  1. В пакете database откройте SleepDatabaseDao.kt .
  2. Обратите внимание, что interface SleepDatabaseDao имеет аннотацию @Dao . Все DAO должны быть аннотированы ключевым словом @Dao .
@Dao
interface SleepDatabaseDao {}
  1. Внутри тела интерфейса добавьте аннотацию @Insert . Ниже @Insert добавьте функцию insert() , которая принимает экземпляр класса Entity SleepNight как его аргумент.

    Вот и все. Room сгенерирует весь необходимый код для вставки SleepNight в базу данных. Когда вы вызываете insert() из своего кода Kotlin, Room выполняет SQL-запрос, чтобы вставить объект в базу данных. (Примечание: вы можете вызывать функцию как угодно.)
@Insert
fun insert(night: SleepNight)
  1. Добавьте аннотацию @Update с функцией update() для одного SleepNight . Обновленная сущность — это сущность с тем же ключом, что и переданная. Вы можете обновить некоторые или все другие свойства сущности.
@Update
fun update(night: SleepNight)

Для остальных функций нет удобной аннотации, поэтому вам нужно использовать аннотацию @Query и предоставлять запросы SQLite.

  1. Добавьте аннотацию @Query с функцией get() , которая принимает Long key аргумент и возвращает значение SleepNight , допускающее значение NULL. Вы увидите ошибку для отсутствующего параметра.
@Query
fun get(key: Long): SleepNight?
  1. Запрос предоставляется как строковый параметр аннотации. Добавьте параметр в @Query . Сделайте это String , которая является запросом SQLite.
  • Выберите все столбцы из daily_sleep_quality_table
  • WHERE nightId соответствует key аргументу :.

    Обратите внимание на :key . Вы используете двоеточие в запросе для ссылки на аргументы функции.
("SELECT * from daily_sleep_quality_table WHERE nightId = :key")
  1. Добавьте еще один @Query с функцией clear() и SQLite-запросом, чтобы DELETE все из daily_sleep_quality_table . Этот запрос не удаляет саму таблицу.

    Аннотация @Delete удаляет один элемент, и вы можете использовать @Delete и предоставить список ночей для удаления. Недостатком является то, что вам нужно получить или знать, что находится в таблице. Аннотация @Delete подходит для удаления определенных записей, но не эффективна для удаления всех записей из таблицы.
@Query("DELETE FROM daily_sleep_quality_table")
fun clear()
  1. Добавьте @Query с getTonight() . Сделайте значение SleepNight , возвращаемое getTonight() , обнуляемым, чтобы функция могла обрабатывать случай, когда таблица пуста. (Таблица вначале пуста, а после данные очищаются.)

    Чтобы получить «сегодня вечером» из базы данных, напишите запрос SQLite, который возвращает первый элемент списка результатов, упорядоченных по nightId в порядке убывания. Используйте LIMIT 1 , чтобы вернуть только один элемент.
@Query("SELECT * FROM daily_sleep_quality_table ORDER BY nightId DESC LIMIT 1")
fun getTonight(): SleepNight?
  1. Добавьте @Query с getAllNights() :
  • Пусть запрос SQLite возвращает все столбцы из daily_sleep_quality_table , упорядоченные в порядке убывания.
  • Пусть getAllNights() возвращает список сущностей SleepNight как LiveData . Room обновляет эти LiveData для вас, что означает, что вам нужно только один раз явно получить данные.
  • Вам может понадобиться импортировать LiveData из androidx.lifecycle.LiveData .
@Query("SELECT * FROM daily_sleep_quality_table ORDER BY nightId DESC")
fun getAllNights(): LiveData<List<SleepNight>>
  1. Хотя вы не увидите видимых изменений, запустите приложение, чтобы убедиться, что в нем нет ошибок.

В этой задаче вы создаете базу данных Room , которая использует Entity и DAO, созданные в предыдущей задаче.

Вам нужно создать абстрактный класс держателя базы данных, аннотированный @Database . Этот класс имеет один метод, который либо создает экземпляр базы данных, если база данных не существует, либо возвращает ссылку на существующую базу данных.

Получение базы данных Room немного сложнее, поэтому вот общий процесс, прежде чем вы начнете с кода:

  • Создайте public abstract класс, extends RoomDatabase . Этот класс должен действовать как держатель базы данных. Класс является абстрактным, потому что Room создает реализацию за вас.
  • Аннотируйте класс с помощью @Database . В аргументах объявите сущности для базы данных и установите номер версии.
  • Внутри companion объекта определите абстрактный метод или свойство, которое возвращает SleepDatabaseDao . Room сгенерирует тело для вас.
  • Вам нужен только один экземпляр базы данных Room для всего приложения, поэтому сделайте RoomDatabase одноэлементным.
  • Используйте конструктор базы данных Room для создания базы данных, только если база данных не существует. В противном случае верните существующую базу данных.

Шаг 1: Создайте базу данных

  1. В пакете database откройте SleepDatabase.kt .
  2. В файле создайте abstract класс SleepDatabase , который расширяет RoomDatabase .

    Аннотируйте класс с помощью @Database .
@Database()
abstract class SleepDatabase : RoomDatabase() {}
  1. Вы увидите сообщение об ошибке для отсутствующих объектов и параметров версии. Аннотация @Database требует несколько аргументов, чтобы Room мог построить базу данных.
  • SleepNight как единственный элемент списка entities .
  • Установите version как 1 . Всякий раз, когда вы меняете схему, вам придется увеличивать номер версии.
  • Установите для exportSchema значение false , чтобы не сохранять резервные копии истории версий схемы.
entities = [SleepNight::class], version = 1, exportSchema = false
  1. База данных должна знать о DAO. Внутри тела класса объявите абстрактное значение, которое возвращает SleepDatabaseDao . У вас может быть несколько DAO.
abstract val sleepDatabaseDao: SleepDatabaseDao
  1. Ниже этого определите companion объект. Сопутствующий объект позволяет клиентам получать доступ к методам создания или получения базы данных без создания экземпляра класса. Поскольку единственной целью этого класса является предоставление базы данных, нет никаких причин создавать его экземпляры.
 companion object {}
  1. Внутри объекта- companion объявите частную переменную INSTANCE , допускающую значение null, для базы данных и инициализируйте ее значением null . Переменная INSTANCE будет хранить ссылку на базу данных после ее создания. Это помогает избежать многократного открытия соединений с базой данных, что дорого обходится.

Аннотируйте INSTANCE с помощью @Volatile . Значение volatile переменной никогда не будет кэшироваться, и все записи и чтения будут выполняться в основную память и из нее. Это помогает убедиться, что значение INSTANCE всегда актуально и одинаково для всех потоков выполнения. Это означает, что изменения, сделанные одним потоком в INSTANCE , немедленно видны всем другим потокам, и вы не получите ситуацию, когда, скажем, два потока обновляют один и тот же объект в кэше, что создало бы проблему.

@Volatile
private var INSTANCE: SleepDatabase? = null
  1. Ниже INSTANCE , все еще внутри объекта- companion , определите метод getInstance() с параметром Context , который понадобится построителю базы данных. Возвращает тип SleepDatabase . Вы увидите ошибку, потому что getInstance() еще ничего не возвращает.
fun getInstance(context: Context): SleepDatabase {}
  1. Внутри getInstance() добавьте блок synchronized{} . Передайте this , чтобы вы могли получить доступ к контексту.

    Несколько потоков потенциально могут запрашивать экземпляр базы данных одновременно, что приводит к созданию двух баз данных вместо одной. Эта проблема вряд ли возникнет в этом примере приложения, но возможна для более сложного приложения. Обертывание кода для перевода базы данных в synchronized режим означает, что только один поток выполнения за раз может войти в этот блок кода, что гарантирует, что база данных будет инициализирована только один раз.
synchronized(this) {}
  1. Внутри синхронизированного блока скопируйте текущее значение INSTANCE в локальную переменную instance . Это сделано для того, чтобы воспользоваться преимуществами интеллектуального приведения , которое доступно только для локальных переменных.
var instance = INSTANCE
  1. Внутри synchronized блока return instance в конце synchronized блока. Игнорировать ошибку несоответствия возвращаемого типа; вы никогда не вернете null, как только закончите.
return instance
  1. Над оператором return добавьте оператор if , чтобы проверить, является ли instance нулевым, то есть базы данных еще нет.
if (instance == null) {}
  1. Если instance равен null , используйте построитель базы данных, чтобы получить базу данных. В теле инструкции if вызовите Room.databaseBuilder и укажите контекст, который вы передали, класс базы данных и имя базы данных, sleep_history_database . Чтобы устранить ошибку, вам нужно будет добавить стратегию миграции и build() в следующих шагах.
instance = Room.databaseBuilder(
                           context.applicationContext,
                           SleepDatabase::class.java,
                           "sleep_history_database")
  1. Добавьте необходимую стратегию миграции в билдер. Используйте .fallbackToDestructiveMigration() .

    Обычно вам нужно будет предоставить объект миграции со стратегией миграции при изменении схемы. Объект миграции — это объект, который определяет, как вы берете все строки со старой схемой и конвертируете их в строки в новой схеме, чтобы данные не были потеряны. Миграция выходит за рамки этой лаборатории кода. Простое решение — уничтожить и перестроить базу данных, что означает потерю данных.
.fallbackToDestructiveMigration()
  1. Наконец, вызовите .build() .
.build()
  1. Назначьте INSTANCE = instance в качестве последнего шага внутри оператора if .
INSTANCE = instance
  1. Ваш окончательный код должен выглядеть так:
@Database(entities = [SleepNight::class], version = 1, exportSchema = false)
abstract class SleepDatabase : RoomDatabase() {

   abstract val sleepDatabaseDao: SleepDatabaseDao

   companion object {

       @Volatile
       private var INSTANCE: SleepDatabase? = null

       fun getInstance(context: Context): SleepDatabase {
           synchronized(this) {
               var instance = INSTANCE

               if (instance == null) {
                   instance = Room.databaseBuilder(
                           context.applicationContext,
                           SleepDatabase::class.java,
                           "sleep_history_database"
                   )
                           .fallbackToDestructiveMigration()
                           .build()
                   INSTANCE = instance
               }
               return instance
           }
       }
   }
}
  1. Создайте и запустите свой код.

Теперь у вас есть все строительные блоки для работы с вашей базой данных Room . Этот код компилируется и запускается, но вы не можете сказать, работает ли он на самом деле. Итак, самое время добавить несколько базовых тестов.

Шаг 2. Протестируйте SleepDatabase

На этом шаге вы запускаете предоставленные тесты, чтобы убедиться, что ваша база данных работает. Это помогает убедиться, что база данных работает до того, как вы начнете использовать ее. Представленные тесты являются базовыми. Для производственного приложения вы будете выполнять все функции и запросы во всех DAO.

Стартовое приложение содержит папку androidTest . Эта папка androidTest содержит модульные тесты, включающие инструменты Android, что является причудливым способом сказать, что тесты нуждаются в платформе Android, поэтому вам нужно запускать тесты на физическом или виртуальном устройстве. Конечно, вы также можете создавать и запускать чистые модульные тесты, не использующие платформу Android.

  1. В Android Studio в папке androidTest откройте файл SleepDatabaseTest .
  2. Чтобы раскомментировать код, выберите весь закомментированный код и нажмите сочетание клавиш Cmd+/ или Control+/ .
  3. Взгляните на файл.

Вот краткий обзор кода тестирования, потому что это еще один фрагмент кода, который вы можете использовать повторно:

  • SleepDabaseTest — тестовый класс .
  • Аннотация @RunWith идентифицирует средство запуска тестов, то есть программу, которая устанавливает и выполняет тесты.
  • Во время установки функция, аннотированная @Before , выполняется и создает в памяти SleepDatabase с SleepDatabaseDao . «В памяти» означает, что эта база данных не сохраняется в файловой системе и будет удалена после запуска тестов.
  • Также при построении базы данных в памяти код вызывает другой метод, специфичный для теста, allowMainThreadQueries . По умолчанию вы получаете сообщение об ошибке, если пытаетесь выполнить запросы в основном потоке. Этот метод позволяет запускать тесты в основном потоке, что следует делать только во время тестирования.
  • В тестовом методе, аннотированном @Test , вы создаете, вставляете и извлекаете SleepNight и утверждаете, что они одинаковы. Если что-то пойдет не так, сгенерируйте исключение. В реальном тесте у вас будет несколько @Test методы.
  • Когда тестирование завершено, функция, аннотированная @After выполняется для закрытия базы данных.
  1. Щелкните правой кнопкой мыши тестовый файл на панели « Проект» и выберите «Выполнить SleepDatabaseTest» .
  2. После выполнения тестов убедитесь в области SleepDatabaseTest , что все тесты пройдены.

Поскольку все тесты пройдены, теперь вы знаете несколько вещей:

  • База создается корректно.
  • Вы можете вставить SleepNight в базу данных.
  • Вы можете вернуть SleepNight .
  • SleepNight имеет правильное значение качества.

Проект Android Studio: TrackMySleepQualityRoomAndTesting

При тестировании базы данных вам необходимо использовать все методы, определенные в DAO. Чтобы завершить тестирование , добавьте и выполните тесты для проверки других методов DAO.

  • Определите свои таблицы как классы данных, аннотированные с помощью @Entity . Определите свойства, аннотированные с помощью @ColumnInfo , как столбцы в таблицах.
  • Определите объект доступа к данным (DAO) как интерфейс с аннотацией @Dao . DAO сопоставляет функции Kotlin с запросами к базе данных.
  • Используйте аннотации для определения @Insert , @Delete и @Update .
  • Используйте аннотацию @Query со строкой запроса SQLite в качестве параметра для любых других запросов.
  • Создайте абстрактный класс с функцией getInstance() , которая возвращает базу данных.
  • Используйте инструментальные тесты, чтобы проверить, что ваша база данных и DAO работают должным образом. Вы можете использовать предоставленные тесты в качестве шаблона.

Удасити курс:

Документация для разработчиков Android:

Другая документация и статьи:

В этом разделе перечислены возможные домашние задания для студентов, которые работают с этой кодовой лабораторией в рамках курса, проводимого инструктором. Инструктор должен сделать следующее:

  • При необходимости задайте домашнее задание.
  • Объясните учащимся, как сдавать домашние задания.
  • Оценивайте домашние задания.

Преподаватели могут использовать эти предложения так мало или так часто, как они хотят, и должны свободно давать любые другие домашние задания, которые они считают подходящими.

Если вы работаете с этой кодовой лабораторией самостоятельно, не стесняйтесь использовать эти домашние задания, чтобы проверить свои знания.

Ответьте на эти вопросы

Вопрос 1

Как указать, что класс представляет объект для хранения в базе данных Room ?

  • Сделайте так, чтобы класс расширял DatabaseEntity .
  • Аннотируйте класс с помощью @Entity .
  • Аннотируйте класс с помощью @Database .
  • Сделайте класс расширением RoomEntity а также аннотируйте класс с помощью @Room .

вопрос 2

DAO (объект доступа к данным) — это интерфейс, который Room использует для сопоставления функций Kotlin с запросами к базе данных.

Как вы указываете, что интерфейс представляет DAO для базы данных Room ?

  • Сделайте интерфейс расширением RoomDAO .
  • Сделайте интерфейс расширением EntityDao , затем реализуйте метод DaoConnection() .
  • Аннотируйте интерфейс с помощью @Dao .
  • Аннотируйте интерфейс с помощью @RoomConnection .

Вопрос 3

Какие из следующих утверждений о базе данных Room верны? Выберите все подходящие.

  • Вы можете определить таблицы для базы данных Room как аннотированные классы данных.
  • Если вы LiveData из запроса, Room будет обновлять LiveData для вас, если LiveData изменится.
  • Каждая база данных Room должна иметь один и только один DAO.
  • Чтобы идентифицировать класс как базу данных Room , сделайте его подклассом RoomDatabase и аннотируйте его с помощью @Database .

Вопрос 4

Какие из следующих аннотаций вы можете использовать в своем интерфейсе @Dao ? Выберите все подходящие.

  • @Get
  • @Update
  • @Insert
  • @Query

Вопрос 5

Как вы можете проверить, что ваша база данных работает? Выбрать все, что подходит.

  • Пишите инструментальные тесты.
  • Продолжайте писать и запускать приложение, пока оно не отобразит данные.
  • Замените вызовы методов в интерфейсе DAO вызовами эквивалентных методов в классе Entity .
  • Запустите verifyDatabase() , предоставленную библиотекой Room .

Начать следующий урок: 6.2 Сопрограммы и комната

Ссылки на другие лаборатории кода в этом курсе см. на целевой странице лаборатории кода Android Kotlin Fundamentals .