Jetpack Room 使用详解

最新推荐文章于 2025-06-18 12:10:02 发布
最新推荐文章于 2025-06-18 12:10:02 发布
阅读量1.6w 收藏 16
点赞数 179
CC 4.0 BY-SA版权
分类专栏： 包罗万象 文章标签： java android kotlin app google
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/sixpp/article/details/147553351

在这里插入图片描述

文章目录

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>
}

6. Room 常见问题与解决方案

6.1 主线程访问问题

默认情况下，Room 不允许在主线程执行数据库操作。解决方法：

  1. 使用异步操作（LiveData, RxJava, 协程等）
  2. 允许主线程访问（不推荐）：
Room.databaseBuilder(context.getApplicationContext(),
        AppDatabase.class, "app_database")
        .allowMainThreadQueries()
        .build();

6.2 数据库升级失败

解决方案：

  1. 确保提供了所有必要的迁移
  2. 使用 fallbackToDestructiveMigration 作为最后手段：
Room.databaseBuilder(context.getApplicationContext(),
        AppDatabase.class, "app_database")
        .fallbackToDestructiveMigration()
        .build();

6.3 类型转换错误

确保所有 TypeConverter 都正确实现，并在数据库类上添加了 @TypeConverters 注解。

6.4 数据库文件过大

解决方案：

  1. 定期清理不必要的数据
  2. 使用数据库压缩工具
  3. 考虑分库分表策略

7. Room 最佳实践

7.1 设计原则

  1. 单一职责：每个 DAO 只处理一个实体的操作
  2. 最小化查询：只查询需要的字段
  3. 合理使用索引：为常用查询字段添加索引
  4. 批量操作：使用事务进行批量操作

7.2 代码组织

推荐的项目结构：

- data/
  - model/       # 实体类
  - dao/         # DAO 接口
  - database/    # 数据库类和相关工具
  - repository/  # 仓库层（可选）

7.3 测试策略

  1. 使用内存数据库进行单元测试
  2. 测试所有自定义查询
  3. 测试数据库迁移
  4. 测试异常情况

8. Room 与其他存储方案比较

8.1 Room vs SQLiteOpenHelper

优势：

  • 编译时 SQL 验证
  • 减少样板代码
  • 更好的类型安全
  • 与架构组件集成

劣势：

  • 学习曲线
  • 灵活性稍低

8.2 Room vs Realm

优势：

  • 基于 SQLite，兼容性好
  • 不需要额外运行时
  • 更小的 APK 体积

劣势：

  • 性能在某些场景下不如 Realm
  • 不支持跨进程

8.3 Room vs ObjectBox

优势：

  • Google 官方支持
  • 基于 SQLite，兼容现有工具
  • 更成熟稳定

劣势：

  • 性能不如 ObjectBox
  • 不支持 NoSQL 特性

9. Room 实际应用案例

9.1 笔记应用

@Entity
public class Note {
    @PrimaryKey(autoGenerate = true)
    private int id;
    private String title;
    private String content;
    private Date createdAt;
    private Date updatedAt;
}

@Dao
public interface NoteDao {
    @Insert
    void insert(Note note);
    
    @Update
    void update(Note note);
    
    @Delete
    void delete(Note note);
    
    @Query("SELECT * FROM notes ORDER BY updatedAt DESC")
    LiveData<List<Note>> getAllNotes();
    
    @Query("SELECT * FROM notes WHERE id = :noteId")
    LiveData<Note> getNoteById(int noteId);
    
    @Query("SELECT * FROM notes WHERE title LIKE :query OR content LIKE :query")
    LiveData<List<Note>> searchNotes(String query);
}

9.2 电商应用

@Entity
public class Product {
    @PrimaryKey
    private String id;
    private String name;
    private String description;
    private double price;
    private int stock;
    private String imageUrl;
}

@Entity
public class CartItem {
    @PrimaryKey
    private String productId;
    private int quantity;
}

public class ProductWithCartStatus {
    @Embedded
    public Product product;
    
    @Relation(parentColumn = "id", entityColumn = "productId")
    public CartItem cartItem;
}

@Dao
public interface ProductDao {
    @Query("SELECT * FROM product")
    LiveData<List<Product>> getAllProducts();
    
    @Transaction
    @Query("SELECT * FROM product")
    LiveData<List<ProductWithCartStatus>> getAllProductsWithCartStatus();
}

10. Room 的未来发展

10.1 多平台支持

Room 正在增加对 Kotlin Multiplatform 的支持，未来可以在 iOS 等平台使用。

10.2 增强的查询功能

未来版本可能会增加更复杂的查询支持，如全文搜索、更强大的关联查询等。

10.3 性能优化

持续的底层性能优化，特别是在大数据量情况下的查询效率。

11. 总结

Room 是 Android 开发中强大的持久化解决方案，它简化了 SQLite 的使用，提供了类型安全的数据库访问，并与 Android 架构组件深度集成。通过合理使用 Room 的各种特性，开发者可以构建高效、可维护的数据层，为应用提供可靠的数据存储和访问能力。

Android Jetpack 的 Room 详解（Room背景和原理、Room特性和优缺点、Room使用注意事项和内存优化）
半夏微凉科技
05-30 488
Android Jetpack 中的 Room 是一款用于简化 SQLite 数据库访问和操作的持久性库。它提供了一个抽象层，让开发者能够在应用中使用更加简洁和类型安全的方式来处理数据库操作。
Android Jetpack(五)：ROOM
前期后期
07-10 870
如果想存储到文件里面，我们需要将inMemoryDatabaseBuilder方法换成databaseBuilder方法，这个方法，需要提供一个数据库名。使用ROOM我们可以快速的生成数据库，表，可以快速的去访问。涉及到的知识点：Entity，Dao，Database，Migration，Repository。大家，有兴趣，可以多上github找一些项目学习，看看别人是如何写的。注意，数据库对象不推荐一直创建的，消耗资源，所以我们需要做成单例的。这是一个数据库，需要协助数据库的版本号，有哪些数据表.
【Jetpack系列二】——Room操作数据库
大帅在唱歌
06-17 980
文章目录Jetpack组件之 Room操作数据库简介主要类依赖定义实体类访问数据创建数据库插入数据删除数据更新数据Tips Jetpack组件之 Room操作数据库 看了google出品的jetpack库，感觉还是很不错的，这里开始我们的Jetpack学习之旅 本文所有源码收录在 --> https://github.com/ddssingsong/AnyTool 简介 官方： Room持久...
jetpack--Room
zhuowalun8427的博客
11-05 1297
jetPack--Room的使用
Android架构组件：Room数据库使用
最新发布
2501_92487499的博客
06-18 333
创建一个实体类，用于表示数据库中的表结构。例如，创建一个User // 省略构造方法和getter/setter方法 本文详细介绍了Android架构组件Room数据库的使用，包括功能特点、使用步骤、优势与不足等方面。通过使用Room数据库，开发者可以简化数据库操作，提高开发效率。然而，Room数据库也存在一定的学习曲线和灵活性限制。未来，Room数据库可能会继续优化性能，提供更多实用的功能，以满足开发者的需求。
Jetpack：Room超详细使用踩坑指南！
Pumpkin's Blog
09-12 3026
文章目录一、简介二、Room使用指南Room使用验证结果三、Room踩坑解答 一、简介 ORM(Object Relational Mapping)关系映射库，在Sqlite上提供了一层封装，优化数据库操作的便捷性。 Room的架构图如下所示： ​ Entity：一个Entity对应于数据库的一张表。Entity类是Sqlite表结构对Java类的映射，在Java中可以被看作一个Model类。 ​ Dao：即 Data Access Objects，数据访问对象。顾名思义，我们可以通过它访问对
JetPack之Room入门
似霰的博客
03-25 1108
JetPack之Room入门
【Android】Room数据库的简单使用方法
摸鱼小小虫的博客
05-08 3713
简单介绍了Room数据库的基本用法，以及Room数据库配合RXjava的用法
Room数据库的使用及原理详解
shenduai的博客
06-11 1744
在数据库DataBase中想要访问数据库的操作，需要获取操作Dao的对象，而Dao会给DataBase返回一个entity的对象。当我们用Room数据库进行存储时，其实存储的并非要存储的具体对象，深度ip转换器而是对象对应的一些信息。因此，我们引入Repository仓库类用于操作Room，而我们给外部暴露的是viewModel类，因此，viewModel需要持有Repository对象。/**------------------------相片--------------------------**/
Jetpack Room Demo
04-01
**Android Jetpack Room 框架详解** 在现代Android应用开发中，数据持久化是必不可少的一个环节。Android Jetpack库中的Room提供了一种简洁、高效的方式来处理SQLite数据库，使得开发者可以更加专注于业务逻辑，而...
Android Jetpack组件库详解：架构组件的使用与最佳实践
[Android Jetpack组件库详解：架构组件的使用与最佳实践](https://ask.qcloudimg.com/http-save/yehe-1907613/4edow60rfe.png) # 1. Android Jetpack组件库概述 ## 1.1 Jetpack组件库的由来与发展 Jetpack组件库是...
掌握Jetpack Room数据库的增删改查操作
### 知识点：Jetpack Room 数据库操作详解 Jetpack Room 是一个持久化库，它为 Android 提供了一套抽象层，用于在SQLite数据库上访问和操作数据。Room 利用了SQLite数据库，但提供了比直接使用SQLite更高层次的抽象...
Room数据库简单使用
qq_52019658的博客
08-24 1430
Room 数据保存简单使用
jetpack组件之Room原理分析
qq_36828822的博客
06-18 1247
Google在没有推出Room组件之前，如果我们想要操作数据库，android是采用sqlite作为数据库存储。有使用过sqlite的读者应该十分清楚，sqlite的使用相当的复杂，而且代码写起来既繁琐又容易出错。因此，各大开源社区便推出了各种ORM库来简化sqlite的操作。而作为Google的亲儿子Room也是对sqlite的一层抽象。它使用了APT机制，通过注解的方式在编译阶段生成sqlite代码，使开发者不需要写冗杂的sqlite代码，提高开发效率。想要了解一个东西的用法，我们首先要会用它。sqli
Jetpack Room 使用详解(上)
热门推荐
百锦再的博客
04-26 1万+
Room 是 Android Jetpack 组件中的一部分，它是一个 SQLite 对象映射库，提供了在 SQLite 上更抽象的层，使开发者能够更流畅地访问数据库。Room 在编译时验证 SQL 查询，避免了运行时错误，并且减少了大量样板代码。
Jetpack Room
txaz6的博客
07-15 699
SQLite说，我明明是你们的“祖宗“，怎么现在都冷落我😭？Room回答道：你难道不知道？我都给开发者飞一般的感觉了😏
初步了解JetPack中的Room
qq_40509784的博客
04-11 1398
初步了解JetPack中的Room关于Room使用Room添加的依赖：创建项目运行项目结束小结 本文为学习类文档，通过学习B站up主longway777的视频，再加上自己的总结与理解的学习类文章，如有侵权，请联系博主进行删除 关于Room Room 持久性库在 SQLite 的基础上提供了一个抽象层，让用户能够在充分利用 SQLite 的强大功能的同时，获享更强健的数据库访问机制。 该库可帮助您在...
【Android】数据库Room的使用总结
liupengcaho的博客
11-15 3042
本文简述了Android开发中Room数据库的应用，包括设置实体类、定义DAO接口、创建数据库类，并在Activity或ViewModel中通过协程进行数据库操作，以实现高效、安全的本地数据管理。
Room数据库的使用
qq_39317095的博客
03-11 360
1、在app的gradle中引入2、在model的gradle中引入3、在DLS中引入相关数据包，因为在新的DLS中需要引入ksp中。
评论 211
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

百锦再@新空间

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

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

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

打赏作者

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

抵扣说明：

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

余额充值