📱 MVC: Apple이 제안한 기본 패턴

MVC는 Model-View-Controller의 약자로, Apple이 iOS 개발의 기본 패턴으로 제안한 아키텍처야. 가장 오래되고 널리 알려진 패턴이지만, iOS에서의 MVC는 다른 플랫폼의 MVC와는 조금 다른 특징을 가지고 있어. 🍎

struct User {
    let name: String
    let email: String
    let profileImageURL: String?
    
    // 비즈니스 로직
    func isValidEmail() -> Bool {
        let emailRegex = "[A-Z0-9a-z._%+-]+@[A-Za-z0-9.-]+\\.[A-Za-z]{2,64}"
        let emailPredicate = NSPredicate(format:"SELF MATCHES %@", emailRegex)
        return emailPredicate.evaluate(with: email)
    }
}

class ProfileView: UIView {
    let nameLabel: UILabel = {
        let label = UILabel()
        label.font = .systemFont(ofSize: 24, weight: .bold)
        label.textColor = .black
        return label
    }()
    
    let emailLabel: UILabel = {
        let label = UILabel()
        label.font = .systemFont(ofSize: 16)
        label.textColor = .gray
        return label
    }()
    
    let profileImageView: UIImageView = {
        let imageView = UIImageView()
        imageView.contentMode = .scaleAspectFill
        imageView.clipsToBounds = true
        imageView.layer.cornerRadius = 50
        return imageView
    }()
    
    override init(frame: CGRect) {
        super.init(frame: frame)
        setupUI()
    }
    
    required init?(coder: NSCoder) {
        fatalError("init(coder:) has not been implemented")
    }
    
    private func setupUI() {
        addSubview(profileImageView)
        addSubview(nameLabel)
        addSubview(emailLabel)
        
        // Auto Layout 설정 (간략화)
        profileImageView.translatesAutoresizingMaskIntoConstraints = false
        nameLabel.translatesAutoresizingMaskIntoConstraints = false
        emailLabel.translatesAutoresizingMaskIntoConstraints = false
        
        NSLayoutConstraint.activate([
            profileImageView.centerXAnchor.constraint(equalTo: centerXAnchor),
            profileImageView.topAnchor.constraint(equalTo: topAnchor, constant: 40),
            profileImageView.widthAnchor.constraint(equalToConstant: 100),
            profileImageView.heightAnchor.constraint(equalToConstant: 100),
            
            nameLabel.centerXAnchor.constraint(equalTo: centerXAnchor),
            nameLabel.topAnchor.constraint(equalTo: profileImageView.bottomAnchor, constant: 20),
            
            emailLabel.centerXAnchor.constraint(equalTo: centerXAnchor),
            emailLabel.topAnchor.constraint(equalTo: nameLabel.bottomAnchor, constant: 8)
        ])
    }
}

class ProfileViewController: UIViewController {
    private let profileView = ProfileView()
    private var user: User?
    
    override func loadView() {
        view = profileView
    }
    
    override func viewDidLoad() {
        super.viewDidLoad()
        view.backgroundColor = .white
        loadUserData()
    }
    
    private func loadUserData() {
        // 실제로는 네트워크나 데이터베이스에서 가져옴
        user = User(
            name: "김개발",
            email: "dev@example.com",
            profileImageURL: nil
        )
        
        updateUI()
    }
    
    private func updateUI() {
        guard let user = user else { return }
        
        profileView.nameLabel.text = user.name
        profileView.emailLabel.text = user.email
        
        if let imageURL = user.profileImageURL {
            // 이미지 로딩 로직
            loadProfileImage(from: imageURL)
        } else {
            profileView.profileImageView.image = UIImage(systemName: "person.circle.fill")
        }
        
        // 이메일 유효성 검사
        if !user.isValidEmail() {
            showInvalidEmailAlert()
        }
    }
    
    private func loadProfileImage(from urlString: String) {
        // 이미지 다운로드 및 캐싱 로직
        guard let url = URL(string: urlString) else { return }
        
        URLSession.shared.dataTask(with: url) { [weak self] data, response, error in
            guard let data = data, let image = UIImage(data: data) else { return }
            
            DispatchQueue.main.async {
                self?.profileView.profileImageView.image = image
            }
        }.resume()
    }
    
    private func showInvalidEmailAlert() {
        let alert = UIAlertController(
            title: "알림",
            message: "유효하지 않은 이메일 형식입니다.",
            preferredStyle: .alert
        )
        alert.addAction(UIAlertAction(title: "확인", style: .default))
        present(alert, animated: true)
    }
}

🎯 MVVM: 데이터 바인딩의 마법

MVVM은 Model-View-ViewModel의 약자로, Microsoft에서 제안한 패턴이야. MVC의 문제점을 해결하기 위해 등장했는데, 핵심은 ViewModel이라는 새로운 레이어를 추가하는 거야. 🌟

같은 프로필 화면을 MVVM으로 다시 구현해보자! 여기서는 간단한 Closure 기반 바인딩을 사용할게. 😊

struct User {
    let name: String
    let email: String
    let profileImageURL: String?
    
    func isValidEmail() -> Bool {
        let emailRegex = "[A-Z0-9a-z._%+-]+@[A-Za-z0-9.-]+\\.[A-Za-z]{2,64}"
        let emailPredicate = NSPredicate(format:"SELF MATCHES %@", emailRegex)
        return emailPredicate.evaluate(with: email)
    }
}

class ProfileViewModel {
    // Observable 패턴을 위한 간단한 바인딩 클래스
    class Observable<T> {
        var value: T {
            didSet {
                listener?(value)
            }
        }
        
        private var listener: ((T) -> Void)?
        
        init(_ value: T) {
            self.value = value
        }
        
        func bind(_ closure: @escaping (T) -> Void) {
            closure(value)
            listener = closure
        }
    }
    
    // View에 바인딩될 데이터
    let userName = Observable<String>("")
    let userEmail = Observable<String>("")
    let profileImage = Observable<UIImage?>(nil)
    let isEmailValid = Observable<Bool>(true)
    let isLoading = Observable<Bool>(false)
    let errorMessage = Observable<String?>(nil)
    
    private var user: User?
    
    // 사용자 데이터 로드
    func loadUserData() {
        isLoading.value = true
        
        // 실제로는 네트워크나 데이터베이스에서 가져옴
        DispatchQueue.main.asyncAfter(deadline: .now() + 1.0) { [weak self] in
            self?.user = User(
                name: "김개발",
                email: "dev@example.com",
                profileImageURL: nil
            )
            
            self?.updateViewData()
            self?.isLoading.value = false
        }
    }
    
    private func updateViewData() {
        guard let user = user else { return }
        
        userName.value = user.name
        userEmail.value = user.email
        isEmailValid.value = user.isValidEmail()
        
        if let imageURL = user.profileImageURL {
            loadProfileImage(from: imageURL)
        } else {
            profileImage.value = UIImage(systemName: "person.circle.fill")
        }
    }
    
    private func loadProfileImage(from urlString: String) {
        guard let url = URL(string: urlString) else { return }
        
        URLSession.shared.dataTask(with: url) { [weak self] data, response, error in
            if let error = error {
                DispatchQueue.main.async {
                    self?.errorMessage.value = "이미지 로딩 실패: \(error.localizedDescription)"
                }
                return
            }
            
            guard let data = data, let image = UIImage(data: data) else { return }
            
            DispatchQueue.main.async {
                self?.profileImage.value = image
            }
        }.resume()
    }
    
    // 사용자 액션 처리
    func didTapRefreshButton() {
        loadUserData()
    }
    
    func didTapEditButton() {
        // 편집 화면으로 이동하는 로직
        // Coordinator 패턴과 함께 사용하면 더 깔끔해져!
    }
}

class ProfileViewController: UIViewController {
    private let profileView = ProfileView()
    private let viewModel = ProfileViewModel()
    
    private let activityIndicator: UIActivityIndicatorView = {
        let indicator = UIActivityIndicatorView(style: .large)
        indicator.hidesWhenStopped = true
        return indicator
    }()
    
    override func loadView() {
        view = profileView
    }
    
    override func viewDidLoad() {
        super.viewDidLoad()
        view.backgroundColor = .white
        setupActivityIndicator()
        bindViewModel()
        viewModel.loadUserData()
    }
    
    private func setupActivityIndicator() {
        view.addSubview(activityIndicator)
        activityIndicator.translatesAutoresizingMaskIntoConstraints = false
        NSLayoutConstraint.activate([
            activityIndicator.centerXAnchor.constraint(equalTo: view.centerXAnchor),
            activityIndicator.centerYAnchor.constraint(equalTo: view.centerYAnchor)
        ])
    }
    
    private func bindViewModel() {
        // 이름 바인딩
        viewModel.userName.bind { [weak self] name in
            self?.profileView.nameLabel.text = name
        }
        
        // 이메일 바인딩
        viewModel.userEmail.bind { [weak self] email in
            self?.profileView.emailLabel.text = email
        }
        
        // 프로필 이미지 바인딩
        viewModel.profileImage.bind { [weak self] image in
            self?.profileView.profileImageView.image = image
        }
        
        // 이메일 유효성 바인딩
        viewModel.isEmailValid.bind { [weak self] isValid in
            if !isValid {
                self?.showInvalidEmailAlert()
            }
        }
        
        // 로딩 상태 바인딩
        viewModel.isLoading.bind { [weak self] isLoading in
            if isLoading {
                self?.activityIndicator.startAnimating()
            } else {
                self?.activityIndicator.stopAnimating()
            }
        }
        
        // 에러 메시지 바인딩
        viewModel.errorMessage.bind { [weak self] message in
            guard let message = message else { return }
            self?.showErrorAlert(message: message)
        }
    }
    
    private func showInvalidEmailAlert() {
        let alert = UIAlertController(
            title: "알림",
            message: "유효하지 않은 이메일 형식입니다.",
            preferredStyle: .alert
        )
        alert.addAction(UIAlertAction(title: "확인", style: .default))
        present(alert, animated: true)
    }
    
    private func showErrorAlert(message: String) {
        let alert = UIAlertController(
            title: "오류",
            message: message,
            preferredStyle: .alert
        )
        alert.addAction(UIAlertAction(title: "확인", style: .default))
        present(alert, animated: true)
    }
}

import Combine

class ProfileViewModel: ObservableObject {
    @Published var userName: String = ""
    @Published var userEmail: String = ""
    @Published var profileImage: UIImage?
    @Published var isEmailValid: Bool = true
    @Published var isLoading: Bool = false
    @Published var errorMessage: String?
    
    private var user: User?
    private var cancellables = Set<AnyCancellable>()
    
    func loadUserData() {
        isLoading = true
        
        // 실제 네트워크 요청 시뮬레이션
        Just(User(name: "김개발", email: "dev@example.com", profileImageURL: nil))
            .delay(for: 1.0, scheduler: DispatchQueue.main)
            .sink { [weak self] user in
                self?.user = user
                self?.updateViewData()
                self?.isLoading = false
            }
            .store(in: &cancellables)
    }
    
    private func updateViewData() {
        guard let user = user else { return }
        
        userName = user.name
        userEmail = user.email
        isEmailValid = user.isValidEmail()
        profileImage = UIImage(systemName: "person.circle.fill")
    }
}

import Combine

class ProfileViewController: UIViewController {
    private let profileView = ProfileView()
    private let viewModel = ProfileViewModel()
    private var cancellables = Set<AnyCancellable>()
    
    override func viewDidLoad() {
        super.viewDidLoad()
        view.backgroundColor = .white
        bindViewModel()
        viewModel.loadUserData()
    }
    
    private func bindViewModel() {
        // 훨씬 간결한 바인딩!
        viewModel.$userName
            .assign(to: \.text, on: profileView.nameLabel)
            .store(in: &cancellables)
        
        viewModel.$userEmail
            .assign(to: \.text, on: profileView.emailLabel)
            .store(in: &cancellables)
        
        viewModel.$profileImage
            .assign(to: \.image, on: profileView.profileImageView)
            .store(in: &cancellables)
        
        viewModel.$isEmailValid
            .filter { !$0 }
            .sink { [weak self] _ in
                self?.showInvalidEmailAlert()
            }
            .store(in: &cancellables)
        
        viewModel.$isLoading
            .sink { [weak self] isLoading in
                // 로딩 인디케이터 처리
            }
            .store(in: &cancellables)
    }
}

보다시피 Combine을 사용하면 코드가 훨씬 간결해지고 선언적으로 변해. @Published 프로퍼티는 값이 변경될 때마다 자동으로 구독자들에게 알려주고, assign이나 sink 같은 오퍼레이터로 쉽게 바인딩할 수 있어. 🎯

🧭 Coordinator: 화면 전환의 달인

자, 이제 MVC와 MVVM을 배웠으니 완벽한 거 아니야? 라고 생각할 수 있지만, 아직 하나 더 남았어! 바로 화면 전환(Navigation) 문제야. 🚦

일반적으로 ViewController나 ViewModel에서 다른 화면으로 이동하는 코드를 작성하게 되는데, 이렇게 하면 여러 문제가 생겨:

이런 문제를 해결하기 위해 등장한 게 바로 Coordinator 패턴이야! Coordinator는 앱의 화면 전환 로직을 전담하는 객체로, Soroush Khanlou가 2015년에 제안한 패턴이야. 🎭

이제 실제 코드로 Coordinator 패턴을 구현해보자! 로그인부터 메인 화면까지의 플로우를 만들어볼게. 😊

protocol Coordinator: AnyObject {
    var childCoordinators: [Coordinator] { get set }
    var navigationController: UINavigationController { get set }
    
    func start()
}

extension Coordinator {
    func addChildCoordinator(_ coordinator: Coordinator) {
        childCoordinators.append(coordinator)
    }
    
    func removeChildCoordinator(_ coordinator: Coordinator) {
        childCoordinators = childCoordinators.filter { $0 !== coordinator }
    }
}

class AppCoordinator: Coordinator {
    var childCoordinators: [Coordinator] = []
    var navigationController: UINavigationController
    
    private let window: UIWindow
    
    init(window: UIWindow) {
        self.window = window
        self.navigationController = UINavigationController()
        self.navigationController.setNavigationBarHidden(true, animated: false)
    }
    
    func start() {
        window.rootViewController = navigationController
        window.makeKeyAndVisible()
        
        // 로그인 상태 확인
        if isUserLoggedIn() {
            showMainFlow()
        } else {
            showLoginFlow()
        }
    }
    
    private func isUserLoggedIn() -> Bool {
        // 실제로는 UserDefaults나 Keychain에서 확인
        return UserDefaults.standard.bool(forKey: "isLoggedIn")
    }
    
    private func showLoginFlow() {
        let loginCoordinator = LoginCoordinator(navigationController: navigationController)
        loginCoordinator.delegate = self
        addChildCoordinator(loginCoordinator)
        loginCoordinator.start()
    }
    
    private func showMainFlow() {
        let mainCoordinator = MainCoordinator(navigationController: navigationController)
        mainCoordinator.delegate = self
        addChildCoordinator(mainCoordinator)
        mainCoordinator.start()
    }
}

extension AppCoordinator: LoginCoordinatorDelegate {
    func loginCoordinatorDidFinish(_ coordinator: LoginCoordinator) {
        removeChildCoordinator(coordinator)
        showMainFlow()
    }
}

extension AppCoordinator: MainCoordinatorDelegate {
    func mainCoordinatorDidLogout(_ coordinator: MainCoordinator) {
        removeChildCoordinator(coordinator)
        showLoginFlow()
    }
}

protocol LoginCoordinatorDelegate: AnyObject {
    func loginCoordinatorDidFinish(_ coordinator: LoginCoordinator)
}

class LoginCoordinator: Coordinator {
    var childCoordinators: [Coordinator] = []
    var navigationController: UINavigationController
    weak var delegate: LoginCoordinatorDelegate?
    
    init(navigationController: UINavigationController) {
        self.navigationController = navigationController
    }
    
    func start() {
        let viewModel = LoginViewModel()
        viewModel.coordinator = self
        
        let loginVC = LoginViewController(viewModel: viewModel)
        navigationController.setViewControllers([loginVC], animated: true)
    }
    
    func showSignUp() {
        let viewModel = SignUpViewModel()
        viewModel.coordinator = self
        
        let signUpVC = SignUpViewController(viewModel: viewModel)
        navigationController.pushViewController(signUpVC, animated: true)
    }
    
    func showForgotPassword() {
        let viewModel = ForgotPasswordViewModel()
        viewModel.coordinator = self
        
        let forgotPasswordVC = ForgotPasswordViewController(viewModel: viewModel)
        navigationController.pushViewController(forgotPasswordVC, animated: true)
    }
    
    func didFinishLogin() {
        UserDefaults.standard.set(true, forKey: "isLoggedIn")
        delegate?.loginCoordinatorDidFinish(self)
    }
}

// LoginViewModel.swift
class LoginViewModel {
    weak var coordinator: LoginCoordinator?
    
    @Published var email: String = ""
    @Published var password: String = ""
    @Published var isLoading: Bool = false
    @Published var errorMessage: String?
    
    func didTapLoginButton() {
        isLoading = true
        
        // 실제 로그인 API 호출
        AuthService.shared.login(email: email, password: password) { [weak self] result in
            self?.isLoading = false
            
            switch result {
            case .success:
                self?.coordinator?.didFinishLogin()
            case .failure(let error):
                self?.errorMessage = error.localizedDescription
            }
        }
    }
    
    func didTapSignUpButton() {
        coordinator?.showSignUp()
    }
    
    func didTapForgotPasswordButton() {
        coordinator?.showForgotPassword()
    }
}

// LoginViewController.swift
class LoginViewController: UIViewController {
    private let viewModel: LoginViewModel
    private var cancellables = Set<AnyCancellable>()
    
    // UI 요소들...
    private let emailTextField = UITextField()
    private let passwordTextField = UITextField()
    private let loginButton = UIButton()
    private let signUpButton = UIButton()
    
    init(viewModel: LoginViewModel) {
        self.viewModel = viewModel
        super.init(nibName: nil, bundle: nil)
    }
    
    required init?(coder: NSCoder) {
        fatalError("init(coder:) has not been implemented")
    }
    
    override func viewDidLoad() {
        super.viewDidLoad()
        setupUI()
        bindViewModel()
        setupActions()
    }
    
    private func setupActions() {
        loginButton.addTarget(self, action: #selector(didTapLogin), for: .touchUpInside)
        signUpButton.addTarget(self, action: #selector(didTapSignUp), for: .touchUpInside)
    }
    
    @objc private func didTapLogin() {
        viewModel.didTapLoginButton()
    }
    
    @objc private func didTapSignUp() {
        viewModel.didTapSignUpButton()
    }
    
    private func bindViewModel() {
        viewModel.$isLoading
            .sink { [weak self] isLoading in
                // 로딩 인디케이터 처리
            }
            .store(in: &cancellables)
        
        viewModel.$errorMessage
            .compactMap { $0 }
            .sink { [weak self] message in
                self?.showErrorAlert(message: message)
            }
            .store(in: &cancellables)
    }
    
    private func setupUI() {
        // UI 설정...
    }
    
    private func showErrorAlert(message: String) {
        let alert = UIAlertController(title: "오류", message: message, preferredStyle: .alert)
        alert.addAction(UIAlertAction(title: "확인", style: .default))
        present(alert, animated: true)
    }
}

protocol MainCoordinatorDelegate: AnyObject {
    func mainCoordinatorDidLogout(_ coordinator: MainCoordinator)
}

class MainCoordinator: Coordinator {
    var childCoordinators: [Coordinator] = []
    var navigationController: UINavigationController
    weak var delegate: MainCoordinatorDelegate?
    
    init(navigationController: UINavigationController) {
        self.navigationController = navigationController
    }
    
    func start() {
        let viewModel = HomeViewModel()
        viewModel.coordinator = self
        
        let homeVC = HomeViewController(viewModel: viewModel)
        navigationController.setViewControllers([homeVC], animated: true)
    }
    
    func showProfile() {
        let profileCoordinator = ProfileCoordinator(navigationController: navigationController)
        profileCoordinator.parentCoordinator = self
        addChildCoordinator(profileCoordinator)
        profileCoordinator.start()
    }
    
    func showDetail(itemId: String) {
        let viewModel = DetailViewModel(itemId: itemId)
        viewModel.coordinator = self
        
        let detailVC = DetailViewController(viewModel: viewModel)
        navigationController.pushViewController(detailVC, animated: true)
    }
    
    func showSettings() {
        let settingsCoordinator = SettingsCoordinator(navigationController: navigationController)
        settingsCoordinator.delegate = self
        addChildCoordinator(settingsCoordinator)
        settingsCoordinator.start()
    }
    
    func childDidFinish(_ child: Coordinator) {
        removeChildCoordinator(child)
    }
}

extension MainCoordinator: SettingsCoordinatorDelegate {
    func settingsCoordinatorDidLogout(_ coordinator: SettingsCoordinator) {
        removeChildCoordinator(coordinator)
        UserDefaults.standard.set(false, forKey: "isLoggedIn")
        delegate?.mainCoordinatorDidLogout(self)
    }
}

class SceneDelegate: UIResponder, UIWindowSceneDelegate {
    var window: UIWindow?
    var appCoordinator: AppCoordinator?
    
    func scene(_ scene: UIScene, willConnectTo session: UISceneSession, options connectionOptions: UIScene.ConnectionOptions) {
        guard let windowScene = (scene as? UIWindowScene) else { return }
        
        let window = UIWindow(windowScene: windowScene)
        self.window = window
        
        appCoordinator = AppCoordinator(window: window)
        appCoordinator?.start()
    }
}

🎨 MVVM-C: 최강의 조합

지금까지 MVC, MVVM, Coordinator를 각각 배웠는데, 실무에서는 이들을 조합해서 사용하는 경우가 많아. 특히 MVVM + Coordinator 조합은 iOS 개발에서 가장 인기 있는 아키텍처 중 하나야! 이를 줄여서 MVVM-C라고 부르지. 🌟

실제 프로젝트에서 MVVM-C를 어떻게 구성하는지 폴더 구조를 보여줄게:

MyApp/
├── Application/
│   ├── AppDelegate.swift
│   └── SceneDelegate.swift
│
├── Coordinators/
│   ├── Protocols/
│   │   └── Coordinator.swift
│   ├── AppCoordinator.swift
│   ├── LoginCoordinator.swift
│   ├── MainCoordinator.swift
│   └── ProfileCoordinator.swift
│
├── Scenes/
│   ├── Login/
│   │   ├── LoginViewController.swift
│   │   ├── LoginViewModel.swift
│   │   └── LoginView.swift
│   │
│   ├── Home/
│   │   ├── HomeViewController.swift
│   │   ├── HomeViewModel.swift
│   │   └── HomeView.swift
│   │
│   └── Profile/
│       ├── ProfileViewController.swift
│       ├── ProfileViewModel.swift
│       └── ProfileView.swift
│
├── Models/
│   ├── User.swift
│   ├── Post.swift
│   └── Comment.swift
│
├── Services/
│   ├── NetworkService.swift
│   ├── AuthService.swift
│   └── StorageService.swift
│
├── Utilities/
│   ├── Extensions/
│   │   ├── UIView+Extensions.swift
│   │   └── String+Extensions.swift
│   └── Helpers/
│       ├── DateHelper.swift
│       └── ValidationHelper.swift
│
└── Resources/
    ├── Assets.xcassets
    └── Fonts/

// Service Protocol
protocol UserServiceProtocol {
    func fetchUser(id: String, completion: @escaping (Result<User, Error>) -> Void)
    func updateUser(_ user: User, completion: @escaping (Result<Void, Error>) -> Void)
}

// 실제 구현
class UserService: UserServiceProtocol {
    func fetchUser(id: String, completion: @escaping (Result<User, Error>) -> Void) {
        // 네트워크 요청
    }
    
    func updateUser(_ user: User, completion: @escaping (Result<Void, Error>) -> Void) {
        // 네트워크 요청
    }
}

// Mock 구현 (테스트용)
class MockUserService: UserServiceProtocol {
    var mockUser: User?
    var shouldFail: Bool = false
    
    func fetchUser(id: String, completion: @escaping (Result<User, Error>) -> Void) {
        if shouldFail {
            completion(.failure(NSError(domain: "test", code: -1)))
        } else if let user = mockUser {
            completion(.success(user))
        }
    }
    
    func updateUser(_ user: User, completion: @escaping (Result<Void, Error>) -> Void) {
        if shouldFail {
            completion(.failure(NSError(domain: "test", code: -1)))
        } else {
            completion(.success(()))
        }
    }
}

// ViewModel with Dependency Injection
class ProfileViewModel {
    weak var coordinator: ProfileCoordinator?
    private let userService: UserServiceProtocol
    
    @Published var user: User?
    @Published var isLoading: Bool = false
    @Published var errorMessage: String?
    
    // 의존성 주입
    init(userService: UserServiceProtocol) {
        self.userService = userService
    }
    
    func loadUser(id: String) {
        isLoading = true
        
        userService.fetchUser(id: id) { [weak self] result in
            self?.isLoading = false
            
            switch result {
            case .success(let user):
                self?.user = user
            case .failure(let error):
                self?.errorMessage = error.localizedDescription
            }
        }
    }
}

// Coordinator에서 의존성 주입
class ProfileCoordinator: Coordinator {
    var childCoordinators: [Coordinator] = []
    var navigationController: UINavigationController
    
    private let userService: UserServiceProtocol
    
    init(navigationController: UINavigationController, userService: UserServiceProtocol) {
        self.navigationController = navigationController
        self.userService = userService
    }
    
    func start() {
        let viewModel = ProfileViewModel(userService: userService)
        viewModel.coordinator = self
        
        let profileVC = ProfileViewController(viewModel: viewModel)
        navigationController.pushViewController(profileVC, animated: true)
    }
}

// 테스트 코드
class ProfileViewModelTests: XCTestCase {
    var sut: ProfileViewModel!
    var mockUserService: MockUserService!
    
    override func setUp() {
        super.setUp()
        mockUserService = MockUserService()
        sut = ProfileViewModel(userService: mockUserService)
    }
    
    func testLoadUserSuccess() {
        // Given
        let expectedUser = User(name: "테스트", email: "test@example.com", profileImageURL: nil)
        mockUserService.mockUser = expectedUser
        
        let expectation = XCTestExpectation(description: "User loaded")
        
        var cancellables = Set<AnyCancellable>()
        sut.$user
            .dropFirst()
            .sink { user in
                XCTAssertEqual(user?.name, expectedUser.name)
                expectation.fulfill()
            }
            .store(in: &cancellables)
        
        // When
        sut.loadUser(id: "123")
        
        // Then
        wait(for: [expectation], timeout: 1.0)
    }
    
    func testLoadUserFailure() {
        // Given
        mockUserService.shouldFail = true
        
        let expectation = XCTestExpectation(description: "Error occurred")
        
        var cancellables = Set<AnyCancellable>()
        sut.$errorMessage
            .dropFirst()
            .sink { message in
                XCTAssertNotNil(message)
                expectation.fulfill()
            }
            .store(in: &cancellables)
        
        // When
        sut.loadUser(id: "123")
        
        // Then
        wait(for: [expectation], timeout: 1.0)
    }
}

🔄 다른 아키텍처 패턴들

MVC, MVVM, Coordinator 외에도 iOS에서 사용할 수 있는 다양한 아키텍처 패턴들이 있어. 각각의 특징을 간단히 알아보자! 🎭

// Entity
struct User {
    let id: String
    let name: String
    let email: String
}

// Interactor
protocol ProfileInteractorProtocol {
    func fetchUser(id: String)
}

class ProfileInteractor: ProfileInteractorProtocol {
    weak var presenter: ProfilePresenterProtocol?
    private let userService: UserServiceProtocol
    
    init(userService: UserServiceProtocol) {
        self.userService = userService
    }
    
    func fetchUser(id: String) {
        userService.fetchUser(id: id) { [weak self] result in
            switch result {
            case .success(let user):
                self?.presenter?.didFetchUser(user)
            case .failure(let error):
                self?.presenter?.didFailToFetchUser(error)
            }
        }
    }
}

// Presenter
protocol ProfilePresenterProtocol: AnyObject {
    func viewDidLoad()
    func didFetchUser(_ user: User)
    func didFailToFetchUser(_ error: Error)
    func didTapEditButton()
}

class ProfilePresenter: ProfilePresenterProtocol {
    weak var view: ProfileViewProtocol?
    var interactor: ProfileInteractorProtocol?
    var router: ProfileRouterProtocol?
    
    private let userId: String
    
    init(userId: String) {
        self.userId = userId
    }
    
    func viewDidLoad() {
        view?.showLoading()
        interactor?.fetchUser(id: userId)
    }
    
    func didFetchUser(_ user: User) {
        view?.hideLoading()
        view?.displayUser(name: user.name, email: user.email)
    }
    
    func didFailToFetchUser(_ error: Error) {
        view?.hideLoading()
        view?.showError(message: error.localizedDescription)
    }
    
    func didTapEditButton() {
        router?.navigateToEditProfile()
    }
}

// View
protocol ProfileViewProtocol: AnyObject {
    func showLoading()
    func hideLoading()
    func displayUser(name: String, email: String)
    func showError(message: String)
}

class ProfileViewController: UIViewController, ProfileViewProtocol {
    var presenter: ProfilePresenterProtocol?
    
    // UI 요소들...
    
    override func viewDidLoad() {
        super.viewDidLoad()
        presenter?.viewDidLoad()
    }
    
    func showLoading() {
        // 로딩 인디케이터 표시
    }
    
    func hideLoading() {
        // 로딩 인디케이터 숨김
    }
    
    func displayUser(name: String, email: String) {
        // UI 업데이트
    }
    
    func showError(message: String) {
        // 에러 알림 표시
    }
}

// Router
protocol ProfileRouterProtocol {
    func navigateToEditProfile()
}

class ProfileRouter: ProfileRouterProtocol {
    weak var viewController: UIViewController?
    
    func navigateToEditProfile() {
        // 편집 화면으로 이동
    }
}

// Module Builder
class ProfileModuleBuilder {
    static func build(userId: String) -> UIViewController {
        let view = ProfileViewController()
        let presenter = ProfilePresenter(userId: userId)
        let interactor = ProfileInteractor(userService: UserService())
        let router = ProfileRouter()
        
        view.presenter = presenter
        presenter.view = view
        presenter.interactor = interactor
        presenter.router = router
        interactor.presenter = presenter
        router.viewController = view
        
        return view
    }
}

import ComposableArchitecture

// State
struct ProfileState: Equatable {
    var user: User?
    var isLoading: Bool = false
    var errorMessage: String?
}

// Action
enum ProfileAction: Equatable {
    case onAppear
    case userResponse(Result<User, Error>)
    case editButtonTapped
}

// Environment (의존성)
struct ProfileEnvironment {
    var userService: UserServiceProtocol
    var mainQueue: AnySchedulerOf<DispatchQueue>
}

// Reducer
let profileReducer = Reducer<ProfileState, ProfileAction, ProfileEnvironment> { state, action, environment in
    switch action {
    case .onAppear:
        state.isLoading = true
        
        return environment.userService
            .fetchUser(id: "123")
            .receive(on: environment.mainQueue)
            .catchToEffect(ProfileAction.userResponse)
        
    case .userResponse(.success(let user)):
        state.isLoading = false
        state.user = user
        return .none
        
    case .userResponse(.failure(let error)):
        state.isLoading = false
        state.errorMessage = error.localizedDescription
        return .none
        
    case .editButtonTapped:
        // 편집 화면으로 이동
        return .none
    }
}

// SwiftUI View
struct ProfileView: View {
    let store: Store<ProfileState, ProfileAction>
    
    var body: some View {
        WithViewStore(store) { viewStore in
            VStack {
                if viewStore.isLoading {
                    ProgressView()
                } else if let user = viewStore.user {
                    Text(user.name)
                        .font(.title)
                    Text(user.email)
                        .foregroundColor(.gray)
                    
                    Button("편집") {
                        viewStore.send(.editButtonTapped)
                    }
                }
            }
            .onAppear {
                viewStore.send(.onAppear)
            }
        }
    }
}

🤔 어떤 아키텍처를 선택해야 할까?

"그래서 뭘 써야 하나요?" 이게 가장 많이 받는 질문이야. 정답은... 상황에 따라 다르다! 😅

각 아키텍처는 장단점이 있고, 프로젝트의 규모, 팀의 경험, 요구사항에 따라 적합한 패턴이 달라져. 다음 가이드를 참고해봐!

🛠️ 실전 팁과 베스트 프랙티스

이론은 충분히 배웠으니, 이제 실전에서 유용한 팁들을 알아보자! 🎯

// Protocol 정의
protocol UserRepositoryProtocol {
    func fetchUser(id: String) async throws -> User
    func saveUser(_ user: User) async throws
}

// 실제 구현
class UserRepository: UserRepositoryProtocol {
    private let networkService: NetworkServiceProtocol
    private let cacheService: CacheServiceProtocol
    
    init(networkService: NetworkServiceProtocol, cacheService: CacheServiceProtocol) {
        self.networkService = networkService
        self.cacheService = cacheService
    }
    
    func fetchUser(id: String) async throws -> User {
        // 캐시 확인
        if let cachedUser = try? await cacheService.getUser(id: id) {
            return cachedUser
        }
        
        // 네트워크 요청
        let user = try await networkService.fetchUser(id: id)
        
        // 캐시 저장
        try? await cacheService.saveUser(user)
        
        return user
    }
    
    func saveUser(_ user: User) async throws {
        try await networkService.updateUser(user)
        try await cacheService.saveUser(user)
    }
}

// Mock 구현 (테스트용)
class MockUserRepository: UserRepositoryProtocol {
    var mockUser: User?
    var shouldThrowError = false
    
    func fetchUser(id: String) async throws -> User {
        if shouldThrowError {
            throw NSError(domain: "test", code: -1)
        }
        return mockUser ?? User(name: "Mock", email: "mock@test.com", profileImageURL: nil)
    }
    
    func saveUser(_ user: User) async throws {
        if shouldThrowError {
            throw NSError(domain: "test", code: -1)
        }
        mockUser = user
    }
}

// ViewModel에서 사용
class ProfileViewModel {
    private let userRepository: UserRepositoryProtocol
    
    init(userRepository: UserRepositoryProtocol) {
        self.userRepository = userRepository
    }
    
    func loadUser(id: String) async {
        do {
            let user = try await userRepository.fetchUser(id: id)
            // UI 업데이트
        } catch {
            // 에러 처리
        }
    }
}

// 기존 Completion Handler 방식
func fetchUserOld(id: String, completion: @escaping (Result<User, Error>) -> Void) {
    URLSession.shared.dataTask(with: url) { data, response, error in
        if let error = error {
            completion(.failure(error))
            return
        }
        
        guard let data = data else {
            completion(.failure(NetworkError.noData))
            return
        }
        
        do {
            let user = try JSONDecoder().decode(User.self, from: data)
            completion(.success(user))
        } catch {
            completion(.failure(error))
        }
    }.resume()
}

// async/await 방식 (훨씬 깔끔!)
func fetchUser(id: String) async throws -> User {
    let (data, response) = try await URLSession.shared.data(from: url)
    
    guard let httpResponse = response as? HTTPURLResponse,
          (200...299).contains(httpResponse.statusCode) else {
        throw NetworkError.invalidResponse
    }
    
    let user = try JSONDecoder().decode(User.self, from: data)
    return user
}

// ViewModel에서 사용
class ProfileViewModel {
    @Published var user: User?
    @Published var isLoading = false
    @Published var errorMessage: String?
    
    func loadUser(id: String) {
        Task {
            isLoading = true
            defer { isLoading = false }
            
            do {
                user = try await fetchUser(id: id)
            } catch {
                errorMessage = error.localizedDescription
            }
        }
    }
    
    // 여러 비동기 작업을 순차적으로
    func loadUserAndPosts(id: String) async throws {
        // 순차 실행
        let user = try await fetchUser(id: id)
        let posts = try await fetchPosts(userId: user.id)
        
        // 또는 병렬 실행
        async let userTask = fetchUser(id: id)
        async let postsTask = fetchPosts(userId: id)
        
        let (user, posts) = try await (userTask, postsTask)
        
        // UI 업데이트
    }
}

// 에러 타입 정의
enum NetworkError: LocalizedError {
    case invalidURL
    case noData
    case decodingError
    case serverError(statusCode: Int)
    case unauthorized
    case networkUnavailable
    
    var errorDescription: String? {
        switch self {
        case .invalidURL:
            return "잘못된 URL입니다."
        case .noData:
            return "데이터를 받지 못했습니다."
        case .decodingError:
            return "데이터 형식이 올바르지 않습니다."
        case .serverError(let statusCode):
            return "서버 오류가 발생했습니다. (코드: \(statusCode))"
        case .unauthorized:
            return "로그인이 필요합니다."
        case .networkUnavailable:
            return "네트워크 연결을 확인해주세요."
        }
    }
    
    var recoverySuggestion: String? {
        switch self {
        case .networkUnavailable:
            return "Wi-Fi 또는 데이터 연결을 확인하고 다시 시도해주세요."
        case .unauthorized:
            return "다시 로그인해주세요."
        case .serverError:
            return "잠시 후 다시 시도해주세요."
        default:
            return "문제가 계속되면 고객센터에 문의해주세요."
        }
    }
}

// ViewModel에서 에러 처리
class ProfileViewModel {
    @Published var alertItem: AlertItem?
    
    struct AlertItem: Identifiable {
        let id = UUID()
        let title: String
        let message: String
        let primaryButton: String
        let secondaryButton: String?
        let primaryAction: (() -> Void)?
        let secondaryAction: (() -> Void)?
    }
    
    func loadUser(id: String) async {
        do {
            let user = try await userRepository.fetchUser(id: id)
            self.user = user
        } catch let error as NetworkError {
            handleNetworkError(error)
        } catch {
            handleUnknownError(error)
        }
    }
    
    private func handleNetworkError(_ error: NetworkError) {
        switch error {
        case .unauthorized:
            alertItem = AlertItem(
                title: "로그인 필요",
                message: error.localizedDescription,
                primaryButton: "로그인",
                secondaryButton: "취소",
                primaryAction: { [weak self] in
                    self?.coordinator?.showLogin()
                },
                secondaryAction: nil
            )
            
        case .networkUnavailable:
            alertItem = AlertItem(
                title: "네트워크 오류",
                message: error.localizedDescription,
                primaryButton: "다시 시도",
                secondaryButton: "취소",
                primaryAction: { [weak self] in
                    Task {
                        await self?.loadUser(id: id)
                    }
                },
                secondaryAction: nil
            )
            
        default:
            alertItem = AlertItem(
                title: "오류",
                message: error.localizedDescription,
                primaryButton: "확인",
                secondaryButton: nil,
                primaryAction: nil,
                secondaryAction: nil
            )
        }
    }
    
    private func handleUnknownError(_ error: Error) {
        alertItem = AlertItem(
            title: "알 수 없는 오류",
            message: "예상치 못한 오류가 발생했습니다.",
            primaryButton: "확인",
            secondaryButton: nil,
            primaryAction: nil,
            secondaryAction: nil
        )
    }
}

import os.log

enum LogCategory: String {
    case network = "🌐 Network"
    case database = "💾 Database"
    case ui = "🎨 UI"
    case business = "💼 Business"
    case error = "❌ Error"
}

class Logger {
    static let shared = Logger()
    
    private let subsystem = Bundle.main.bundleIdentifier ?? "com.app"
    
    private init() {}
    
    func log(_ message: String, category: LogCategory = .business, type: OSLogType = .default) {
        let log = OSLog(subsystem: subsystem, category: category.rawValue)
        os_log("%{public}@", log: log, type: type, message)
        
        #if DEBUG
        print("\(category.rawValue) \(message)")
        #endif
    }
    
    func debug(_ message: String, category: LogCategory = .business) {
        log(message, category: category, type: .debug)
    }
    
    func info(_ message: String, category: LogCategory = .business) {
        log(message, category: category, type: .info)
    }
    
    func error(_ message: String, category: LogCategory = .error) {
        log(message, category: category, type: .error)
    }
    
    func fault(_ message: String, category: LogCategory = .error) {
        log(message, category: category, type: .fault)
    }
}

// 사용 예시
class ProfileViewModel {
    func loadUser(id: String) async {
        Logger.shared.info("사용자 로딩 시작: \(id)", category: .business)
        
        do {
            let user = try await userRepository.fetchUser(id: id)
            Logger.shared.info("사용자 로딩 성공: \(user.name)", category: .business)
            self.user = user
        } catch {
            Logger.shared.error("사용자 로딩 실패: \(error.localizedDescription)", category: .error)
            handleError(error)
        }
    }
}

// ❌ 나쁜 예 - 순환 참조 발생
class ProfileViewModel {
    var coordinator: ProfileCoordinator? // strong reference
    
    func didTapButton() {
        coordinator?.showDetail() // coordinator가 self를 강하게 참조하면 순환 참조!
    }
}

// ✅ 좋은 예 - weak 사용
class ProfileViewModel {
    weak var coordinator: ProfileCoordinator? // weak reference
    
    func didTapButton() {
        coordinator?.showDetail()
    }
}

// Closure에서도 주의!
class ProfileViewModel {
    var onComplete: (() -> Void)?
    
    func loadData() {
        // ❌ 나쁜 예
        networkService.fetch { data in
            self.processData(data) // self를 강하게 캡처
            self.onComplete?()
        }
        
        // ✅ 좋은 예
        networkService.fetch { [weak self] data in
            guard let self = self else { return }
            self.processData(data)
            self.onComplete?()
        }
    }
}

// Combine에서도 주의!
class ProfileViewModel {
    private var cancellables = Set<AnyCancellable>()
    
    func setupBindings() {
        // ❌ 나쁜 예
        $userName
            .sink { name in
                self.updateUI(name) // self를 강하게 캡처
            }
            .store(in: &cancellables)
        
        // ✅ 좋은 예
        $userName
            .sink { [weak self] name in
                self?.updateUI(name)
            }
            .store(in: &cancellables)
    }
}

// Coordinator에서 자식 관리
class ParentCoordinator: Coordinator {
    var childCoordinators: [Coordinator] = []
    
    func startChildFlow() {
        let child = ChildCoordinator(navigationController: navigationController)
        child.delegate = self // child가 self를 weak으로 참조해야 함!
        addChildCoordinator(child)
        child.start()
    }
    
    func childDidFinish(_ child: Coordinator) {
        removeChildCoordinator(child) // 반드시 제거!
    }
}

📚 학습 로드맵과 추가 자료

iOS 아키텍처를 마스터하는 건 하루아침에 되는 게 아니야. 단계적으로 학습하고 실전에 적용해보는 게 중요해! 🎓

🎬 마무리하며

와! 여기까지 정말 긴 여정이었어. 🎉 iOS 디자인 패턴과 아키텍처에 대해 많은 걸 배웠지?

핵심을 다시 한번 정리해보자:

아키텍처는 은탄환(Silver Bullet)이 아니야. 완벽한 아키텍처는 없고, 상황에 맞는 최선의 선택만 있을 뿐이지. 처음엔 어렵게 느껴지겠지만, 계속 연습하고 실전에 적용하다 보면 자연스럽게 몸에 익게 될 거야. 💪

가장 중요한 건 일관성이야. 어떤 패턴을 선택하든 팀 전체가 같은 방식으로 코드를 작성하고, 명확한 규칙을 따르는 게 중요해. 그래야 코드를 읽고 이해하기 쉬워지고, 유지보수도 편해져.

혹시 막히는 부분이 있거나 더 깊이 있는 조언이 필요하다면, 재능넷에서 경험 많은 iOS 개발자들을 찾아보는 것도 좋은 방법이야. 실무 경험을 바탕으로 한 멘토링은 책이나 강의에서 배울 수 없는 귀중한 인사이트를 제공해줄 거야! 🌟

자, 이제 당신의 차례야! 오늘 배운 내용을 바탕으로 멋진 iOS 앱을 만들어봐. 처음엔 서툴러도 괜찮아. 모든 전문가도 처음엔 초보였으니까. 화이팅! 🚀