罗罗编程学习记录
本页内容 展开查看

07.6.4 架构模式(MVVM/TCA/依赖注入)

所属:全栈开发面试题库 / 07 端侧与桌面开发 / 07.6 iOS 深入

覆盖范围

  • MVVM 在 SwiftUI 中的落地
  • TCA(The Composable Architecture)核心概念
  • 依赖注入:协议抽象、Environment、工厂
  • 单向数据流与状态管理
  • 模块边界与可测试性

高频题速览

编号 题目 难度 频率
07.6.4-001 MVVM 在 SwiftUI 中怎么落地? 基础 ★★★★★
07.6.4-002 TCA 的核心概念是什么? 进阶 ★★★
07.6.4-003 依赖注入在 iOS 中怎么做? 基础 ★★★★
07.6.4-004 什么是单向数据流? 进阶 ★★★
07.6.4-005 ViewModel 应该放什么、不应该放什么? 进阶 ★★★★
07.6.4-006 如何让 View 可测试? 进阶 ★★★
07.6.4-007 Coordinator 模式在 SwiftUI 中还需要吗? 进阶 ★★
07.6.4-008 如何处理全局状态? 进阶 ★★★
07.6.4-009 TCA 与 MVVM 怎么选? 基础 ★★
07.6.4-010 协议抽象的边界怎么定? 高级 ★★

07.6.4-001 MVVM 在 SwiftUI 中怎么落地?

频率 ★★★★★ | 难度 基础

一句话结论

View 是声明式的 UI 描述,ObservableObject 作为 ViewModel 持有视图状态和业务逻辑,@Published 属性驱动视图刷新;View 把用户操作转发给 ViewModel,ViewModel 调用服务层获取数据并更新状态,View 自动观察变化刷新。

概念解释

  • View:只负责布局和事件转发,不做业务逻辑。
  • ViewModel:ObservableObject,@Published 状态,处理用户交互,调用 UseCase/Service。
  • 与 UIKit 时代的 MVVM 区别:SwiftUI 是声明式的,不需要绑定工具,@Published 自动驱动刷新。

代码 / 示例

// ViewModel
class LoginViewModel: ObservableObject {
    @Published var username = ""
    @Published var password = ""
    @Published var isLoading = false
    @Published var errorMessage: String?

    private let authService: AuthServiceProtocol

    init(authService: AuthServiceProtocol) {
        self.authService = authService
    }

    @MainActor
    func login() async {
        isLoading = true
        errorMessage = nil
        do {
            try await authService.login(username: username, password: password)
        } catch {
            errorMessage = error.localizedDescription
        }
        isLoading = false
    }
}

// View
struct LoginView: View {
    @StateObject private var vm: LoginViewModel

    var body: some View {
        Form {
            TextField("用户名", text: $vm.username)
            SecureField("密码", text: $vm.password)
            if vm.isLoading { ProgressView() }
            if let error = vm.errorMessage { Text(error).foregroundColor(.red) }
            Button("登录") { Task { await vm.login() } }
        }
    }
}

常见误区

  • 误区:View 里写大量业务逻辑;正解:View 只负责布局和事件转发。
  • 误区:ViewModel 直接引用 View;正解:ViewModel 不知道 View 的存在,通过状态驱动 UI。

追问 / 延伸

  • ViewModel 应该是 class 还是 struct?class(ObservableObject 要求引用类型)。
  • 如何处理导航?ViewModel 持有路由状态(如 var navigation: Navigation?),View 观察并导航。

07.6.4-002 TCA 的核心概念是什么?

频率 ★★★ | 难度 进阶

一句话结论

TCA(The Composable Architecture)是一个单向数据流架构:State(状态结构体)、Action(事件枚举)、Reducer(纯函数,根据 Action 和当前 State 生成新 State 和 Effect 副作用)、Environment(依赖注入容器);View 发送 Action,Reducer 处理,State 变化驱动 View 刷新。

概念解释

  • State:struct,描述当前界面所有状态。
  • Action:enum,所有用户操作、系统事件、副作用结果。
  • Reducer:纯函数 (inout State, Action) -> Effect<Action>,不做副作用,只更新状态。
  • Effect:副作用(网络请求、数据库操作),完成后把结果包装成 Action 发回。
  • Store:持有 State 和 Reducer,View 通过 Store 发送 Action、观察 State。

代码 / 示例

import ComposableArchitecture

struct CounterState: Equatable {
    var count = 0
}

enum CounterAction: Equatable {
    case increment
    case decrement
    case factResponse(TaskResult<String>)
}

struct CounterEnvironment {
    var fact: (Int) async -> String
}

let counterReducer = Reducer<CounterState, CounterAction, CounterEnvironment> {
    state, action, env in
    switch action {
    case .increment:
        state.count += 1
        return .task { .factResponse(await TaskResult { env.fact(state.count) }) }
    case .decrement:
        state.count -= 1
        return .none
    case .factResponse(.success(let fact)):
        // 处理返回的事实
        return .none
    case .factResponse(.failure(let error)):
        return .none
    }
}

// View
struct CounterView: View {
    let store: Store<CounterState, CounterAction>
    var body: some View {
        WithViewStore(store) { viewStore in
            HStack {
                Button("-") { viewStore.send(.decrement) }
                Text("\(viewStore.count)")
                Button("+") { viewStore.send(.increment) }
            }
        }
    }
}

常见误区

  • 误区:TCA 适合所有项目;正解:TCA 学习曲线陡,小项目用 MVVM 更轻。
  • 误区:Reducer 里做网络请求;正解:Reducer 是纯函数,副作用必须放 Effect。

追问 / 延伸

  • TCA 如何组合小模块?Reducer 用 .combine 把多个子 Reducer 拼起来。
  • 如何处理导航?TCA 有官方的导航工具(如 NavigationStack 的 state 驱动)。

07.6.4-003 依赖注入在 iOS 中怎么做?

频率 ★★★★ | 难度 基础

一句话结论

三种主要方式:构造器注入(ViewModel 初始化时传入依赖协议)、环境注入(SwiftUI 的 @Environment,全局依赖)、工厂容器(一个 DIContainer 注册和解析依赖);iOS 推荐用协议抽象 + 构造器注入,便于测试和解耦。

概念解释

  • 协议抽象:Service 定义协议,具体实现遵循协议,ViewModel 依赖协议不依赖具体实现。
  • 构造器注入:在初始化时传入,依赖关系显式。
  • 环境注入:SwiftUI 中用 .environment(\.xxx) 注入,适合全局依赖。

代码 / 示例

// 协议
protocol AuthServiceProtocol {
    func login(username: String, password: String) async throws -> User
}

// 实现
class AuthService: AuthServiceProtocol {
    func login(username: String, password: String) async throws -> User {
        // 真实网络请求
    }
}

// Mock 实现(测试用)
class MockAuthService: AuthServiceProtocol {
    var result: Result<User, Error> = .success(User(id: "1", name: "Test"))
    func login(username: String, password: String) async throws -> User {
        try result.get()
    }
}

// ViewModel 依赖协议
class LoginViewModel: ObservableObject {
    private let authService: AuthServiceProtocol

    init(authService: AuthServiceProtocol) {
        self.authService = authService
    }
}

// 使用
let vm = LoginViewModel(authService: AuthService())
let testVm = LoginViewModel(authService: MockAuthService())

常见误区

  • 误区:ViewModel 直接 new 具体 Service;正解:依赖协议,初始化时传入。
  • 误区:所有依赖都从单例取;正解:单例增加耦合,测试时不好替换。

追问 / 延伸

  • 要不要用第三方 DI 容器(如 Swinject)?小项目手动注入就够,大项目可以用容器。
  • 环境变量怎么注入?SwiftUI 的 @Environment 适合,但类型安全要自己保证。

07.6.4-004 什么是单向数据流?

频率 ★★★ | 难度 进阶

一句话结论

单向数据流:View 发送 Action → Reducer/ViewModel 处理 → 状态更新 → View 自动刷新;数据流是单向的,View 不能直接修改状态,必须通过 Action 触发,保证状态变化可追踪、可调试。

概念解释

  • 双向绑定(如早期 iOS 的 KVO):View 和状态互相绑定,数据流混乱,难以追踪。
  • 单向数据流:状态是唯一数据源,View 是状态的投影,所有修改都通过 Action。
  • 好处:可预测、可调试、可测试。

常见误区

  • 误区:@State 和 @Binding 不是单向数据流;正解:@Binding 是双向的,但它只在本地状态,业务状态仍应单向。
  • 误区:单向数据流太麻烦;正解:项目越大,单向数据流的可维护性优势越明显。

追问 / 延伸

  • 如何调试状态变化?在 Reducer 中加 print,或用第三方工具(TCA 有 reducer 调试器)。
  • 单向数据流适合小项目吗?小项目可以简单点,不需要严格的 Action/Reducer 模式。

07.6.4-005 ViewModel 应该放什么、不应该放什么?

频率 ★★★★ | 难度 进阶

一句话结论

ViewModel 应该放:视图状态、用户操作处理、调用 UseCase/Service、数据转换(从模型到 View 展示);不应该放:视图引用、导航逻辑(可抽出)、具体的网络实现、格式字符串/日期格式化(可放工具类)。

概念解释

  • ViewModel 的职责:把业务数据转成 View 需要的展示数据,处理用户交互。
  • 不应该持有 View 引用:否则无法测试,也违背 MVVM 解耦原则。
  • 导航逻辑可以放 ViewModel(路由状态),也可以放 Coordinator,看团队习惯。

常见误区

  • 误区:ViewModel 直接做网络请求;正解:ViewModel 调用 Service/UseCase,不关心网络细节。
  • 误区:ViewModel 里放格式化逻辑;正解:日期/数字格式化应该放格式化器或 View 层。

追问 / 延伸

  • 大页面 ViewModel 太大怎么办?按功能拆分子 ViewModel,或者用 TCA 的模块化。
  • ViewModel 怎么处理多个网络请求?用 async/await 并发,或 Combine 合并流。

07.6.4-006 如何让 View 可测试?

频率 ★★★ | 难度 进阶

一句话结论

View 本身测试意义不大(UI 测试另说),可测试的核心是 ViewModel:依赖协议注入 Mock 实现,调用 ViewModel 方法,验证状态变化;View 只做快照测试或 UI 测试(XCUITest)。

概念解释

  • ViewModel 测试:给定输入(用户操作),验证输出(状态变化)。
  • Mock 依赖:网络层返回固定数据或错误,不依赖真实网络。
  • 快照测试:给 ViewModel 状态,生成 View 截图,对比是否变化。

代码 / 示例

class LoginViewModelTests: XCTestCase {
    func testLoginSuccess() async {
        let mockService = MockAuthService()
        mockService.result = .success(User(id: "1", name: "Test"))
        let vm = LoginViewModel(authService: mockService)

        vm.username = "test"
        vm.password = "123"
        await vm.login()

        XCTAssertFalse(vm.isLoading)
        XCTAssertNil(vm.errorMessage)
        XCTAssertTrue(mockService.loginCalled)
    }

    func testLoginFailure() async {
        let mockService = MockAuthService()
        mockService.result = .failure(AuthError.invalidPassword)
        let vm = LoginViewModel(authService: mockService)

        await vm.login()

        XCTAssertNotNil(vm.errorMessage)
    }
}

常见误区

  • 误区:测试 View 本身;正解:View 是声明式的,测试 ViewModel 就够。
  • 误区:测试用真实网络;正解:必须用 Mock,测试要快且稳定。

追问 / 延伸

  • 快照测试怎么集成?用 PointFree 或第三方库,或者 Xcode 15+ 内置的 Swipe 测试。
  • 覆盖率多少合适?核心业务逻辑 80%+,View 层不强制。

07.6.4-007 Coordinator 模式在 SwiftUI 中还需要吗?

频率 ★★ | 难度 进阶

一句话结论

UIKit 时代的 Coordinator 模式(管理导航、页面跳转)在 SwiftUI 中大部分被 NavigationStack 的 state 驱动导航替代了;复杂的跨模块导航、深链接处理仍然可以用 Coordinator 思路,但不需要像 UIKit 那样手动管理 UINavigationController。

概念解释

  • UIKit Coordinator:每个页面有一个 Coordinator,负责创建子页面、push/present。
  • SwiftUI:NavigationPath 是一个状态,View 根据状态自动导航,不需要手动管理。
  • 保留价值:跨模块的导航协调、深链接路由、复杂的页面流转。

常见误区

  • 误区:SwiftUI 完全不需要 Coordinator;正解:简单页面用 state 导航就够,复杂业务还是需要协调层。
  • 误区:NavigationStack 就是万能的;正解:modal 弹出、全屏覆盖还是需要额外管理。

追问 / 延伸

  • 深链接怎么处理?用 .onOpenURL,把 URL 转成路由状态,更新 NavigationPath。
  • 如何做全局导航?一个根路由 ObservableObject,所有页面观察它。

07.6.4-008 如何处理全局状态?

频率 ★★★ | 难度 进阶

一句话结论

全局状态(用户登录信息、主题设置、购物车)用 @EnvironmentObject 注入到根视图,所有子视图可以访问;按领域拆分(AppState、ThemeState、CartState),不要用一个超大的 AppState 管理所有状态。

概念解释

  • 全局状态是跨页面共享的,如登录态、主题、用户设置。
  • 按领域拆分:登录状态一个、主题一个、购物车一个,避免一个属性变化触发所有页面刷新。
  • 持久化:全局状态变化时同步到 UserDefaults 或 SwiftData。

代码 / 示例

// 登录状态
@MainActor
class AuthState: ObservableObject {
    @Published var user: User?
    @Published var isLoggedIn = false

    func login(user: User) {
        self.user = user
        self.isLoggedIn = true
    }

    func logout() {
        self.user = nil
        self.isLoggedIn = false
    }
}

// 根视图注入
@main
struct MyApp: App {
    @StateObject var authState = AuthState()
    var body: some Scene {
        WindowGroup {
            RootView()
                .environmentObject(authState)
        }
    }
}

// 子视图使用
struct ProfileView: View {
    @EnvironmentObject var authState: AuthState
    var body: some View {
        if authState.isLoggedIn {
            Text("你好, \(authState.user?.name ?? "")")
            Button("退出") { authState.logout() }
        } else {
            LoginView()
        }
    }
}

常见误区

  • 误区:所有状态都放全局;正解:页面私有状态放 @State 或页面级 ViewModel,只有跨页面共享的才放全局。
  • 误区:全局状态是单例;正解:用 @StateObject 在根视图创建,注入环境,不用单例。

追问 / 延伸

  • 全局状态怎么持久化?didSet 里写 UserDefaults,或启动时从本地加载。
  • 多个全局状态怎么组织?按功能分多个 ObservableObject,不要合并成一个。

07.6.4-009 TCA 与 MVVM 怎么选?

频率 ★★ | 难度 基础

一句话结论

小项目、快速原型、团队不熟悉函数式:选 MVVM,简单直接;大项目、复杂状态管理、团队愿意学习函数式思维、需要严格的可测试性和可追溯性:选 TCA。

概念解释

  • MVVM:灵活,没有严格约定,容易写乱,但上手快。
  • TCA:严格的单向数据流,所有状态变化可追踪,模块化好,但学习曲线陡、样板代码多。
  • 决策因素:团队经验、项目规模、维护周期。

常见误区

  • 误区:TCA 一定比 MVVM 好;正解:TCA 适合大项目,小项目反而过重。
  • 误区:用了 TCA 就不需要写测试;正解:TCA 让测试容易写,但不写测试还是不行。

追问 / 延伸

  • 老项目能迁移到 TCA 吗?可以,从新页面开始用 TCA,老页面保持 MVVM。
  • TCA 有什么缺点?依赖一个外部库,版本升级要跟进;Redux 模式对习惯命令式的人不直观。

07.6.4-010 协议抽象的边界怎么定?

频率 ★★ | 难度 高级

一句话结论

对外部依赖(网络、数据库、推送、设备能力)做协议抽象,方便测试和替换;对内部业务逻辑(View 之间、ViewModel 之间)不要过度抽象,否则增加复杂度;原则:稳定的部分抽象,多变的部分直接用。

概念解释

  • 该抽象:网络层、数据库、第三方 SDK、设备能力(相机、定位)。
  • 不该抽象:简单的工具函数、只有一个实现的模块。
  • 过早抽象的代价:修改接口要改多处,不如直接用。

常见误区

  • 误区:所有类都抽协议;正解:只有需要替换(测试、多实现)的才抽。
  • 误区:协议越细越好;正解:胖协议(一个协议很多方法)不如多个小协议。

追问 / 延伸

  • 怎么判断要不要抽象?问自己:「这个需要 Mock 吗?」需要就抽,不需要就不抽。
  • 抽象和封装的区别?抽象是为了替换,封装是为了隐藏实现。

待整理清单

  • [ ] TCA 高级用法(Effect 取消、并发)
  • [ ] 模块化拆分(SPM)
  • [ ] 路由设计(DeepLink)