iOS 앱 MVP 아키텍처 패턴 구현: 초보자도 쉽게 따라하는 가이드 🚀

안녕, 친구들! 오늘은 iOS 앱 개발에서 정말 중요한 주제인 'MVP 아키텍처 패턴'에 대해 재미있게 알아볼 거야. 😎 이 글을 읽고 나면 너도 MVP 패턴의 달인이 될 수 있을 거야! 자, 그럼 시작해볼까?

잠깐! MVP가 뭔지 모르겠다고? 걱정 마! 이 글에서 차근차근 설명해줄 테니까. 그리고 혹시 더 많은 개발 지식이 필요하다면, 재능넷(https://www.jaenung.net)에서 다양한 개발 관련 재능을 찾아볼 수 있다는 것도 알아두면 좋겠어!

MVP, 그게 뭐야? 🤔

MVP는 'Model-View-Presenter'의 약자야. 이름부터 좀 어려워 보이지? 하지만 걱정 마! 우리가 쉽게 풀어서 설명해줄게.

Model(모델): 데이터와 비즈니스 로직을 담당해. 쉽게 말해서, 앱에서 사용하는 정보들의 창고라고 생각하면 돼.
View(뷰): 사용자가 실제로 보는 화면이야. 예쁘게 꾸미는 것도 뷰의 역할이지.
Presenter(프레젠터): 모델과 뷰 사이에서 중재자 역할을 해. 데이터를 가공하고 뷰에 전달하는 역할이야.

이렇게 세 가지 요소로 앱을 구성하면 코드를 관리하기가 훨씬 쉬워져. 마치 방을 깔끔하게 정리하는 것처럼 말이야! 🧹✨

위의 다이어그램을 보면 MVP 패턴의 구조를 한눈에 이해할 수 있어. 멋지지 않아? 😍

MVP 패턴의 장점 💪

MVP 패턴을 사용하면 어떤 좋은 점이 있을까? 한번 알아보자!

코드 분리: 각 부분이 독립적이라 코드 관리가 쉬워져.
테스트 용이성: 각 부분을 따로 테스트할 수 있어서 버그 찾기가 쉬워.
재사용성: 한 번 만든 컴포넌트를 다른 프로젝트에서도 쉽게 사용할 수 있어.
유지보수 편의성: 코드 구조가 깔끔해서 나중에 수정하기 편해.

이런 장점들 때문에 많은 개발자들이 MVP 패턴을 선호한다고 할 수 있어. 특히 큰 규모의 프로젝트에서 더욱 빛을 발하지!

🌟 꿀팁: MVP 패턴을 처음 적용할 때는 조금 어려울 수 있어. 하지만 걱정 마! 재능넷에서 경험 많은 개발자의 도움을 받아볼 수 있다는 거 알고 있었어? 함께 배우면 더 빨리 성장할 수 있을 거야!

iOS에서 MVP 패턴 구현하기 🍏

자, 이제 실제로 iOS 앱에서 MVP 패턴을 어떻게 구현하는지 알아볼 거야. 준비됐니? 출발~! 🚀

1. Model 만들기

먼저 Model부터 만들어볼게. 예를 들어, 사용자 정보를 담는 모델을 만들어보자.


struct User {
    let id: Int
    let name: String
    let email: String
}

간단하지? 이게 바로 Model이야. 데이터의 구조를 정의하고 있어.

2. View 만들기

다음은 View를 만들 차례야. iOS에서는 주로 UIViewController를 사용해서 View를 구현해.


class UserViewController: UIViewController {
    @IBOutlet weak var nameLabel: UILabel!
    @IBOutlet weak var emailLabel: UILabel!
    
    var presenter: UserPresenter?
    
    override func viewDidLoad() {
        super.viewDidLoad()
        presenter?.viewDidLoad()
    }
    
    func updateUI(with user: User) {
        nameLabel.text = user.name
        emailLabel.text = user.email
    }
}

여기서 중요한 점은 View가 직접 Model을 다루지 않는다는 거야. 대신 Presenter를 통해서 데이터를 받아와.

3. Presenter 만들기

마지막으로 Presenter를 만들어볼게. Presenter는 Model과 View 사이에서 중재자 역할을 해.


class UserPresenter {
    weak var view: UserViewController?
    var user: User?
    
    init(view: UserViewController) {
        self.view = view
    }
    
    func viewDidLoad() {
        // 여기서 데이터를 가져오는 로직을 구현해
        // 예를 들어, API 호출이나 데이터베이스 조회 등
        let user = User(id: 1, name: "홍길동", email: "hong@example.com")
        self.user = user
        view?.updateUI(with: user)
    }
}

Presenter는 View에서 발생하는 이벤트(예: viewDidLoad)를 처리하고, 필요한 데이터를 Model에서 가져와 View에 전달해줘.

🔍 주목! Presenter에서 view를 weak 참조로 선언한 걸 봤어? 이건 메모리 관리를 위해서야. 순환 참조를 방지하고 메모리 누수를 막아주는 중요한 테크닉이지.

MVP 패턴 실전 적용하기 💡

자, 이제 기본적인 구조는 알았으니 실제 앱에 어떻게 적용하는지 더 자세히 알아보자!

1. 프로토콜 정의하기

MVP 패턴을 더 유연하게 사용하려면 프로토콜을 활용하는 게 좋아. View와 Presenter 사이의 계약을 정의하는 거지.


protocol UserView: AnyObject {
    func showLoading()
    func hideLoading()
    func updateUI(with user: User)
    func showError(_ error: Error)
}

protocol UserPresenterProtocol: AnyObject {
    var view: UserView? { get set }
    func viewDidLoad()
    func refreshData()
}

이렇게 프로토콜을 정의하면 나중에 테스트하기도 쉽고, 코드 변경도 더 유연하게 할 수 있어.

2. 네트워크 요청 처리하기

실제 앱에서는 대부분 서버와 통신을 해야 해. Presenter에서 이런 네트워크 요청을 어떻게 처리하는지 보자.


class UserPresenter: UserPresenterProtocol {
    weak var view: UserView?
    private let userService: UserServiceProtocol
    
    init(view: UserView, userService: UserServiceProtocol) {
        self.view = view
        self.userService = userService
    }
    
    func viewDidLoad() {
        fetchUserData()
    }
    
    func refreshData() {
        fetchUserData()
    }
    
    private func fetchUserData() {
        view?.showLoading()
        userService.fetchUser { [weak self] result in
            guard let self = self else { return }
            self.view?.hideLoading()
            switch result {
            case .success(let user):
                self.view?.updateUI(with: user)
            case .failure(let error):
                self.view?.showError(error)
            }
        }
    }
}

여기서 userService는 실제 네트워크 요청을 담당하는 객체야. Presenter는 이 서비스를 통해 데이터를 가져오고, 그 결과를 View에 전달해주는 역할을 해.

3. 의존성 주입

MVP 패턴을 제대로 활용하려면 의존성 주입(Dependency Injection)을 이해해야 해. 이게 뭐냐고? 쉽게 말해서, 필요한 객체를 외부에서 만들어서 넣어주는 거야.


class SceneDelegate: UIResponder, UIWindowSceneDelegate {
    var window: UIWindow?

    func scene(_ scene: UIScene, willConnectTo session: UISceneSession, options connectionOptions: UIScene.ConnectionOptions) {
        guard let windowScene = (scene as? UIWindowScene) else { return }
        
        let window = UIWindow(windowScene: windowScene)
        let viewController = UserViewController()
        let userService = UserService() // 실제 네트워크 요청을 담당하는 서비스
        let presenter = UserPresenter(view: viewController, userService: userService)
        viewController.presenter = presenter
        
        window.rootViewController = viewController
        self.window = window
        window.makeKeyAndVisible()
    }
}

이렇게 하면 테스트할 때 가짜(Mock) 객체를 주입하기 쉬워져서 단위 테스트가 훨씬 편해진다구!

⚠️ 주의사항: MVP 패턴을 처음 적용할 때는 과도하게 복잡하게 만들지 않도록 조심해. 간단한 구조부터 시작해서 점진적으로 개선해 나가는 게 좋아.

MVP 패턴의 실제 사용 예시 🌟

자, 이제 실제로 어떤 상황에서 MVP 패턴을 사용하면 좋은지 구체적인 예를 들어볼게.

1. 사용자 프로필 화면

사용자 프로필 화면은 MVP 패턴을 적용하기 좋은 예야. 왜냐하면 데이터(Model)를 가져와서 화면(View)에 표시하고, 사용자 상호작용을 처리해야 하니까.


// Model
struct Profile {
    let name: String
    let bio: String
    let avatarURL: URL
}

// View
class ProfileViewController: UIViewController, ProfileView {
    @IBOutlet weak var nameLabel: UILabel!
    @IBOutlet weak var bioLabel: UILabel!
    @IBOutlet weak var avatarImageView: UIImageView!
    
    var presenter: ProfilePresenterProtocol!
    
    override func viewDidLoad() {
        super.viewDidLoad()
        presenter.viewDidLoad()
    }
    
    func updateUI(with profile: Profile) {
        nameLabel.text = profile.name
        bioLabel.text = profile.bio
        // 이미지 로딩 로직
    }
    
    func showLoading() {
        // 로딩 인디케이터 표시
    }
    
    func hideLoading() {
        // 로딩 인디케이터 숨기기
    }
    
    func showError(_ error: Error) {
        // 에러 알림 표시
    }
}

// Presenter
class ProfilePresenter: ProfilePresenterProtocol {
    weak var view: ProfileView?
    private let profileService: ProfileServiceProtocol
    
    init(view: ProfileView, profileService: ProfileServiceProtocol) {
        self.view = view
        self.profileService = profileService
    }
    
    func viewDidLoad() {
        fetchProfile()
    }
    
    private func fetchProfile() {
        view?.showLoading()
        profileService.fetchProfile { [weak self] result in
            guard let self = self else { return }
            self.view?.hideLoading()
            switch result {
            case .success(let profile):
                self.view?.updateUI(with: profile)
            case .failure(let error):
                self.view?.showError(error)
            }
        }
    }
}

이렇게 구현하면 프로필 데이터를 가져오는 로직과 UI를 업데이트하는 로직이 깔끔하게 분리돼. 👍

2. 할 일 목록 앱

할 일 목록 앱도 MVP 패턴을 적용하기 좋은 예야. 할 일 항목을 추가, 삭제, 수정하는 기능이 필요하니까.


// Model
struct TodoItem {
    let id: UUID
    var title: String
    var isCompleted: Bool
}

// View
class TodoListViewController: UIViewController, TodoListView {
    @IBOutlet weak var tableView: UITableView!
    
    var presenter: TodoListPresenterProtocol!
    
    override func viewDidLoad() {
        super.viewDidLoad()
        presenter.viewDidLoad()
    }
    
    func reloadData() {
        tableView.reloadData()
    }
    
    func showError(_ error: Error) {
        // 에러 알림 표시
    }
    
    @IBAction func addTodoTapped(_ sender: Any) {
        presenter.addTodoTapped()
    }
}

// Presenter
class TodoListPresenter: TodoListPresenterProtocol {
    weak var view: TodoListView?
    private let todoService: TodoServiceProtocol
    private var todos: [TodoItem] = []
    
    init(view: TodoListView, todoService: TodoServiceProtocol) {
        self.view = view
        self.todoService = todoService
    }
    
    func viewDidLoad() {
        fetchTodos()
    }
    
    func addTodoTapped() {
        // 새 할 일 추가 로직
    }
    
    private func fetchTodos() {
        todoService.fetchTodos { [weak self] result in
            guard let self = self else { return }
            switch result {
            case .success(let todos):
                self.todos = todos
                self.view?.reloadData()
            case .failure(let error):
                self.view?.showError(error)
            }
        }
    }
}

이런 식으로 구현하면 할 일 목록을 관리하는 로직과 화면을 표시하는 로직을 깔끔하게 분리할 수 있어.

💡 팁: MVP 패턴을 사용할 때는 View와 Presenter 사이의 의존성을 최소화하는 게 중요해. 그래야 나중에 View를 변경하거나 다른 플랫폼으로 포팅할 때 Presenter를 그대로 재사용할 수 있거든.

MVP 패턴의 고급 기법 🚀

자, 이제 MVP 패턴의 기본은 알았으니 조금 더 고급 기법을 알아볼까?

1. 상태 관리

복잡한 앱에서는 상태 관리가 중요해. Presenter에서 상태를 관리하고, 그 상태에 따라 View를 업데이트하는 방식을 사용할 수 있어.


enum ViewState {
    case loading
    case loaded([TodoItem])
    case error(Error)
}

class TodoListPresenter: TodoListPresenterProtocol {
    private var state: ViewState = .loading {
        didSet {
            updateView()
        }
    }
    
    private func updateView() {
        switch state {
        case .loading:
            view?.showLoading()
        case .loaded(let todos):
            view?.hideLoading()
            view?.showTodos(todos)
        case .error(let error):
            view?.hideLoading()
            view?.showError(error)
        }
    }
    
    func fetchTodos() {
        state = .loading
        todoService.fetchTodos { [weak self] result in
            switch result {
            case .success(let todos):
                self?.state = .loaded(todos)
            case .failure(let error):
                self?.state = .error(error)
            }
        }
    }
}

이렇게 하면 앱의 상태 변화를 더 명확하게 추적할 수 있고, 버그도 줄일 수 있어.

2. 코디네이터 패턴과의 결합

MVP 패턴을 코디네이터 패턴과 결합하면 화면 전환 로직을 더 깔끔하게 관리할 수 있어.


protocol Coordinator {
    func start()
}

class AppCoordinator: Coordinator {
    let window: UIWindow
    
    init(window: UIWindow) {
        self.window = window
    }
    
    func start() {
        let todoListVC = TodoListViewController()
        let todoService = TodoService()
        let presenter = TodoListPresenter(view: todoListVC, todoService: todoService)
        todoListVC.presenter = presenter
        
        window.rootViewController = UINavigationController(rootViewController: todoListVC)
        window.makeKeyAndVisible()
    }
}

이렇게 하면 화면 전환 로직을 Presenter에서 분리할 수 있어서 각 컴포넌트의 책임이 더 명확해져.

3. 반응형 프로그래밍과의 결합

RxSwift나 Combine 같은 반응형 프로그래밍 프레임워크를 MVP 패턴과 결합하면 더 강력한 앱을 만들 수 있어.


import RxSwift
import RxCocoa

class TodoListPresenter: TodoListPresenterProtocol {
    private let todoService: TodoServiceProtocol
    private let disposeBag = DisposeBag()
    
    let todos: BehaviorRelay<[TodoItem]> = BehaviorRelay(value: [])
    
    init(todoService: TodoServiceProtocol) {
        self.todoService = todoService
    }
    
    func viewDidLoad() {
        fetchTodos()
    }
    
    private func fetchTodos() {
        todoService.fetchTodos()
            .subscribe(onSuccess: { [weak self] fetchedTodos in
                self?.todos.accept(fetchedTodos)
            }, onFailure: { error in
                print("Error fetching todos: \(error)")
            })
            .disposed(by: disposeBag)
    }
}

이렇게 하면 데이터 흐름을 더 쉽게 관리할 수 있고, 비동기 작업도 더 우아하게 처리할 수 있어.

🌈 참고: 반응형 프로그래밍은 학습 곡선이 있어서 처음에는 어려울 수 있어. 하지만 익숙해지면 정말 강력한 도구가 될 거야. 재능넷에서 반응형 프로그래밍 관련 강의를 들어보는 것도 좋은 방법이 될 수 있어!