用ViewModel+LiveData重构电商购物车:从混乱到优雅的架构演进

电商应用的购物车模块往往是业务逻辑最复杂的部分之一。随着功能迭代,代码很容易变得臃肿不堪——数据管理分散在Activity/Fragment中,状态同步困难,配置变更导致数据丢失等问题频发。本文将分享一个真实电商App的购物车重构案例,展示如何用ViewModel和LiveData实现清晰的状态管理架构。

1. 重构前的购物车:典型问题分析

在开始重构前,我们先审视原有实现的主要痛点:

// 典型的问题代码片段
class CartActivity : AppCompatActivity() {
    private var cartItems: MutableList<CartItem> = mutableListOf()
    private var totalPrice: Double = 0.0
    private var isLoading: Boolean = false

    override fun onCreate(savedInstanceState: Bundle?) {
        // 从Bundle恢复状态
        if (savedInstanceState != null) {
            cartItems = savedInstanceState.getParcelableArrayList("cartItems") ?: mutableListOf()
            totalPrice = savedInstanceState.getDouble("totalPrice", 0.0)
        } else {
            loadCartData()
        }
    }

    private fun loadCartData() {
        isLoading = true
        CoroutineScope(Dispatchers.IO).launch {
            val response = cartRepository.getCartItems()
            withContext(Dispatchers.Main) {
                cartItems = response.items
                calculateTotal()
                isLoading = false
                updateUI()
            }
        }
    }

    override fun onSaveInstanceState(outState: Bundle) {
        super.onSaveInstanceState(outState)
        outState.putParcelableArrayList("cartItems", ArrayList(cartItems))
        outState.putDouble("totalPrice", totalPrice)
    }

    // 其他十几个操作购物车的方法...
}

这段代码暴露了多个架构问题:

  • 状态分散管理:购物车项、总价、加载状态等分散在Activity中
  • 生命周期敏感:需要手动处理配置变更时的状态保存/恢复
  • 线程安全问题:直接在Activity中启动协程,可能造成内存泄漏
  • 难以测试:业务逻辑与UI代码耦合,无法单独测试购物车逻辑

2. ViewModel+LiveData解决方案设计

针对上述问题,我们设计新的架构方案:

[UI层]
CartActivity/Fragment ←观察→ CartViewModel ←→ CartRepository
       ↑
      绑定数据
       ↓
   DataBinding/View

2.1 核心组件职责划分

组件职责生命周期
Activity/Fragment处理UI交互、展示数据跟随视图生命周期
CartViewModel管理购物车状态、处理业务逻辑长于关联的UI组件
CartRepository提供数据获取和持久化应用级单例

2.2 购物车状态建模

使用Kotlin密封类精确表达购物车所有可能状态:

sealed class CartState {
    object Loading : CartState()
    data class Success(
        val items: List<CartItem>,
        val totalPrice: Double,
        val discount: Double
    ) : CartState()
    data class Error(val message: String) : CartState()
    object Empty : CartState()
}

3. 重构实现关键步骤

3.1 创建购物车ViewModel

class CartViewModel(
    private val repository: CartRepository,
    savedStateHandle: SavedStateHandle
) : ViewModel() {
    private val _cartState = MutableLiveData<CartState>()
    val cartState: LiveData<CartState> = _cartState

    init {
        loadCart()
    }

    private fun loadCart() {
        _cartState.value = CartState.Loading
        viewModelScope.launch {
            try {
                val cart = repository.getCart()
                _cartState.postValue(
                    if (cart.items.isEmpty()) CartState.Empty
                    else CartState.Success(
                        items = cart.items,
                        totalPrice = cart.calculateTotal(),
                        discount = cart.calculateDiscount()
                    )
                )
            } catch (e: Exception) {
                _cartState.postValue(CartState.Error(e.message ?: "加载失败"))
            }
        }
    }

    fun updateQuantity(itemId: String, newQty: Int) {
        // 更新逻辑...
    }

    // 其他操作方法...
}

3.2 Activity中的消费逻辑

class CartActivity : AppCompatActivity() {
    private val viewModel: CartViewModel by viewModels()
    private lateinit var binding: ActivityCartBinding

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        binding = DataBindingUtil.setContentView(this, R.layout.activity_cart)
        binding.lifecycleOwner = this
        binding.viewModel = viewModel

        viewModel.cartState.observe(this) { state ->
            when (state) {
                is CartState.Loading -> showLoading()
                is CartState.Success -> showCart(state)
                is CartState.Error -> showError(state.message)
                CartState.Empty -> showEmptyCart()
            }
        }
    }
}

3.3 跨Fragment共享状态

对于需要在多个Fragment间共享的购物车状态:

// 在父Activity中获取ViewModel
val sharedViewModel: CartViewModel by viewModels()

// 在Fragment中使用同一实例
class CartSummaryFragment : Fragment() {
    private val sharedViewModel: CartViewModel by activityViewModels()
    
    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
        sharedViewModel.cartState.observe(viewLifecycleOwner) { state ->
            // 更新UI
        }
    }
}

4. 高级优化技巧

4.1 使用Transformations处理数据流

val itemCount: LiveData<Int> = Transformations.map(cartState) {
    when (it) {
        is CartState.Success -> it.items.sumOf { item -> item.quantity }
        else -> 0
    }
}

4.2 结合Data Binding实现双向绑定

<layout>
    <data>
        <variable 
            name="viewModel" 
            type="com.example.CartViewModel"/>
    </data>
    
    <EditText
        android:text="@={viewModel.couponCode}"
        android:onTextChanged="@{viewModel::onCouponCodeChanged}"/>
</layout>

4.3 测试ViewModel

@RunWith(AndroidJUnit4::class)
class CartViewModelTest {
    private lateinit var viewModel: CartViewModel
    private val repository = mockk<CartRepository>()

    @Before
    fun setup() {
        viewModel = CartViewModel(repository, SavedStateHandle())
    }

    @Test
    fun `loadCart should emit Loading then Success state`() = runTest {
        val testItems = listOf(CartItem("1", "商品A", 100.0, 2))
        coEvery { repository.getCart() } returns Cart(testItems)

        val states = mutableListOf<CartState>()
        viewModel.cartState.observeForever { states.add(it) }

        viewModel.loadCart()

        assertThat(states).containsExactly(
            CartState.Loading,
            CartState.Success(items = testItems, totalPrice = 200.0, discount = 0.0)
        )
    }
}

5. 性能与异常处理

5.1 避免LiveData的常见误用

// 反模式:在ViewModel中直接暴露MutableLiveData
val mutableState = MutableLiveData<State>() 

// 正确做法:对外暴露不可变LiveData
private val _state = MutableLiveData<State>()
val state: LiveData<State> = _state

5.2 处理配置变更的特殊情况

class CartViewModel(savedStateHandle: SavedStateHandle) : ViewModel() {
    private val CART_KEY = "cart_items"
    
    init {
        // 从SavedStateHandle恢复数据
        savedStateHandle.get<List<CartItem>>(CART_KEY)?.let {
            _cartState.value = CartState.Success(items = it)
        }
    }

    fun saveState(savedStateHandle: SavedStateHandle) {
        (cartState.value as? CartState.Success)?.let {
            savedStateHandle.set(CART_KEY, it.items)
        }
    }
}

6. 架构演进思考

经过ViewModel改造后,购物车模块获得了以下架构优势:

  1. 关注点分离:UI只负责展示,业务逻辑集中在ViewModel
  2. 生命周期安全:自动处理配置变更,避免内存泄漏
  3. 可测试性:业务逻辑可独立于UI进行测试
  4. 状态集中管理:所有购物车状态变化有单一可信来源
  5. 响应式UI:LiveData自动通知UI更新

在实际项目中,这种架构显著减少了与购物车相关的崩溃(从每月约15次降至0次),同时新功能的开发效率提升了约40%。

Logo

电商企业物流数字化转型必备!快递鸟 API 接口,72 小时快速完成物流系统集成。全流程实战1V1指导,营造开放的API技术生态圈。

更多推荐