RoomDatabase继承与关联处理：电子钱包余额变更存储问题

我正在开发一款简易电子钱包APP，需要在RoomDatabase中存储每笔交易后的账户余额变更详情及当前余额。目前在处理Room中的继承关系时遇到问题：

我定义了父类BalanceChanges：

open class BalanceChanges(
    open var type:Int,
    open var referenceid:String,
    open val date:String
)

以及TopUp等子类：

data class TopUp(
    var amount:Int,
    override val date: String, 
    val bank:String,
    val odersn:String,
    override var referenceid:String,
    override var type:Int = TYPE_TOPUP
):BalanceChanges(type,referenceid, date)

我希望存储如下结构的数据：

class BalanceChangesWithCurrentBalance(
    val referenceid: String,
    val balanceChanges: BalanceChanges,
    val currentbalance: Int
) {
}

该类包含当前余额及代表多个子类的父类BalanceChanges实例。请问如何实现该类在Room中的插入与查询？

我曾考虑利用共享且唯一的referenceid字段建立关联关系，但核心难点是如何处理父类与子类的关系：是为每个子类表建立多关联，还是将所有子类存储到同一张表中？

Room支持两种处理继承关系的方式，针对电子钱包的交易场景，单表策略是更优选择——交易类型（充值、消费、转账等）的核心字段重叠度高，单表查询更高效，也更贴合你统一返回BalanceChanges父类实例的需求。

一、单表策略（表继承） #

将所有子类的字段合并到一张表中，用type字段区分交易类型，通过Room的@Entity和@TypeConverters实现类型转换。

1. 定义实体类 #

修改父类为Room实体，包含所有子类的可选字段；子类用@Ignore标记父类已存在的字段，避免冲突：

// 父类作为核心实体，包含所有交易类型的字段
@Entity(tableName = "balance_changes")
open class BalanceChanges(
    @PrimaryKey val referenceid: String, // 用唯一referenceid做主键
    var type: Int,
    val date: String,
    // 子类特有字段设为可空或默认值
    var amount: Int? = null,
    var bank: String? = null,
    var odersn: String? = null,
    // 直接存储当前余额，无需额外关联表
    val currentbalance: Int
)

// TopUp子类，忽略父类已定义的字段
data class TopUp(
    @Ignore override val referenceid: String,
    @Ignore override val type: Int = TYPE_TOPUP,
    @Ignore override val date: String,
    val amount: Int,
    val bank: String,
    val odersn: String,
    @Ignore override val currentbalance: Int
) : BalanceChanges(referenceid, type, date, amount, bank, odersn, currentbalance)

注：TYPE_TOPUP是自定义常量，比如const val TYPE_TOPUP = 1，用来标记交易类型。

2. 添加类型转换器 #

让Room能在BalanceChanges与具体子类之间做JSON序列化/反序列化：

class BalanceChangesConverter {
    @TypeConverter
    fun fromBalanceChanges(balanceChanges: BalanceChanges): String {
        return Gson().toJson(balanceChanges)
    }

    @TypeConverter
    fun toBalanceChanges(json: String): BalanceChanges {
        val type = object : TypeToken<BalanceChanges>() {}.type
        return Gson().fromJson(json, type)
    }
}

在RoomDatabase类上注册转换器：

@Database(entities = [BalanceChanges::class], version = 1)
@TypeConverters(BalanceChangesConverter::class)
abstract class WalletDatabase : RoomDatabase() {
    abstract fun balanceChangesDao(): BalanceChangesDao
}

3. DAO层实现插入与查询 #

@Dao
interface BalanceChangesDao {
    // 直接插入子类实例，Room会自动映射到父类实体表
    @Insert
    suspend fun insert(balanceChanges: BalanceChanges)

    // 查询所有交易记录，返回父类列表，自动保留子类属性
    @Query("SELECT * FROM balance_changes ORDER BY date DESC")
    suspend fun getAllBalanceChanges(): List<BalanceChanges>

    // 查询单条记录并封装为BalanceChangesWithCurrentBalance
    suspend fun getBalanceChangesWithCurrentBalance(refId: String): BalanceChangesWithCurrentBalance? {
        val record = getBalanceChangesById(refId) ?: return null
        return BalanceChangesWithCurrentBalance(record.referenceid, record, record.currentbalance)
    }

    @Query("SELECT * FROM balance_changes WHERE referenceid = :refId")
    private suspend fun getBalanceChangesById(refId: String): BalanceChanges?
}

二、多表策略（关联继承） #

如果不同交易类型的字段差异极大，可给每个子类单独建表，父类表存储公共字段，通过referenceid关联。但这种方式会增加查询和插入的复杂度。

1. 定义实体类 #

父类表存公共字段，子类表存特有字段，通过外键关联：

@Entity(tableName = "balance_changes_base")
open class BalanceChangesBase(
    @PrimaryKey val referenceid: String,
    val type: Int,
    val date: String,
    val currentbalance: Int
)

@Entity(tableName = "top_up", foreignKeys = [ForeignKey(
    entity = BalanceChangesBase::class,
    parentColumns = ["referenceid"],
    childColumns = ["referenceid"],
    onDelete = ForeignKey.CASCADE
)])
data class TopUp(
    @PrimaryKey val referenceid: String,
    val amount: Int,
    val bank: String,
    val odersn: String
)

2. 定义关联数据类 #

data class BalanceChangesWithCurrentBalance(
    @Embedded val base: BalanceChangesBase,
    @Relation(
        parentColumn = "referenceid",
        entityColumn = "referenceid"
    )
    val topUp: TopUp? // 其他子类如Payment、Transfer也需添加可空字段
)

3. DAO层实现 #

插入时需同时操作父类和子类表，查询时通过事务关联多表：

@Dao
interface BalanceChangesDao {
    @Insert
    suspend fun insertBase(base: BalanceChangesBase)

    @Insert
    suspend fun insertTopUp(topUp: TopUp)

    // 插入充值记录的事务
    suspend fun insertTopUpTransaction(topUp: TopUp, currentBalance: Int) {
        insertBase(BalanceChangesBase(topUp.referenceid, TYPE_TOPUP, topUp.date, currentBalance))
        insertTopUp(topUp)
    }

    // 查询所有交易记录，关联子类表
    @Transaction
    @Query("SELECT * FROM balance_changes_base ORDER BY date DESC")
    suspend fun getAllBalanceChanges(): List<BalanceChangesWithCurrentBalance>
}

查询后需手动根据base.type判断具体子类，封装为BalanceChanges实例。

三、方案选择建议 #

• 优先选单表策略：电子钱包交易类型的字段重叠度高，单表查询更快、代码更简洁，完全满足返回BalanceChanges父类的需求。
• 多表策略仅适合子类字段差异极大、需要严格数据隔离的场景，但会显著增加开发和维护成本。

内容的提问来源于stack exchange，提问作者DAT Vu