SwiftUI 架构
何时使用此技能
在以下情况使用此技能:
- 你的 SwiftUI 视图文件中包含逻辑,并希望将其提取出来
- 在 MVVM、TCA、原生 SwiftUI 模式或 Coordinator 之间做出选择
- 重构视图以分离关注点
- 让 SwiftUI 代码可测试
- 询问“这段代码应该放哪里?”
- 决定使用哪个属性包装器(@State、@Environment、@Bindable)
- 为团队开发组织 SwiftUI 代码库
示例提示
| 你可能问的问题 | 此技能的帮助 |
|---|---|
| “我的模型视图文件中有很多关于逻辑的代码。如何提取它们?” | 提供包含决策树的重构工作流,指导逻辑应放在何处 |
| “我应该使用 MVVM、TCA 还是苹果的原生模式?” | 基于应用复杂性、团队规模、测试需求提供决策标准 |
| “如何让我的 SwiftUI 代码可测试?” | 展示无需 SwiftUI 导入即可实现测试的分离模式 |
| “格式化和计算应该放在哪里?” | 反模式部分防止逻辑出现在视图主体中 |
| “我应该使用哪个属性包装器?” | 针对 @State、@Environment、@Bindable 或普通属性的决策树 |
快速架构决策树
什么驱动你的架构选择?
│
├─ 从零开始,中小型应用,想要苹果的模式?
│ └─ 使用苹果原生模式(第 1 部分)
│ - @Observable 模型用于业务逻辑
│ - State-as-Bridge 用于异步边界
│ - 属性包装器决策树
│
├─ 熟悉 UIKit 中的 MVVM?
│ └─ 使用 MVVM 模式(第 2 部分)
│ - ViewModel 作为表现层适配器
│ - 清晰的 View/ViewModel/Model 分离
│ - 与 @Observable 配合良好
│
├─ 复杂应用,需要严格的测试性和团队一致性?
│ └─ 考虑 TCA(第 3 部分)
│ - State/Action/Reducer/Store 架构
│ - 出色的测试能力
│ - 学习曲线与样板代码的权衡
│
└─ 复杂导航、深度链接、多个入口点?
└─ 添加 Coordinator 模式(第 4 部分)
- 可以与其他任何模式结合
- 将导航逻辑从视图中提取
- NavigationPath + Coordinator 对象
第 1 部分:苹果原生模式(iOS 26+)
核心原则
“数据模型提供了数据与交互数据的视图之间的分离。这种分离促进模块化、提高可测试性,并有助于更容易地推理应用的工作原理。” — 苹果开发者文档
苹果现代的 SwiftUI 模式(WWDC 2023-2025)聚焦于:
- @Observable 用于数据模型(替代 ObservableObject)
- State-as-Bridge 用于异步边界(WWDC 2025)
- 三个属性包装器:@State、@Environment、@Bindable
- 同步 UI 更新 用于动画
State-as-Bridge 模式
问题
异步函数会创建可能导致动画中断的暂停点:
// ❌ 问题:动画可能错过帧截止时间
struct ColorExtractorView: View {
@State private var isLoading = false
var body: some View {
Button("提取颜色") {
Task {
isLoading = true // 同步 ✅
await extractColors() // ⚠️ 暂停点!
isLoading = false // ❌ 可能发生得太晚
}
}
.scaleEffect(isLoading ? 1.5 : 1.0) // ⚠️ 动画时机不确定
}
}
解决方案:将状态用作桥梁
“找到需要时间敏感性变化的 UI 代码与长时间运行的异步逻辑之间的边界。”
// ✅ 正确:State 桥接了 UI 和异步代码
@Observable
class ColorExtractor {
var isLoading = false
var colors: [Color] = []
func extract(from image: UIImage) async {
// 此方法是异步的,可以存在于模型中
let extracted = await heavyComputation(image)
// 用于 UI 更新的同步赋值
self.colors = extracted
}
}
struct ColorExtractorView: View {
let extractor: ColorExtractor
var body: some View {
Button("提取颜色") {
// 用于动画的同步状态更改
withAnimation {
extractor.isLoading = true
}
// 启动异步工作
Task {
await extractor.extract(from: currentImage)
// 用于动画的同步状态更改
withAnimation {
extractor.isLoading = false
}
}
}
.scaleEffect(extractor.isLoading ? 1.5 : 1.0)
}
}
优势:
- UI 逻辑保持同步(动画正常工作)
- 异步代码存在于模型中(无需 SwiftUI 即可测试)
- 时间敏感性 UI 与长时间运行工作之间的清晰边界
属性包装器决策树
只需回答 3 个问题:
我应该使用哪个属性包装器?
│
├─ 这个模型需要是视图本身的状态吗?
│ └─ 是 → 使用 @State
│ 示例:表单输入、局部开关、弹出式展示
│ 生命周期:由视图的生命周期管理
│
├─ 这个模型需要成为全局环境的一部分吗?
│ └─ 是 → 使用 @Environment
│ 示例:用户账户、应用程序设置、依赖注入
│ 生命周期:存在于应用/场景级别
│
├─ 这个模型只需要绑定吗?
│ └─ 是 → 使用 @Bindable
│ 示例:编辑从父视图传入的模型
│ 轻量:仅启用 $ 语法用于绑定
│
└─ 以上都不是?
└─ 作为普通属性使用
示例:不可变数据、父视图拥有的模型
不需要包装器:@Observable 已处理观察
示例
// ✅ @State — 视图拥有模型
struct DonutEditor: View {
@State private var donutToAdd = Donut() // 视图自己的状态
var body: some View {
TextField("名称", text: $donutToAdd.name)
}
}
// ✅ @Environment — 应用级别的模型
struct MenuView: View {
@Environment(Account.self) private var account // 全局
var body: some View {
Text("欢迎,\(account.userName)")
}
}
// ✅ @Bindable — 需要绑定到父视图拥有的模型
struct DonutRow: View {
@Bindable var donut: Donut // 父视图拥有
var body: some View {
TextField("名称", text: $donut.name) // 需要绑定
}
}
// ✅ 普通属性 — 仅读取
struct DonutRow: View {
let donut: Donut // 父视图拥有,不需要绑定
var body: some View {
Text(donut.name) // 仅读取
}
}
@Observable 模型模式
对需要触发 UI 更新的业务逻辑使用 @Observable:
// ✅ 包含业务逻辑的领域模型
@Observable
class FoodTruckModel {
var orders: [Order] = []
var donuts = Donut.all
var orderCount: Int {
orders.count // 计算属性自动生效
}
func addDonut() {
donuts.append(Donut())
}
}
// ✅ 视图自动追踪已访问的属性
struct DonutMenu: View {
let model: FoodTruckModel // 不需要包装器!
var body: some View {
List {
Section("甜甜圈") {
ForEach(model.donuts) { donut in
Text(donut.name) // 追踪 model.donuts
}
Button("添加") {
model.addDonut()
}
}
Section("订单") {
Text("数量:\(model.orderCount)") // 追踪 model.orders
}
}
}
}
工作原理(WWDC 2023/10149):
- SwiftUI 追踪在
body执行期间访问了哪些属性 - 只有那些属性在更改时会触发视图更新
- 细粒度的依赖追踪 = 更好的性能
ViewModel 适配器模式
当你需要过滤、排序或视图特定逻辑时,使用 ViewModel 作为表现层适配器:
// ✅ ViewModel 作为表现层适配器
@Observable
class PetStoreViewModel {
let petStore: PetStore // 领域模型
var searchText: String = ""
// 视图特定的计算属性
var filteredPets: [Pet] {
guard !searchText.isEmpty else { return petStore.myPets }
return petStore.myPets.filter { $0.name.contains(searchText) }
}
}
struct PetListView: View {
@Bindable var viewModel: PetStoreViewModel
var body: some View {
List {
ForEach(viewModel.filteredPets) { pet in
PetRowView(pet: pet)
}
}
.searchable(text: $viewModel.searchText)
}
}
何时使用 ViewModel 适配器:
- 为显示进行过滤、排序、分组
- 为表现层进行格式化(但不要进行重计算)
- 不属于领域模型的视图特定状态
- 在领域模型与 SwiftUI 约定之间搭建桥梁
何时不使用 ViewModel:
- 仅显示模型数据的简单视图
- 属于领域模型的逻辑
- 仅为“模式纯洁性”而过度提取
第 2 部分:MVVM 模式
何时使用 MVVM
MVVM(Model-View-ViewModel)在以下情况适用:
✅ 你从 UIKit 就很熟悉它 — 团队成员学习曲线更平坦 ✅ 你想要显式的 View/ViewModel 分离 — 清晰的契约 ✅ 你有复杂的表现层逻辑 — 多种过滤/排序操作 ✅ 你正在从 UIKit 迁移 — 熟悉的心智模型
❌ 在以下情况避免 MVVM:
- 视图很简单(只展示数据)
- 你从零开始使用 SwiftUI(苹果原生模式更简单)
- 你在创建不必要的抽象层
SwiftUI 的 MVVM 结构
// Model — 领域数据和业务逻辑
struct Pet: Identifiable {
let id: UUID
var name: String
var kind: Kind
var trick: String
var hasAward: Bool = false
mutating func giveAward() {
hasAward = true
}
}
// ViewModel — 表现层逻辑
@Observable
class PetListViewModel {
private let petStore: PetStore
var pets: [Pet] { petStore.myPets }
var searchText: String = ""
var selectedSort: SortOption = .name
var filteredSortedPets: [Pet] {
let filtered = pets.filter { pet in
searchText.isEmpty || pet.name.contains(searchText)
}
return filtered.sorted { lhs, rhs in
switch selectedSort {
case .name: lhs.name < rhs.name
case .kind: lhs.kind.rawValue < rhs.kind.rawValue
}
}
}
init(petStore: PetStore) {
self.petStore = petStore
}
func awardPet(_ pet: Pet) {
petStore.awardPet(pet.id)
}
}
// View — 仅 UI
struct PetListView: View {
@Bindable var viewModel: PetListViewModel
var body: some View {
List {
ForEach(viewModel.filteredSortedPets) { pet in
PetRow(pet: pet) {
viewModel.awardPet(pet)
}
}
}
.searchable(text: $viewModel.searchText)
}
}
SwiftUI 中常见的 MVVM 错误
❌ 错误 1:在 View 和 ViewModel 中重复 @Observable
// ❌ @State + @Observable 是冗余的— @State 会创建自己的存储
struct MyView: View {
@State private var viewModel = MyViewModel() // ❌ 冗余包装器
}
// ✅ 直接传递 @Observable— 仅当视图拥有生命周期时才使用 @State
struct MyView: View {
let viewModel: MyViewModel // ✅ 如果视图创建它,则使用 @State
}
❌ 错误 2:上帝 ViewModel
// ❌ 不要这样做
@Observable
class AppViewModel {
// 设置
var isDarkMode = false
var notificationsEnabled = true
// 用户
var userName = ""
var userEmail = ""
// 内容
var posts: [Post] = []
var comments: [Comment] = []
// ... 还有 50 个属性
}
// ✅ 正确:分离关注点
@Observable
class SettingsViewModel {
var isDarkMode = false
var notificationsEnabled = true
}
@Observable
class UserProfileViewModel {
var user: User
}
@Observable
class FeedViewModel {
var posts: [Post] = []
}
❌ 错误 3:业务逻辑在 ViewModel 中
// ❌ 业务规则应放在 Model 中,而不是 ViewModel
@Observable class OrderViewModel {
func calculateDiscount(for order: Order) -> Double { /* ... */ } // ❌ 业务逻辑
}
// ✅ Model 拥有业务逻辑;ViewModel 仅进行显示格式化
struct Order {
func calculateDiscount() -> Double { /* 业务规则 */ }
}
@Observable class OrderViewModel {
let order: Order
var displayDiscount: String {
"$\(order.calculateDiscount(), specifier: "%.2f")" // ✅ 仅格式化
}
}
第 3 部分:TCA(可组合架构)
何时考虑 TCA
TCA 是来自 Point-Free 的第三方架构。在以下情况考虑它:
✅ 严格的测试性至关重要 — TestStore 使测试确定性强 ✅ 大型团队需要一致性 — 严格的模式减少差异 ✅ 复杂的状态管理 — 副作用、依赖、组合 ✅ 你重视类似 Redux 的模式 — 单向数据流
❌ 在以下情况避免 TCA:
- 小型应用或原型(开销太大)
- 团队不熟悉函数式编程
- 你需要快速迭代(样板代码拖慢开发速度)
- 你想要最小依赖
TCA 核心概念
TCA 有 4 个构建块— State(数据)、Action(事件)、Reducer(状态演化)和 Store(运行时引擎)。以下是单个功能中的它们:
// STATE — 功能所需的数据
@ObservableState
struct CounterFeature {
var count = 0
var fact: String?
var isLoading = false
}
// ACTION — 所有可能的事件
enum Action {
case incrementButtonTapped
case decrementButtonTapped
case factButtonTapped
case factResponse(String)
}
// REDUCER — 状态如何响应动作而演化
struct CounterFeature: Reducer {
var body: some ReducerOf<Self> {
Reduce { state, action in
switch action {
case .incrementButtonTapped:
state.count += 1
return .none
case .decrementButtonTapped:
state.count -= 1
return .none
case .factButtonTapped:
state.isLoading = true
return .run { send in
let fact = await numberFact(state.count)
await send(.factResponse(fact))
}
case let .factResponse(fact):
state.fact = fact
state.isLoading = false
return .none
}
}
}
}
// STORE — 运行时的 State 和 Action 引擎
struct CounterView: View {
@Bindable var store: StoreOf<CounterFeature>
var body: some View {
List {
Section {
Text("\(store.count)")
HStack {
Button("减少") { store.send(.decrementButtonTapped) }
Button("增加") { store.send(.incrementButtonTapped) }
}
Button("获取趣闻") { store.send(.factButtonTapped) }
}
if store.isLoading {
ProgressView()
}
if let fact = store.fact {
Section {
Text(fact)
}
}
}
.navigationTitle("计数器")
}
}
第 4 部分:Coordinator 导航模式
何时使用 Coordinator
Coordinator 模式将导航逻辑从视图中提取。在以下情况使用它:
✅ 复杂的导航流程 — 多步注册、向导 ✅ 深度链接 — 从外部链接直接导航到深层页面 ✅ 多个入口点 — 推送通知、快捷方式、快捷指令 ✅ 需要导航重用的应用程序 — 从不同上下文中呈现相同的流程
❌ 在以下情况避免 Coordinator:
- 简单的层级导航(List → Detail)
- 小型应用,或有一次性的导航需求
- 你正在使用 NavigationStack 和 NavigationLink,这已经足够了
使用 NavigationPath 的 Coordinator
// Coordinator 管理导航路径
@Observable
class AppCoordinator {
var path = NavigationPath()
func navigateToOrder(_ order: Order) {
path.append(AppRoute.orderDetail(order))
}
func navigateToPayment(for order: Order) {
path.append(AppRoute.payment(order.id))
}
func navigateToSettings() {
path.append(AppRoute.settings)
}
func popToRoot() {
path.removeLast(path.count)
}
}
// Route 枚举定义了所有可能的导航目的地
enum AppRoute: Hashable {
case orderDetail(Order)
case payment(UUID)
case settings
case about
case profile(User)
}
// 视图通过 Coordinator 进行导航
struct ContentView: View {
@Environment(AppCoordinator.self) private var coordinator
var body: some View {
NavigationStack(path: Bindable(coordinator).path) {
HomeView()
.navigationDestination(for: AppRoute.self) { route in
switch route {
case .orderDetail(let order):
OrderDetailView(order: order)
case .payment(let orderId):
PaymentView(orderId: orderId)
case .settings:
SettingsView()
case .about:
AboutView()
case .profile(let user):
ProfileView(user: user)
}
}
}
}
}
第 5 部分:常见反模式与重构
❌ 反模式:视图主体中的格式化
// ❌ 不好的做法:格式化和计算在视图中
struct OrderView: View {
let order: Order
var body: some View {
let total = order.items.reduce(0) { $0 + $1.price * Double($1.quantity) }
let tax = total * 0.08
let finalTotal = total + tax
VStack {
Text("小计:$\(total, specifier: "%.2f")")
Text("税费:$\(tax, specifier: "%.2f")")
Text("总计:$\(finalTotal, specifier: "%.2f")")
}
}
}
// ✅ 好的做法:逻辑在模型中
@Observable
class Order {
var items: [OrderItem] = []
var subtotal: Double {
items.reduce(0) { $0 + $1.price * Double($1.quantity) }
}
var tax: Double { subtotal * 0.08 }
var total: Double { subtotal + tax }
}
struct OrderView: View {
let order: Order // 不需要包装器
var body: some View {
VStack {
Text("小计:$\(order.subtotal, specifier: "%.2f")")
Text("税费:$\(order.tax, specifier: "%.2f")")
Text("总计:$\(order.total, specifier: "%.2f")")
}
}
}
❌ 反模式:不需要时创建 ViewModel
// ❌ 过度提取:添加 ViewModel 只是为显示数据
struct UserView: View {
let user: User
var body: some View {
VStack {
Text(user.name)
Text(user.email)
}
}
}
❌ 反模式:在视图中混合异步和同步
// ❌ 视图尝试自行管理工作
struct UserListView: View {
@State private var users: [User] = []
@State private var isLoading = false
var body: some View {
List(users) { user in
Text(user.name)
}
.task {
isLoading = true
let result = await api.fetchUsers()
users = result
isLoading = false
}
}
}
// ✅ 模型管理自己数据的获取
@Observable
class UserListModel {
var users: [User] = []
var isLoading = false
@MainActor
func loadUsers() async {
isLoading = true
users = await api.fetchUsers()
isLoading = false
}
}
struct UserListView: View {
let model: UserListModel
var body: some View {
List(model.users) { user in
Text(user.name)
}
.task {
await model.loadUsers()
}
}
}
重构清单
将逻辑从视图移至模型时,对每一行代码使用此清单:
-
这是 UI 逻辑吗? → 保持在视图中
- 过渡、动画、布局计算
- 拖放手势处理
- 本地 UI 状态(菜单展开/折叠)
-
这是表现层逻辑吗? → ViewModel(可选)
- 格式化日期/货币
- 过滤/排序列表
- 组合来自不同模型的数据
-
这是领域逻辑吗? → 领域模型
- 业务规则和计算
- 数据验证
- API 调用和数据处理
-
这是异步工作吗? → 模型
- async/await 函数
- 长时间运行的任务
- 网络请求