SwiftUI中ViewModel的设计模式与最佳实践

1. SwiftUI中ViewModel的核心价值

在iOS开发生态中，SwiftUI彻底改变了我们构建用户界面的方式。作为苹果推出的声明式UI框架，它最大的特点是将视图描述与数据管理分离。这种分离带来的直接挑战就是：如何优雅地管理那些需要与界面交互的数据？

这就是ViewModel的用武之地。它本质上是一个中间层，负责：

• 封装业务逻辑
• 处理数据转换
• 维护状态变化
• 协调网络请求

与UIKit时代的MVC不同，SwiftUI的ViewModel更接近MVVM模式中的"VM"角色。我见过不少开发者直接把逻辑写在View里，这会导致：

1. 视图层变得臃肿难维护
2. 业务逻辑无法复用
3. 状态管理混乱
4. 单元测试难以实施

2. ViewModel的三种实现范式

2.1 ObservableObject基础版

这是最基础的实现方式，适合简单场景：

swift复制class ProductViewModel: ObservableObject {
    @Published var products: [Product] = []
    @Published var isLoading = false
    
    func loadProducts() {
        isLoading = true
        APIService.fetchProducts { [weak self] result in
            self?.isLoading = false
            switch result {
            case .success(let products):
                self?.products = products
            case .failure(let error):
                print("Error: \(error.localizedDescription)")
            }
        }
    }
}

关键点：

• 必须继承ObservableObject
• @Published属性变更时会触发视图更新
• 弱引用避免循环引用

2.2 结合StateObject的最佳实践

SwiftUI 2.0引入的StateObject解决了某些场景下的状态丢失问题：

swift复制struct ProductListView: View {
    @StateObject private var viewModel = ProductViewModel()
    
    var body: some View {
        List(viewModel.products) { product in
            ProductRow(product: product)
        }
        .onAppear {
            viewModel.loadProducts()
        }
    }
}

与ObservedObject的区别：

• StateObject由视图持有生命周期
• 适合创建和拥有ViewModel的视图使用
• 在视图重新创建时保持状态

2.3 使用Combine的高级模式

对于复杂数据流，可以结合Combine框架：

swift复制class SearchViewModel: ObservableObject {
    @Published var searchText = ""
    @Published var results: [SearchResult] = []
    
    private var cancellables = Set<AnyCancellable>()
    
    init() {
        $searchText
            .debounce(for: .seconds(0.5), scheduler: RunLoop.main)
            .removeDuplicates()
            .flatMap { query in
                APIService.search(query: query)
                    .replaceError(with: [])
            }
            .assign(to: \.results, on: self)
            .store(in: &cancellables)
    }
}

这种模式的优点：

• 自动处理搜索去抖
• 错误处理内置
• 响应式数据流

3. 实战中的五个关键技巧

3.1 依赖注入的灵活运用

避免在ViewModel内部直接初始化依赖项：

swift复制class OrderViewModel: ObservableObject {
    private let paymentService: PaymentServiceProtocol
    
    init(paymentService: PaymentServiceProtocol = PaymentService()) {
        self.paymentService = paymentService
    }
    
    func processPayment() {
        paymentService.process()
    }
}

这样做的好处：

• 方便单元测试时替换mock对象
• 降低模块间耦合度
• 支持不同的实现切换

3.2 线程安全的注意事项

ViewModel经常需要处理多线程场景，常见陷阱：

swift复制class UserViewModel: ObservableObject {
    @Published var user: User?
    
    func fetchUser() {
        DispatchQueue.global().async {
            // 错误：在后台线程修改Published属性
            self.user = Database.fetchUser()
        }
    }
}

正确做法：

swift复制func fetchUser() {
    DispatchQueue.global().async {
        let user = Database.fetchUser()
        DispatchQueue.main.async {
            self.user = user
        }
    }
}

重要提示：所有@Published属性的修改必须在主线程执行

3.3 状态管理的艺术

复杂状态建议使用枚举管理：

swift复制enum LoadingState<T> {
    case idle
    case loading
    case loaded(T)
    case failed(Error)
}

class ContentViewModel: ObservableObject {
    @Published var state: LoadingState<[Post]> = .idle
    
    func loadContent() {
        state = .loading
        APIService.fetchPosts { [weak self] result in
            switch result {
            case .success(let posts):
                self?.state = .loaded(posts)
            case .failure(let error):
                self?.state = .failed(error)
            }
        }
    }
}

这种模式的优势：

• 状态变化更加明确
• 避免多个Bool标志位
• 视图可以根据不同状态显示不同UI

3.4 内存泄漏预防方案

常见内存泄漏场景及解决方案：

示例代码：

swift复制deinit {
    NotificationCenter.default.removeObserver(self)
    cancellables.forEach { $0.cancel() }
}

3.5 测试驱动开发实践

ViewModel非常适合单元测试：

swift复制class LoginViewModelTests: XCTestCase {
    var sut: LoginViewModel!
    var mockAuthService: MockAuthService!
    
    override func setUp() {
        mockAuthService = MockAuthService()
        sut = LoginViewModel(authService: mockAuthService)
    }
    
    func testLoginSuccess() {
        mockAuthService.result = .success(())
        let expectation = XCTestExpectation(description: "Login succeeds")
        
        sut.login(email: "test@example.com", password: "password") { result in
            if case .success = result {
                expectation.fulfill()
            }
        }
        
        wait(for: [expectation], timeout: 1)
    }
}

测试要点：

• 使用protocol隔离依赖
• 测试各种状态变化
• 验证Published属性的预期值

4. 与SwiftUI视图的深度集成

4.1 绑定技术的进阶用法

除了简单的@Published绑定，还可以使用自定义绑定：

swift复制class SettingsViewModel: ObservableObject {
    @Published var fontSize: CGFloat = 14
    
    var fontSizeBinding: Binding<CGFloat> {
        Binding(
            get: { self.fontSize },
            set: {
                self.fontSize = $0
                self.saveSettings()
            }
        )
    }
}

struct SettingsView: View {
    @ObservedObject var viewModel: SettingsViewModel
    
    var body: some View {
        Slider(value: viewModel.fontSizeBinding, in: 10...24)
    }
}

这种模式适合需要执行副作用的场景。

4.2 环境对象的巧妙应用

对于需要跨视图共享的ViewModel：

swift复制@main
struct MyApp: App {
    @StateObject var userSession = UserSessionViewModel()
    
    var body: some Scene {
        WindowGroup {
            ContentView()
                .environmentObject(userSession)
        }
    }
}

struct ProfileView: View {
    @EnvironmentObject var session: UserSessionViewModel
    
    var body: some View {
        Text("Hello, \(session.username)")
    }
}

适用场景：

• 用户会话信息
• 应用主题设置
• 全局配置参数

4.3 与CoreData的集成方案

对于持久化数据，可以直接在ViewModel中使用@FetchRequest：

swift复制class TaskListViewModel: ObservableObject {
    @FetchRequest(
        sortDescriptors: [NSSortDescriptor(keyPath: \Task.dueDate, ascending: true)],
        animation: .default
    ) var tasks: FetchedResults<Task>
    
    func addTask(title: String) {
        let newTask = Task(context: PersistenceController.shared.container.viewContext)
        newTask.title = title
        newTask.dueDate = Date()
        try? PersistenceController.shared.save()
    }
}

注意事项：

• 确保在主线程访问NSManagedObject
• 考虑使用单独的PersistenceController
• 错误处理要完善

5. 性能优化关键点

5.1 减少不必要的视图更新

使用objectWillChange.send()手动控制更新：

swift复制class OptimizedViewModel: ObservableObject {
    private var internalValue = 0 {
        didSet {
            if internalValue % 10 == 0 {
                objectWillChange.send()
            }
        }
    }
    
    var displayedValue: String {
        "Count: \(internalValue)"
    }
    
    func increment() {
        internalValue += 1
    }
}

适用场景：

• 高频变化的数据
• 中间状态不需要触发视图更新
• 批量操作时

5.2 大型数据集的处理技巧

对于可能包含大量数据的列表：

swift复制class LargeDataViewModel: ObservableObject {
    @Published private var allItems: [Item] = []
    @Published var displayedItems: [Item] = []
    
    private let batchSize = 20
    private var currentIndex = 0
    
    func loadMoreIfNeeded(currentItem item: Item?) {
        guard let item = item else { return }
        
        let thresholdIndex = allItems.index(allItems.endIndex, offsetBy: -5)
        if allItems.firstIndex(where: { $0.id == item.id }) == thresholdIndex {
            loadNextBatch()
        }
    }
    
    private func loadNextBatch() {
        let nextBatch = Array(allItems[currentIndex..<min(currentIndex + batchSize, allItems.count)])
        displayedItems.append(contentsOf: nextBatch)
        currentIndex += batchSize
    }
}

优化点：

• 分批加载数据
• 动态计算加载时机
• 避免一次性处理全部数据

5.3 图像资源的优化管理

当ViewModel需要处理大量图片时：

swift复制class ImageLoader: ObservableObject {
    @Published var image: UIImage?
    private var cancellable: AnyCancellable?
    
    func load(from url: URL) {
        cancellable = URLSession.shared.dataTaskPublisher(for: url)
            .map { UIImage(data: $0.data) }
            .replaceError(with: nil)
            .receive(on: DispatchQueue.main)
            .sink { [weak self] in self?.image = $0 }
    }
    
    func cancel() {
        cancellable?.cancel()
    }
}

struct ImageView: View {
    @StateObject private var loader = ImageLoader()
    let url: URL
    
    var body: some View {
        Group {
            if let image = loader.image {
                Image(uiImage: image)
                    .resizable()
            } else {
                ProgressView()
            }
        }
        .onAppear { loader.load(from: url) }
        .onDisappear { loader.cancel() }
    }
}

关键优化：

• 取消不必要的网络请求
• 内存管理
• 错误处理

6. 常见问题排查指南

6.1 视图不更新的五种原因

1. 未使用@Published：

   swift复制// 错误
   var count = 0
   
   // 正确
   @Published var count = 0
   

2. 在后台线程修改状态：

   swift复制DispatchQueue.global().async {
       // 错误
       self.count += 1
       
       // 正确
       DispatchQueue.main.async {
           self.count += 1
       }
   }
   

3. ViewModel生命周期问题：

   • 使用StateObject替代ObservedObject
   • 确保ViewModel没有被意外重新创建

4. Equatable检查阻止更新：

   swift复制struct MyView: View {
       @ObservedObject var vm: ViewModel
       
       var body: some View {
           // 添加调试语句检查
           let _ = Self._printChanges()
           Text("Count: \(vm.count)")
       }
   }
   

5. 对象未正确实现ObservableObject：

   • 确保继承ObservableObject
   • 检查objectWillChange发送时机

6.2 内存泄漏的三种典型场景

案例一：闭包强引用

swift复制class LeakyViewModel: ObservableObject {
    @Published var data: Data?
    
    func loadData() {
        NetworkService.fetchData { result in
            // 错误：隐式强引用self
            self.data = result
        }
    }
}

修复方案：

swift复制func loadData() {
    NetworkService.fetchData { [weak self] result in
        self?.data = result
    }
}

案例二：Combine订阅未存储

swift复制class LeakyViewModel: ObservableObject {
    func setupTimer() {
        // 错误：订阅立即被丢弃
        Timer.publish(every: 1, on: .main, in: .common)
            .autoconnect()
            .sink { _ in
                self.update()
            }
    }
}

修复方案：

swift复制private var cancellables = Set<AnyCancellable>()

func setupTimer() {
    Timer.publish(every: 1, on: .main, in: .common)
        .autoconnect()
        .sink { [weak self] _ in
            self?.update()
        }
        .store(in: &cancellables)
}

案例三：通知中心未清理

swift复制class LeakyViewModel: ObservableObject {
    init() {
        NotificationCenter.default.addObserver(
            self,
            selector: #selector(handleNotification),
            name: .myNotification,
            object: nil
        )
    }
    
    // 缺少deinit
}

修复方案：

swift复制deinit {
    NotificationCenter.default.removeObserver(self)
}

6.3 调试ViewModel的实用技巧

1. 打印状态变化：

   swift复制class DebuggableViewModel: ObservableObject {
       @Published var value = 0 {
           willSet {
               print("Value changing from \(value) to \(newValue)")
           }
       }
   }
   

2. 使用Combine调试操作符：

   swift复制$searchText
       .print("SearchText") // 打印流事件
       .debounce(for: .seconds(0.5), scheduler: RunLoop.main)
       .flatMap { query in
           APIService.search(query: query)
               .print("API Call") // 打印网络请求
       }
   

3. 检查对象生命周期：

   swift复制deinit {
       print("ViewModel deinitialized")
   }
   

4. Xcode断点技巧：

   • 在objectWillChange.send()设置断点
   • 观察Published属性变化
   • 使用内存图调试器检查引用关系

7. 架构演进建议

7.1 从简单到复杂的演进路径

阶段一：基础ViewModel

• 单个文件包含所有逻辑
• 直接调用网络服务
• 适合小型项目或独立功能模块

阶段二：分层ViewModel

code复制Sources/
├── Models/
├── Services/
├── ViewModels/
│   ├── Base/
│   ├── Features/
└── Views/

• 服务层抽象
• 基础ViewModel包含共享逻辑
• 功能特定的ViewModel继承或组合

阶段三：模块化架构

code复制Features/
├── Product/
│   ├── Models/
│   ├── Services/
│   ├── ViewModels/
│   └── Views/
└── Order/
    ├── Models/
    ├── Services/
    ├── ViewModels/
    └── Views/

• 功能模块完全独立
• 明确依赖关系
• 适合大型团队协作

7.2 与Redux-like架构的结合

对于超大型应用，可以考虑单向数据流：

swift复制struct AppState {
    var user: User?
    var products: [Product] = []
    // 其他共享状态
}

enum AppAction {
    case login(User)
    case loadProducts([Product])
    // 其他操作类型
}

class Store: ObservableObject {
    @Published private(set) var state: AppState
    
    func dispatch(_ action: AppAction) {
        state = reducer(state: state, action: action)
    }
    
    private func reducer(state: AppState, action: AppAction) -> AppState {
        var newState = state
        switch action {
        case .login(let user):
            newState.user = user
        case .loadProducts(let products):
            newState.products = products
        }
        return newState
    }
}

ViewModel的角色转变为：

• 从Store获取状态
• 向Store派发动作
• 处理本地临时状态

7.3 面向协议的设计模式

使用协议提高可测试性和灵活性：

swift复制protocol ProductServiceProtocol {
    func fetchProducts() async throws -> [Product]
}

class ProductViewModel: ObservableObject {
    private let service: ProductServiceProtocol
    
    init(service: ProductServiceProtocol = DefaultProductService()) {
        self.service = service
    }
    
    @Published var products: [Product] = []
    
    @MainActor
    func loadProducts() async {
        do {
            products = try await service.fetchProducts()
        } catch {
            print("Error: \(error)")
        }
    }
}

优势：

• 轻松替换实现（如MockService）
• 清晰的接口定义
• 更好的模块分离

8. 实战案例：电商应用ViewModel设计

8.1 商品列表ViewModel

swift复制class ProductListViewModel: ObservableObject {
    @Published var state: LoadingState<[Product]> = .idle
    @Published var searchQuery = ""
    @Published var selectedCategory: Category?
    
    private let productService: ProductServiceProtocol
    private var cancellables = Set<AnyCancellable>()
    
    init(service: ProductServiceProtocol = ProductService()) {
        self.productService = service
        
        $searchQuery
            .combineLatest($selectedCategory)
            .debounce(for: .seconds(0.3), scheduler: RunLoop.main)
            .sink { [weak self] _ in
                self?.loadProducts()
            }
            .store(in: &cancellables)
    }
    
    @MainActor
    func loadProducts() async {
        state = .loading
        do {
            let products = try await productService.fetchProducts(
                query: searchQuery,
                category: selectedCategory
            )
            state = .loaded(products)
        } catch {
            state = .failed(error)
        }
    }
}

8.2 购物车ViewModel

swift复制class CartViewModel: ObservableObject {
    @Published var items: [CartItem] = []
    @Published var totalPrice: Decimal = 0
    @Published var checkoutState: CheckoutState = .ready
    
    private let inventoryService: InventoryServiceProtocol
    
    init(service: InventoryServiceProtocol = InventoryService()) {
        self.inventoryService = service
    }
    
    func addProduct(_ product: Product) async {
        do {
            let available = try await inventoryService.checkAvailability(productID: product.id)
            if available {
                if let index = items.firstIndex(where: { $0.product.id == product.id }) {
                    items[index].quantity += 1
                } else {
                    items.append(CartItem(product: product, quantity: 1))
                }
                calculateTotal()
            }
        } catch {
            print("Inventory check failed: \(error)")
        }
    }
    
    private func calculateTotal() {
        totalPrice = items.reduce(0) { $0 + $1.product.price * Decimal($1.quantity) }
    }
}

8.3 用户个人中心ViewModel

swift复制class ProfileViewModel: ObservableObject {
    @Published var user: User?
    @Published var orders: [Order] = []
    @Published var isLoading = false
    @Published var errorMessage: String?
    
    private let userService: UserServiceProtocol
    private let orderService: OrderServiceProtocol
    
    init(
        userService: UserServiceProtocol = UserService(),
        orderService: OrderServiceProtocol = OrderService()
    ) {
        self.userService = userService
        self.orderService = orderService
    }
    
    @MainActor
    func loadUserData() async {
        isLoading = true
        errorMessage = nil
        
        async let userTask = userService.fetchCurrentUser()
        async let ordersTask = orderService.fetchUserOrders()
        
        do {
            user = try await userTask
            orders = try await ordersTask
        } catch {
            errorMessage = error.localizedDescription
        }
        
        isLoading = false
    }
    
    func logout() {
        AuthService.shared.logout()
        user = nil
        orders = []
    }
}

9. 性能监控与优化指标

9.1 关键性能指标

9.2 优化检查清单

1. 内存方面：

   • 检查ViewModel是否意外保留
   • 确认Combine订阅已正确取消
   • 验证闭包是否使用weak引用

2. 性能方面：

   • 减少不必要的Published属性更新
   • 批量处理状态变化
   • 使用debounce处理高频事件

3. 代码组织：

   • 遵循单一职责原则
   • 考虑将大型ViewModel拆分为多个小ViewModel
   • 使用协议明确依赖关系

4. 测试覆盖：

   • 单元测试覆盖核心业务逻辑
   • UI测试验证关键用户流程
   • 性能测试确保滚动流畅度

10. 未来兼容性设计

10.1 Swift Concurrency适配

随着Swift并发模型的演进，ViewModel也需要相应调整：

swift复制class ModernViewModel: ObservableObject {
    @Published var data: [DataItem] = []
    @Published var isLoading = false
    
    private let service: DataServiceProtocol
    
    init(service: DataServiceProtocol = DataService()) {
        self.service = service
    }
    
    @MainActor
    func loadData() async {
        isLoading = true
        defer { isLoading = false }
        
        do {
            data = try await service.fetchData()
        } catch {
            print("Error loading data: \(error)")
        }
    }
}

关键变化：

• 使用async/await替代回调
• @MainActor确保线程安全
• 结构化并发管理任务生命周期

10.2 Swift 6语言特性的准备

为即将到来的Swift 6做准备：

1. 采用Sendable协议：

   swift复制class FutureProofViewModel: ObservableObject, @unchecked Sendable {
       // 线程安全的状态管理
   }
   

2. 严格并发检查：

   swift复制@MainActor
   class StrictViewModel: ObservableObject {
       // 所有属性修改自动在主线程
   }
   

3. 隔离域的使用：

   swift复制actor DataLoader {
       private var cache: [URL: Data] = [:]
       
       func load(from url: URL) async throws -> Data {
           if let cached = cache[url] {
               return cached
           }
           
           let data = try await URLSession.shared.data(from: url).0
           cache[url] = data
           return data
       }
   }
   

10.3 跨平台兼容策略

考虑macOS、watchOS等平台的适配：

swift复制#if os(iOS)
import UIKit
#elseif os(macOS)
import AppKit
#endif

class UniversalViewModel: ObservableObject {
    @Published var platformSpecificData: String
    
    init() {
        #if os(iOS)
        platformSpecificData = UIDevice.current.model
        #elseif os(macOS)
        platformSpecificData = ProcessInfo.processInfo.hostName
        #endif
    }
}

设计原则：

• 将平台相关代码隔离
• 使用条件编译
• 提供统一的接口给视图层