一、踩坑现场还原

去年在迭代电商App的购物车功能时,我们遇到了一个非常诡异的线上故障:用户明明只勾选了1件商品提交结算,最后跳转到订单确认页的时候,后台接口里居然传了3件商品的参数,有不少用户反馈自己莫名其妙多付了钱,我们排查了快3天才找到根因,整个问题的始作俑者就是大家天天用的Kotlin数据类copy方法,嵌套可变集合带来的浅拷贝问题直接篡改了全局的状态数据源。

1.1 业务场景背景

当时的购物车逻辑非常常规:全局维护一份从数据库拉取的原始购物车可信数据源,页面渲染的时候所有UI状态都从这份数据源取,用户点击勾选、修改商品数量、进入批量编辑模式删除商品的时候,我们的开发同学想着直接调用数据类自带的copy方法生成一份新的对象,在新对象上修改状态,这样就不会污染全局的原始数据源,避免页面刷新的时候出现状态错乱。这套逻辑跑了小半年都没出问题,直到我们新增了一个跨页面同步购物车状态的需求,突然就爆发了批量的状态篡改问题。

1.2 最初的错误判断

最开始我们都以为是Android的点击事件被多次触发导致重复赋值,后来加了事件防抖之后问题依旧,接着怀疑是协程异步更新数据源的时候出现了线程安全问题,加了同步锁之后bug还是随机出现,直到我们把两个不同生命周期里的购物车对象的哈希值全部打印出来,才发现两个完全不同的购物车对象,里面存商品的列表居然指向了同一个内存地址,问题根源才彻底浮出水面。

二、问题代码完整复盘

我们直接把当时出问题的代码完整贴出来,所有代码均基于Kotlin技术栈实现:

// 定义购物车商品条目数据类
data class CartItem(
    val goodsId: String, // 商品全局唯一ID
    val goodsName: String, // 商品展示名称
    val goodsPic: String, // 商品封面图地址
    var isSelected: Boolean, // 用户手动勾选的选中状态
    var count: Int // 用户选择的商品购买数量
)

// 定义购物车总容器数据类,这里是整个坑的核心位置
data class CartContainer(
    val userId: String, // 所属用户ID
    val totalCount: Int, // 购物车总商品件数
    val totalPayPrice: Float, // 购物车商品总原价
    val selectedTotalPrice: Float, // 用户选中商品的总价
    val items: MutableList<CartItem> // 所有商品的集合,当时为了方便增删直接用了可变集合
)

fun main() {
    // 从本地Room数据库拉取的全局唯一可信原始数据源
    val originalGlobalCart = CartContainer(
        userId = "202405010001",
        totalCount = 3,
        totalPayPrice = 399.7f,
        selectedTotalPrice = 0f,
        items = mutableListOf(
            CartItem("g001", "纯棉宽松T恤", "https://xxx/1.jpg", false, 1),
            CartItem("g002", "冰丝运动短裤", "https://xxx/2.jpg", false, 1),
            CartItem("g003", "回弹休闲跑鞋", "https://xxx/3.jpg", false, 1)
        )
    )

    // 场景:用户在购物车列表页点击第一个商品的勾选框
    // 开发同学想当然调用copy生成新对象,只在新对象上修改状态,不碰原始数据源
    val uiDisplayCart = originalGlobalCart.copy()
    // 修改新对象里第一个商品的勾选状态为选中
    uiDisplayCart.items[0] = uiDisplayCart.items[0].copy(isSelected = true)

    // 打印两个对象里第一个商品的选中状态
    println("全局原始数据源第一个商品的选中状态:${originalGlobalCart.items[0].isSelected}")
    println("UI展示用对象第一个商品的选中状态:${uiDisplayCart.items[0].isSelected}")
}

把这段代码跑起来你会发现两个打印结果全是true,完全不符合我们的预期,我们本来想的是只修改UI展示用的临时对象,结果把全局的原始数据源直接改了,后续不管用户点什么操作,所有跨页面读取全局数据源的逻辑拿到的都是已经被篡改的脏数据,最后提交结算的时候自然就把没选中的商品也带过去了。

三、问题根因深度拆解

很多刚接触Kotlin的开发者都会天然形成一个错误认知:数据类的copy方法是万能的,调用之后生成的新对象和老对象完全没有任何关联,改任何属性都不会互相影响,实际上这个认知完全是错的。

3.1 你不知道的copy方法浅拷贝本质

Kotlin编译器给数据类自动生成的copy方法,只会做最外层属性的浅拷贝:如果你的属性是基本数据类型、String这种值类型或者不可变类型,那新老对象的属性确实是完全独立的,改新的不会影响老的。但如果属性是引用类型,比如我们代码里用的MutableList可变集合,copy方法根本不会给你生成一个全新的集合,它只会把老集合的内存地址赋值给新对象的对应属性,相当于两个对象里的集合引用指向的是堆内存里同一个集合实体,你在任何一个对象里修改集合的内容,另一个对象的集合自然也会跟着变。

3.2 嵌套多层可变集合的放大效应

如果你的数据结构嵌套了多层可变集合,比如购物车的商品下面还有用户选的SKU规格列表,整个数据类的结构是CartContainer嵌套MutableList,CartItem再嵌套MutableList,这时候你哪怕在外层调用十次copy,所有嵌套层的可变集合全都是共享引用的,你改任意一层的集合内容,所有指向这个引用的对象都会同步变化,这种问题在复杂的列表页面里几乎排查不到,状态篡改完全是随机发生的,复现成本极高。

四、不同场景解决方案对比

针对这个问题我们测试了市面上常用的三种解决方案,每一种的优缺点和适用场景都非常明确,你可以根据自己项目的实际情况选最合适的:

4.1 手动实现全量深拷贝

直接给每一层数据类写一个专门的deepCopy方法,所有嵌套的可变集合全部手动生成全新的对象,示例代码如下:

// 给CartItem添加自定义深拷贝方法
data class CartItem(
    val goodsId: String,
    val goodsName: String,
    val isSelected: Boolean,
    val count: Int
){
    // 手动实现全拷贝逻辑,所有属性重新赋值
    fun deepCopy(): CartItem {
        return this.copy()
    }
}

// 给CartContainer添加自定义深拷贝方法
data class CartContainer(
    val userId: String,
    val items: MutableList<CartItem>
){
    fun deepCopy(): CartContainer {
        // 生成全新的MutableList,遍历所有旧元素逐个拷贝
        val newItems = this.items.map { it.deepCopy() }.toMutableList()
        return this.copy(items = newItems)
    }
}

这个方案的优点是零第三方依赖,性能最高,没有额外的序列化开销,缺点是如果数据结构嵌套层级特别多,每次新增属性都要记得改deepCopy方法,一旦漏写就会继续出问题,适合数据结构不多、迭代节奏稳定的中小项目。

4.2 序列化反序列化自动深拷贝

借助Gson或者Moshi这类JSON序列化框架,先把旧对象序列化成JSON字符串,再把字符串反序列化成全新的对象,框架会自动把所有嵌套的引用类型全部生成独立的新实体,不需要你手动写任何拷贝逻辑,示例代码如下:

// 基于Gson实现通用深拷贝扩展方法
inline fun <reified T> T.deepCopyByGson(): T {
    val gson = Gson()
    val jsonStr = gson.toJson(this)
    return gson.fromJson(jsonStr, T::class.java)
}

// 使用方式,一行代码就能拿到完全独立的新对象
val newCart = originalGlobalCart.deepCopyByGson<CartContainer>()

这个方案的优点是完全通用,不管嵌套多少层都能自动处理,几乎零维护成本,缺点是序列化反序列化会有一定的性能损耗,如果你的集合里有上百上千个元素,在主线程调用可能会引发短暂的UI卡顿,适合中等复杂度的项目使用。

4.3 全程使用不可变集合从根源规避问题

这是最符合Kotlin设计思想的最优解,彻底把所有数据类里的MutableList全部替换成Kotlin自带的只读不可变List,任何需要修改集合内容的场景都先调用toList生成全新的集合再重新赋值,从根源上杜绝可变引用的共享问题,示例代码如下:

// 所有属性全部定义为val,集合用不可变的List
data class CartContainer(
    val userId: String,
    val items: List<CartItem> // 完全去掉MutableList,用只读集合
)

// 修改选中状态的时候,生成全新的集合再生成新的CartContainer对象
val newItems = originalGlobalCart.items.mapIndexed { index, item ->
    if(index == 0) item.copy(isSelected = true) else item
}
val newCart = originalGlobalCart.copy(items = newItems)

这个方案的优点是完全不存在引用共享的问题,所有对象都是不可变的,天然线程安全,不会出现任何意料之外的状态篡改,是Google官方推荐的Android状态管理方案,唯一的缺点是老项目的存量代码改造工作量比较大,适合正在推进现代化架构改造的中大型项目。

五、实际开发中的注意事项

很多开发者遇到这个问题之后第一反应是直接给所有数据类全部写深拷贝,其实完全没必要,我们整理了几个日常开发中可以直接落地的避坑规则: 第一,除非万不得已,不要在任何作为状态载体的数据类里定义可变属性,尤其是MutableList、MutableMap、MutableSet这类可变集合,所有集合默认用只读的不可变类型,从根源上就不会出现嵌套可变集合的问题; 第二,不要迷信Kotlin语法糖的便利性,调用copy方法之后一定要对嵌套的引用类型做单独校验,如果你不确定新老对象的集合是不是指向同一个地址,直接打印两个集合的哈希值对比一下,避免埋下隐患; 第三,所有作为全局可信数据源的对象,绝对不能直接暴露给UI层修改,UI层需要临时修改状态的时候必须拿到完全独立的拷贝对象,不能直接操作全局数据源的属性; 第四,核心的状态修改逻辑一定要加单元测试,比如写一个测试用例,调用copy方法之后修改新对象的嵌套属性,校验原始数据源有没有被篡改,提前在测试阶段把这类问题暴露出来,不要等到线上出故障了再排查。

六、全文总结

这个bug本质上是大家长期依赖语法糖养成的思维惰性导致的,我们想当然认为Kotlin提供的copy方法是万能的,完全忽略了浅拷贝的边界条件,最后引发了非常严重的线上故障。实际上Kotlin的copy方法本身的设计是完全合理的,它本身就不是为了做全量深拷贝设计的,我们只是把它的能力想象得太强大了而已。日常开发里我们经常会遇到类似的场景,很多看起来非常方便的语法糖,背后都有你没注意到的隐含限制,只要你不盲目迷信工具的能力,多花几分钟搞清楚底层的运行逻辑,完全可以避开绝大多数这类低级但是杀伤力极强的坑。