Jetpack Room 使用详解(上)

最新推荐文章于 2025-09-23 07:59:29 发布
原创 最新推荐文章于 2025-09-23 07:59:29 发布 · 1.6w 阅读 · 17 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#kotlin #学习 #微信 #android #xml #room #jetpack

文章目录


在这里插入图片描述

1. Room 概述

1.1 Room 简介

Room 是 Android Jetpack 组件中的一部分，它是一个 SQLite 对象映射库，提供了在 SQLite 上更抽象的层，使开发者能够更流畅地访问数据库。Room 在编译时验证 SQL 查询，避免了运行时错误，并且减少了大量样板代码。

1.2 Room 的优势

  1. 编译时 SQL 验证：Room 会在编译时检查 SQL 查询的正确性，避免运行时错误。
  2. 减少样板代码：自动生成大量重复的数据库操作代码。
  3. 与 LiveData 和 RxJava 集成：可以轻松地将数据库操作与 UI 更新结合。
  4. 类型安全：使用注解处理器生成代码，确保类型安全。
  5. 迁移支持：提供简单的数据库迁移方案。

1.3 Room 组件架构

Room 主要由三个组件组成：

  1. Database：包含数据库持有者，并作为与应用持久关联数据的底层连接的主要访问点。
  2. Entity：表示数据库中的表。
  3. DAO：包含用于访问数据库的方法。

2. Room 基本使用

2.1 添加依赖

首先需要在项目的 build.gradle 文件中添加 Room 的依赖：

dependencies {
    def room_version = "2.4.0"

    implementation "androidx.room:room-runtime:$room_version"
    annotationProcessor "androidx.room:room-compiler:$room_version"
    
    // 可选 - Kotlin 扩展和协程支持
    implementation "androidx.room:room-ktx:$room_version"
    
    // 可选 - RxJava 支持
    implementation "androidx.room:room-rxjava2:$room_version"
    implementation "androidx.room:room-rxjava3:$room_version"
    
    // 可选 - 测试助手
    testImplementation "androidx.room:room-testing:$room_version"
}

2.2 创建 Entity

Entity 是数据表的 Java/Kotlin 表示。每个 Entity 类对应数据库中的一个表，类的字段对应表中的列。

@Entity(tableName = "users")
public class User {
    @PrimaryKey(autoGenerate = true)
    private int id;
    
    @ColumnInfo(name = "user_name")
    private String name;
    
    private int age;
    
    // 构造方法、getter 和 setter
}

常用注解：

  • @Entity：标记类为数据实体
  • @PrimaryKey：标记主键
  • @ColumnInfo：自定义列名
  • @Ignore：忽略字段，不存入数据库

2.3 创建 DAO

DAO (Data Access Object) 是访问数据库的主要组件，定义了访问数据库的方法。

@Dao
public interface UserDao {
    @Insert
    void insert(User user);
    
    @Update
    void update(User user);
    
    @Delete
    void delete(User user);
    
    @Query("SELECT * FROM users")
    List<User> getAllUsers();
    
    @Query("SELECT * FROM users WHERE id = :userId")
    User getUserById(int userId);
}

常用注解：

  • @Insert：插入数据
  • @Update：更新数据
  • @Delete：删除数据
  • @Query：自定义 SQL 查询

2.4 创建 Database

Database 类是 Room 的主要访问点，它持有数据库并作为持久化数据的底层连接的主要访问点。

@Database(entities = {User.class}, version = 1)
public abstract class AppDatabase extends RoomDatabase {
    public abstract UserDao userDao();
    
    private static volatile AppDatabase INSTANCE;
    
    public static AppDatabase getInstance(Context context) {
        if (INSTANCE == null) {
            synchronized (AppDatabase.class) {
                if (INSTANCE == null) {
                    INSTANCE = Room.databaseBuilder(context.getApplicationContext(),
                            AppDatabase.class, "app_database")
                            .build();
                }
            }
        }
        return INSTANCE;
    }
}

2.5 使用 Room 数据库

// 获取数据库实例
AppDatabase db = AppDatabase.getInstance(context);

// 获取 DAO
UserDao userDao = db.userDao();

// 插入用户
User user = new User();
user.setName("John");
user.setAge(30);
userDao.insert(user);

// 查询所有用户
List<User> users = userDao.getAllUsers();

3. Room 高级特性

3.1 数据库关系

Room 支持三种类型的关系：

  1. 一对一关系：一个实体只与另一个实体关联
  2. 一对多关系：一个实体可以与多个实体关联
  3. 多对多关系：多个实体可以相互关联
3.1.1 一对一关系
@Entity
public class User {
    @PrimaryKey public long userId;
    public String name;
}

@Entity
public class Library {
    @PrimaryKey public long libraryId;
    public long userOwnerId;
}

public class UserAndLibrary {
    @Embedded public User user;
    @Relation(
         parentColumn = "userId",
         entityColumn = "userOwnerId"
    )
    public Library library;
}

@Dao
public interface UserDao {
    @Transaction
    @Query("SELECT * FROM User")
    public List<UserAndLibrary> getUsersAndLibraries();
}
3.1.2 一对多关系
@Entity
public class User {
    @PrimaryKey public long userId;
    public String name;
}

@Entity
public class Playlist {
    @PrimaryKey public long playlistId;
    public long userCreatorId;
    public String playlistName;
}

public class UserWithPlaylists {
    @Embedded public User user;
    @Relation(
         parentColumn = "userId",
         entityColumn = "userCreatorId"
    )
    public List<Playlist> playlists;
}

@Dao
public interface UserDao {
    @Transaction
    @Query("SELECT * FROM User")
    public List<UserWithPlaylists> getUsersWithPlaylists();
}
3.1.3 多对多关系
@Entity
public class Playlist {
    @PrimaryKey public long playlistId;
    public String playlistName;
}

@Entity
public class Song {
    @PrimaryKey public long songId;
    public String songName;
    public String artist;
}

@Entity(primaryKeys = {"playlistId", "songId"})
public class PlaylistSongCrossRef {
    public long playlistId;
    public long songId;
}

public class PlaylistWithSongs {
    @Embedded public Playlist playlist;
    @Relation(
         parentColumn = "playlistId",
         entityColumn = "songId",
         associateBy = @Junction(PlaylistSongCrossref.class)
    )
    public List<Song> songs;
}

public class SongWithPlaylists {
    @Embedded public Song song;
    @Relation(
         parentColumn = "songId",
         entityColumn = "playlistId",
         associateBy = @Junction(PlaylistSongCrossref.class)
    )
    public List<Playlist> playlists;
}

3.2 类型转换器

Room 默认支持基本类型和它们的包装类，但如果想存储自定义类型，需要使用 @TypeConverter。

public class Converters {
    @TypeConverter
    public static Date fromTimestamp(Long value) {
        return value == null ? null : new Date(value);
    }

    @TypeConverter
    public static Long dateToTimestamp(Date date) {
        return date == null ? null : date.getTime();
    }
}

@Database(entities = {User.class}, version = 1)
@TypeConverters({Converters.class})
public abstract class AppDatabase extends RoomDatabase {
    // ...
}

@Entity
public class User {
    @PrimaryKey public int id;
    public String name;
    public Date birthday;
}

3.3 数据库迁移

当数据库结构发生变化时，需要升级数据库版本并提供迁移策略。

// 版本1的数据库
@Database(entities = {User.class}, version = 1)
public abstract class AppDatabase extends RoomDatabase {
    // ...
}

// 版本2的数据库 - 添加了新表
@Database(entities = {User.class, Book.class}, version = 2)
public abstract class AppDatabase extends RoomDatabase {
    // ...
    
    private static final Migration MIGRATION_1_2 = new Migration(1, 2) {
        @Override
        public void migrate(SupportSQLiteDatabase database) {
            database.execSQL("CREATE TABLE IF NOT EXISTS `Book` (`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, `title` TEXT, `author` TEXT)");
        }
    };
    
    public static AppDatabase getInstance(Context context) {
        if (INSTANCE == null) {
            synchronized (AppDatabase.class) {
                if (INSTANCE == null) {
                    INSTANCE = Room.databaseBuilder(context.getApplicationContext(),
                            AppDatabase.class, "app_database")
                            .addMigrations(MIGRATION_1_2)
                            .build();
                }
            }
        }
        return INSTANCE;
    }
}

3.4 预填充数据库

有时需要在应用首次启动时预填充数据库：

Room.databaseBuilder(context.getApplicationContext(),
        AppDatabase.class, "app_database")
        .createFromAsset("database/myapp.db")
        .build();

3.5 数据库测试

Room 提供了测试支持：

@RunWith(AndroidJUnit4.class)
public class UserDaoTest {
    private UserDao userDao;
    private AppDatabase db;

    @Before
    public void createDb() {
        Context context = ApplicationProvider.getApplicationContext();
        db = Room.inMemoryDatabaseBuilder(context, AppDatabase.class).build();
        userDao = db.userDao();
    }

    @After
    public void closeDb() throws IOException {
        db.close();
    }

    @Test
    public void insertAndGetUser() throws Exception {
        User user = new User();
        user.setName("John");
        userDao.insert(user);
        
        List<User> allUsers = userDao.getAllUsers();
        assertEquals(allUsers.get(0).getName(), "John");
    }
}

4. Room 与架构组件集成

4.1 Room 与 LiveData

Room 可以返回 LiveData 对象，使数据库变化自动反映到 UI 上。

@Dao
public interface UserDao {
    @Query("SELECT * FROM users")
    LiveData<List<User>> getAllUsers();
}

// 在 Activity/Fragment 中观察
userDao.getAllUsers().observe(this, users -> {
    // 更新 UI
});

4.2 Room 与 ViewModel

public class UserViewModel extends AndroidViewModel {
    private UserDao userDao;
    private LiveData<List<User>> allUsers;

    public UserViewModel(@NonNull Application application) {
        super(application);
        AppDatabase db = AppDatabase.getInstance(application);
        userDao = db.userDao();
        allUsers = userDao.getAllUsers();
    }

    public LiveData<List<User>> getAllUsers() {
        return allUsers;
    }
}

// 在 Activity/Fragment 中
UserViewModel viewModel = new ViewModelProvider(this).get(UserViewModel.class);
viewModel.getAllUsers().observe(this, users -> {
    // 更新 UI
});

4.3 Room 与 Paging Library

Room 支持 Paging Library，可以轻松实现分页加载：

@Dao
public interface UserDao {
    @Query("SELECT * FROM users")
    PagingSource<Integer, User> usersByName();
}

// 在 ViewModel 中
public class UserViewModel extends ViewModel {
    public LiveData<PagingData<User>> users;
    
    public UserViewModel(UserDao userDao) {
        users = Pager(
            new PagingConfig(pageSize = 20)
        ) {
            userDao.usersByName()
        }.liveData
            .cachedIn(viewModelScope);
    }
}

5. Room 性能优化

5.1 索引优化

@Entity(indices = {@Index("name"), @Index(value = {"last_name", "address"}, unique = true)})
public class User {
    @PrimaryKey public int id;
    public String name;
    @ColumnInfo(name = "last_name") public String lastName;
    public String address;
}

5.2 事务处理

@Dao
public interface UserDao {
    @Transaction
    default void insertUsers(User user1, User user2) {
        insert(user1);
        insert(user2);
    }
}

5.3 批量操作

@Dao
public interface UserDao {
    @Insert
    void insertAll(User... users);
    
    @Update
    void updateAll(User... users);
    
    @Delete
    void deleteAll(User... users);
}

5.4 异步查询

使用 RxJava 或 Kotlin 协程进行异步操作：

@Dao
public interface UserDao {
    @Query("SELECT * FROM users")
    Flowable<List<User>> getAllUsers();
    
    @Query("SELECT * FROM users")
    Single<List<User>> getAllUsersSingle();
    
    @Query("SELECT * FROM users")
    Maybe<List<User>> getAllUsersMaybe();
}

// 或使用 Kotlin 协程
@Dao
interface UserDao {
    @Query("SELECT * FROM users")
    suspend fun getAllUsers(): List<User>
}
Android Jetpack 的 Room 详解（Room背景和原理、Room特性和优缺点、Room使用注意事项和内存优化）
半夏微凉科技
05-30 690
Android Jetpack 中的 Room 是一款用于简化 SQLite 数据库访问和操作的持久性库。它提供了一个抽象层，让开发者能够在应用中使用更加简洁和类型安全的方式来处理数据库操作。
Android Jetpack(五)：ROOM
前期后期
07-10 962
如果想存储到文件里面，我们需要将inMemoryDatabaseBuilder方法换成databaseBuilder方法，这个方法，需要提供一个数据库名。使用ROOM我们可以快速的生成数据库，表，可以快速的去访问。涉及到的知识点：Entity，Dao，Database，Migration，Repository。大家，有兴趣，可以多上github找一些项目学习，看看别人是如何写的。注意，数据库对象不推荐一直创建的，消耗资源，所以我们需要做成单例的。这是一个数据库，需要协助数据库的版本号，有哪些数据表.
Jetpack：Room超详细使用踩坑指南！
Pumpkin's Blog
09-12 3168
文章目录一、简介二、Room使用指南Room使用验证结果三、Room踩坑解答 一、简介 ORM(Object Relational Mapping)关系映射库，在Sqlite上提供了一层封装，优化数据库操作的便捷性。 Room的架构图如下所示： ​ Entity：一个Entity对应于数据库的一张表。Entity类是Sqlite表结构对Java类的映射，在Java中可以被看作一个Model类。 ​ Dao：即 Data Access Objects，数据访问对象。顾名思义，我们可以通过它访问对
Jetpack Room 使用及原理解析
neuHenry
05-17 2848
Room 是 Google 官方推出的数据库 **ORM 框架**。ORM：即 Object Relational Mapping，即对象关系映射，也就是将关系型数据库映射为面向对象的语言。使用 ORM 框架，我们就可以用面向对象的思想操作关系型数据库，不再需要编写 SQL 语句。 Room 是在 **SQLite** 的基础上提供了一个抽象层，以便在充分利用 SQLite 的强大功能的同时，能够更简便的访问数据库。
Jetpack Room 从入门到精通
最新发布
csdn_silent的博客
09-23 1411
Room是Google官方推出的Android持久化库，通过注解简化SQLite操作。相比原生SQLite，Room减少样板代码，提供编译时SQL验证，支持LiveData/Flow和协程。与greenDao相比，Room与Jetpack生态深度集成，但greenDao在批量操作性能更优。Room核心组件包括@Entity(实体类)、@Dao(数据访问对象)和@Database(数据库类)，通过注解自动生成代码，实现类型安全的数据库操作。Room适合MVVM架构项目，提供完善的迁移机制和实时数据同步功能。
Android Jetpack架构组件 — Room入坑详解
weixin_36659321的博客
02-02 634
本文首发于微信公众号「Android开发之旅」，欢迎关注 ，获取更多技术干货 Room是Jetpack组件库一员，属于ORM库，主要是对Sqlite做了一层抽象，从而简化开发者对数据库操作。Room支持编译时的语法检查，并且支持返回LiveData。 添加依赖 在app的build.gradle中添加如下依赖： def room_version = "2.2.0-rc01" ...
Jetpack Room
txaz6的博客
07-15 737
SQLite说，我明明是你们的“祖宗“，怎么现在都冷落我😭？Room回答道：你难道不知道？我都给开发者飞一般的感觉了😏
Jetpack-room
qq_35388369的博客
01-17 425
记录 room 2.1.0-alpha02 中 新增api @TypeConverters 类型装换器 针对于room 非基础类型 存储方法 如： books就是不可直接存储的数据类型 需要添加 类型装换器 必须提供成对的方法 、重点是输入和返回的数据类型、方法名不做要求。 使用方法 直接在实体类名上添加 ...
Jetpack Room Demo
04-01
**Android Jetpack Room 框架详解** 在现代Android应用开发中，数据持久化是必不可少的一个环节。Android Jetpack库中的Room提供了一种简洁、高效的方式来处理SQLite数据库，使得开发者可以更加专注于业务逻辑，而...
Jetpack：Room数据库升级详解实战！
Pumpkin's Blog
09-20 2566
系列文章目录 相关文章： Jetpack：Room超详细使用踩坑指南！ Jetpack:Room+kotlin协程? 事务问题分析，withTransaction API 详解. Jetpack:Room使用报错FAQ Jetpack:Room配合LiveData/Flow使用优化，Room+Flow使用原理解析。 文章目录系列文章目录Room升级简介异常处理实战扩展知识 Room升级简介 随着业务的变化，数据库可能也需要做一些调整，列如新增或则修改一个字段等等。这时候就需要对数据库进行升级的操作了。
JetPack-Room
qq_36642554的博客
07-10 384
简介 android架构组件中的数据持久化组件库，是在Sqlite上实现的一条ORM（对象关系映射，Object Relational Mapping）解决方案 相关概念 Database 使用@Database注解，要求继承RoomDatabase并且是抽象类，因为创建数据库比较消耗资源，所以一般都是使用单例模式 Entity 使用@Entity注解，每个Entity都对应这数据库中的一张表 DAO 使用@Dao注解，定义了访问表的接口，主要是在里面定义增删改查方法，并在方法上使用注解添加对应
JetPack之Room入门
似霰的博客
03-25 1247
JetPack之Room入门
jetpack--Room
zhuowalun8427的博客
11-05 1335
jetPack--Room的使用
Jetpack——Room
大风起兮云飞扬
09-23 690
/ 声明一个书籍数据库对象// App启动时调用@Override// 构建书籍数据库的实例// 允许迁移数据库（发生数据库变更时，Room默认删除原数据库再创建新数据库，如此一来原来的记录会丢失，故而要改为迁移方式以便保存原有记录）// 允许主线程中操作数据库（Room默认不能在主线程中操作数据库）.build();
JetPack中的Room
Huang兄
10-31 606
2018年谷歌I/O 发布了一系列辅助android开发者的实用工具，合称Jetpack，以帮助开发者构建出色的 Android 应用。 这次发布的 Android Jetpack 组件覆盖以下 4 个方面：Architecture、Foundation、Behavior 以及 UI。该系列博客介绍一下Jetpack中常用组件，本篇介绍Room，结合ViewModel和LiveData完成上图的结构。最后借助于https://github.com/android/sunflower 来写一个完整的应用
Jetpack（七）—— Room
xingyu19911016的博客
02-16 1968
Room SQLite数据库是使用了一些原生的API来进行数据的增删改查操作。这些原生API虽然简单易用，但是如果放到大型项目当中的话，会容易让项目的代码变得混乱，除非进行了很好的封装。为此出现了诸多专门为Android数据库设计的ORM框架。 ORM(Object Relational Mapping)也叫对象关系映射。简单来讲，我们使用的编程语言是面向对象语言，而使用的数据库则是关系型数据库，将面向对象的语言和面向关系的数据库之间建立一种映射关系，这就是ORM了。 relational [rɪˈleɪʃ
【Android】Jetpack-Room
LeGuan_Ha的博客
10-14 610
是Android Jetpack中的一个组件，它提供了一个抽象层，帮助开发者在本地数据库（如SQLite）上进行持久化数据存储。Room通过简化数据库操作，使得数据管理变得更加容易和高效。在Android开发中，使用DAO（Data Access Object）、Repository和ViewModel的架构模式是为了实现数据与界面的清晰分离，提高应用的可维护性和扩展性。4.定义StudentRepository。5.定义StudentViewModel。3.定义MyDatabase。
Android Jetpack系列（一） Room
游逸的博客
11-18 502
Android Jetpack系列（一） Room前言Room简介Room使用1 引用2 编写Entity实体类2 编写Dao数据操作类3 编写Database数据库操作类4 调用示例 前言 Jetpack是2017年谷歌在开发者大会上发布的一套开发工具。 Jetpack共包含4个部分：Architecture、Foundation、Behavior 以及 UI 。 其中的Architecture又称为AAC（Android Architecture Components），是谷歌推荐的android开
Android---Jetpack之Room
qq_44950283的博客
04-03 746
Android 采用 SQLite 作为数据库存储，开源社区常见的 ORM(Object Relational Mapping)库有ORMLite、GreenDAO等。Room 和其它库一样，也是在 SQLite 上提供了一层封装。Entity：实体类，对应的是数据库的一张表结构，使用注解 @Entity 标记。相当于 JavaBeanDao：包含访问数据库的一些列方法，使用注解 @Dao 标记。DataBase：数据库持有者，作为与应用持久化相关数据的底层连接的主要接入点。
评论 353
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

百锦再@新空间

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值