SwiftUI跨Tab视图ViewModel数据刷新方案咨询

先分析你提到的两个方案的问题：

方案1：直接传递ViewModelA给ViewC #

• 耦合度极高：ViewC/ViewModelC需要依赖ViewModelA，违背了单一职责原则——ViewC原本只需要处理自身业务，现在还要关心ViewModelA的刷新逻辑，后续如果新增ViewD也依赖数据库数据，就得继续传递更多ViewModel，扩展性极差。
• 维护成本高：如果ViewModelA的刷新方法修改，ViewC这边必须同步调整，牵一发而动全身。
• 不符合MVVM设计初衷：ViewModel之间应该通过中间层解耦，而非直接依赖调用。

方案2：单例+needsToBeRefresh标记 #

• 单例的固有问题：全局单例难以进行单元测试，即使是可注入的单例，needsToBeRefresh的Bool类型也存在局限性——只能触发一次刷新，需要手动重置状态，否则后续的数据库修改无法触发更新；多线程场景下还可能出现状态不一致的问题。
• 状态管理混乱：如果多个地方都依赖这个标记，容易出现重复通知或者遗漏通知的情况，排查问题难度大。

更推荐的方案：基于发布订阅的解耦方案 #

利用Swift的Combine框架或者SwiftUI的ObservableObject特性，让数据层（Interactor/Synchronizer）负责发布数据变化事件，依赖数据的ViewModel自动订阅并刷新，完全解耦ViewModel之间的依赖。

实现方式1：Interactor发布更新事件 #

// 数据交互层：封装数据库操作并发布更新通知
class DataInteractor {
    // 用PassthroughSubject发布无参数的更新事件
    let dataUpdated = PassthroughSubject<Void, Never>()
    private let database: AppDatabase
    
    init(database: AppDatabase) {
        self.database = database
    }
    
    // 修改数据库后发送更新通知
    func updateData(newData: TargetData) {
        database.update(newData)
        dataUpdated.send()
    }
    
    // 提供数据查询方法
    func fetchData() -> [TargetData] {
        return database.fetch()
    }
}

// ViewModelA：订阅更新事件，自动刷新数据
class ViewModelA: ObservableObject {
    @Published var displayData: [TargetData] = []
    private let interactor: DataInteractor
    private var cancellables = Set<AnyCancellable>()
    
    init(interactor: DataInteractor) {
        self.interactor = interactor
        // 初始加载数据
        loadData()
        // 订阅数据更新事件，收到通知就刷新
        interactor.dataUpdated
            .sink { [weak self] in
                self?.loadData()
            }
            .store(in: &cancellables)
    }
    
    private func loadData() {
        displayData = interactor.fetchData()
    }
}

// ViewModelC：只负责调用修改方法，无需关心其他ViewModel
class ViewModelC: ObservableObject {
    private let interactor: DataInteractor
    
    init(interactor: DataInteractor) {
        self.interactor = interactor
    }
    
    func performDatabaseUpdate() {
        let newData = TargetData(...)
        interactor.updateData(newData: newData)
        // 不需要手动通知ViewModelA，Interactor会自动发事件
    }
}

实现方式2：共享ObservableObject数据模型 #

如果数据库数据可以封装成一个可观察的模型，直接利用SwiftUI的自动更新机制：

// 共享数据仓库：封装数据库数据并自动通知更新
class DataStore: ObservableObject {
    @Published var dataItems: [TargetData] = []
    private let database: AppDatabase
    
    init(database: AppDatabase) {
        self.database = database
        loadData()
    }
    
    func loadData() {
        dataItems = database.fetch()
    }
    
    func updateItem(_ item: TargetData) {
        database.update(item)
        loadData() // 重新加载数据，触发@Published通知所有订阅者
    }
}

// MainView中创建共享DataStore，传给所有ViewModel
@StateObject private var dataStore = DataStore(database: AppDatabase.shared)

// ViewModelA直接使用共享数据，无需手动刷新
class ViewModelA: ObservableObject {
    let dataStore: DataStore
    
    init(dataStore: DataStore) {
        self.dataStore = dataStore
    }
}

// ViewModelC修改数据，自动触发所有依赖视图刷新
class ViewModelC: ObservableObject {
    let dataStore: DataStore
    
    init(dataStore: DataStore) {
        self.dataStore = dataStore
    }
    
    func modifyData() {
        let updatedItem = TargetData(...)
        dataStore.updateItem(updatedItem)
    }
}

这两种方案的核心优势是：

• 完全解耦：ViewModelA和ViewModelC无需知道对方存在，只依赖数据层/共享仓库
• 扩展性强：新增依赖数据库的视图，只需订阅事件或注入共享仓库即可
• 符合MVVM设计：职责清晰，数据层负责数据管理和通知，ViewModel只处理业务逻辑

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