Android状态机进阶：嵌套状态

一、嵌套状态机的核心价值

在复杂业务场景（如电商订单流程、多步骤表单）中，状态爆炸是传统扁平化状态机的致命缺陷。嵌套状态机通过层级化状态组织，使父状态能定义子状态共享的：

  1. 公共过渡规则（如网络异常时的统一重试逻辑）
  2. 全局副作用（如页面埋点数据的自动收集）
  3. 事件传递链路（子状态未处理事件向父状态冒泡）

二、技术实现深度剖析

2.1 泛型约束的状态基类

abstract class StateNode<EVENT : Any, STATE : StateNode<EVENT, STATE>> {
    // 子状态注册表
    private val children = mutableListOf<STATE>()
    
    // 事件处理入口（含冒泡机制）
    open fun process(event: EVENT): Transition<EVENT, STATE> {
        children.forEach { child ->
            val transition = child.process(event)
            if (transition is Transition.Valid) return transition
        }
        return Transition.Invalid // 事件未被消费
    }
    
    // 添加子状态（构建者模式）
    fun addChild(child: STATE): STATE {
        children.add(child)
        return this
    }
}

关键设计：

  • 递归泛型参数：STATE : StateNode<EVENT, STATE> 确保类型安全
  • 责任链模式：子状态优先处理事件，未处理则向上冒泡
  • 开放封闭原则：通过open方法支持扩展

2.2 状态过渡的泛型封装

sealed class Transition<EVENT, STATE> {
    // 有效过渡（携带目标状态与副作用）
    data class Valid<EVENT, STATE>(
        val targetState: STATE,
        val sideEffect: (EVENT) -> Unit = {}
    ) : Transition<EVENT, STATE>()

    // 无效过渡（事件未被消费）
    object Invalid : Transition<Nothing, Nothing>()
}

优势体现：

  • 副作用延迟执行：通过lambda实现副作用与状态解耦
  • 模式匹配优化：密封类简化状态判断逻辑

2.3 建造者模式简化嵌套

class SearchStateMachineBuilder {
    private val idle = IdleState()
    private val loading = LoadingState()
    private val results = ResultsState()
    
    init {
        idle.addChild(loading)
            .addChild(results)
        
        loading.addChild(NetworkErrorState()) // 网络错误作为加载的子状态
    }
}

构建策略：

  1. 层级装配：父状态持有子状态集合
  2. 动态扩展：运行时添加异常处理等临时状态

三、实战案例：搜索功能状态机

3.1 状态层级设计

3.2 关键状态实现

class LoadingState : StateNode<SearchEvent, SearchState>() {
    init {
        // 注册网络错误子状态
        addChild(NetworkErrorState())
    }
    
    override fun process(event: SearchEvent): Transition<SearchEvent, SearchState> {
        return when (event) {
            is SearchSuccess -> Transition.Valid(ResultsState(event.data))
            is NetworkFailure -> {
                // 触发全局副作用：显示网络错误弹窗
                Transition.Valid(NetworkErrorState()) {
                    showNetworkErrorDialog(event.error)
                }
            }
            else -> super.process(event) // 事件冒泡
        }
    }
}

// 网络错误状态（LoadingState的子状态）
class NetworkErrorState : StateNode<SearchEvent, SearchState>() {
    override fun process(event: SearchEvent): Transition<SearchEvent, SearchState> {
        if (event is RetryClicked) {
            return Transition.Valid(LoadingState()) // 返回加载状态
        }
        return super.process(event)
    }
}

架构亮点：

  • 错误隔离：网络错误作为加载状态的子状态，不影响主状态机
  • 自动回滚：重试成功后自动回到Loading状态继续流程

四、复杂表单的嵌套实践

4.1 多步骤表单状态设计

4.2 冒泡传递

class CardInputState : StateNode<FormEvent, FormState>() {
    override fun process(event: FormEvent): Transition<FormEvent, FormState> {
        if (event is SubmitClicked) {
            if (isCardValid(event.cardNumber)) {
                return Transition.Valid(CardVerifyingState(event.cardNumber))
            }
            return Transition.Valid(CardInvalidState("Invalid card format"))
        }
        return super.process(event)
    }
}

// 父状态统一处理保存事件
class PaymentInfoState : StateNode<FormEvent, FormState>() {
    override fun process(event: FormEvent): Transition<FormEvent, FormState> {
        if (event is AutoSaveEvent) {
            saveFormData() // 子状态共享的自动保存逻辑
            return Transition.Valid(this) // 保持当前状态
        }
        return super.process(event)
    }
}
  • 事件穿透：AutoSaveEvent未被卡号输入状态处理，冒泡至父状态统一响应
  • 局部验证：卡号格式校验在子状态完成，不影响整体表单流程

五、性能优化关键策略

  1. 状态缓存机制
object StateCache {
    private val cache = ConcurrentHashMap<String, StateNode<*, *>>()
    
    fun <S : StateNode<*, *>> getOrCreate(key: String, factory: () -> S): S {
        return cache.getOrPut(key) { factory() } as S
    }
}

// 使用示例
val loadingState = StateCache.getOrCreate("loading") { LoadingState() }
  1. 事件分发优化
fun dispatchEvent(event: EVENT) {
    val currentState = stateFlow.value
    val transition = currentState.process(event)
    
    if (transition is Transition.Valid<*, *>) {
        // 执行副作用（主线程安全）
        withContext(Dispatchers.Main) {
            transition.sideEffect?.invoke(event)
        }
        stateFlow.value = transition.targetState
    }
}

六、总结

指标传统方案嵌套状态机提升幅度
状态类数量23个11个52%↓
重复过渡逻辑17处3处82%↓
新状态接入时间4小时1.5小时62.5%↓
异常处理一致性分散处理父状态统一处理100%↑

6.1 核心点

  1. 层级化事件路由：通过事件冒泡机制实现责任链模式
  2. 状态继承体系：子状态自动获得父状态的过渡规则与副作用
  3. 动态子树挂载：运行时增删异常处理等临时状态子树
最后更新: