01-10-28 Room数据库框架：Android官方SQLite封装方案

原创 于 2026-04-02 15:11:43 发布 · 53 阅读 · 0 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
GEO检测
标签
#数据库 #android #sqlite

01-10-28 Room数据库框架：Android官方SQLite封装方案

摘要

Room是Google官方推出的Android SQLite数据库封装库，通过编译时注解处理生成数据库访问代码，提供了类型安全、易于测试和维护的数据库操作API。本文深入剖析Room的核心实现原理，包括数据库架构设计、DAO代码生成机制、Migration迁移策略、LiveData集成以及多线程处理，揭示其如何简化Android数据库开发。

关键词：Room、SQLite、数据库、ORM、编译时注解、DAO、Migration、Android Jetpack

一、Room架构概览

1.1 核心架构设计

应用层

@Database注解类

@Dao接口

@Entity数据类

RoomProcessor

生成实现类

DatabaseImpl

DaoImpl

EntityCursorAdapter

SQLiteOpenHelper

SQLiteStatement

SQLite数据库

1.2 三大核心组件

@Database

数据库配置

@Entity

表结构定义

@Dao

数据访问接口

版本管理

DAO引用

Entity列表

字段映射

主键定义

索引配置

查询方法

插入方法

更新/删除方法

二、核心注解设计

2.1 @Database注解

// room-common/src/main/java/androidx/room/Database.java
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.CLASS)
public @interface Database {
    /**
     * 数据库中的Entity列表
     */
    Class<?>[] entities();

    /**
     * 数据库中的View列表
     */
    Class<?>[] views() default {};

    /**
     * 数据库版本号
     */
    int version();

    /**
     * 是否导出schema文件
     */
    boolean exportSchema() default true;
}

// 使用示例
@Database(
    entities = {User.class, Order.class},
    version = 1,
    exportSchema = false
)
public abstract class AppDatabase extends RoomDatabase {

    public abstract UserDao userDao();
    public abstract OrderDao orderDao();

    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.2 @Entity注解

// room-common/src/main/java/androidx/room/Entity.java
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.CLASS)
public @interface Entity {
    /**
     * 表名，默认使用类名
     */
    String tableName() default "";

    /**
     * 索引定义
     */
    Index[] indices() default {};

    /**
     * 是否继承父类字段
     */
    boolean inheritSuperIndices() default false;

    /**
     * 主键定义
     */
    String[] primaryKeys() default {};

    /**
     * 外键定义
     */
    ForeignKey[] foreignKeys() default {};
}

// 使用示例
@Entity(
    tableName = "users",
    indices = {
        @Index(value = {"email"}, unique = true),
        @Index(value = {"name", "age"})
    }
)
public class User {

    @PrimaryKey(autoGenerate = true)
    private long id;

    @ColumnInfo(name = "user_name")
    private String name;

    @ColumnInfo(name = "user_age")
    private int age;

    private String email;

    @Ignore
    private String tempData;

    // Getters and setters
}

2.3 @Dao注解

// room-common/src/main/java/androidx/room/Dao.java
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.CLASS)
public @interface Dao {
}

// 使用示例
@Dao
public interface UserDao {

    @Query("SELECT * FROM users")
    List<User> getAllUsers();

    @Query("SELECT * FROM users WHERE id = :userId")
    User getUserById(long userId);

    @Query("SELECT * FROM users WHERE name LIKE :searchQuery")
    LiveData<List<User>> searchUsers(String searchQuery);

    @Insert(onConflict = OnConflictStrategy.REPLACE)
    long insertUser(User user);

    @Insert
    void insertUsers(List<User> users);

    @Update
    int updateUser(User user);

    @Delete
    void deleteUser(User user);

    @Query("DELETE FROM users WHERE id = :userId")
    void deleteUserById(long userId);

    @Transaction
    @Query("SELECT * FROM users WHERE id = :userId")
    UserWithOrders getUserWithOrders(long userId);
}

三、编译时注解处理

3.1 RoomProcessor核心逻辑

// room-compiler/src/main/kotlin/androidx/room/RoomProcessor.kt
@AutoService(Processor::class)
class RoomProcessor : BasicAnnotationProcessor() {

    override fun steps(): Iterable<Step> {
        return listOf(
            DatabaseProcessingStep(),
            DaoProcessingStep(),
            EntityProcessingStep()
        )
    }

    private inner class DatabaseProcessingStep : Step {
        override fun annotations(): Set<String> {
            return setOf(Database::class.java.canonicalName)
        }

        override fun process(
            elementsByAnnotation: SetMultimap<String, Element>
        ): Set<Element> {
            val databases = elementsByAnnotation[Database::class.java.canonicalName]

            databases.forEach { element ->
                val typeElement = element as TypeElement
                val database = DatabaseProcessor(
                    processingEnv,
                    typeElement
                ).process()

                // 生成DatabaseImpl类
                DatabaseWriter(database).write(processingEnv)
            }

            return emptySet()
        }
    }
}

3.2 Database代码生成

// room-compiler/src/main/kotlin/androidx/room/writer/DatabaseWriter.kt
class DatabaseWriter(val database: Database) : ClassWriter(database.typeName) {

    override fun createTypeSpecBuilder(): TypeSpec.Builder {
        val builder = TypeSpec.classBuilder(database.implTypeName)
            .addModifiers(PUBLIC)
            .superclass(database.typeName)

        // 生成DAO实例字段
        database.daoMethods.forEach { dao ->
            builder.addField(
                FieldSpec.builder(dao.dao.typeName, dao.dao.implTypeName.simpleName())
                    .addModifiers(PRIVATE, VOLATILE)
                    .build()
            )
        }

        // 生成createOpenHelper方法
        builder.addMethod(createOpenHelperMethod())

        // 生成createInvalidationTracker方法
        builder.addMethod(createInvalidationTrackerMethod())

        // 生成clearAllTables方法
        builder.addMethod(createClearAllTablesMethod())

        // 生成DAO getter方法
        database.daoMethods.forEach { dao ->
            builder.addMethod(createDaoMethod(dao))
        }

        return builder
    }

    private fun createOpenHelperMethod(): MethodSpec {
        val implVar = "_helper"
        return MethodSpec.methodBuilder("createOpenHelper")
            .addAnnotation(Override::class.java)
            .addModifiers(PROTECTED)
            .returns(SupportSQLiteOpenHelper::class.java)
            .addParameter(DatabaseConfiguration::class.java, "configuration")
            .apply {
                addStatement(
                    "\$T \$L = new \$T(\$N, new \$T(\$N, \$L, \$L) { ... })",
                    SupportSQLiteOpenHelper::class.java, implVar,
                    FrameworkSQLiteOpenHelperFactory::class.java, "configuration",
                    SupportSQLiteOpenHelper.Callback::class.java, "configuration",
                    database.version, database.version
                )

                addStatement("return \$L", implVar)
            }
            .build()
    }

    private fun createDaoMethod(dao: DaoMethod): MethodSpec {
        val daoFieldName = dao.dao.implTypeName.simpleName()
        return MethodSpec.methodBuilder(dao.name)
            .addAnnotation(Override::class.java)
            .addModifiers(PUBLIC)
            .returns(dao.dao.typeName)
            .apply {
                beginControlFlow("if (\$L != null)", daoFieldName)
                addStatement("return \$L", daoFieldName)
                nextControlFlow("else")
                beginControlFlow("synchronized(this)")
                beginControlFlow("if(\$L == null)", daoFieldName)
                addStatement("\$L = new \$T(this)", daoFieldName, dao.dao.implTypeName)
                endControlFlow()
                addStatement("return \$L", daoFieldName)
                endControlFlow()
                endControlFlow()
            }
            .build()
    }
}

3.3 DAO代码生成

// room-compiler/src/main/kotlin/androidx/room/writer/DaoWriter.kt
class DaoWriter(val dao: Dao, val dbParam: DatabaseWriter.DaoParamField) : ClassWriter(dao.typeName) {

    override fun createTypeSpecBuilder(): TypeSpec.Builder {
        val builder = TypeSpec.classBuilder(dao.implTypeName)
            .addModifiers(PUBLIC, FINAL)
            .addSuperinterface(dao.typeName)

        // 添加数据库引用字段
        builder.addField(
            FieldSpec.builder(dbParam.type, dbParam.name, PRIVATE, FINAL).build()
        )

        // 添加构造器
        builder.addMethod(createConstructor())

        // 生成所有方法实现
        dao.queryMethods.forEach { method ->
            builder.addMethod(createQueryMethod(method))
        }

        dao.insertionMethods.forEach { method ->
            builder.addMethod(createInsertMethod(method))
        }

        dao.updateMethods.forEach { method ->
            builder.addMethod(createUpdateMethod(method))
        }

        dao.deletionMethods.forEach { method ->
            builder.addMethod(createDeleteMethod(method))
        }

        return builder
    }

    private fun createQueryMethod(method: QueryMethod): MethodSpec {
        val returnType = method.returnType
        val methodBuilder = MethodSpec.methodBuilder(method.name)
            .addAnnotation(Override::class.java)
            .addModifiers(PUBLIC)
            .returns(returnType.typeName)

        // 添加参数
        method.parameters.forEach { param ->
            methodBuilder.addParameter(param.typeName, param.name)
        }

        // 生成SQL查询代码
        val queryVar = scope.getTmpVar("_sql")
        methodBuilder.addStatement(
            "final \$T \$L = \$S",
            String::class.java, queryVar, method.query.original
        )

        // 生成RoomSQLiteQuery
        val roomSqlQueryVar = scope.getTmpVar("_statement")
        methodBuilder.addStatement(
            "final \$T \$L = \$T.acquire(\$L, \$L)",
            RoomSQLiteQuery::class.java, roomSqlQueryVar,
            RoomSQLiteQuery::class.java, queryVar,
            method.parameters.size
        )

        // 绑定参数
        method.parameters.forEachIndexed { index, param ->
            bindQueryParameter(methodBuilder, param, index + 1, roomSqlQueryVar)
        }

        // 执行查询并处理结果
        if (returnType is LiveDataType) {
            // LiveData返回类型
            createLiveDataQuery(methodBuilder, method, roomSqlQueryVar)
        } else {
            // 普通返回类型
            createNormalQuery(methodBuilder, method, roomSqlQueryVar)
        }

        return methodBuilder.build()
    }

    private fun createInsertMethod(method: InsertionMethod): MethodSpec {
        val methodBuilder = MethodSpec.methodBuilder(method.name)
            .addAnnotation(Override::class.java)
            .addModifiers(PUBLIC)
            .returns(method.returnType.typeName)

        method.parameters.forEach { param ->
            methodBuilder.addParameter(param.typeName, param.name)
        }

        // 生成插入代码
        methodBuilder.addStatement("\$L.assertNotSuspendingTransaction()", dbParam.name)
        methodBuilder.addStatement("\$L.beginTransaction()", dbParam.name)

        methodBuilder.beginControlFlow("try")

        val insertStmtVar = scope.getTmpVar("_stmt")
        methodBuilder.addStatement(
            "\$T \$L = \$L.getInsertionStatement()",
            SupportSQLiteStatement::class.java, insertStmtVar, method.entity.insertionAdapterField
        )

        // 绑定参数并执行
        method.parameters.forEach { param ->
            bindInsertParameter(methodBuilder, param, insertStmtVar)
            methodBuilder.addStatement("\$L.executeInsert()", insertStmtVar)
        }

        methodBuilder.addStatement("\$L.setTransactionSuccessful()", dbParam.name)

        if (method.returnType.typeName != TypeName.VOID) {
            methodBuilder.addStatement("return \$L", scope.getTmpVar("_result"))
        }

        methodBuilder.nextControlFlow("finally")
        methodBuilder.addStatement("\$L.endTransaction()", dbParam.name)
        methodBuilder.endControlFlow()

        return methodBuilder.build()
    }
}

四、数据库迁移机制

4.1 Migration接口

// room-runtime/src/main/java/androidx/room/migration/Migration.java
public abstract class Migration {

    public final int startVersion;
    public final int endVersion;

    public Migration(int startVersion, int endVersion) {
        this.startVersion = startVersion;
        this.endVersion = endVersion;
    }

    /**
     * 执行迁移逻辑
     */
    public abstract void migrate(@NonNull SupportSQLiteDatabase database);
}

// 使用示例
static final Migration MIGRATION_1_2 = new Migration(1, 2) {
    @Override
    public void migrate(@NonNull SupportSQLiteDatabase database) {
        // 添加新列
        database.execSQL("ALTER TABLE users ADD COLUMN phone TEXT");
    }
};

static final Migration MIGRATION_2_3 = new Migration(2, 3) {
    @Override
    public void migrate(@NonNull SupportSQLiteDatabase database) {
        // 创建新表
        database.execSQL("CREATE TABLE IF NOT EXISTS `orders` " +
            "(`id` INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, " +
            "`user_id` INTEGER NOT NULL, " +
            "`total` REAL NOT NULL)");

        // 创建索引
        database.execSQL("CREATE INDEX `index_orders_user_id` ON `orders` (`user_id`)");
    }
};

// 应用迁移
AppDatabase db = Room.databaseBuilder(context, AppDatabase.class, "database")
    .addMigrations(MIGRATION_1_2, MIGRATION_2_3)
    .build();

4.2 迁移路径查找

多步迁移

版本1

MIGRATION_1_2

版本2

MIGRATION_2_3

版本3

MIGRATION_3_4

版本4

MIGRATION_1_3

 
// room-runtime/src/main/java/androidx/room/migration/MigrationPathFinder.java
class MigrationPathFinder {

    /**
     * 查找迁移路径
     */
    public List<Migration> findMigrationPath(int start, int end) {
        if (start == end) {
            return Collections.emptyList();
        }

        boolean migratingUp = end > start;
        List<Migration> result = new ArrayList<>();
        return findUpMigrationPath(result, migratingUp, start, end);
    }

    private List<Migration> findUpMigrationPath(
        List<Migration> result,
        boolean upgrade,
        int start,
        int end
    ) {
        while (upgrade ? start < end : start > end) {
            Set<Migration> targetNodes = mMigrations.get(start);
            if (targetNodes == null) {
                return null;
            }

            int targetVersion = upgrade ? end : start;
            int finalVersion = upgrade ? start : end;

            Migration migration = null;
            int minDistance = Integer.MAX_VALUE;

            // 查找最短路径
            for (Migration m : targetNodes) {
                int potentialVersion = upgrade ? m.endVersion : m.startVersion;
                if (potentialVersion <= targetVersion && potentialVersion > finalVersion) {
                    int distance = Math.abs(potentialVersion - targetVersion);
                    if (distance < minDistance) {
                        migration = m;
                        minDistance = distance;
                    }
                }
            }

            if (migration == null) {
                return null;
            }

            result.add(migration);
            start = upgrade ? migration.endVersion : migration.startVersion;
        }

        return result;
    }
}

4.3 自动迁移（Room 2.4+）

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

// 复杂自动迁移（需要自定义逻辑）
@Database(
    entities = [User::class],
    version = 3,
    autoMigrations = [
        AutoMigration(
            from = 2,
            to = 3,
            spec = Migration2To3::class
        )
    ]
)
abstract class AppDatabase : RoomDatabase() {

    @DeleteColumn(tableName = "users", columnName = "temp_data")
    @RenameColumn(tableName = "users", fromColumnName = "name", toColumnName = "user_name")
    class Migration2To3 : AutoMigrationSpec
}

五、LiveData和Flow集成

5.1 LiveData支持

@Dao
interface UserDao {

    // 返回LiveData，自动监听数据变化
    @Query("SELECT * FROM users")
    fun getAllUsersLive(): LiveData<List<User>>

    @Query("SELECT * FROM users WHERE id = :userId")
    fun getUserLive(userId: Long): LiveData<User>
}

// 使用
val usersLiveData = database.userDao().getAllUsersLive()
usersLiveData.observe(lifecycleOwner) { users ->
    // 数据更新时自动触发
    adapter.submitList(users)
}

5.2 LiveData实现原理

// room-runtime/src/main/java/androidx/room/RoomTrackingLiveData.java
class RoomTrackingLiveData<T> extends LiveData<T> {

    final RoomDatabase mDatabase;
    final boolean mInTransaction;
    final Callable<T> mComputeFunction;

    private final InvalidationTracker.Observer mObserver;

    private AtomicBoolean mInvalid = new AtomicBoolean(true);
    private AtomicBoolean mComputing = new AtomicBoolean(false);
    private AtomicBoolean mRegisteredObserver = new AtomicBoolean(false);

    final Runnable mRefreshRunnable = new Runnable() {
        @Override
        public void run() {
            if (mRegisteredObserver.compareAndSet(false, true)) {
                mDatabase.getInvalidationTracker().addObserver(mObserver);
            }

            boolean computed;
            do {
                computed = false;
                if (mComputing.compareAndSet(false, true)) {
                    try {
                        T value = null;
                        while (mInvalid.compareAndSet(true, false)) {
                            computed = true;
                            try {
                                // 执行查询
                                value = mComputeFunction.call();
                            } catch (Exception e) {
                                throw new RuntimeException("Exception while computing database"
                                    + " live data.", e);
                            }
                        }
                        if (computed) {
                            postValue(value);
                        }
                    } finally {
                        mComputing.set(false);
                    }
                }
            } while (computed && mInvalid.get());
        }
    };

    RoomTrackingLiveData(
        RoomDatabase database,
        String[] tableNames,
        boolean inTransaction,
        Callable<T> computeFunction
    ) {
        mDatabase = database;
        mInTransaction = inTransaction;
        mComputeFunction = computeFunction;
        mObserver = new InvalidationTracker.Observer(tableNames) {
            @Override
            public void onInvalidated(@NonNull Set<String> tables) {
                ArchTaskExecutor.getInstance().executeOnMainThread(mInvalidRefreshRunnable);
            }
        };
    }

    @Override
    protected void onActive() {
        super.onActive();
        mDatabase.getQueryExecutor().execute(mRefreshRunnable);
    }

    @Override
    protected void onInactive() {
        super.onInactive();
        ArchTaskExecutor.getInstance().executeOnDiskIO(mInvalidationRunnable);
    }
}

5.3 Flow支持（Kotlin协程）

@Dao
interface UserDao {

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

    @Query("SELECT * FROM users WHERE id = :userId")
    fun getUserFlow(userId: Long): Flow<User?>
}

// 使用
lifecycleScope.launch {
    database.userDao().getAllUsersFlow()
        .collect { users ->
            // 数据更新时自动触发
            adapter.submitList(users)
        }
}

六、性能优化

6.1 批量操作

@Dao
interface UserDao {

    // 批量插入
    @Insert
    suspend fun insertUsers(users: List<User>)

    // 批量更新
    @Update
    suspend fun updateUsers(users: List<User>)

    // 批量删除
    @Delete
    suspend fun deleteUsers(users: List<User>)

    // 事务保证原子性
    @Transaction
    suspend fun updateUsersAndOrders(users: List<User>, orders: List<Order>) {
        insertUsers(users)
        insertOrders(orders)
    }
}

6.2 索引优化

@Entity(
    tableName = "users",
    indices = [
        // 单列索引
        @Index(value = ["email"], unique = true),
        // 复合索引
        @Index(value = ["name", "age"]),
        // 全文搜索索引（需要FTS）
        @Index(value = ["content"], orders = [Index.Order.ASC])
    ]
)
data class User(
    @PrimaryKey(autoGenerate = true)
    val id: Long = 0,
    val name: String,
    val age: Int,
    val email: String
)

6.3 查询优化

查询优化

使用索引

减少JOIN

投影查询

分页加载

复合索引

唯一索引

@Relation

@Embedded

仅查询需要的列

PagingSource

LimitOffset

 
// [通过] 投影查询（只查询需要的列）
@Query("SELECT id, name FROM users")
fun getUserNames(): List<UserName>

data class UserName(val id: Long, val name: String)

// [通过] 分页查询
@Query("SELECT * FROM users LIMIT :limit OFFSET :offset")
fun getUsersPaged(limit: Int, offset: Int): List<User>

// [通过] 使用Paging 3
@Query("SELECT * FROM users ORDER BY name ASC")
fun getUsersPagingSource(): PagingSource<Int, User>

七、测试支持

7.1 内存数据库测试

@RunWith(AndroidJUnit4::class)
class UserDaoTest {

    private lateinit var database: AppDatabase
    private lateinit var userDao: UserDao

    @Before
    fun createDb() {
        val context = ApplicationProvider.getApplicationContext<Context>()
        database = Room.inMemoryDatabaseBuilder(
            context,
            AppDatabase::class.java
        ).build()
        userDao = database.userDao()
    }

    @After
    fun closeDb() {
        database.close()
    }

    @Test
    fun insertAndGetUser() = runBlocking {
        val user = User(name = "Alice", age = 25, email = "alice@example.com")
        val id = userDao.insertUser(user)

        val loadedUser = userDao.getUserById(id)
        assertThat(loadedUser.name, equalTo("Alice"))
    }

    @Test
    fun getAllUsers() = runBlocking {
        val users = listOf(
            User(name = "Alice", age = 25, email = "alice@example.com"),
            User(name = "Bob", age = 30, email = "bob@example.com")
        )
        userDao.insertUsers(users)

        val allUsers = userDao.getAllUsers()
        assertThat(allUsers.size, equalTo(2))
    }
}

7.2 Migration测试

@RunWith(AndroidJUnit4::class)
class MigrationTest {

    private val TEST_DB = "migration-test"

    @get:Rule
    val helper: MigrationTestHelper = MigrationTestHelper(
        InstrumentationRegistry.getInstrumentation(),
        AppDatabase::class.java.canonicalName,
        FrameworkSQLiteOpenHelperFactory()
    )

    @Test
    fun migrate1To2() {
        // 创建版本1数据库并插入数据
        helper.createDatabase(TEST_DB, 1).apply {
            execSQL("INSERT INTO users (id, name, age) VALUES (1, 'Alice', 25)")
            close()
        }

        // 执行迁移到版本2
        helper.runMigrationsAndValidate(TEST_DB, 2, true, MIGRATION_1_2)

        // 验证迁移后的数据
        val db = getMigratedRoomDatabase()
        val user = db.userDao().getUserById(1)
        assertThat(user.name, equalTo("Alice"))
    }

    private fun getMigratedRoomDatabase(): AppDatabase {
        val database = Room.databaseBuilder(
            InstrumentationRegistry.getInstrumentation().targetContext,
            AppDatabase::class.java,
            TEST_DB
        ).addMigrations(MIGRATION_1_2, MIGRATION_2_3).build()

        helper.closeWhenFinished(database)
        return database
    }
}

八、总结与最佳实践

8.1 核心优势

  1. 编译时验证：SQL语法错误在编译期发现
  2. 类型安全：避免运行时类型转换错误
  3. LiveData集成：自动监听数据变化
  4. 迁移管理：清晰的版本升级路径
  5. 测试友好：支持内存数据库测试

8.2 最佳实践

// [通过] 推荐：使用单例模式
class DatabaseProvider {
    companion object {
        @Volatile
        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"
                )
                .addMigrations(MIGRATION_1_2, MIGRATION_2_3)
                .build()
                INSTANCE = instance
                instance
            }
        }
    }
}

// [通过] 推荐：使用suspend函数
@Dao
interface UserDao {
    @Insert
    suspend fun insertUser(user: User): Long

    @Query("SELECT * FROM users")
    suspend fun getAllUsers(): List<User>
}

// [通过] 推荐：使用事务保证数据一致性
@Transaction
suspend fun transferMoney(fromId: Long, toId: Long, amount: Double) {
    updateBalance(fromId, -amount)
    updateBalance(toId, amount)
}

// [未通过] 避免：在主线程执行数据库操作
// 使用协程或RxJava处理异步操作

// [未通过] 避免：频繁打开关闭数据库
// 使用单例模式复用数据库实例

8.3 性能数据

  • 查询性能：接近原生SQLite（额外开销<5%）
  • 编译时间：增加10-30秒（中型项目）
  • APK增量：约100-300KB（生成的代码）
  • 内存占用：约1-3MB（数据库连接池）

Room通过编译时代码生成和类型安全设计，为Android开发者提供了优雅的数据库访问方案，是现代Android应用的标准选择。

参考资源：

android room数据库简单使用
lcp0633的博客
05-12 1729
room
Andriod开发 Room 数据库处理框架
jmqxnxg的博客
06-03 1608
Room是Android Jetpack组件库中的一部分，它是一个SQLite数据库的抽象层，提供了更简单的API和更好的性能，适合于中大型应用程序。举个例子，我们要将书本信息存储到数据库中，那么可以先创建一个书本信息的新类，用于封装书本信息。在该实体类中，用注解表明实体：@Entity， 和对应表中的主键：@PrimaryKey。这个接口不需要实现具体的增删改查操作，只需要用注解标记好对应的操作。也是类似的，用注解写清楚该数据库涉及的实体类。这样数据库的实例就是全局变量。3）创建数据库的抽象类。
【Android】Room—数据库的基本操作
最新发布
2301_79828182的博客
09-15 3607
在Android开发中，数据持久化是一个不可或缺的部分。随着应用的复杂度增加，选择合适的数据存储方式变得尤为重要。Room数据库作为Android Jetpack架构组件之一，提供了一种抽象层，使得开发者能够以更简洁、更安全的方式操作SQLite数据库。本文将带你深入了解Room数据库的基本概念、使用方式以及最佳实践。
Android Room DataBase(一)
李岳锋的专栏
02-22 8936
前言： 众所周知，安卓原生的Sqlite数据库的操作不仅冗余麻烦，而且操作过程容易出问题。所以，后续github上出现了许多开源的封装了Sqlite的第三方library，来帮助你简化操作数据库，摆脱Sqlite的魔掌。比如，举世闻名的GreenDao。又比如，白痴化不需写Sql语句的Realm。又比如…. 。Anyway, 谷歌也注意到这个问题。所以，推出了Room DataBase，来解决这...
Android Room DataBase(二)
李岳锋的专栏
02-23 8533
前言： 1、在学习本篇之前，请确保你读过Android Room DataBase(一)，或者知道如何定义Room的三大组件以及如何简单的使用它们。 2、本篇，将着重讲解Room的Entity（表）。包含如何定义Entity的主键、索引、唯一性 and so on。 3、Sql的基本语法：http://www.w3school.com.cn/sql/index.asp 一、在Room数据库...
android field 类型,Android中MIME类型的解释
weixin_39594457的博客
06-01 250
小弟也是android的初学者，该文完全代表了个人的理解，错误之处望各位凛然指出，必当虚心纠正；若能对懵懂中人起到些许提示作用，小弟深感欣慰！初始MIME类型，是在学习ContentProvider的时候。当在创建自己的ContentProvider的时，需要从抽象类ContentProvider中派生出自己的子类，并实现其中5个抽象方法：insert(Uri, ContentValues)wh...
Android 修改 final 类型的field
aprilxiaomeixiaomei的博客
01-25 877
最近做Android 测试的时候用到反射，与平常java用来修改final的方法不太一样，走了一些弯路，记录下来方便以后查阅 Field field = MyClass.class.getField("FINAL_NAME"); field.setAccessible(true); field.set(null, "NAME_VALUE");
android field 类型,android – 如何生成buildConfigField与String类型
weixin_36036271的博客
06-01 1464
在我的Android Studio项目中有两个buildConfigField的构建配置：buildTypes {def SERVER_URL = "SERVER_URL"def APP_VERSION = "APP_VERSION"debug {buildConfigField "String", SERVER_URL, "http://dev.myserver.com"buildConfigF...
Android 修改 final 类型的 field
ReadyShowShow的博客
11-20 2132
这是一个比较特殊的知识点，需要从HotSpot与Dalvik的区别说起。 问题起因 相信大家在继承RecycleView时，对ViewHolder中的itemView都有重写的欲望。这个itemView是final类型的，不容许被修改，极大的限制了开发的自由。 那首先想到的就是利用反射来修改该字段。可是运行会报错。 创建一个通用方法进行反射修改属性值,如下： public static void ...
android field 类型,Gradle buildConfigField 使用Hashmap ArrayList 等类型
weixin_39915267的博客
06-01 916
buildConfigField可以在gradle脚本中定义我们需要的变量，然后在代码中引用。官方文档上buildConfigField 定义的格式是这样的：void buildConfigField(String type, String name, String value)我们可以很方便的定义基础类型，如type为Long String int boolean等基础类型，但是我们能不能定义数...
android中Room数据库的基本使用
Gefangenes的博客
05-13 5198
Room是Google官方推荐使用的数据库，相比较某些优秀数据库框架来说，不用过于担心某天库会停止维护，且访问数据库非常流畅，并且提供了与常规的ORM框架一样，通过添加编译期注解来进行表和字段的配置，譬如@Database、@Dao、@Entity、@Query、@Insert、@Update、@Detele等的注解,可以使用简单代码实现相比以前SQLite更复杂的代码的效果，这点儿有点儿类似于java世界里的mybatis。它包含了一个抽象方法wordDao()，用于获取WordDao接口的实例。
Android Room Database 学习
成长的烧年
05-09 2397
Room数据库学习初衷概览配置定义data类定义UserDao定义抽象数据库项目build 自动生成文件使用定义数据实体定义对象之间关系使用DAOS数据库更新 初衷 由于接手的项目中，看到别人使用的是Android Jetpack下的Android Room数据库，由于以前也只是接触过GreenDao和自己写的sqlite数据库，所以就学习了一下，做一个笔记记录一下。这是我以前学习的greenda...
Android : Room 数据库的基本用法 —简单应用_一_入门
javaGHui的博客
12-10 1万+
Android : Room 数据库的基本用法 —简单应用_一_入门
安卓Room框架的详解
m0_64881205的博客
01-22 2768
就是创建一个application并且继承自application，单例模式，同时关联database类的属性，也就是实例化这个类中对象，先是设置为全局，然后再oncreate方法中定义，表示在app创建的时候，就创建数据库的连接.addMigrations()//允许数据迁移.allowMainThreadQueries()//允许在主线程中操作数据库.build();//调用build方法生成Application对象。
Android开发之Room数据库深入分析
wlred1980的博客
03-15 1203
Room是Android Jetpack组件的一部分，由Google推出，它是一个抽象层位于SQLite之上，用于更方便地访问和操作本地数据库。Room提供了编译时的检查来避免常见的运行时错误，并简化了数据库的迁移过程。通过使用Room, 开发者可以以更加直观和简洁的方式定义数据库模式和执行数据库操作。
Android-第十三节04Room框架详解
H_xxxxd的博客
07-27 3708
room数据库框架使用方法
Android Room 数据库详解
yingaizhu的博客
06-10 1万+
数据库是 Room 的三大组件之一，数据库是用来存储数据的，是 Room 中必不可少的一部分。本篇幅将详细讲解 Room 数据库相关的内容
一文带你了解Room数据库
热门推荐
养生阿华田
12-21 1万+
1.引言 Sqlite的代码写起来繁琐且容易出错，数据和对象之间的映射过程写起来实在无趣，还是不如使用ORM框架来的得心应手。 2.Room是什么 Room是Goole推出的数据库框架，属于ORM库。 Room提供了SQLite的抽象层，以便在充分利用SQLite的同时允许流畅的数据库访问。 Room与其他ORM框架对比有以下优点： 编译期检查，Room会在编译的时候验证每个@Query和@Entity等，它不仅检查语法问题，还会检查是否有该表,这就意味着几乎没有任何运行时错误的风险 较少的模板代码 与
Android JetPack 框架库之Room数据库
qq_15596445的博客
05-21 411
Dao@Insert。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

龚寿生

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

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

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

打赏作者

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

抵扣说明：

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

余额充值