Corda中两状态对比及生成第三状态的实现方法问询

可行性说明 #

当然可行！这种场景在Corda的业务逻辑里非常常见——比如对账、数据同步后的差异记录，都可以通过对比两个状态生成第三个差异状态来实现。你可以在Flow（业务流程）中完成状态对比和新状态的构造，也可以在必要时把部分校验逻辑放在Contract里，但对比计算本身更适合放在Flow中执行。

基础实现：逐字段对比 #

这是最直观的方式，适合字段数量少、结构稳定的状态。步骤很清晰：

1. 获取需要对比的两个状态实例（可以从Vault查询，或者作为Flow参数传入）
2. 逐个字段对比，计算差异值或标记变化情况
3. 用计算得到的差异数据构造第三个状态
4. 在Flow中完成新状态的签名、提交和存证

举个具体的代码例子：
假设我们有两个账户状态，要生成一个记录差异的状态：

// 定义三个状态类
data class OldAccountState(
    val balance: Int,
    val owner: Party,
    val linearId: UniqueIdentifier,
    override val participants: List<Party>
) : ContractState

data class NewAccountState(
    val balance: Int,
    val owner: Party,
    val linearId: UniqueIdentifier,
    override val participants: List<Party>
) : ContractState

data class AccountDiffState(
    val balanceDiff: Int,
    val ownerChanged: Boolean,
    val relatedLinearId: UniqueIdentifier,
    override val participants: List<Party>,
    override val linearId: UniqueIdentifier = UniqueIdentifier()
) : LinearState

// 在Flow中实现对比逻辑
private fun generateDiffState(oldState: OldAccountState, newState: NewAccountState): AccountDiffState {
    // 计算余额差异
    val balanceDiff = newState.balance - oldState.balance
    // 判断账户所有人是否变更
    val ownerChanged = oldState.owner != newState.owner
    // 合并参与方，确保新状态的参与者包含前两个状态的所有相关节点
    val mergedParticipants = oldState.participants.union(newState.participants).toList()
    
    return AccountDiffState(
        balanceDiff = balanceDiff,
        ownerChanged = ownerChanged,
        relatedLinearId = oldState.linearId,
        participants = mergedParticipants
    )
}

更优方案：避免硬编码的通用对比方法 #

如果你的状态字段较多、或者字段可能频繁变动，逐字段硬编码会很繁琐且不易维护。这里有几个更优雅的实现思路：

方案1：利用Kotlin反射自动对比字段 #

借助Kotlin的反射特性，可以遍历状态类的所有字段，自动对比差异并生成差异映射，再用这个映射构造新状态。这种方式无需修改代码就能适配字段变化：

import kotlin.reflect.full.memberProperties

// 通用对比函数：返回两个状态的差异字段及新旧值
fun <T : ContractState, U : ContractState> compareStates(oldState: T, newState: U): Map<String, Pair<Any?, Any?>> {
    // 获取两个状态的所有字段
    val oldProps = oldState::class.memberProperties.associateBy { it.name }
    val newProps = newState::class.memberProperties.associateBy { it.name }
    // 取两个状态共有的字段
    val commonFieldNames = oldProps.keys.intersect(newProps.keys)
    
    // 过滤出值不同的字段
    return commonFieldNames.associate { fieldName ->
        val oldValue = oldProps[fieldName]?.get(oldState)
        val newValue = newProps[fieldName]?.get(newState)
        fieldName to (oldValue to newValue)
    }.filter { (_, valuePair) -> valuePair.first != valuePair.second }
}

// 用差异映射构造第三个状态
private fun generateDiffFromMap(diffMap: Map<String, Pair<Any?, Any?>>, relatedLinearId: UniqueIdentifier, participants: List<Party>): AccountDiffState {
    val balanceDiff = (diffMap["balance"]?.second as Int) - (diffMap["balance"]?.first as Int)
    // 只要owner字段在差异映射里，说明值有变化
    val ownerChanged = diffMap.containsKey("owner")
    
    return AccountDiffState(balanceDiff, ownerChanged, relatedLinearId, participants)
}

方案2：用注解标记需要对比的字段 #

如果不是所有字段都需要对比，可以自定义一个注解，标记需要参与对比的字段，让工具函数只处理这些字段，更灵活：

// 自定义注解
annotation class CompareField

// 修改状态类，标记需要对比的字段
data class OldAccountState(
    @CompareField val balance: Int,
    @CompareField val owner: Party,
    val linearId: UniqueIdentifier,
    override val participants: List<Party>
) : ContractState

// 只对比带注解的字段
fun <T : ContractState, U : ContractState> compareAnnotatedFields(oldState: T, newState: U): Map<String, Pair<Any?, Any?>> {
    val oldAnnotatedProps = oldState::class.memberProperties
        .filter { it.annotations.any { ann -> ann is CompareField } }
        .associateBy { it.name }
    
    val newAnnotatedProps = newState::class.memberProperties
        .filter { it.annotations.any { ann -> ann is CompareField } }
        .associateBy { it.name }
    
    val commonFieldNames = oldAnnotatedProps.keys.intersect(newAnnotatedProps.keys)
    
    return commonFieldNames.associate { fieldName ->
        val oldValue = oldAnnotatedProps[fieldName]?.get(oldState)
        val newValue = newAnnotatedProps[fieldName]?.get(newState)
        fieldName to (oldValue to newValue)
    }.filter { (_, valuePair) -> valuePair.first != valuePair.second }
}

方案3：通过状态指针延迟计算差异 #

如果差异的使用场景不固定，或者不想提前计算所有差异，可以让第三个状态直接持有前两个状态的StatePointer，需要时再查询状态并计算差异。这种方式更灵活，也能减少不必要的计算：

data class AccountDiffState(
    val oldStatePointer: StatePointer<OldAccountState>,
    val newStatePointer: StatePointer<NewAccountState>,
    override val participants: List<Party>,
    override val linearId: UniqueIdentifier = UniqueIdentifier()
) : LinearState {
    // 按需计算余额差异
    fun getBalanceDiff(serviceHub: ServiceHub): Int {
        val oldState = serviceHub.vaultService.queryBy(
            OldAccountState::class.java,
            QueryCriteria.LinearStateQueryCriteria(linearId = listOf(oldStatePointer.pointer))
        ).states.single().state.data
        
        val newState = serviceHub.vaultService.queryBy(
            NewAccountState::class.java,
            QueryCriteria.LinearStateQueryCriteria(linearId = listOf(newStatePointer.pointer))
        ).states.single().state.data
        
        return newState.balance - oldState.balance
    }
}

注意事项 #

• 对比逻辑尽量放在Flow中执行，Contract只负责状态的合法性校验（比如检查新状态的差异计算是否符合业务规则），避免在Contract中做复杂计算影响节点性能。
• 如果涉及敏感字段对比，要确保Flow有严格的权限控制，只有授权节点能访问相关状态。
• 反射方案虽然灵活，但性能略低于硬编码，如果是性能敏感的场景，优先考虑硬编码或注解方案。

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