SwiftUI 아키텍처은(는) 무엇을 하나요?
이 스킬을 사용해야 할 때
다음과 같은 상황에서 이 스킬을 사용하세요:
- SwiftUI 뷰 파일에 로직이 있어 이를 분리하려는 경우
- MVVM, TCA, 일반 SwiftUI 패턴, 또는 Coordinator 중에서 선택해야 하는 경우
- 관심사를 분리하기 위해 뷰를 리팩토링하는 경우
- SwiftUI 코드를 테스트 가능하게 만들려는 경우
- "이 코드는 어디에 넣어야 하지?"라고 묻는 경우
- 어떤 프로퍼티 래퍼(@State, @Environment, @Bindable)를 사용할지 결정해야 하는 경우
- 팀 개발을 위해 SwiftUI 코드베이스를 구성하는 경우
프롬프트 예시
| 질문 예시 | 이 스킬이 도움이 되는 이유 |
|---|---|
| "제 모델 뷰 파일에 로직 관련 코드가 꽤 많습니다. 어떻게 분리하나요?" | 로직이 어디에 속해야 하는지에 대한 의사 결정 트리가 포함된 리팩토링 워크플로우 제공 |
| "MVVM, TCA, 또는 Apple의 기본 패턴 중 무엇을 사용해야 하나요?" | 앱 복잡성, 팀 규모, 테스트 용이성 요구 사항에 기반한 결정 기준 제공 |
| "SwiftUI 코드를 어떻게 테스트 가능하게 만들 수 있나요?" | SwiftUI 임포트 없이 테스트를 가능하게 하는 분리 패턴 제시 |
| "포맷터와 계산은 어디에 넣어야 하나요?" | 안티패턴 섹션에서 뷰 본문에 로직을 두지 않도록 방지 |
| "어떤 프로퍼티 래퍼를 사용해야 하나요?" | @State, @Environment, @Bindable 또는 일반 프로퍼티에 대한 의사 결정 트리 제공 |
빠른 아키텍처 의사 결정 트리
아키텍처 선택을 결정하는 요소는 무엇인가요?
│
├─ 새로 시작하는 중소규모 앱이고 Apple 패턴을 원하시나요?
│ └─ Apple 네이티브 패턴 사용 (파트 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: Apple 네이티브 패턴 (iOS 26+)
핵심 원칙
"데이터 모델은 데이터와 데이터와 상호작용하는 뷰 사이의 분리를 제공합니다. 이러한 분리는 모듈성을 촉진하고, 테스트 용이성을 향상시키며, 앱이 어떻게 작동하는지 추론하기 쉽게 만듭니다." — Apple 개발자 문서
Apple의 현대적인 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) // ⚠️ 애니메이션 타이밍 불확실
}
}
해결책: State를 브릿지로 사용
"시간에 민감한 변경이 필요한 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가지 질문만 있습니다:
어떤 프로퍼티 래퍼를 사용해야 하나요?
│
├─ 이 모델이 VIEW 자체의 STATE가 되어야 하나요?
│ └─ 예 → @State 사용
│ 예시: 폼 입력, 로컬 토글, 시트 표시
│ 수명: 뷰의 수명에 의해 관리됨
│
├─ 이 모델이 GLOBAL ENVIRONMENT의 일부가 되어야 하나요?
│ └─ 예 → @Environment 사용
│ 예시: 사용자 계정, 앱 설정, 의존성 주입
│ 수명: 앱/씬 레벨에서 유지
│
├─ 이 모델이 BINDINGS만 필요하나요?
│ └─ 예 → @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로 새로 시작하는 경우 (Apple 패턴이 더 간단함)
- 불필요한 추상화 계층을 만드는 경우
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: God 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 (Composable Architecture)
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 getFact(number: state.count)
await send(.factResponse(fact))
}
case let .factResponse(fact):
state.fact = fact
state.isLoading = false
return .none
}
}
}
}
// VIEW — Store를 통해 액션 전송
struct CounterView: View {
let store: StoreOf<CounterFeature>
var body: some View {
Form {
Text("\(store.count)")
HStack {
Button("-") { store.send(.decrementButtonTapped) }
Button("+") { store.send(.incrementButtonTapped) }
}
Button("사실 가져오기") { store.send(.factButtonTapped) }
.disabled(store.isLoading)
}
}
}
State, Action, Reducer, Store만 기억하세요
| 구성 요소 | 설명 | 예시 |
|---|---|---|
| State | 기능에 필요한 데이터 | count, fact, isLoading |
| Action | 기능이 처리하는 모든 이벤트 | 버튼 탭, 네트워크 응답 |
| Reducer | 액션에 응답하여 상태를 진화시키는 순수 함수 | 비즈니스 로직, 부수 효과 |
| Store | Reducer를 실행하는 런타임 (주입된 의존성 포함) | 뷰와 테스트 모두에서 실행 |
의존성 관리
TCA는 의존성을 명시적으로 관리하여 테스트를 쉽게 만듭니다:
// 의존성 등록
struct NumberFactClient {
var fetch: @Sendable (Int) async throws -> String
}
extension NumberFactClient: DependencyKey {
static let liveValue = Self(
fetch: { number in
let url = URL(string: "http://numbersapi.com/\(number)")!
let (data, _) = try await URLSession.shared.data(from: url)
return String(decoding: data, as: UTF8.self)
}
)
}
// Reducer에서 사용
@Dependency(\.numberFact) var numberFact
// 테스트에서 재정의
let store = TestStore(initialState: CounterFeature.State()) {
CounterFeature()
} withDependencies: {
$0.numberFact.fetch = { _ in "0은 숫자입니다" }
}
TCA 대 Apple 네이티브 패턴
| 측면 | Apple 네이티브 | TCA |
|---|---|---|
| 보일러플레이트 | 최소 | 더 많음 (Action, Reducer, Store) |
| 테스트 용이성 | 수동 설정 | 기본 제공 (TestStore) |
| 학습 곡선 | 낮음 | 중간-높음 |
| 팀 일관성 | 느슨함 | 엄격함 |
| 부수 효과 | 수동 관리 | 구조화됨, 취소 가능 |
| 의존성 | 주입 패턴 | 선언적, 검증 가능 |
| 적합한 앱 규모 | 소규모-중간 | 중간-대규모 |
파트 4: Coordinator 패턴
Coordinator를 사용할 때
Coordinator는 앱이 다음과 같은 경우 특히 유용합니다:
✅ 복잡한 탐색 — 깊게 중첩된 뷰 계층 ✅ 딥 링킹 — 특정 기능으로의 외부 URL 처리 ✅ 멀티 윈도우/씬 — 여러 진입점 ✅ 조건부 온보딩 — 사용자 상태에 따른 흐름 ✅ 탐색 테스트 — 뷰에서 탐색 로직 분리
기본 Coordinator
// Coordinator가 탐색 상태 관리
@Observable
class AppCoordinator {
var path = NavigationPath()
func showDetail(for item: Item) {
path.append(AppRoute.detail(item))
}
func showSettings() {
path.append(AppRoute.settings)
}
func goBack() {
path.removeLast()
}
}
어떤 패턴과도 결합
Coordinator는 단일 패턴이 아닌 추가 기능입니다. 위의 모든 패턴과 결합할 수 있습니다.